/**
* @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?·*/
}
