/** * @brief Initialize the watchdog timer for a specified timeout * * It is important to note that this function returns the achieved timeout * for this hardware. For hardware independence this should be checked when * scheduling updates. Other hardware dependent details may need to be * considered such as a window time which sets a minimum update time, * and this function should return a recommended delay for clearing. * * For the STM32 nominal clock rate is 32 khz, but for the maximum clock rate of * 60 khz and a prescaler of 4 yields a clock rate of 15 khz. The delay that is * set in the watchdog assumes the nominal clock rate, but the delay for FreeRTOS * to use is 75% of the minimal delay. * * @returns Maximum recommended delay between updates based on PIOS_WATCHDOG_TIMEOUT constant */ uint16_t PIOS_WDG_Init() { uint16_t delay = ((uint32_t) PIOS_WATCHDOG_TIMEOUT * 60) / 16; if (delay > 0x0fff) delay = 0x0fff; #if defined(PIOS_INCLUDE_WDG) DBGMCU_Config(DBGMCU_IWDG_STOP, ENABLE); // make the watchdog stop counting in debug mode IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable); IWDG_SetPrescaler(IWDG_Prescaler_16); IWDG_SetReload(delay); IWDG_ReloadCounter(); IWDG_Enable(); // watchdog flags now stored in backup registers PWR_BackupAccessCmd(ENABLE); wdg_configuration.bootup_flags = RTC_ReadBackupRegister(PIOS_WDG_REGISTER); /* * Start from an empty set of registered flags so previous boots * can't influence the current one */ RTC_WriteBackupRegister(PIOS_WDG_REGISTER, 0); #endif return delay; }
int main(void) { //RCC_ClocksTypeDef Clocks; uint8_t pos = 128+64; SystemInit(); SystemCoreClockUpdate(); //update the system clock variable RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE); GPIO_Init(GPIOA, &GPIOA_InitStruct); timercounter = 0; //set systick to 1 every 1uS SysTick_Config(SystemCoreClock/8); initUSART1(); GPIO_SetBits(GPIOA, GPIO_Pin_10); //initialize the watchdog IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable); IWDG_SetPrescaler(0x00); //while(IWDG_GetFlagStatus(IWDG_FLAG_PVU)==SET); IWDG_SetReload(0xFFFF); //while(IWDG_GetFlagStatus(IWDG_FLAG_RVU)==SET); //IWDG_SetWindowValue(0x0000); //while(IWDG_GetFlagStatus(IWDG_FLAG_PVU)==SET); IWDG_ReloadCounter(); IWDG_Enable(); static BitAction toggle = Bit_SET; int i =0; //init the u8g library u8g_InitComFn(&u8g, &u8g_dev_ssd1306_128x64_i2c, u8g_com_hw_i2c_fn); u8g_SetDefaultForegroundColor(&u8g); while(1){ u8g_FirstPage(&u8g); do { IWDG_ReloadCounter(); draw(pos); } while ( u8g_NextPage(&u8g) ); /* refresh screen after some delay */ ///* update position */ if(pos < 128+128){ pos--; }else { pos = 128+128; } } }
/*=========================================================================== SI446X_WAIT_CTS(); Function : wait the device ready to response a command ============================================================================*/ void SI446X_WAIT_CTS(void) { INT8U cts; IWDG_ReloadCounter(); do { SI_CSN_LOW(); SPI_ExchangeByte(READ_CMD_BUFF); cts = SPI_ExchangeByte(0xFF); SI_CSN_HIGH(); }while(cts != 0xFF); IWDG_ReloadCounter(); }
/** * @brief Main program. * @param None * @retval None */ void main(void) { u8 i, cnt; disableInterrupts(); Config(); HBRIDGE_OFF; Errors_Init(); RTMS_INIT(runtime_it_1ms); enableInterrupts(); LED_GREEN_ON; // Wait for power supply settling Timeout_SetTimeout2(200); while(!Timeout_IsTimeout2()); // END Wait for power supply settling LED_OFF; // Handle RESET flags if(RST_GetFlagStatus(RST_FLAG_IWDGF)) { BLINK_REDLED(1); } else if(RST_GetFlagStatus(RST_FLAG_ILLOPF)) { BLINK_REDLED(2); } RST_ClearFlag(RST_FLAG_POR_PDR | RST_FLAG_SWIMF | RST_FLAG_ILLOPF | RST_FLAG_IWDGF); while(ISBLINKING_REDLED); // END Handle RESET flags Retrieve_Check_ROM_Timer_Val(); Timeout_SetTimeout1(HBRIDGE_CHARGE_TIME); IWDG_Enable(); IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable); IWDG_SetPrescaler(IWDG_Prescaler_64); /* 431.15ms for RL[7:0]= 0xFF */ IWDG_SetReload(0xFF); IWDG_WriteAccessCmd(IWDG_WriteAccess_Disable); IWDG_ReloadCounter(); LoadStateRequest = LOAD_NOT_POWERED; state = ST_WAIT_CAP_CHARGE; while (1) { TimerSwitch_StateMachine(); Programming_Mode_Manager(); Task_1000ms(); Error_Handler(); Display_Remaining_Time(); IWDG_ReloadCounter(); } }
void vApplicationIdleHook( void ) { unsigned long ulFreeSizeStackTask; //свободное место в процессах RTOS. unsigned long ulFreeHeapSize; //свободное место в "куче" RTOS uint8_t ucCPU_load; //загрузка RTOS portTickType WakeTick = 0; uint32_t count = 0; uint32_t max_count = 0; //максимальное значение счетчика, вычисляется при калибровке и соответствует 100% CPU idle WakeTick = xTaskGetTickCount() + configTICK_RATE_HZ; while(1) { if (xTaskGetTickCount() >= WakeTick) { #if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) ulFreeSizeStackTask = uxTaskGetStackHighWaterMark(xHandleDebugTask) << 2; ulFreeHeapSize = (unsigned long) xPortGetFreeHeapSize(); //in Byte #endif /* Определяем загруженность OS */ WakeTick += configTICK_RATE_HZ; if(count > max_count) { max_count = count; //калибровка } ucCPU_load = (uint8_t)(100.0 - 100.0 * (float)count / (float)max_count); //вычисляем текущую загрузку count = 0; //обнуляем счетчик } if(WakeTick > xTaskGetTickCount() + configTICK_RATE_HZ<<1) { WakeTick = configTICK_RATE_HZ + xTaskGetTickCount(); } count++; //приращение счетчика IWDG_ReloadCounter(); // Reload IWDG counter } }
/** * @brief Main program * @param None * @retval None */ int main(void) { RCC_Configuration(); GPIO_Configuration(); USART_Configuration(); SysTick_Config(SystemCoreClock/10); // Enable the LSI OSC RCC_LSICmd(ENABLE); // Wait till LSI is ready while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET) {}; IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable); // IWDG counter clock: LSI/256 IWDG_SetPrescaler(IWDG_Prescaler_256); IWDG_SetReload(0x0FFF); // Reload IWDG counter IWDG_ReloadCounter(); // Enable IWDG (the LSI oscillator will be enabled by hardware) IWDG_Enable(); // Write memmory FLASH_UnlockBank1(); FLASH_ErasePage(FLAG_ADDR); FLASH_ProgramWord(FLAG_ADDR,(u32)FLAG_UPDATED); FLASH_LockBank1(); updateFW_control(); }
void WatchDogInit(void) { /* IWDG timeout equal to 250 ms (the timeout may varies due to LSI frequency dispersion) */ /* Enable write access to IWDG_PR and IWDG_RLR registers */ IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable); /* IWDG counter clock: LSI/32 */ /* prescaler min/ms max/ms 4 0.1 409.6 8 0.2 819.2 16 0.4 1638.4 32 0.8 3276.8 64 1.6 6553.5 128 3.2 13107.2 256 6.4 26214.4 */ IWDG_SetPrescaler(IWDG_Prescaler_16); /* Set counter reload value to obtain 250ms IWDG TimeOut. Counter Reload Value = 250ms/IWDG counter clock period = 250ms / (LSI/32) = 0.25s / (LsiFreq/32) = LsiFreq/(32 * 4) = LsiFreq/128 */ IWDG_SetReload(0X4AAA);//(LsiFreq/128); /* Reload IWDG counter */ IWDG_ReloadCounter(); /* Enable IWDG (the LSI oscillator will be enabled by hardware) */ IWDG_Enable(); }
void main (void) { SPIRIT_INIT(); while (1) { if (Spirit_data == Spirit_waiting_window) // check if there is data ready to be sent { if(SysyTickCnt > ((endpoint_address * 100) + 50)) // check if window for sending { send_to_Base_Station(); // sending to Base Station } } if(command_pending == 1) { apply_command(); } IWDG_ReloadCounter(); //przeladowanie IWDG // SdkEvalLedToggle(LED_GREEN); if (App == App_connected) { daas_manage(); }else { app_connect(); } } } // End of main()
/** * @brief iwdg config */ void IWDG_Configuration(void) { /* Enable write access to IWDG_PR and IWDG_RLR registers */ IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable); /* IWDG counter clock: LSI/32 */ IWDG_SetPrescaler(IWDG_Prescaler_32); /* Set counter reload value to obtain 250ms IWDG TimeOut. Counter Reload Value = 250ms/IWDG counter clock period = 250ms / (LSI/32) = 0.25s / (LsiFreq/32) = LsiFreq/(32 * 4) = LsiFreq/128 */ // IWDG_SetReload(LSI_FREQ / 128); // iwdg period is 1000mS IWDG_SetReload(LSI_FREQ / 32); /* Reload IWDG counter */ IWDG_ReloadCounter(); /* Enable IWDG (the LSI oscillator will be enabled by hardware) */ IWDG_Enable(); }
/** * Initializes the boards watchdog timer. If the behavior of the board is changed, this method may need to be * modified if the main control loop is changed. * * @param none * @retval none */ void Watchdog_Init(void) { /* Get the LSI frequency from TIM5 */ LsiFreq = GetLSIFrequency(); printf("LSI Frequency: %" PRIu32 "\n", LsiFreq); /* Enable write access to IWDG_PR and IWDG_RLR registers */ IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable); /* IWDG counter clock: LSI/32 */ IWDG_SetPrescaler(IWDG_Prescaler_64); /* Set counter reload value to obtain 1s IWDG TimeOut. IWDG counter clock Frequency = LsiFreq/32 Counter Reload Value = 250ms/IWDG counter clock period = 0.25s / (32/LsiFreq) = LsiFreq/(32 * 4) = LsiFreq/128 */ IWDG_SetReload(LsiFreq/16); /* Reload IWDG counter */ IWDG_ReloadCounter(); /* Enable IWDG (the LSI oscillator will be enabled by hardware) */ IWDG_Enable(); }
void ADSample(void) { u8 i,tttemp; ADC1_DeInit(); ADC1_ConversionConfig(ADC1_CONVERSIONMODE_SINGLE, ADC1_CHANNEL_3, ADC1_ALIGN_RIGHT); ADC1_SchmittTriggerConfig(ADC1_SCHMITTTRIG_CHANNEL4,ENABLE); ADC1_ITConfig(ADC1_IT_EOCIE,DISABLE); ADC1_Cmd(ENABLE); ADC1->CSR &= (u8)(~0x80); ADC1_StartConversion(); while((ADC1->CSR & 0x80)!=0x80) IWDG_ReloadCounter(); // µÈ´ýת»»½áÊø Conversion_Value += ADC1_GetConversionValue(); ADC1->CSR &= (u8)(~0x80); u8ADChannelCnt++; if(u8ADChannelCnt>=SAMPLE_TIMES) { u8ADChannelCnt = 0; tttemp = (u8)((Conversion_Value>>2)/SAMPLE_TIMES); if((tttemp<20) || (tttemp>200) ) u8Temp = OFF_TMP_SET; else { for(i=0;T3580Tab[i]<tttemp;i++); u8Temp = (u8)(i+(40*2)); } Conversion_Value = 0; }
int main(void) { uint32_t setHour=0,setMinute=0; //uint32_t v; Init(); while (1) { LED1( ON ); // 亮 Delay(500000); LED1( OFF ); // 灭 Delay(500000); if(receive[19]==1) { Accept_to_complete(&setHour,&setMinute); memset(receive,0,sizeof(receive)); } IWDG_ReloadCounter(); tmpchange(); vTemp = tmp(); printf("the temp =%d",vTemp/1000); isTimeOut(setHour,setMinute); } }
int LCDPANELProcessInit(void) { rt_thread_t init_thread; rt_err_t result = RT_EOK; // 创建消息队列,分配队列存储空间 result = rt_mq_init(&rx_mq, "mqt", &msg_pool[0], 32 - sizeof(void*), sizeof(msg_pool), RT_IPC_FLAG_FIFO); if (result != RT_EOK) { rt_kprintf("init message queue failed.\n"); return result; } IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable); // Enable write access to IWDG_PR and IWDG_RLR registers IWDG_SetPrescaler(IWDG_Prescaler_32); // IWDG counter clock: 40KHz(LSI) / 32 = 1.25 KHz IWDG_SetReload(1250); // Set counter reload value to 1250 IWDG_ReloadCounter(); // Reload IWDG counter // IWDG_Enable(); // Enable IWDG (the LSI oscillator will be enabled by hardware) init_thread = rt_thread_create( "lcdpanel", LCDPANELProcess_thread_entry, RT_NULL, 2048,10,10); if( init_thread != RT_NULL ) { rt_thread_startup(init_thread); } return 0; }
void Watchdog(void) { #ifdef __PFM6__ IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable); IWDG_ReloadCounter(); IWDG_WriteAccessCmd(IWDG_WriteAccess_Disable); #endif }
extern hal_result_t hal_watchdog_refresh(hal_watchdog_t id) { hal_watchdog_internal_item_t* intitem = s_hal_watchdog_theinternals.items[HAL_watchdog_id2index(id)]; hal_result_t res = hal_res_NOK_generic; if(hal_false == s_hal_watchdog_initted_is(id)) { return(hal_res_NOK_generic); } switch(id) { case hal_watchdog1_normal: { IWDG_ReloadCounter(); res = hal_res_OK; } break; case hal_watchdog2_window: { WWDG_SetCounter(intitem->reload); res = hal_res_OK; } break; default: { res = hal_res_NOK_generic; } break; } return(res); }
//============================================================================== // 看門狗設定 : 用來當RESET 用 //============================================================================== void IWDG_Config(unsigned char timeout) { /* IWDG timeout equal to 250 ms (the timeout may varies due to LSI frequency dispersion) */ /* Enable write access to IWDG_PR and IWDG_RLR registers */ IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable); /* IWDG counter clock: LSI/32 */ //IWDG_SetPrescaler(IWDG_Prescaler_32); /* IWDG counter clock: LSI/256 */ IWDG_SetPrescaler(IWDG_Prescaler_256); /* Set counter reload value to obtain 250ms IWDG TimeOut. Counter Reload Value = 250ms/IWDG counter clock period = 250ms / (LSI/32) = 0.25s / (LsiFreq/32) = LsiFreq/(32 * 4) = LsiFreq/128 */ // IWDG_SetReload(LsiFreq/128); IWDG_SetReload(timeout); /* Reload IWDG counter */ IWDG_ReloadCounter(); /* Enable IWDG (the LSI oscillator will be enabled by hardware) */ IWDG_Enable(); }
static void program_loop(void) { /* Infinite loop */ while (1) { /* Service the inputs/outputs */ ServiceTasks(); /* Check if any packet received */ if (ETH_CheckFrameReceived()) { /* Process received ethernet packet */ LwIP_Pkt_Handle(); } /* Handle periodic timers for LwIP */ LwIP_Periodic_Handle(GetLocalTime()); if (TelnetIsConnected() == true) { /* We have an active Telnet connection to service */ /* Do server stuff */ character = TelnetRead(); if (character != '\0') { Command_AddChar(character); } } /* Check to see if any faults have occurred */ Tekdaqc_CheckStatus(); /* Reload the IWDG Counter to prevent reset */ IWDG_ReloadCounter(); } }
OSStatus PlatformWDGInitialize( uint32_t timeout_ms ) { plat_log_trace(); OSStatus err = kNoErr; // PLATFORM_TO_DO /* Get the LSI frequency: TIM5 is used to measure the LSI frequency */ LsiFreq = GetLSIFrequency(); IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable); /* IWDG counter clock: LSI/32 */ IWDG_SetPrescaler(IWDG_Prescaler_128); /* Set counter reload value to obtain 250ms IWDG TimeOut. Counter Reload Value = 250ms/IWDG counter clock period = 250ms / (LSI/32) = 0.25s / (LsiFreq/32) = LsiFreq/(32 * 4) = LsiFreq/128 */ IWDG_SetReload((uint16_t)(LsiFreq*timeout_ms/128000)); /* Reload IWDG counter */ IWDG_ReloadCounter(); /* Enable IWDG (the LSI oscillator will be enabled by hardware) */ IWDG_Enable(); return err; }
//================================================================================== void write_hour(void) { if(PKDU.Min>58) { PKDU.Min=0; if(PKDU.Hour>9999) PKDU.Hour=0; else ++PKDU.Hour; EEPROM_save_hour(PKDU.Hour); } if(PKDU.SchowPar==6) { if(!((PKDU.StatusKN>>8)&1)&& ((PKDU.StatusKN>>2)&1)&& ((PKDU.StatusKN>>3)&1)) { PKDU.Hour=0; EEPROM_save_hour(0); ShowParam(); } while(!((PKDU.StatusKN>>8)&1)&& ((PKDU.StatusKN>>2)&1)&& ((PKDU.StatusKN>>3)&1)) { IWDG_ReloadCounter(); } } }
//*******************初始化独立看门狗************************************* //函数定义: void IWDG_Configuration(void) //描 述:初始化独立看门狗 //入口参数:无 //出口参数:无 //备 注:分频因子=4*2^prer.但最大值只能是256!时间计算(大概):Tout=40K/((4*2^prer)*rlr)值 2S超时 //Editor:liuqh 2013-1-16 Company: BXXJS //******************************************************************* static void IWDG_Configuration(void) { IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);//使能对IWDG->PR和IWDG->RLR的写 IWDG_SetPrescaler(IWDG_Prescaler_64);//64分频 IWDG_SetReload(1300); IWDG_ReloadCounter(); IWDG_Enable(); }
/** * IWDG_Configuration */ static void IWDG_Configuration(void) { IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable); IWDG_SetPrescaler(IWDG_Prescaler_64); IWDG_SetReload(1875); IWDG_ReloadCounter(); IWDG_Enable(); }
void WDT_init(void) { IWDG_WriteAccessEnable(); IWDG_SetPrescaler(IWDG_Prescaler_256); IWDG_SetReload(0xFFF); IWDG_Enable(); IWDG_ReloadCounter(); }
/** * @brief This function handles SysTick Handler. * @param None * @retval None */ void SysTick_Handler(void) { /* Reload IWDG counter */ IWDG_ReloadCounter(); /* Toggle LED2 */ STM_EVAL_LEDToggle(LED2); }
void IWDG_Init() { IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable); IWDG_SetPrescaler(IWDG_Prescaler_256); IWDG_SetReload(781); IWDG_ReloadCounter(); IWDG_Enable(); }
void MicoWdgReload( void ) { #ifndef MICO_DISABLE_WATCHDOG IWDG_ReloadCounter(); #else return; #endif }
/** * @brief 初始化独立看门狗 * @param prer : IWDG预分频值 , rlr 重装载值 * @retval None */ void IWDG_Init(u8 prer, u16 rlr) { IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable); //使能对寄存器IWDG_PR和IWDG_RLR的写操作 IWDG_SetPrescaler(prer); //设置IWDG预分频值:设置IWDG预分频值为64 IWDG_SetReload(rlr); //设置IWDG重装载值 IWDG_ReloadCounter(); //按照IWDG重装载寄存器的值重装载IWDG计数器 IWDG_Enable(); //使能IWDG IWDG_Feed(); }
OSStatus platform_watchdog_kick( void ) { #ifndef MICO_DISABLE_WATCHDOG IWDG_ReloadCounter(); return kNoErr; #else return kUnsupportedErr; #endif }
void IWDG_Init(void) { //konfigurowanie watchdoga IWDG IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable); // Zezwolenie na zapis rejestrów IWDG IWDG_SetPrescaler(IWDG_Prescaler_64); // IWDG taktowany zegarem: 37kHz/64 = 0.578kHz IWDG_SetReload(0xFFF); // Przepelnienie IWDG po okolo 7s IWDG_ReloadCounter(); // Przeladowanie IWDG IWDG_Enable(); // Wlaczenie IWDG i LSI }
/******************************************************************************* 函 数 名:void IWDG_Init(void) 功能描述:看门狗初始化 入口参数: 返回参数: 创建时间: 2011.6.24 ********************************************************************************/ void IWDG_Init(void) { IWDG_WriteAccessCmd( IWDG_WriteAccess_Enable ); IWDG_SetPrescaler( IWDG_Prescaler_64); //最小 IWDG_SetReload( 0x138); //40KHz内部时钟 (1/40000 * 64 * 0x138 = 0.5s) IWDG_WriteAccessCmd( IWDG_WriteAccess_Disable ); IWDG_Enable(); IWDG_ReloadCounter(); }
/******************************************************************************* * Function Name : IWDG_Configuration * Description : ?/AA?·AaOA * Input : None * Output : None * Return : None * Attention : None *******************************************************************************/ void IWDG_Configuration(void) { IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable); /* ?/Ee0x5555,OAOUOE?i?·?·?A/????/Ee?¦AU */ IWDG_SetPrescaler(IWDG_Prescaler_256); /* AU²?µIEUE±OO256·O?µ 40K/256=156HZ(6.4ms) */ /* ?/AA?·¶¨E±??Oc³oE±?a */ IWDG_SetReload(781); /* I??·E±?a 5s/6.4MS=781 .??Oa²»AU/oOU0xfff*/ IWDG_ReloadCounter(); /* I??·*/ IWDG_Enable(); /* E?AU?/AA?·*/ }