/***********************************************************
* 函数名：Write_GPS_Info
* 描述 ：把GPS信息从CPU写入Flash
* 输入 : 无
* 输出 : 无
***********************************************************/
void Write_Flash_GPS_Info(void)
{
FLASHStatus = FLASH_COMPLETE;
MemoryProgramStatus = PASSED;
FLASH_Unlock(); //FLASH解锁
FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);//清标志位
NbrOfPage = (EndAddr[10] - StartAddr[10]) / FLASH_PAGE_SIZE; //页面擦除子程序
FLASHStatus = FLASH_ErasePage(StartAddr[10] + (FLASH_PAGE_SIZE * NbrOfPage));
FlashAddress = StartAddr[10];
FLASHStatus = FLASH_ProgramWord(FlashAddress, jingdu);
FlashAddress = FlashAddress + 4;
FLASHStatus = FLASH_ProgramWord(FlashAddress, weidu);
FlashAddress = FlashAddress + 4;
FLASHStatus = FLASH_ProgramWord(FlashAddress, sog);
FlashAddress = FlashAddress + 4;
FLASHStatus = FLASH_ProgramWord(FlashAddress, direction);
BKP_WriteBackupRegister(BKP_DR4,(u16)(jingdu >> 16));
BKP_WriteBackupRegister(BKP_DR5,(u16)(weidu >> 16));
BKP_WriteBackupRegister(BKP_DR7,(u16)jingdu);
BKP_WriteBackupRegister(BKP_DR8,(u16)weidu);
BKP_WriteBackupRegister(BKP_DR9,sog);
BKP_WriteBackupRegister(BKP_DR10,direction);
}
/*********************************
**函数名:SetRTCTime
**功能:设置时间，除了把Real_Time的值改变外,还要把时分秒转换为RTC计数值,年月日存到后备寄存器上
**注意事项:函数内会自动根据年月日计算星期,并且返回到*time上
**********************************/
void SetRTCTime(T_STRUCT* time)
{
u32 count;
RTC_ITConfig(RTC_IT_SEC, DISABLE); //关闭秒中断
RTC_WaitForLastTask();
//付时间值到Real_Time上
Real_Time.year=time->year;
Real_Time.month=time->month;
Real_Time.day=time->day;
Real_Time.hour=time->hour;
Real_Time.minute=time->minute;
Real_Time.sec=time->sec;
//计算星期
time->date=Real_Time.date=GetDate(time);
//把新的年月日存到掉电寄存器上
BKP_WriteBackupRegister(BKP_TIME_DATE,Real_Time.date);
// RTC_WaitForLastTask();
BKP_WriteBackupRegister(BKP_TIME_DAY,Real_Time.day);
// RTC_WaitForLastTask();
BKP_WriteBackupRegister(BKP_TIME_MONTH,Real_Time.month);
// RTC_WaitForLastTask();
BKP_WriteBackupRegister(BKP_TIME_YEAR,Real_Time.year);
// RTC_WaitForLastTask();
//计算新的RTC count值
count=Real_Time.hour*3600+Real_Time.minute*60+Real_Time.sec;
RTC_WaitForLastTask();
RTC_SetCounter(count);
RTC_WaitForLastTask();
RTC_ITConfig(RTC_IT_SEC, ENABLE); //打开秒中断
}
/***********************************************************
* 函数名：ReadflashMPeriod
* 描述 ：把msequence_poly从Flash读入CPU
* 输入 : 无
* 输出 : 无
***********************************************************/
void ReadflashMPeriod(void) //记录发射间隔次数固定值
{
FlashAddress = StartAddr[4];
gps_invalid = *(u16*)FlashAddress;
FlashAddress += 4;
intervalA = *(u16*)FlashAddress;
FlashAddress += 4;
intervalB = *(u16*)FlashAddress;
FlashAddress += 4;
interval_num = *(u16*)FlashAddress;
FlashAddress += 4;
//time_o = *(u16*)FlashAddress;
FlashAddress += 4;
interval_s = *(u16*)FlashAddress;
BKP_WriteBackupRegister(BKP_DR1,interval_num);
// BKP_WriteBackupRegister(BKP_DR2,time_o);
BKP_WriteBackupRegister(BKP_DR3,interval_s);
// interval_num = BKP_ReadBackupRegister(BKP_DR1);
// gps_invalid_num = BKP_ReadBackupRegister(BKP_DR2);
// interval_s = BKP_ReadBackupRegister(BKP_DR3);
}
/***********************************************************
* 函数名：WriteflashMPeriod
* 描述 ：把interval_s从CPU写入Flash
* 输入 : 无
* 输出 : 无
***********************************************************/
void WriteflashMPeriod(void)
{
FLASHStatus = FLASH_COMPLETE;
MemoryProgramStatus = PASSED;
FLASH_Unlock(); //FLASH解锁
FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);//清标志位
NbrOfPage = (EndAddr[4] - StartAddr[4]) / FLASH_PAGE_SIZE;//页面擦除子程序
FLASHStatus = FLASH_ErasePage(StartAddr[4] + (FLASH_PAGE_SIZE * NbrOfPage));
FlashAddress = StartAddr[4];
FLASHStatus = FLASH_ProgramWord(FlashAddress, gps_invalid);
FlashAddress = FlashAddress + 4;
FLASHStatus = FLASH_ProgramWord(FlashAddress, intervalA);
FlashAddress = FlashAddress + 4;
FLASHStatus = FLASH_ProgramWord(FlashAddress, intervalB);
FlashAddress = FlashAddress + 4;
FLASHStatus = FLASH_ProgramWord(FlashAddress, interval_num);
FlashAddress = FlashAddress + 4;
// FLASHStatus = FLASH_ProgramWord(FlashAddress, time_o);
FlashAddress = FlashAddress + 4;
FLASHStatus = FLASH_ProgramHalfWord(FlashAddress, interval_s);
BKP_WriteBackupRegister(BKP_DR1,interval_num);
//BKP_WriteBackupRegister(BKP_DR2,time_o);
BKP_WriteBackupRegister(BKP_DR3,interval_s);
}
void PVD_IRQHandler(void)
{
unsigned poweroff_cnt;
unsigned long time;
EXTI->PR = EXTI_Line16; //EXTI_ClearITPendingBit(EXTI_Line16);
/* 系统上电前500ms, 不认为是掉电; 若已处于系统掉电状态, 将不再处理 */
if ((rt_tick_get() < 50) || (NULL == rtc_dev) || is_system_powerdown) {
return;
}
/*
lcd_bl_led_off();
buzzer_off(buzzer_gpio, buzzer_pin);
*/
is_system_powerdown = 1;
sys_powerdown_delay4confirm = rt_tick_get();
PWR_BackupAccessCmd(ENABLE);
poweroff_cnt = BKP_ReadBackupRegister(RX_POWEROFF_CNT_BKP16BITS);
BKP_WriteBackupRegister(RX_POWEROFF_CNT_BKP16BITS, ++poweroff_cnt);
rt_device_control(rtc_dev, RT_DEVICE_CTRL_RTC_GET_TIME, &time);
BKP_WriteBackupRegister(RX_POWEROFF_N_BKP16BITS_H, (time>>16) & 0xffff);
BKP_WriteBackupRegister(RX_POWEROFF_N_BKP16BITS_L, (time) & 0xffff);
PWR_BackupAccessCmd(DISABLE);
//rt_kprintf("%s", __FUNCTION__);
return;
}
void save_2g_err( unsigned char force, GPRS_REASON reason)
{
u16 result_temp ;
//force=1: save to BK reg even BKP_DR1 have data, force=0: don't save if have data
//BKP_DR1, ERR index: 15~12:MCU reset
// 11~8:upgrade fw failure code
// 7~4:GPRS failure reason
// 3~0:GSM module poweroff reason
//BKP_DR4, GPRS failure time (UTC Time) high
//BKP_DR5, GPRS failure time (UTC Time) low
if ( (BKP_ReadBackupRegister(BKP_DR1))&0x00F0 ) {//have data
if ( !force ) {//don't cover if have data
return ;
}
}
result_temp = (BKP_ReadBackupRegister(BKP_DR1))&0xFF0F;
result_temp = result_temp | ((reason<<4)&0xF0) ;
BKP_WriteBackupRegister(BKP_DR1, result_temp);
BKP_WriteBackupRegister(BKP_DR4, ((RTC_GetCounter( ))>>16)&0xFFFF);//high
BKP_WriteBackupRegister(BKP_DR5, (RTC_GetCounter( ))&0xFFFF);//low
}
/**************************************************************
** 函数名:SaveTouchAdjInfo
** 功能:保存触摸校正信息(4变量)
** 注意事项:触摸定位四变量,保存在后备寄存器中,并标志化后备寄存器2
***************************************************************/
void SaveTouchAdjInfo(void)
{
BKP_WriteBackupRegister(BKP_TOUCH_X_BEGIN,LCDX_Begin_AD );
BKP_WriteBackupRegister(BKP_TOUCH_LENGTH,LCD_Length_AD );
BKP_WriteBackupRegister(BKP_TOUCH_Y_BEGIN,LCDY_Begin_AD );
BKP_WriteBackupRegister(BKP_TOUCH_HEIGHT,LCD_Height_AD );
//标志化2
BKP_WriteBackupRegister(BKP_TOUCH_SET,0xA55A);
}
void HAL_Core_System_Reset_Ex(int reason, uint32_t data, void *reserved)
{
if (HAL_Feature_Get(FEATURE_RESET_INFO))
{
// Save reset info to backup registers
BKP_WriteBackupRegister(BKP_DR2, reason);
BKP_WriteBackupRegister(BKP_DR3, data >> 16);
BKP_WriteBackupRegister(BKP_DR4, data & 0xffff);
}
HAL_Core_System_Reset();
}
void backupSave() {
PWR_BackupAccessCmd(ENABLE);
BKP_ClearFlag();
BKP_WriteBackupRegister(BKP_DR1, BACKUP_MARKER);
BKP_WriteBackupRegister(BKP_DR2, (gUtcOffset >> 16) & 0xFFFF);
BKP_WriteBackupRegister(BKP_DR3, gUtcOffset & 0xFFFF);
BKP_WriteBackupRegister(BKP_DR4, gGridOc.TIM_Pulse);
PWR_BackupAccessCmd(DISABLE);
}
void rtc_setTime(char * argv[], int argc)
{
if(argc > 4)
{
t_print("Setting time\n");
mHour = t_atoi(argv[0]);
mMinute = t_atoi(argv[1]);
s_DateStructVar.Day = t_atoi(argv[2]);
s_DateStructVar.Month = t_atoi(argv[3]);
s_DateStructVar.Year = t_atoi(argv[4]);
uint32_t CounterValue = ((mHour * 3600)+ (mMinute * 60));
RTC_WaitForLastTask();
RTC_SetCounter(CounterValue);
RTC_WaitForLastTask();
BKP_WriteBackupRegister(BKP_DR2,s_DateStructVar.Day);
BKP_WriteBackupRegister(BKP_DR3,s_DateStructVar.Month);
BKP_WriteBackupRegister(BKP_DR4,s_DateStructVar.Year);
}
else if(argc > 1)
{
mHour = t_atoi(argv[0]);
mMinute = t_atoi(argv[1]);
uint32_t CounterValue = ((mHour * 3600)+ (mMinute * 60));
RTC_WaitForLastTask();
RTC_SetCounter(CounterValue);
RTC_WaitForLastTask();
}
t_print("Time: ");
d_print(mHour);
t_print(":");
d_print(mMinute);
t_print(":");
d_print(mSecond);
t_print(" ");
d_print(s_DateStructVar.Day);
t_print("-");
d_print(s_DateStructVar.Month);
t_print("-");
d_print(s_DateStructVar.Year);
t_print("\n");
}
void HAL_Core_Enter_Bootloader(bool persist)
{
if (persist)
{
BKP_WriteBackupRegister(BKP_DR10, 0xFFFF);
FLASH_OTA_Update_SysFlag = 0xFFFF;
Save_SystemFlags();
}
else
{
BKP_WriteBackupRegister(BKP_DR1, ENTER_DFU_APP_REQUEST);
}
HAL_Core_System_Reset();
}
void HAL_Core_Enter_Stop_Mode(uint16_t wakeUpPin, uint16_t edgeTriggerMode, long seconds)
{
if (seconds > 0) {
HAL_RTC_Cancel_UnixAlarm();
HAL_RTC_Set_UnixAlarm((time_t) seconds);
}
if ((wakeUpPin < TOTAL_PINS) && (edgeTriggerMode <= FALLING))
{
uint16_t BKP_DR9_Data = wakeUpPin;//set wakeup pin mumber
BKP_DR9_Data |= (edgeTriggerMode << 8);//set edge trigger mode
BKP_DR9_Data |= (0xA << 12);//set stop mode flag
/*************************************************/
//BKP_DR9_Data: 0xAXXX
// ||||
// ||----- octet wakeUpPin number
// |------ nibble edgeTriggerMode
// ------- nibble stop mode flag
/*************************************************/
/* Execute Stop mode on next system reset */
BKP_WriteBackupRegister(BKP_DR9, BKP_DR9_Data);
/* Reset System */
NVIC_SystemReset();
}
}
/*设置系统时间*/
void SysSetTime(FUN_BLOCK **funBlock)
{
DIS_SING *sing_temp;
GetSubFunBlock(&pfunSubBlock);
sing_temp = (DIS_SING *)(pfunSubBlock->current_display);
pfunSubBlock->data_type = ZINUM;//显示属性
RTC_ITConfig(RTC_IT_SEC, DISABLE); //关RTC中断，防止systmtime被修改
strcpy(sing_temp->y2 , "请输入时间");
/*取得VIRTUAL_NUM_LENGTH位数的箱门数*/
if(CANCEL == KeyDisplay(pfunSubBlock , 10))
{
FreeMem();
return;
}
/*读取时间值*/
systmtime.tm_year = 2000 + (sing_temp->y3[0]-'0')*10 + sing_temp->y3[1]-'0';
systmtime.tm_mon = (sing_temp->y3[2]-'0')*10 + sing_temp->y3[3]-'0';
systmtime.tm_mday = (sing_temp->y3[4]-'0')*10 + sing_temp->y3[5]-'0';
systmtime.tm_hour = (sing_temp->y3[6]-'0')*10 + sing_temp->y3[7]-'0';
systmtime.tm_min = (sing_temp->y3[8]-'0')*10 + sing_temp->y3[9]-'0';
memset(sing_temp->y3 , 0 , 10);
/*写入时间*/
RTC_Configuration();
Time_Adjust(&systmtime);//写入系统时间
BKP_WriteBackupRegister(BKP_DR1, 0xA5A5);
strcpy(sing_temp->y2 , "系统时间修改成功");
DisplaySubBlock(pfunSubBlock);
FreeMem();
}
/*******************************************************************************
* Function Name : Date_PreAdjust
* Description : Pre-Adjusts the current date (MM/DD/YYYY).
* Input : None
* Output : None
* Return : None
*******************************************************************************/
static void Date_PreAdjust(void)
{
uint32_t tmp = 0, pressedkey = 0;
/* Clear the LCD */
LCD_Clear(White);
LCD_SetBackColor(Blue);
LCD_SetTextColor(White);
if(BKP_ReadBackupRegister(BKP_DR1) != 0xA5A5)
{
LCD_DisplayStringLine(Line7, "Time and Date Config");
LCD_DisplayStringLine(Line8, "Select: Press SEL ");
LCD_DisplayStringLine(Line9, "Abort: Press Any Key");
while(1)
{
pressedkey = ReadKey();
if(pressedkey == SEL)
{
/* Adjust Time */
Time_PreAdjust();
/* Clear the LCD */
LCD_Clear(White);
return;
}
else if (pressedkey != NOKEY)
{
return;
}
}
}
else
{
/* Display the current date */
Date_Display(date_s.year, date_s.month, date_s.day);
/* Change the current date */
Date_Regulate();
BKP_WriteBackupRegister(BKP_DR2, date_s.year);
tmp = date_s.month << 8;
tmp |= date_s.day;
BKP_WriteBackupRegister(BKP_DR3, tmp);
BKP_WriteBackupRegister(BKP_DR4, daycolumn);
BKP_WriteBackupRegister(BKP_DR5, dayline);
}
}
/**
* @file RTC_Init
* @brief RTC Initialization
* @param 无
* @retval 无
*/
void RTC_Init(void)
{
if (BKP_ReadBackupRegister(BKP_DR1)!= 0xA5A5)
{
/* Backup data register value is not correct or not yet programmed (when
the first time the program is executed) */
printf("RTC not yet configured....\r\n");
/* RTC Configuration */
RTC_Configuration();
Time_Regulate();
/* Adjust time by values entred by the user on the hyperterminal */
printf("RTC configured....\r\n");
BKP_WriteBackupRegister(BKP_DR1, 0xA5A5);
}
else
{
/* Check if the Power On Reset flag is set */
if (RCC_GetFlagStatus(RCC_FLAG_PORRST) != RESET)
{
printf("Power On Reset occurred....\r\n");
}
/* Check if the Pin Reset flag is set */
else if (RCC_GetFlagStatus(RCC_FLAG_PINRST) != RESET)
{
printf("External Reset occurred....\r\n");
}
printf("No need to configure RTC....\r\n");
/* Wait for RTC registers synchronization */
RTC_WaitForSynchro();
/* Enable the RTC Second */
RTC_ITConfig(RTC_IT_SEC, ENABLE);
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
}
/* NVIC configuration */
NVIC_Configuration();
#ifdef RTCClockOutput_Enable
/* Enable PWR and BKP clocks */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
/* Allow access to BKP Domain */
PWR_BackupAccessCmd(ENABLE);
/* Disable the Tamper Pin */
BKP_TamperPinCmd(DISABLE); /* To output RTCCLK/64 on Tamper pin, the tamper
functionality must be disabled */
/* Enable RTC Clock Output on Tamper Pin */
BKP_RTCOutputConfig(BKP_RTCOutputSource_CalibClock);
#endif
/* Clear reset flags */
RCC_ClearFlag();
return;
}
void BKP_storeWord(uint16_t bkpidx,uint16_t value)
{
if (bkpidx >= BKP_DR_NUMBER)
return;
vPortEnterCritical();
BKP_WriteBackupRegister(BKPDataReg[bkpidx],value);
vPortExitCritical();
}
void HAL_Core_Enter_Standby_Mode(void)
{
/* Execute Standby mode on next system reset */
BKP_WriteBackupRegister(BKP_DR9, 0xA5A5);
/* Reset System */
NVIC_SystemReset();
}
void PIOS_BKP_WriteRegister(uint32_t regnumber, uint16_t data)
{
if (PIOS_BKP_REGISTERS_COUNT < regnumber) {
PIOS_Assert(0);
} else {
BKP_WriteBackupRegister(pios_bkp_registers_map[regnumber], (uint32_t)data);
}
}
/**
* @brief Writes data Backup DRx registers.
* @param FirstBackupData: data to be written to Backup data registers.
* @retval None
*/
void WriteToBackupReg(uint16_t FirstBackupData)
{
uint32_t index = 0;
for (index = 0; index < BKP_DR_NUMBER; index++)
{
BKP_WriteBackupRegister(BKPDataReg[index], FirstBackupData + (index * 0x5A));
}
}
void BKP_storeDWord(uint16_t bkpidx,uint32_t value)
{
if (bkpidx >= (BKP_DR_NUMBER-1))
return;
vPortEnterCritical();
BKP_WriteBackupRegister(BKPDataReg[bkpidx],(uint16_t)(value >> 16));
BKP_WriteBackupRegister(BKPDataReg[bkpidx+1],(uint16_t)value);
vPortExitCritical();
}
/**
* @brief Function called by modules to indicate they are still running
*
* This function will set this flag in the active flags register (which is
* a backup regsiter) and if all the registered flags are set will clear
* the watchdog and set only this flag in the backup register
*
* @param[in] flag the flag to set
* @return true if the watchdog cleared, false if flags are pending
*/
bool PIOS_WDG_UpdateFlag(uint16_t flag)
{
// we can probably avoid using a semaphore here which will be good for
// efficiency and not blocking critical tasks. race condition could
// overwrite their flag update, but unlikely to block _all_ of them
// for the timeout window
uint16_t cur_flags = BKP_ReadBackupRegister(PIOS_WDG_REGISTER);
if((cur_flags | flag) == wdg_configuration.used_flags) {
PIOS_WDG_Clear();
BKP_WriteBackupRegister(PIOS_WDG_REGISTER, flag);
return true;
} else {
BKP_WriteBackupRegister(PIOS_WDG_REGISTER, cur_flags | flag);
return false;
}
}
void obd_set_type( u8 type )
{
u16 bk_reg ;
//BKP_DR2, OBD Flag: 3~0: OBD_TYPEDEF
bk_reg = BKP_ReadBackupRegister(BKP_DR2) & 0xFFF0 ;
bk_reg = bk_reg | (type&0x0F) ;
BKP_WriteBackupRegister(BKP_DR2, bk_reg);
}
/**
* @brief Write userdata to Backup DRx registers.
* @param UserBackupData: data to be written to Backup data registers.
* @retval None
*/
void WriteToBackupReg(uint16_t UserBackupData)
{
uint32_t temp = 0;
for (temp = 0; temp < BKP_DR_NUM; temp++)
{
BKP_WriteBackupRegister(BKPDataReg[temp], UserBackupData + (temp * 0x50));
}
}
static void Init_Last_Reset_Info()
{
if (HAL_Core_System_Reset_FlagSet(SOFTWARE_RESET))
{
// Load reset info from backup registers
last_reset_info.reason = BKP_ReadBackupRegister(BKP_DR2);
const uint16_t hi = BKP_ReadBackupRegister(BKP_DR3);
const uint16_t lo = BKP_ReadBackupRegister(BKP_DR4);
last_reset_info.data = ((uint32_t)hi << 16) | (uint32_t)lo;
// Clear backup registers
BKP_WriteBackupRegister(BKP_DR2, 0);
BKP_WriteBackupRegister(BKP_DR3, 0);
BKP_WriteBackupRegister(BKP_DR4, 0);
}
else // Hardware reset
{
if (HAL_Core_System_Reset_FlagSet(WATCHDOG_RESET))
{
last_reset_info.reason = RESET_REASON_WATCHDOG;
}
else if (HAL_Core_System_Reset_FlagSet(POWER_MANAGEMENT_RESET))
{
last_reset_info.reason = RESET_REASON_POWER_MANAGEMENT; // Reset generated when entering standby mode (nRST_STDBY: 0)
}
else if (HAL_Core_System_Reset_FlagSet(POWER_DOWN_RESET))
{
last_reset_info.reason = RESET_REASON_POWER_DOWN;
}
else if (HAL_Core_System_Reset_FlagSet(PIN_RESET)) // Pin reset flag should be checked in the last place
{
last_reset_info.reason = RESET_REASON_PIN_RESET;
}
else if (PWR_GetFlagStatus(PWR_FLAG_SB) != RESET) // Check if MCU was in standby mode
{
last_reset_info.reason = RESET_REASON_POWER_MANAGEMENT; // Reset generated when exiting standby mode (nRST_STDBY: 1)
}
else
{
last_reset_info.reason = RESET_REASON_UNKNOWN;
}
last_reset_info.data = 0; // Not used
}
// Note: RCC reset flags should be cleared, see HAL_Core_Init()
}
void SetRtcTime(void)
{
/* Enable PWR and BKP clocks */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
/* Allow access to BKP Domain */
PWR_BackupAccessCmd(ENABLE);
/* Reset Backup Domain */
BKP_DeInit();
#ifdef RTC_LSE
/* Enable LSE */
RCC_LSEConfig(RCC_LSE_ON);
/* Wait till LSE is ready */
while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
{}
/* Select LSE as RTC Clock Source */
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
#else
/* Enable the LSI OSC */
RCC_LSICmd(ENABLE);
/* Wait till LSI is ready */
while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET)
{}
/* Select the RTC Clock Source */
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI);
#endif
/* Enable RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC registers synchronization */
RTC_WaitForSynchro();
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
/* Enable the RTC Second */
RTC_ITConfig(RTC_IT_SEC, ENABLE);
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
printf("\r\n RTC configured....");
/* Adjust time by values entred by the user on the hyperterminal */
// Time_Adjust();
Time_SetCalendarTime(time_set);
BKP_WriteBackupRegister(BKP_DR1, 0xA5A5);
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
}
/**
* @brief Displays the current time.
* @param TimeVar: RTC counter value.
* @retval None
*/
void Time_Display(uint32_t TimeVar) {
/* Reset RTC Counter when Time is 23:59:59 */
if (RTC_GetCounter() == 0x0001517F) {
RTC_SetCounter(0x0);
IncreaseSingleDay();
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
/* Backup routine*/
int YY, MD;
YY = GetYearAndMergeToInt();
MD = GetMonthAndMergeToInt() * 100 + GetDayAndMergeToInt();
printf("\r\n\n Automatic Backup routine excuted");
BKP_WriteBackupRegister(BKP_DR2, YY);
BKP_WriteBackupRegister(BKP_DR3, MD);
printf("\r\n Calendar data successfully saved to backup register BKP_DR2, 3");
}
/* get calendar */
TYR = GetYearAndMergeToInt();
TMO = GetMonthAndMergeToInt();
TDD = GetDayAndMergeToInt();
/* Compute hours */
THH = TimeVar / 3600;
/* Compute minutes */
TMM = (TimeVar % 3600) / 60;
/* Compute seconds */
TSS = (TimeVar % 3600) % 60;
int mTHH, mTMM, mTSS;
mTHH = THH; mTMM = TMM; mTSS = TSS;
sprintf(DATE, "DATE: %04d.%02d.%02d", TYR, TMO, TDD);
sprintf(TIME, "TIME: %02d:%02d:%02d", mTHH, mTMM, mTSS);
/* Display through CLCD */
CLCD_Write(0, 0, DATE);
CLCD_Write(0, 1, TIME);
}
void btn_enter_pressed_in_set_chk_interval(){
/* Allow access to BKP Domain */
PWR_BackupAccessCmd(ENABLE);
BKP_WriteBackupRegister(CHECK_INTERVAL_BKP, chk_int);
PWR_BackupAccessCmd(DISABLE);
regim = DISPLAY_REGIM_MENU; //выходим в меню
lcd_set_state(LCD_ENABLE, CURSOR_DISABLE);
}
void RTC_Config(void)
{
/*后备寄存器1中，存了一个特殊字符0xA5A5
第一次上电或后备电源掉电后，该寄存器数据丢失，
表明RTC数据丢失，需要重新配置 */
if(BKP_ReadBackupRegister(BKP_DR1) != 0xA5A5) //检查是否第一次上电或后备电池已经掉电，
{
Write_Log("Backup VBAT PowerDown or First time PowerUp,Initialize RTC\r\n");
RTC_Configuration();
BKP_WriteBackupRegister(BKP_DR1, 0xA5A5);
time_now.tm_year = 2011;
time_now.tm_mon = 10; //月份表示为0~11
time_now.tm_mday = 13;
time_now.tm_hour = 13;
time_now.tm_min = 16;
time_now.tm_sec = 38;
Time_SetCalendarTime(time_now);//设置初始时间
}
else //若后备寄存器没有掉电，则无需重新配置RTC
{
Write_Log("Backup VBAT Keep, Don't RTC Configuralation\r\n");
//等待RTC与APB同步
RTC_WaitForSynchro();
RTC_WaitForLastTask();
//使能秒中断
RTC_ITConfig(RTC_IT_SEC, ENABLE);
RTC_WaitForLastTask();
}
//这里我们可以利用RCC_GetFlagStatus()函数查看本次复位类型
if (RCC_GetFlagStatus(RCC_FLAG_PORRST) != RESET)
{
por_rst_flag = 1;
Write_Log("PowerUp Reset\r\n");
}
else if (RCC_GetFlagStatus(RCC_FLAG_PINRST) != RESET)
{
pin_rst_flag = 1;
Write_Log("pin Reset\r\n");
}
else if(PWR_GetFlagStatus(PWR_FLAG_WU)!= RESET) //wakeup唤醒
{
Write_Log("WakeUp...\r\n");
}
if(PWR_GetFlagStatus(PWR_FLAG_SB) != RESET) //检查是否由待机模式下唤醒，如是则不需要配置RTC
/* System resumed from STANDBY mode */
/* Clear StandBy flag */
PWR_ClearFlag(PWR_FLAG_SB);
//清除RCC中复位标志
RCC_ClearFlag();
return;
}
void SystemClass::bootloader(void)
{
//Work in Progress
//The drawback here being it will enter bootloader mode until firmware
//is loaded again. Require bootloader changes for proper working.
BKP_WriteBackupRegister(BKP_DR10, 0xFFFF);
FLASH_OTA_Update_SysFlag = 0xFFFF;
Save_SystemFlags();
reset();
}
_fx uint32_t fx_generate_alarm_time(void)
{
uint32_t rtc_now, interval_time, fixed_time, wakeup_time;
uint8_t fixed_time_flag, fixed_cnt_now, fixed_totle_cnt, flash_read_len;
char *flash_read_buf;
uint32_t *ram_fixed_time;
uint16_t fixed_run_time;
rtc_now = RTC_GetCounter();
interval_time = rtc_now + (FX_SLEEP_INTERVAL - FX_INTERVAL_WAKEUP_TIME);
wakeup_time = interval_time;
fixed_time_flag = 0;
// fixed_totle_cnt = BKP_ReadBackupRegister(BKP_DR_FIXED_CNT_TOTLE);
fixed_cnt_now = BKP_ReadBackupRegister(BKP_DR_FIXED_CNT_NOW);
fixed_time = BKP_ReadBackupRegister(BKP_DR_FIXED_TIME_H);
fixed_time <<= 16;
fixed_time |= BKP_ReadBackupRegister(BKP_DR_FIXED_TIME_L);
if(fixed_time < rtc_now){
ax_flash_config_info_read(FLASH_SPACE_TYPE_FIXED_TIME,
&flash_read_buf, &flash_read_len);
fixed_cnt_now ++; // 当前时刻的下一时刻
ram_fixed_time = flash_read_buf[8]; // 定点时刻缓存头
ram_fixed_time += fixed_cnt_now << 2; // 指向下一定点时刻
fixed_totle_cnt = flash_read_buf[3];
while(fixed_cnt_now < fixed_totle_cnt){
if(*ram_fixed_time > fixed_cnt_now){
break;
}
fixed_cnt_now ++;
ram_fixed_time += 4;
}
BKP_WriteBackupRegister(BKP_DR_FIXED_CNT_NOW, (uint16_t)fixed_cnt_now);
if(fixed_cnt_now < fixed_totle_cnt){
fixed_time = *ram_fixed_time;
BKP_WriteBackupRegister(BKP_DR_FIXED_TIME_H,
(uint16_t)(fixed_time >> 16));
BKP_WriteBackupRegister(BKP_DR_FIXED_TIME_L, (uint16_t)(fixed_time));
fixed_run_time = (uint16_t)*(ram_fixed_time + fixed_totle_cnt);
BKP_WriteBackupRegister(BKP_DR_FIXED_RUN_TIME, fixed_run_time);
}
