/**
* @brief Callback function of the Settings dialog
* @param pMsg: pointer to a data structure of type WM_MESSAGE
* @retval None
*/
static void _cbDialogSettings(WM_MESSAGE * pMsg) {
WM_HWIN hItem;
int Id, NCode, idx;
static int8_t sec, min, hour;
static int8_t asec, amin, ahour;
static int8_t day, month, max_days;
static int16_t year;
SPINBOX_Handle hSpin;
DROPDOWN_Handle hDropMonth;
TEXT_Handle hText ;
static CALENDAR_DATE current_date;
RTC_TimeTypeDef RTC_TimeStructure;
RTC_DateTypeDef RTC_DateStructure;
static uint8_t TempStr[50];
switch (pMsg->MsgId) {
case WM_INIT_DIALOG:
/* Get Clock setting from RTC */
RTC_GetTime(RTC_Format_BIN, &RTC_TimeStructure);
sec = RTC_TimeStructure.RTC_Seconds;
min = RTC_TimeStructure.RTC_Minutes;
hour = RTC_TimeStructure.RTC_Hours;
RTC_GetAlarm(RTC_Format_BIN, RTC_Alarm_A, &RTC_AlarmStructure);
asec = RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds;
amin = RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes;
ahour = RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours;
RTC_GetDate(RTC_Format_BIN, &RTC_DateStructure);
year = RTC_DateStructure.RTC_Year + 2000;
month = RTC_DateStructure.RTC_Month;
day = RTC_DateStructure.RTC_Date;
max_days = GetMaxDays(month, year);
/* Update the dialog items */
hItem = pMsg->hWin;
FRAMEWIN_SetFont(hItem, GUI_FONT_13B_ASCII);
/* Date */
hText = TEXT_CreateEx(20, 20, 100, 25, pMsg->hWin, WM_CF_SHOW,0, 0x11F," Date : ");
TEXT_SetFont(hText, GUI_FONT_13B_ASCII);
TEXT_SetTextColor(hText, 0x00804000);
hSpin = SPINBOX_CreateEx(20, 35, 40, 18, pMsg->hWin, WM_CF_SHOW, ID_CLOCK_DAY, 1, max_days);
SPINBOX_SetFont(hSpin, GUI_FONT_13B_ASCII);
SPINBOX_SetTextColor(hSpin, SPINBOX_CI_ENABLED, 0x00804000);
SPINBOX_EnableBlink(hSpin, 250, 1);
SPINBOX_SetValue(hSpin, day);
hDropMonth = DROPDOWN_CreateEx(65, 35, 80, 160, pMsg->hWin, WM_CF_SHOW, 0, ID_CLOCK_MONTH);
DROPDOWN_SetFont(hDropMonth, GUI_FONT_13B_ASCII);
DROPDOWN_SetTextColor(hDropMonth, DROPDOWN_CI_UNSEL, 0x00804000);
DROPDOWN_SetTextColor(hDropMonth, DROPDOWN_CI_SEL, 0x00804000);
for (idx = 0; idx < 12; idx++ )
{
DROPDOWN_AddString (hDropMonth, (char *)strMonth[idx]);
}
DROPDOWN_SetSel(hDropMonth, month - 1);
hSpin = SPINBOX_CreateEx(150, 35, 50, 18, pMsg->hWin, WM_CF_SHOW, ID_CLOCK_YEAR, 2000, 2099);
SPINBOX_SetFont(hSpin, GUI_FONT_13B_ASCII);
SPINBOX_SetTextColor(hSpin, SPINBOX_CI_ENABLED, 0x00804000);
SPINBOX_EnableBlink(hSpin, 250, 1);
SPINBOX_SetValue(hSpin, year);
hItem = CHECKBOX_Create(205, 37, 20, 26, pMsg->hWin, ID_CLOCK_CHECK_DATE ,WM_CF_SHOW);
CHECKBOX_SetState(hItem, 1);
/* Time */
hText = TEXT_CreateEx(20, 50 + 20, 100, 25, pMsg->hWin, WM_CF_SHOW,0, 0x123," Time : ");
TEXT_SetFont(hText, GUI_FONT_13B_ASCII);
TEXT_SetTextColor(hText, 0x00804000);
hSpin = SPINBOX_CreateEx(20, 65 + 20, 40, 18, pMsg->hWin, WM_CF_SHOW, ID_CLOCK_HOUR, 0,23);
SPINBOX_SetFont(hSpin, GUI_FONT_13B_ASCII);
SPINBOX_SetTextColor(hSpin, SPINBOX_CI_ENABLED, 0x00804000);
SPINBOX_SetValue(hSpin, hour);
SPINBOX_EnableBlink(hSpin, 250, 1);
hSpin = SPINBOX_CreateEx(75, 65 + 20, 40, 18, pMsg->hWin, WM_CF_SHOW, ID_CLOCK_MIN, 0, 59);
SPINBOX_SetFont(hSpin, GUI_FONT_13B_ASCII);
SPINBOX_SetTextColor(hSpin, SPINBOX_CI_ENABLED, 0x00804000);
SPINBOX_SetValue(hSpin, min);
SPINBOX_EnableBlink(hSpin, 250, 1);
hSpin = SPINBOX_CreateEx(130, 65 + 20, 40, 18, pMsg->hWin, WM_CF_SHOW, ID_CLOCK_SEC, 0, 59);
SPINBOX_SetFont(hSpin, GUI_FONT_13B_ASCII);
SPINBOX_SetTextColor(hSpin, SPINBOX_CI_ENABLED, 0x00804000);
SPINBOX_SetValue(hSpin, sec);
SPINBOX_EnableBlink(hSpin, 250, 1);
hItem = CHECKBOX_Create(205, 65 + 20, 20, 26, pMsg->hWin, ID_CLOCK_CHECK_TIME ,WM_CF_SHOW);
CHECKBOX_SetState(hItem, 1);
/* Alarm */
hText = TEXT_CreateEx(20, 78 + 40, 100, 25, pMsg->hWin, WM_CF_SHOW,0, 0x126," Alarm : ");
TEXT_SetFont(hText, GUI_FONT_13B_ASCII);
TEXT_SetTextColor(hText, 0x00804000);
hSpin = SPINBOX_CreateEx(20, 93 + 40, 40, 18, pMsg->hWin, WM_CF_SHOW, ID_CLOCK_AHOUR, 0,23);
SPINBOX_SetFont(hSpin, GUI_FONT_13B_ASCII);
SPINBOX_SetTextColor(hSpin, SPINBOX_CI_ENABLED, 0x00804000);
SPINBOX_SetValue(hSpin, ahour);
SPINBOX_EnableBlink(hSpin, 250, 1);
hSpin = SPINBOX_CreateEx(75, 93 + 40, 40, 18, pMsg->hWin, WM_CF_SHOW, ID_CLOCK_AMIN, 0, 59);
SPINBOX_SetFont(hSpin, GUI_FONT_13B_ASCII);
SPINBOX_SetTextColor(hSpin, SPINBOX_CI_ENABLED, 0x00804000);
SPINBOX_SetValue(hSpin, amin);
SPINBOX_EnableBlink(hSpin, 250, 1);
hSpin = SPINBOX_CreateEx(130, 93 + 40, 40, 18, pMsg->hWin, WM_CF_SHOW, ID_CLOCK_ASEC, 0, 59);
SPINBOX_SetFont(hSpin, GUI_FONT_13B_ASCII);
SPINBOX_SetTextColor(hSpin, SPINBOX_CI_ENABLED, 0x00804000);
SPINBOX_SetValue(hSpin, asec);
hItem = CHECKBOX_Create(205, 93 + 40, 20, 26, pMsg->hWin, ID_CLOCK_CHECK_ALARM ,WM_CF_SHOW);
CHECKBOX_SetState(hItem, 1);
SPINBOX_EnableBlink(hSpin, 250, 1);
break;
case WM_NOTIFY_PARENT:
Id = WM_GetId(pMsg->hWinSrc);
NCode = pMsg->Data.v;
switch(Id) {
case ID_CLOSE_SETTINGS: /* Notifications sent by 'Close' */
switch(NCode) {
case WM_NOTIFICATION_RELEASED:
/* Exit */
GUI_EndDialog(pMsg->hWin, 0);
GUI_EndDialog (hNumPad, 0);
break;
}
break;
case ID_SET_SETTINGS: /* Notifications sent by 'Apply' */
switch(NCode) {
case WM_NOTIFICATION_RELEASED:
if(CHECKBOX_GetState( WM_GetDialogItem(WM_GetParent(pMsg->hWin), ID_CLOCK_CHECK_DATE)))
{
current_date.Year = year = SPINBOX_GetValue (WM_GetDialogItem(pMsg->hWin, ID_CLOCK_YEAR));
current_date.Month = month = DROPDOWN_GetSel (WM_GetDialogItem(pMsg->hWin, ID_CLOCK_MONTH)) + 1;
current_date.Day = day = SPINBOX_GetValue (WM_GetDialogItem(pMsg->hWin, ID_CLOCK_DAY));
RTC_DateStructure.RTC_Year = year - 2000;
RTC_DateStructure.RTC_Month = month;
RTC_DateStructure.RTC_Date = day;
RTC_DateStructure.RTC_WeekDay = 0;
RTC_SetDate(RTC_Format_BIN, &RTC_DateStructure);
hItem = WM_GetDialogItem(WM_GetParent(pMsg->hWin), ID_CALENDAR);
CALENDAR_SetDate(hItem, ¤t_date);
CALENDAR_SetSel(hItem, ¤t_date);
/* Date */
hItem = WM_GetDialogItem(WM_GetParent(pMsg->hWin), ID_TEXT_DATE);
sprintf((char *)TempStr, "%02d, %s, %04d",day , strMonth[month-1], year);
TEXT_SetText(hItem, (char *)TempStr);
}
if(CHECKBOX_GetState( WM_GetDialogItem(WM_GetParent(pMsg->hWin), ID_CLOCK_CHECK_TIME)))
{
/* Save new param in RTC */
sec = SPINBOX_GetValue (WM_GetDialogItem(pMsg->hWin, ID_CLOCK_SEC));
min = SPINBOX_GetValue (WM_GetDialogItem(pMsg->hWin, ID_CLOCK_MIN));
hour = SPINBOX_GetValue (WM_GetDialogItem(pMsg->hWin, ID_CLOCK_HOUR));
RTC_TimeStructure.RTC_Seconds = sec;
RTC_TimeStructure.RTC_Minutes = min;
RTC_TimeStructure.RTC_Hours = hour;
RTC_SetTime(RTC_Format_BIN, &RTC_TimeStructure);
}
if(CHECKBOX_GetState( WM_GetDialogItem(WM_GetParent(pMsg->hWin), ID_CLOCK_CHECK_ALARM)))
{
asec = SPINBOX_GetValue (WM_GetDialogItem(pMsg->hWin, ID_CLOCK_ASEC));
amin = SPINBOX_GetValue (WM_GetDialogItem(pMsg->hWin, ID_CLOCK_AMIN));
ahour = SPINBOX_GetValue (WM_GetDialogItem(pMsg->hWin, ID_CLOCK_AHOUR));
/* Disable the Alarm A */
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
/* Disable the RTC Alarm A Interrupt */
RTC_ITConfig(RTC_IT_ALRA, DISABLE);
STM_EVAL_LEDOff(LED4);
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = asec;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = amin;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = ahour;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmDateWeekDay = day;
RTC_SetAlarm(RTC_Format_BIN, RTC_Alarm_A, &RTC_AlarmStructure);
/* Enable the RTC Alarm A Interrupt */
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
/* Enable the alarm A */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
alarm_set = 1;
}
/* Exit */
WM_InvalidateWindow(WM_GetParent(pMsg->hWin));
GUI_EndDialog(pMsg->hWin, 0);
GUI_EndDialog (hNumPad, 0);
break;
}
break;
}
break;
default:
WM_DefaultProc(pMsg);
break;
}
}
/**
* @brief This function handles External line 10 to 15 interrupts request.
* @param None
* @retval None
*/
void EXTI15_10_IRQHandler(void)
{
if((EXTI_GetITStatus(KEY_BUTTON_EXTI_LINE) != RESET))
{
/* Set the LCD Back Color */
LCD_SetBackColor(White);
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
/* Enable the alarmA */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
/* Clear the LEFT EXTI pending bit */
EXTI_ClearITPendingBit(KEY_BUTTON_EXTI_LINE);
}
else if((EXTI_GetITStatus(TAMPER_BUTTON_EXTI_LINE) != RESET))
{
/* Disable the RTC Clock */
RCC_RTCCLKCmd(DISABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
/* Clear the TAMPER EXTI pending bit */
EXTI_ClearITPendingBit(TAMPER_BUTTON_EXTI_LINE);
}
}
static void RtcSetAlarmConfig( void )
{
EXTI_InitTypeDef EXTI_InitStructure;
RTC_AlarmTypeDef RTC_AlarmStructure;
NVIC_InitTypeDef NVIC_InitStructure;
/* EXTI configuration */
EXTI_ClearITPendingBit( EXTI_Line17 );
EXTI_InitStructure.EXTI_Line = EXTI_Line17;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init( &EXTI_InitStructure );
/* Enable the RTC Alarm Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = RTC_Alarm_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
//NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init( &NVIC_InitStructure );
/* Set the alarmA Masks */
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay;
RTC_SetAlarm( RTC_Format_BIN, RTC_Alarm_A, &RTC_AlarmStructure );
/* Enable AlarmA interrupt */
RTC_ITConfig( RTC_IT_ALRA, DISABLE );
/* Enable the alarmA */
RTC_AlarmCmd( RTC_Alarm_A, DISABLE );
}
/**
* @brief This function handles External line 10 to 15 interrupt request.
* @param None
* @retval None
*/
void EXTI15_10_IRQHandler(void)
{
if (EXTI_GetITStatus(SEL_BUTTON_EXTI_LINE) != RESET)
{
if(StartEvent == 8)
{
StartEvent = 0;
/* Enable the alarmA */
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
/* Clear the TAMPER EXTI pending bit */
EXTI_ClearITPendingBit(SEL_BUTTON_EXTI_LINE);
/* Displays MESSAGE4 on line 5 */
LCD_SetFont(&Font12x12);
/* Set the LCD Back Color */
LCD_SetBackColor(Blue);
LCD_SetTextColor(White);
LCD_DisplayStringLine(LINE(19), (uint8_t *)MESSAGE4);
LCD_SetFont(&Font16x24);
/* Set the LCD Text Color */
LCD_SetTextColor(Black);
}
else
{
/* Displays MESSAGE5 on line 5 */
LCD_SetFont(&Font12x12);
/* Set the LCD Back Color */
LCD_SetBackColor(Blue);
LCD_SetTextColor(White);
LCD_DisplayStringLine(LINE(19), (uint8_t *)MESSAGE5);
LCD_SetFont(&Font16x24);
/* Set the LCD Back Color */
LCD_SetBackColor(White);
/* Enable the alarmA */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
StartEvent = 8;
/* Clear the SEL EXTI pending bit */
EXTI_ClearITPendingBit(SEL_BUTTON_EXTI_LINE);
}
}
}
void TM_RTC_DisableAlarm(TM_RTC_Alarm_t Alarm) {
switch (Alarm) {
case TM_RTC_Alarm_A:
/* Disable Alarm A */
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
/* Disable Alarm A interrupt */
RTC_ITConfig(RTC_IT_ALRA, DISABLE);
/* Clear Alarm A pending bit */
RTC_ClearFlag(RTC_IT_ALRA);
break;
case TM_RTC_Alarm_B:
/* Disable Alarm B */
RTC_AlarmCmd(RTC_Alarm_B, DISABLE);
/* Disable Alarm B interrupt */
RTC_ITConfig(RTC_IT_ALRB, DISABLE);
/* Clear Alarm B pending bit */
RTC_ClearFlag(RTC_IT_ALRB);
break;
default:
break;
}
/* Clear RTC Alarm pending bit */
EXTI_ClearITPendingBit(EXTI_Line17);
/* Configure EXTI 17 as interrupt */
EXTI_InitStruct.EXTI_Line = EXTI_Line17;
EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStruct.EXTI_LineCmd = ENABLE;
/* Initialite Alarm EXTI interrupt */
EXTI_Init(&EXTI_InitStruct);
/* Configure the RTC Alarm Interrupt */
NVIC_InitStruct.NVIC_IRQChannel = RTC_Alarm_IRQn;
NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = RTC_PRIORITY;
NVIC_InitStruct.NVIC_IRQChannelSubPriority = RTC_ALARM_SUBPRIORITY;
NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
/* Initialize RTC Alarm Interrupt */
NVIC_Init(&NVIC_InitStruct);
}
void Set_Alarm_Time(uint8_t Sec)
{
uint32_t sec_time;
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
sec_time = Get_Time().Hour*3600 + Get_Time().Min*60 + Get_Time().Sec + Sec;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = (sec_time / 3600) % 24;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = (sec_time % 3600) / 60;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = sec_time % 60;
RTC_AlarmStructure.RTC_AlarmDateWeekDay = Get_Time().Day + (sec_time > 86400 ? 1 : 0);
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_None;
RTC_SetAlarm(RTC_Format_BIN, RTC_Alarm_A, &RTC_AlarmStructure);
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
RTC_ClearFlag(RTC_FLAG_ALRAF);
PWR_ClearFlag(PWR_FLAG_WU);
}
/**
* @brief This function handles RTC Alarm interrupt (A and B) request.
* @param None
* @retval None
*/
void RTC_Alarm_IRQHandler(void)
{
uint32_t tmp =0;
/* Check on the AlarmA falg and on the number of interrupts per Second (60*8) */
if(RTC_GetITStatus(RTC_IT_ALRA) != RESET)
{
/* Clear RTC AlarmA Flags */
RTC_ClearITPendingBit(RTC_IT_ALRA);
/* Generate alarms 480 = 60 * 8 */
if(RTCAlarmCount != (8 * SecondNumb))
{
/* Increament the counter of Alarma interrupts*/
RTCAlarmCount++;
/* Define the rate of Progress bar */
tmp = (uint32_t) ((RTCAlarmCount * 100)/ (8 * SecondNumb));
/* Set the LCD text color */
LCD_SetTextColor(Blue);
/* Set the LCD Font */
LCD_SetFont(&Font16x24);
/* Display Char on the LCD : XXX% */
LCD_DisplayChar(40,110, (tmp / 100) +0x30);
LCD_DisplayChar(40,88, ((tmp % 100 ) / 10) +0x30);
LCD_DisplayChar(40,66, (tmp % 10) +0x30);
LCD_DisplayChar(40,44, 0x25);
if(SecondNumb > 13)
{
if((tmp % 2) == 0 )
{
/* Set the LCD text color */
LCD_SetTextColor(White);
LCD_DrawLine(70 + (tmp/2) , 120 - (tmp/2) , 100 - tmp ,Horizontal);
LCD_DrawLine(170 - (tmp/2) , 120 - (tmp/2) , 100 - tmp ,Horizontal);
/* Set the LCD Text Color */
LCD_SetTextColor(Blue);
LCD_DrawLine(170 - (tmp/2) , 120 - (tmp/2) , 100 - tmp ,Horizontal);
}
}
}
else
{
StartEvent = 9;
/* Disable the alarmA */
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
}
}
/* Clear the EXTIL line 17 */
EXTI_ClearITPendingBit(EXTI_Line17);
}
/**
* @brief Configures the RTC Alarm.
* @param None
* @retval None
*/
static void RTC_AlarmConfig(void) {
EXTI_InitTypeDef EXTI_InitStructure;
RTC_AlarmTypeDef RTC_AlarmStructure;
NVIC_InitTypeDef NVIC_InitStructure;
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
//RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 ;
/* EXTI configuration */
EXTI_ClearITPendingBit(EXTI_Line17);
EXTI_InitStructure.EXTI_Line = EXTI_Line17;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
/* Enable the RTC Alarm Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = RTC_Alarm_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 7;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/* Set the alarm A Masks */
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_None;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_WeekDay;
//RTC_AlarmStructure.RTC_AlarmDateWeekDay = RTC_Weekday_Monday | RTC_Weekday_Tuesday | RTC_Weekday_Wednesday | RTC_Weekday_Thursday | RTC_Weekday_Friday;
RTC_AlarmStructure.RTC_AlarmDateWeekDay = (RTC_Weekday_Tuesday | RTC_Weekday_Sunday);
//RTC_AlarmStructure.RTC_AlarmDateWeekDay = RTC_Weekday_Wednesday;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = 0x00;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = 0x01;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = 0x00;
RTC_SetAlarm(RTC_Format_BCD, RTC_Alarm_A, &RTC_AlarmStructure);
/* Set alarm A sub seconds and enable SubSec Alarm : generate 8 interrupts per Second */
//RTC_AlarmSubSecondConfig(RTC_Alarm_A, 0xFF, RTC_AlarmSubSecondMask_SS14_5);
/* Enable the RTC Alarm A Interrupt */
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
/* Enable the alarm A */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
}
/**
* @brief This function handles External lines 9 to 5 interrupt request.
* @param None
* @retval None
*/
void EXTI15_10_IRQHandler(void)
{
if(EXTI_GetITStatus(KEY_BUTTON_EXTI_LINE) != RESET)
{
/* Clear the SEL Button EXTI line pending bit */
EXTI_ClearITPendingBit(KEY_BUTTON_EXTI_LINE);
/* Disable the Alarm A */
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
/* Disable RTC Alarm A Interrupt */
RTC_ITConfig(RTC_IT_ALRA, DISABLE);
/* Clear Power WakeUp (CWUF) pending flag */
PWR_ClearFlag(PWR_FLAG_WU);
RTC_GetTime(RTC_Format_BIN, &RTC_TimeStructure);
/* Set the alarm to current time + 5s */
RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_TimeStructure.RTC_H12;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = RTC_TimeStructure.RTC_Hours;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = RTC_TimeStructure.RTC_Minutes;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = (RTC_TimeStructure.RTC_Seconds + 0x5) % 60;
RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay | RTC_AlarmMask_Hours | RTC_AlarmMask_Minutes;
RTC_SetAlarm(RTC_Format_BIN, RTC_Alarm_A, &RTC_AlarmStructure);
/* Enable RTC Alarm A Interrupt: this Interrupt will wake-up the system from
STANDBY mode (RTC Alarm IT not enabled in NVIC) */
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
/* Enable the Alarm A */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
/* Clear RTC Alarm Flag */
RTC_ClearFlag(RTC_FLAG_ALRAF);
/* Request to enter STANDBY mode (Wake Up flag is cleared in PWR_EnterSTANDBYMode function) */
PWR_EnterSTANDBYMode();
}
}
void platform_mcu_enter_standby(uint32_t secondsToWakeup)
{
platform_rtc_time_t time;
uint32_t currentSecond;
RTC_AlarmTypeDef RTC_AlarmStructure;
PWR_WakeUpPinCmd(ENABLE);
if(secondsToWakeup == MICO_WAIT_FOREVER)
PWR_EnterSTANDBYMode();
platform_log("Wake up in %d seconds", secondsToWakeup);
platform_rtc_get_time(&time);
currentSecond = time.hr*3600 + time.min*60 + time.sec;
currentSecond += secondsToWakeup;
RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_HourFormat_24;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = currentSecond/3600%24;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = currentSecond/60%60;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = currentSecond%60;
RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay ;
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
/* Disable the Alarm A */
RTC_ITConfig(RTC_IT_ALRA, DISABLE);
/* Clear RTC Alarm Flag */
RTC_ClearFlag(RTC_FLAG_ALRAF);
RTC_SetAlarm(RTC_Format_BIN, RTC_Alarm_A, &RTC_AlarmStructure);
/* Enable RTC Alarm A Interrupt: this Interrupt will wake-up the system from
STANDBY mode (RTC Alarm IT not enabled in NVIC) */
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
/* Enable the Alarm A */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
PWR_EnterSTANDBYMode();
}
void EXTI9_5_IRQHandler(void)
#endif
{
if(EXTI_GetITStatus(SEL_BUTTON_EXTI_LINE) != RESET)
{
/* Clear the SEL Button EXTI line pending bit */
EXTI_ClearITPendingBit(SEL_BUTTON_EXTI_LINE);
/* Turn on LED1 */
STM_EVAL_LEDOn(LED1);
/* Disable the Alarm A */
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
RTC_GetTime(RTC_Format_BCD, &RTC_TimeStructure);
/* Set the alarm X+5s */
RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_TimeStructure.RTC_H12;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = RTC_TimeStructure.RTC_Hours;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = RTC_TimeStructure.RTC_Minutes;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = (RTC_TimeStructure.RTC_Seconds + 0x5) % 60;
RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay;
RTC_SetAlarm(RTC_Format_BCD, RTC_Alarm_A, &RTC_AlarmStructure);
/* Enable RTC Alarm A Interrupt */
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
/* Enable the Alarm A */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
/* Clear RTC Alarm A flag */
RTC_ClearFlag(RTC_FLAG_ALRAF);
/* Clear WakeUp flag */
PWR_ClearFlag(PWR_FLAG_WU);
/* Request to enter STANDBY mode (Wake Up flag is cleared in PWR_EnterSTANDBYMode function) */
PWR_EnterSTANDBYMode();
}
}
static void RtcClearStatus( void )
{
/* Clear RTC Alarm Flag */
RTC_ClearFlag(RTC_FLAG_ALRAF);
/* Enable RTC Alarm A Interrupt */
RTC_ITConfig( RTC_IT_ALRA, DISABLE );
/* Enable the Alarm A */
RTC_AlarmCmd( RTC_Alarm_A, DISABLE );
}
static int rtc_standbyUntil( lua_State* L )
{
RTC_AlarmTypeDef RTC_AlarmStructure;
mico_rtos_suspend_all_thread();
RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_HourFormat_24;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = luaL_checkinteger( L, 1 );
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = luaL_checkinteger( L, 2 );
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = luaL_checkinteger( L, 3 );
RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay ;
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
/* Disable the Alarm A */
RTC_ITConfig(RTC_IT_ALRA, DISABLE);
/* Clear RTC Alarm Flag */
RTC_ClearFlag(RTC_FLAG_ALRAF);
RTC_SetAlarm(RTC_Format_BIN, RTC_Alarm_A, &RTC_AlarmStructure);
/* Enable RTC Alarm A Interrupt: this Interrupt will wake-up the system from
STANDBY mode (RTC Alarm IT not enabled in NVIC) */
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
/* Enable the Alarm A */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
char buff[32];
sprintf(buff,"Wake up at %02d:%02d:%02d\r\n", RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours, RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes, RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds);
l_message(NULL,buff);
PWR_EnterSTANDBYMode();
mico_rtos_resume_all_thread();
lua_pushstring(L, "RETURN FROM STANDBY");
return 1;
}
static void set_alarm_time(void)
{
RTC_AlarmTypeDef RTC_AlarmStructure;
RTC_AlarmCmd(RTC_Alarm_A, DISABLE); /* disable before setting or cann't write */
/* set alarm time 8:30:0 everyday */
RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_H12_AM;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = 0x08;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = 0x30;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = 0x10;
RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31; // Nonspecific
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay; // Everyday
RTC_SetAlarm(RTC_Format_BCD, RTC_Alarm_A, &RTC_AlarmStructure);
/* Enable Alarm */
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
RTC_ClearFlag(RTC_FLAG_ALRAF);
}
/**
* @brief Configure gpio
*/
void WATER_Init(void)
{
// Enable GPIO clock
RCC_AHB1PeriphClockCmd(WATER_GPIO_CLOCK_PORT, ENABLE);
// Configure key pin to analog input
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = WATER_PIN_NUM;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_Init(WATER_PIN_PORT, &GPIO_InitStructure);
GPIO_SetBits(WATER_PIN_PORT, WATER_PIN_NUM);
// set default water time
m_waterTime.RTC_AlarmTime.RTC_H12 = RTC_H12_AM;
m_waterTime.RTC_AlarmTime.RTC_Hours = WATER_DEFAULT_HOUR;
m_waterTime.RTC_AlarmTime.RTC_Minutes = WATER_DEFAULT_MINUTE;
m_waterTime.RTC_AlarmTime.RTC_Seconds = WATER_DEFAULT_SECOND;
m_waterTime.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay;
RTC_SetAlarm(RTC_Format_BIN, RTC_Alarm_A, &m_waterTime);
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
m_period = WATER_DEFAULT_PERIOD;
m_moistureThreshold = WATER_DEFAULT_MOISTURE_THRESHOLD;
m_waterLock = xSemaphoreCreateMutex();
// Create that task that handles the console itself.
xTaskCreate( WATER_Task, /* The task that implements the command console. */
"WATER", /* Text name assigned to the task. This is just to assist debugging. The kernel does not use this name itself. */
WATER_TASK_STACK, /* The size of the stack allocated to the task. */
NULL, /* The parameter is not used, so NULL is passed. */
WATER_TASK_PRIORITY, /* The priority allocated to the task. */
&m_waterTask ); /* A handle is not required, so just pass NULL. */
#if SUPPORT_WATER_TEST_COMMAND
FreeRTOS_CLIRegisterCommand(&xWaterOpen);
#endif
}
void SetRTC_AlarmTime(void)
{
/* Set the alarm to current time + 5s */
RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_H12_AM;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = RTC_TimeStructure.RTC_Hours;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = RTC_TimeStructure.RTC_Minutes;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = RTC_TimeStructure.RTC_Seconds + 10;
RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay | RTC_AlarmMask_Minutes | RTC_AlarmMask_Hours;
RTC_SetAlarm(RTC_Format_BIN, RTC_Alarm_A, &RTC_AlarmStructure);
// Enable the RTC Alarm A interrupt
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
// Enable the alarm
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
// Clear the Alarm A Pending Bit
RTC_ClearITPendingBit(RTC_IT_ALRA);
}
/**
* @brief This function handles External line 0 interrupt request.
* @param None
* @retval None
*/
void EXTI0_IRQHandler(void)
{
if((EXTI_GetITStatus(WAKEUP_BUTTON_EXTI_LINE) != RESET))
{
/* Set the LCD Back Color */
LCD_SetBackColor(White);
/* Clear the LCD line 2 */
LCD_ClearLine(Line2);
/* Disable the RTC Clock */
RCC_RTCCLKCmd(DISABLE);
/* Reset Counter*/
uwRTCAlarmCount = 0;
/* Disable the alarm */
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
/* Set the LCD Back Color */
LCD_SetBackColor(White);
/* Display a Full rectangle on the LCD */
LCD_DrawFullRect(80, 290,240, 25 );
/* Set LCD text color */
LCD_SetTextColor(Red);
/* Display rectangle on the LCD */
LCD_DrawRect(80, 290, 25, 240 );
/* Clear the WAKEUP EXTI pending bit */
EXTI_ClearITPendingBit(WAKEUP_BUTTON_EXTI_LINE);
}
}
static void RTC_Config32768Internal(void) {
NVIC_InitTypeDef NVIC_InitStructure;
EXTI_InitTypeDef EXTI_InitStructure;
RTC_DateTypeDef RTC_DateStruct;
//uint8_t yr;
/* Enable the PWR clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
/* SYSCFG Peripheral clock enable */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
PWR_DeInit();
/* Allow access to RTC */
PWR_RTCAccessCmd(ENABLE);
/* LSI used as RTC source clock */
/* The RTC Clock may varies due to LSI frequency dispersion. */
/* Enable the LSI OSC */
//RCC_LSICmd(ENABLE);
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
RCC_LSEConfig(RCC_LSE_ON);
/* Wait till LSI is ready */
//while(RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET)
while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET) {
}
/* Select the RTC Clock Source */
//RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI);
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
// LSE 32768
RTC_InitStructure.RTC_AsynchPrediv = 127;
RTC_InitStructure.RTC_SynchPrediv = 255;
/* Calendar Configuration with LSI supposed at 37KHz */
//RTC_InitStructure.RTC_AsynchPrediv = 124;
//RTC_InitStructure.RTC_SynchPrediv = 295; /* (32KHz / 128) - 1 = 0xFF*/
RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24;
RTC_Init(&RTC_InitStructure);
/* Set the time to 05h 20mn 00s AM */
RTC_TimeStructure.RTC_H12 = RTC_H12_PM;
RTC_TimeStructure.RTC_Hours = 0x23;
RTC_TimeStructure.RTC_Minutes = 0x59;
RTC_TimeStructure.RTC_Seconds = 0x50;
RTC_SetTime(RTC_Format_BCD, &RTC_TimeStructure);
RTC_DateStruct.RTC_Year = 14;
RTC_DateStruct.RTC_Month = 10;
RTC_DateStruct.RTC_Date = 4;
RTC_DateStruct.RTC_WeekDay = 6;
//day = 5;
RTC_SetDate(RTC_Format_BIN, &RTC_DateStruct);
//RTC_GetDate(RTC_Format_BCD, &RTC_DateStruct);
//yr = RTC_DateStruct.RTC_Year;
/* EXTI configuration *******************************************************/
EXTI_ClearITPendingBit(EXTI_Line20);
EXTI_InitStructure.EXTI_Line = EXTI_Line20;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
// Configuring RTC_WakeUp interrupt
NVIC_InitStructure.NVIC_IRQChannel = RTC_WKUP_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
// RTC Wakeup Configuration
RTC_WakeUpClockConfig(RTC_WakeUpClock_CK_SPRE_16bits);
// RTC Set WakeUp Counter
RTC_SetWakeUpCounter(0);
// Enabling RTC_WakeUp interrupt
RTC_ITConfig(RTC_IT_WUT, ENABLE);
// Disabling Alarm Flags
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
RTC_AlarmCmd(RTC_Alarm_B, DISABLE);
// RTC Enable the Wakeup Function
RTC_WakeUpCmd(ENABLE);
}
//------------------------------------------------------------------------------
void rtc_init(void)
{
RTC_InitTypeDef initRtc;
RTC_AlarmTypeDef alarmRtc;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
PWR_BackupAccessCmd(ENABLE);
//RCC_BackupResetCmd(ENABLE);
//RCC_BackupResetCmd(DISABLE);
RCC_LSICmd(ENABLE);
while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET);
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI);
RCC_RTCCLKCmd(ENABLE);
if (RTC_WaitForSynchro() == ERROR) {
#ifdef USE_SERIAL
usart_str("E RTC 0\r\n");
#endif
}
initRtc.RTC_AsynchPrediv = 99; // LSI is 40kHz
initRtc.RTC_SynchPrediv = 399;
initRtc.RTC_HourFormat = RTC_HourFormat_24;
if (RTC_Init(&initRtc) == ERROR) {
#ifdef USE_SERIAL
usart_str("E RTC 1\r\n");
#endif
}
// Sets time
//
timeRtc.RTC_H12 = RTC_H12_AM;
timeRtc.RTC_Hours = 12;
timeRtc.RTC_Minutes = 00;
timeRtc.RTC_Seconds = 00;
if (RTC_SetTime(RTC_Format_BIN, &timeRtc)) {
#ifdef USE_SERIAL
usart_str("E RTC 2\r\n");
#endif
}
// Configure alarm
//
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
alarmRtc.RTC_AlarmTime.RTC_H12 = RTC_H12_AM;
alarmRtc.RTC_AlarmTime.RTC_Hours = 12;
alarmRtc.RTC_AlarmTime.RTC_Minutes = 00;
alarmRtc.RTC_AlarmTime.RTC_Seconds = 20;
alarmRtc.RTC_AlarmDateWeekDay = 0x31;
alarmRtc.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
alarmRtc.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay;
RTC_SetAlarm(RTC_Format_BIN, RTC_Alarm_A, &alarmRtc);
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32f30x.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f30x.c file
*/
/* LEDs Init */
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);
STM_EVAL_LEDInit(LED5);
STM_EVAL_LEDInit(LED6);
STM_EVAL_LEDInit(LED7);
STM_EVAL_LEDInit(LED8);
STM_EVAL_LEDInit(LED9);
STM_EVAL_LEDInit(LED10);
/* Enable PWR APB1 Clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
/* Allow access to Backup */
PWR_BackupAccessCmd(ENABLE);
/* Reset RTC Domain */
RCC_BackupResetCmd(ENABLE);
RCC_BackupResetCmd(DISABLE);
/* Allow access to RTC */
PWR_BackupAccessCmd(ENABLE);
/* The RTC Clock may varies due to LSI frequency dispersion */
/* 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);
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
/* RTC prescaler configuration */
RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24;
RTC_InitStructure.RTC_AsynchPrediv = 88;
RTC_InitStructure.RTC_SynchPrediv = 470;
RTC_Init(&RTC_InitStructure);
/* Set the alarm 01h:00min:04s */
RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_H12_AM;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = 0x01;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = 0x00;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = 0x04;
RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
/* Alarm mask hour, min and second:default Alarm generation each 1s */
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_All;
RTC_SetAlarm(RTC_Format_BCD, RTC_Alarm_A, &RTC_AlarmStructure);
/* Enable RTC Alarm A Interrupt */
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
/* Enable the alarm */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
/* Set the date: Wednesday August 15th 2012 */
RTC_DateStructure.RTC_Year = 12;
RTC_DateStructure.RTC_Month = RTC_Month_September;
RTC_DateStructure.RTC_Date = 11;
RTC_DateStructure.RTC_WeekDay = RTC_Weekday_Tuesday;
RTC_SetDate(RTC_Format_BCD, &RTC_DateStructure);
/* Set the time to 01h 00mn 00s AM */
RTC_TimeStructure.RTC_H12 = RTC_H12_AM;
RTC_TimeStructure.RTC_Hours = 0x01;
RTC_TimeStructure.RTC_Minutes = 0x00;
RTC_TimeStructure.RTC_Seconds = 0x00;
RTC_SetTime(RTC_Format_BCD, &RTC_TimeStructure);
RTC_ClearFlag(RTC_FLAG_ALRAF);
/* RTC Alarm A Interrupt Configuration */
/* EXTI configuration */
EXTI_ClearITPendingBit(EXTI_Line17);
EXTI_InitStructure.EXTI_Line = EXTI_Line17;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
/* Enable the RTC Alarm Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = RTC_Alarm_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/* Infinite loop */
while (1)
{
/* Get the RTC current Time */
RTC_GetTime(RTC_Format_BCD, &RTC_TimeStructure);
/* Get the RTC current Date */
RTC_GetDate(RTC_Format_BCD, &RTC_DateStructure);
/* Display time Format : hh:mm:ss */
// sprintf((char*)showtime,"%0.2d:%0.2d:%0.2d",RTC_TimeStructure.RTC_Hours, RTC_TimeStructure.RTC_Minutes, RTC_TimeStructure.RTC_Seconds);
/* Display date Format : mm-dd-yy */
//sprintf((char*)showdate,"%0.2d-%0.2d-%0.2d",RTC_DateStructure.RTC_Month, RTC_DateStructure.RTC_Date, 2000 + RTC_DateStructure.RTC_Year);
}
}
void TM_RTC_SetAlarm(TM_RTC_Alarm_t Alarm, TM_RTC_AlarmTime_t* DataTime, TM_RTC_Format_t format) {
RTC_AlarmTypeDef RTC_AlarmStruct;
/* Disable alarm first */
TM_RTC_DisableAlarm(Alarm);
/* Set RTC alarm settings */
/* Set alarm time */
RTC_AlarmStruct.RTC_AlarmTime.RTC_Hours = DataTime->hours;
RTC_AlarmStruct.RTC_AlarmTime.RTC_Minutes = DataTime->minutes;
RTC_AlarmStruct.RTC_AlarmTime.RTC_Seconds = DataTime->seconds;
RTC_AlarmStruct.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay;
/* Alarm type is every week the same day in a week */
if (DataTime->alarmtype == TM_RTC_AlarmType_DayInMonth) {
/* Alarm trigger every week the same day in a week */
RTC_AlarmStruct.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_WeekDay;
/* Week day can be between 1 and 7 */
if (DataTime->day == 0) {
RTC_AlarmStruct.RTC_AlarmDateWeekDay = 1;
} else if (DataTime->day > 7) {
RTC_AlarmStruct.RTC_AlarmDateWeekDay = 7;
} else {
RTC_AlarmStruct.RTC_AlarmDateWeekDay = DataTime->day;
}
} else { /* Alarm type is every month the same day */
/* Alarm trigger every month the same day in a month */
RTC_AlarmStruct.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
/* Month day can be between 1 and 31 */
if (DataTime->day == 0) {
RTC_AlarmStruct.RTC_AlarmDateWeekDay = 1;
} else if (DataTime->day > 31) {
RTC_AlarmStruct.RTC_AlarmDateWeekDay = 31;
} else {
RTC_AlarmStruct.RTC_AlarmDateWeekDay = DataTime->day;
}
}
switch (Alarm) {
case TM_RTC_Alarm_A:
/* Configure the RTC Alarm A */
RTC_SetAlarm(format, RTC_Alarm_A, &RTC_AlarmStruct);
/* Enable Alarm A */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
/* Enable Alarm A interrupt */
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
/* Clear Alarm A pending bit */
RTC_ClearFlag(RTC_IT_ALRA);
break;
case TM_RTC_Alarm_B:
/* Configure the RTC Alarm B */
RTC_SetAlarm(format, RTC_Alarm_B, &RTC_AlarmStruct);
/* Enable Alarm B */
RTC_AlarmCmd(RTC_Alarm_B, ENABLE);
/* Enable Alarm B interrupt */
RTC_ITConfig(RTC_IT_ALRB, ENABLE);
/* Clear Alarm B pending bit */
RTC_ClearFlag(RTC_IT_ALRB);
break;
default:
break;
}
}
static void RtcStartWakeUpAlarm( uint32_t timeoutValue )
{
uint16_t rtcSeconds = 0;
uint16_t rtcMinutes = 0;
uint16_t rtcHours = 0;
uint16_t rtcDays = 0;
uint8_t rtcAlarmSeconds = 0;
uint8_t rtcAlarmMinutes = 0;
uint8_t rtcAlarmHours = 0;
uint16_t rtcAlarmDays = 0;
RTC_AlarmTypeDef RTC_AlarmStructure;
RTC_TimeTypeDef RTC_TimeStruct;
RTC_DateTypeDef RTC_DateStruct;
RtcClearStatus( );
RtcTimerContext = RtcGetCalendarValue( );
RTC_GetTime( RTC_Format_BIN, &RTC_TimeStruct );
RTC_GetDate( RTC_Format_BIN, &RTC_DateStruct );
timeoutValue = timeoutValue / RTC_ALARM_TIME_BASE;
if( timeoutValue > 2160000 ) // 25 "days" in tick
{ // drastically reduce the computation time
rtcAlarmSeconds = RTC_TimeStruct.RTC_Seconds;
rtcAlarmMinutes = RTC_TimeStruct.RTC_Minutes;
rtcAlarmHours = RTC_TimeStruct.RTC_Hours;
rtcAlarmDays = 25 + RTC_DateStruct.RTC_Date; // simply add 25 days to current date and time
if( ( RTC_DateStruct.RTC_Year == 0 ) || ( RTC_DateStruct.RTC_Year % 4 == 0 ) )
{
if( rtcAlarmDays > DaysInMonthLeapYear[ RTC_DateStruct.RTC_Month - 1 ] )
{
rtcAlarmDays = rtcAlarmDays % DaysInMonthLeapYear[ RTC_DateStruct.RTC_Month - 1];
}
}
else
{
if( rtcAlarmDays > DaysInMonth[ RTC_DateStruct.RTC_Month - 1 ] )
{
rtcAlarmDays = rtcAlarmDays % DaysInMonth[ RTC_DateStruct.RTC_Month - 1];
}
}
}
else
{
rtcSeconds = ( timeoutValue % SecondsInMinute ) + RTC_TimeStruct.RTC_Seconds;
rtcMinutes = ( ( timeoutValue / SecondsInMinute ) % SecondsInMinute ) + RTC_TimeStruct.RTC_Minutes;
rtcHours = ( ( timeoutValue / SecondsInHour ) % HoursInDay ) + RTC_TimeStruct.RTC_Hours;
rtcDays = ( timeoutValue / SecondsInDay ) + RTC_DateStruct.RTC_Date;
rtcAlarmSeconds = ( rtcSeconds ) % 60;
rtcAlarmMinutes = ( ( rtcSeconds / 60 ) + rtcMinutes ) % 60;
rtcAlarmHours = ( ( ( ( rtcSeconds / 60 ) + rtcMinutes ) / 60 ) + rtcHours ) % 24;
rtcAlarmDays = ( ( ( ( ( rtcSeconds / 60 ) + rtcMinutes ) / 60 ) + rtcHours ) / 24 ) + rtcDays;
if( ( RTC_DateStruct.RTC_Year == 0 ) || ( RTC_DateStruct.RTC_Year % 4 == 0 ) )
{
if( rtcAlarmDays > DaysInMonthLeapYear[ RTC_DateStruct.RTC_Month - 1 ] )
{
rtcAlarmDays = rtcAlarmDays % DaysInMonthLeapYear[ RTC_DateStruct.RTC_Month - 1 ];
}
}
else
{
if( rtcAlarmDays > DaysInMonth[ RTC_DateStruct.RTC_Month - 1 ] )
{
rtcAlarmDays = rtcAlarmDays % DaysInMonth[ RTC_DateStruct.RTC_Month - 1 ];
}
}
}
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = rtcAlarmSeconds;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = rtcAlarmMinutes;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = rtcAlarmHours;
RTC_AlarmStructure.RTC_AlarmDateWeekDay = ( uint8_t )rtcAlarmDays;
RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_TimeStruct.RTC_H12;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_None;
RTC_SetAlarm( RTC_Format_BIN, RTC_Alarm_A, &RTC_AlarmStructure );
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro( );
/* Enable RTC Alarm A Interrupt */
RTC_ITConfig( RTC_IT_ALRA, ENABLE );
/* Enable the Alarm A */
RTC_AlarmCmd( RTC_Alarm_A, ENABLE );
}
/**
* @brief Configure the RTC peripheral by selecting the clock source.
* @param None
* @retval None
*/
void RTC_Config(void) {
RTC_DateTypeDef RTC_DateStructure;
RTC_TimeTypeDef RTC_TimeStructure;
RTC_InitTypeDef RTC_InitStructure;
RTC_AlarmTypeDef RTC_AlarmStructure;
/* Enable the PWR clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
/* Allow access to RTC */
PWR_BackupAccessCmd(ENABLE);
#if defined (RTC_CLOCK_SOURCE_LSI) /* LSI used as RTC source clock*/
/* The RTC Clock may varies due to LSI frequency dispersion */
/* 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);
/* ck_spre(1Hz) = RTCCLK(LSI) /(uwAsynchPrediv + 1)*(uwSynchPrediv + 1)*/
uwSynchPrediv = 0xFF;
uwAsynchPrediv = 0x7F;
printf("\r\n * LSI used as RTC source clock");
#elif defined (RTC_CLOCK_SOURCE_LSE) /* LSE used as RTC source clock */
/* Enable the LSE OSC */
RCC_LSEConfig(RCC_LSE_ON);
/* Wait till LSE is ready */
while(RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET);
/* Select the RTC Clock Source */
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
/* ck_spre(1Hz) = RTCCLK(LSE) /(uwAsynchPrediv + 1)*(uwSynchPrediv + 1)*/
uwSynchPrediv = 0xFF;
uwAsynchPrediv = 0x7F;
printf("\r\n * LSE used as RTC source clock");
#else
#error Please select the RTC Clock source inside the main.c file
#endif /* RTC_CLOCK_SOURCE_LSI */
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
/* Configure the RTC data register and RTC prescaler */
RTC_InitStructure.RTC_AsynchPrediv = uwAsynchPrediv;
RTC_InitStructure.RTC_SynchPrediv = uwSynchPrediv;
RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24;
RTC_Init(&RTC_InitStructure);
/* Set the alarm 00h:00min:00s */
RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_H12_AM;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = 0x00;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = 0x00;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = 0x00;
RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay;
/* Configure the RTC Alarm A register */
RTC_SetAlarm(RTC_Format_BCD, RTC_Alarm_A, &RTC_AlarmStructure);
/* Configure the RTC WakeUp Clock source: CK_SPRE (1Hz) */
RTC_WakeUpClockConfig(RTC_WakeUpClock_CK_SPRE_16bits);
RTC_SetWakeUpCounter(0x0);
/* Enable RTC Wakeup and RTC Alarm A Interrupt */
RTC_ITConfig(RTC_IT_WUT | RTC_IT_ALRA, ENABLE);
/* Enable Wakeup Counter */
RTC_WakeUpCmd(ENABLE);
/* Enable the alarm */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
RTC_ClearFlag(RTC_FLAG_ALRAF);
/* Set the date: Saturday April 20th 2013 */
RTC_DateStructure.RTC_Year = 0x13;
RTC_DateStructure.RTC_Month = RTC_Month_April;
RTC_DateStructure.RTC_Date = 0x14;
RTC_DateStructure.RTC_WeekDay = RTC_Weekday_Saturday;
RTC_SetDate(RTC_Format_BCD, &RTC_DateStructure);
/* Set the time to 00h 00mn 00s AM */
RTC_TimeStructure.RTC_H12 = RTC_H12_AM;
RTC_TimeStructure.RTC_Hours = 0x00;
RTC_TimeStructure.RTC_Minutes = 0x00;
RTC_TimeStructure.RTC_Seconds = 0x00;
RTC_SetTime(RTC_Format_BCD, &RTC_TimeStructure);
/* Indicator for the RTC configuration */
RTC_WriteBackupRegister(RTC_BKP_DR0, 0x32F2);
}
//====================================
static int rtc_standby( lua_State* L )
{
char buff[60];
uint8_t mode = luaL_checkinteger( L, 1 );
if (mode > 1) {
l_message( NULL, "mode has to be 0 or 1" );
return 0;
}
if (mode==1 && use_wwdg == 0) {
l_message(NULL,"IWDG active, cannot enter STOP mode.");
return 0;
}
int nsec = luaL_checkinteger( L, 2 );
if ((nsec < 1) || (nsec > 84559)) {
l_message(NULL,"wrong interval (1~84599)");
return 0;
}
TM_RTC_DisableAlarm(TM_RTC_Alarm_A);
TM_RTC_DisableAlarm(TM_RTC_Alarm_B);
platform_rtc_time_t time;
uint32_t currentSecond;
RTC_AlarmTypeDef RTC_AlarmStructure;
platform_rtc_get_time(&time);
currentSecond = time.hr*3600 + time.min*60 + time.sec;
currentSecond += nsec;
RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_HourFormat_24;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = currentSecond/3600%24;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = currentSecond/60%60;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = currentSecond%60;
RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay ;
RTC_SetAlarm(RTC_Format_BIN, RTC_Alarm_A, &RTC_AlarmStructure);
// Enable RTC Alarm A Interrupt
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
// Enable the Alarm A
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
/* Clear Alarm A pending bit */
/* Clear RTC Alarm Flag */
RTC_ClearFlag(RTC_FLAG_ALRAF);
RTC_ClearFlag(RTC_IT_ALRA);
if (mode == 0) sprintf(buff,"Going to STANDBY MODE...\r\n");
else if (mode == 1) sprintf(buff,"Going to STOP MODE...\r\n");
l_message(NULL,buff);
sprintf(buff,"Wake up in %d second(s)\r\n", nsec);
l_message(NULL,buff);
//mico_rtos_suspend_all_thread();
if (mode == 0) {
PWR_EnterSTANDBYMode();
// RESET
}
else if (mode == 1) {
PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
// restore clocks
init_clocks();
}
//mico_rtos_resume_all_thread();
// *** Back from stop ***
TM_RTC_DisableAlarm(TM_RTC_Alarm_A);
TM_RTC_DisableAlarm(TM_RTC_Alarm_B);
luaWdgReload();
l_message(NULL,"Back from power save mode.");
return 0;
}
//=========================================
static int rtc_standbyUntil( lua_State* L )
{
uint8_t h,m,s;
RTC_AlarmTypeDef RTC_AlarmStructure;
char buff[64];
uint8_t mode = luaL_checkinteger( L, 1 );
if (mode > 1) {
l_message( NULL, "mode has to be 0 or 1" );
return 0;
}
if (mode==1 && use_wwdg == 0) {
l_message(NULL,"IWDG active, cannot enter STOP mode.");
return 0;
}
if (!lua_istable(L, 2)) {
l_message( NULL, "table arg needed" );
return 0;
}
if (lua_objlen( L, 2 ) != 3) {
l_message( NULL, "hour,minute,second expected" );
return 0;
}
lua_rawgeti( L, 2, 1 );
h = ( int )luaL_checkinteger( L, -1 );
lua_pop( L, 1 );
lua_rawgeti( L, 2, 2 );
m = ( int )luaL_checkinteger( L, -1 );
lua_pop( L, 1 );
lua_rawgeti( L, 2, 3 );
s = ( int )luaL_checkinteger( L, -1 );
lua_pop( L, 1 );
TM_RTC_DisableAlarm(TM_RTC_Alarm_A);
TM_RTC_DisableAlarm(TM_RTC_Alarm_B);
RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_HourFormat_24;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = h;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = m;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = s;
RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay ;
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
/* Disable the Alarm A */
RTC_ITConfig(RTC_IT_ALRA, DISABLE);
/* Clear RTC Alarm Flag */
RTC_ClearFlag(RTC_FLAG_ALRAF);
RTC_ClearFlag(RTC_IT_ALRA);
RTC_SetAlarm(RTC_Format_BIN, RTC_Alarm_A, &RTC_AlarmStructure);
/* Enable RTC Alarm A Interrupt: this Interrupt will wake-up the system from
STANDBY mode (RTC Alarm IT not enabled in NVIC) */
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
/* Enable the Alarm A */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
if (mode == 0) sprintf(buff,"Going to STANDBY MODE...\r\n");
else if (mode == 1) sprintf(buff,"Going to STOP MODE...\r\n");
l_message(NULL,buff);
sprintf(buff,"Wake up at %02d:%02d:%02d\r\n", RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours, RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes, RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds);
l_message(NULL,buff);
//mico_rtos_suspend_all_thread();
if (mode == 0) {
PWR_EnterSTANDBYMode();
}
else if (mode == 1) {
PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
init_clocks();
}
//mico_rtos_resume_all_thread();
// *** Back from stop ***
TM_RTC_DisableAlarm(TM_RTC_Alarm_A);
TM_RTC_DisableAlarm(TM_RTC_Alarm_B);
luaWdgReload();
l_message(NULL,"Back from power save mode.");
return 0;
}
/**
* @brief This function handles External lines 9 to 5 interrupt request.
* @param None
* @retval None
*/
void EXTI9_5_IRQHandler(void)
{
uint32_t tmp = 0, tmp1 = 0;
uint8_t index = 0;
if((EXTI_GetITStatus(LEFT_BUTTON_EXTI_LINE) != RESET) )
{
/* Set the LCD Back Color */
LCD_SetBackColor(White);
StartEvent = 0;
/* Reset Counter*/
RTCAlarmCount = 0;
/* Disable the alarm */
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
/* Display Char on the LCD : XXX% */
LCD_DisplayChar(40,110,0x30);
LCD_DisplayChar(40,88, 0x30);
LCD_DisplayChar(40,66, 0x30);
LCD_DisplayChar(40,44, 0x25);
for (index = 0; index < 100 ; index++)
{
if ((index % 2) ==0)
{
/* Set the LCD Text Color */
LCD_SetTextColor(Blue);
LCD_DrawLine(70 + (index/2) , 120 - (index/2) , 101 - (index + 1) ,Horizontal);
/* Set the LCD Text Color */
LCD_SetTextColor(White);
LCD_DrawLine(170 - (index/2) , 120 - (index/2) , 101 - (index + 1) ,Horizontal);
}
}
/* Displays MESSAGE6 on line 5 */
LCD_SetFont(&Font12x12);
/* Set the LCD Back Color */
LCD_SetBackColor(Blue);
LCD_SetTextColor(White);
LCD_DisplayStringLine(LINE(19), (uint8_t *)MESSAGE6);
LCD_SetFont(&Font16x24);
/* Set the LCD Text Color */
LCD_SetTextColor(Black);
/* Clear the LEFT EXTI pending bit */
EXTI_ClearITPendingBit(LEFT_BUTTON_EXTI_LINE);
}
else if (EXTI_GetITStatus(RIGHT_BUTTON_EXTI_LINE) != RESET)
{
if(StartEvent == 8)
{
StartEvent = 0;
/* Enable the alarmA */
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
/* Clear the TAMPER EXTI pending bit */
EXTI_ClearITPendingBit(RIGHT_BUTTON_EXTI_LINE);
/* Displays MESSAGE4 on line 5 */
LCD_SetFont(&Font12x12);
/* Set the LCD Back Color */
LCD_SetBackColor(Blue);
LCD_SetTextColor(White);
LCD_DisplayStringLine(LINE(19), (uint8_t *)MESSAGE4);
LCD_SetFont(&Font16x24);
/* Set the LCD Text Color */
LCD_SetTextColor(Black);
}
else
{
/* Displays MESSAGE5 on line 5 */
LCD_SetFont(&Font12x12);
/* Set the LCD Back Color */
LCD_SetBackColor(Blue);
LCD_SetTextColor(White);
LCD_DisplayStringLine(LINE(19), (uint8_t *)MESSAGE5);
LCD_SetFont(&Font16x24);
/* Set the LCD Back Color */
LCD_SetBackColor(White);
/* Enable the alarmA */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
StartEvent = 8;
/* Clear the LEFT EXTI pending bit */
EXTI_ClearITPendingBit(RIGHT_BUTTON_EXTI_LINE);
}
}
else if(EXTI_GetITStatus(DOWN_BUTTON_EXTI_LINE) != RESET)
{
if(RTCAlarmCount == 0)
{
SecondNumb--;
if(SecondNumb < 15) SecondNumb = 15;
tmp = (uint32_t) (SecondNumb/60);
tmp1 = SecondNumb -(tmp*60);
LCD_SetFont(&Font16x24);
/* Set the LCD text color */
LCD_SetTextColor(Blue);
/* Set the LCD Back Color */
LCD_SetBackColor(White);
LCD_DisplayStringLine(95, " ");
/* Display Char on the LCD : XXX% */
LCD_DisplayChar(95,294, (tmp / 10) +0x30);
LCD_DisplayChar(95,278, (tmp % 10 ) +0x30);
LCD_DisplayChar(95,262, ':');
LCD_DisplayChar(95,246, (tmp1 / 10) +0x30);
LCD_DisplayChar(95,230, (tmp1 % 10 ) +0x30);
}
/* Clear the LEFT EXTI pending bit */
EXTI_ClearITPendingBit(DOWN_BUTTON_EXTI_LINE);
/* Clear the EXTI Line 8 */
EXTI_ClearITPendingBit(EXTI_Line8);
}
}
/**
* @brief This function configures the system to enter Stop mode with RTC
* clocked by LSI for current consumption measurement purpose.
* STOP Mode with RTC clocked by LSI
* =====================================
* - RTC Clocked by LSI
* - Regulator in LP mode
* - HSI, HSE OFF and LSI OFF if not used as RTC Clock source
* - No IWDG
* - FLASH in deep power down mode
* - Automatic Wakeup using RTC clocked by LSI (~5s)
* @param None
* @retval None
*/
void StopMode_Measure(void)
{
__IO uint32_t index = 0;
GPIO_InitTypeDef GPIO_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
EXTI_InitTypeDef EXTI_InitStructure;
RTC_InitTypeDef RTC_InitStructure;
RTC_TimeTypeDef RTC_TimeStructure;
RTC_AlarmTypeDef RTC_AlarmStructure;
/* Allow access to RTC */
PWR_BackupAccessCmd(ENABLE);
/* The RTC Clock may varies due to LSI frequency dispersion. */
/* 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);
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
/* Configure all GPIO as analog to reduce current consumption on non used IOs */
/* Enable GPIOs clock */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA | RCC_AHBPeriph_GPIOB | RCC_AHBPeriph_GPIOC |
RCC_AHBPeriph_GPIOD | RCC_AHBPeriph_GPIOF , ENABLE);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
GPIO_Init(GPIOC, &GPIO_InitStructure);
GPIO_Init(GPIOD, &GPIO_InitStructure);
GPIO_Init(GPIOF, &GPIO_InitStructure);
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* Disable GPIOs clock */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA |RCC_AHBPeriph_GPIOB | RCC_AHBPeriph_GPIOC |
RCC_AHBPeriph_GPIOD | RCC_AHBPeriph_GPIOF, DISABLE);
RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24;
RTC_InitStructure.RTC_AsynchPrediv = 0x7F;
RTC_InitStructure.RTC_SynchPrediv = 0x0138;
if (RTC_Init(&RTC_InitStructure) == ERROR)
{
while(1);
}
/* EXTI configuration */
EXTI_ClearITPendingBit(EXTI_Line17);
EXTI_InitStructure.EXTI_Line = EXTI_Line17;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
/* NVIC configuration */
NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/* Set the alarm X+5s */
RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_H12_AM;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = 0x01;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = 0x00;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = 0x05;
RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay;
RTC_SetAlarm(RTC_Format_BCD, RTC_Alarm_A, &RTC_AlarmStructure);
/* Enable the alarm */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
/* Enable the RTC Alarm A interrupt */
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
/* Set the time to 01h 00mn 00s AM */
RTC_TimeStructure.RTC_H12 = RTC_H12_AM;
RTC_TimeStructure.RTC_Hours = 0x01;
RTC_TimeStructure.RTC_Minutes = 0x00;
RTC_TimeStructure.RTC_Seconds = 0x00;
RTC_SetTime(RTC_Format_BCD, &RTC_TimeStructure);
/* Clear the Alarm A Pending Bit */
RTC_ClearITPendingBit(RTC_IT_ALRA);
/* Enter Stop Mode */
PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
/* Initialize LED4 on STM320518-EVAL board */
STM_EVAL_LEDInit(LED4);
/* Infinite loop */
while (1)
{
/* Toggle The LED4 */
STM_EVAL_LEDToggle(LED4);
/* Inserted Delay */
for(index = 0; index < 0x5FFFF; index++);
}
}
/**
* @brief Configures the RTC clock source.
* @param None
* @retval None
*/
void RTC_Config(void)
{
RTC_InitTypeDef RTC_InitStructure;
RTC_AlarmTypeDef RTC_AlarmStructure;
RTC_TimeTypeDef RTC_TimeStructure;
/* Enable the PWR clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
/* Allow access to Backup Domain */
PWR_BackupAccessCmd(ENABLE);
/* Check if the StandBy flag is set */
if (PWR_GetFlagStatus(PWR_FLAG_SB) != RESET)
{
/* Clear StandBy flag */
PWR_ClearFlag(PWR_FLAG_SB);
/* Check if the StandBy flag is cleared */
if (PWR_GetFlagStatus(PWR_FLAG_SB) != RESET)
{
while(1);
}
RTC_WaitForSynchro();
/* No need to configure the RTC as the RTC config(clock source, enable,
prescaler,...) are kept after wake-up from STANDBY */
}
else
{
/* RTC Configuration ******************************************************/
/* Reset Backup Domain */
RCC_BackupResetCmd(ENABLE);
RCC_BackupResetCmd(DISABLE);
/* 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);
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24;
RTC_InitStructure.RTC_AsynchPrediv = 0x7F;
RTC_InitStructure.RTC_SynchPrediv = 0x0138;
RTC_Init(&RTC_InitStructure);
/* Set the alarm X+5s */
RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_H12_AM;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = 0x01;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = 0x00;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = 0x3;
RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay;
RTC_SetAlarm(RTC_Format_BCD, RTC_Alarm_A, &RTC_AlarmStructure);
/* Enable RTC Alarm A Interrupt */
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
/* Enable the alarm */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
}
/* Set the time to 01h 00mn 00s AM */
RTC_TimeStructure.RTC_H12 = RTC_H12_AM;
RTC_TimeStructure.RTC_Hours = 0x01;
RTC_TimeStructure.RTC_Minutes = 0x00;
RTC_TimeStructure.RTC_Seconds = 0x00;
RTC_SetTime(RTC_Format_BCD, &RTC_TimeStructure);
/* Clear Wakeup flag */
PWR_ClearFlag(PWR_FLAG_WU);
RTC_ClearFlag(RTC_FLAG_ALRAF);
/* Request to enter STANDBY mode (Wake Up flag is cleared in PWR_EnterSTANDBYMode function) */
PWR_EnterSTANDBYMode();
}
/**
* @brief Returns the time entered by user, using Hyperterminal.
* @param None
* @retval None
*/
void RTC_TimeRegulate(void)
{
uint32_t tmp_hh = 0xFF, tmp_mm = 0xFF, tmp_ss = 0xFF;
printf("\n\r==============Time Settings=====================================\n\r");
RTC_TimeStructure.RTC_H12 = RTC_H12_AM;
printf(" Please Set Hours:\n\r");
while (tmp_hh == 0xFF)
{
tmp_hh = USART_Scanf(23);
RTC_TimeStructure.RTC_Hours = tmp_hh;
}
printf(" %u\n\r", tmp_hh);
printf(" Please Set Minutes:\n\r");
while (tmp_mm == 0xFF)
{
tmp_mm = USART_Scanf(59);
RTC_TimeStructure.RTC_Minutes = tmp_mm;
}
printf(" %0.2d\n\r", tmp_mm);
printf(" Please Set Seconds:\n\r");
while (tmp_ss == 0xFF)
{
tmp_ss = USART_Scanf(59);
RTC_TimeStructure.RTC_Seconds = tmp_ss;
}
printf(" %0.2d\n\r", tmp_ss);
/* Configure the RTC time register */
if(RTC_SetTime(RTC_Format_BIN, &RTC_TimeStructure) == ERROR)
{
printf("\n\r>> !! RTC Set Time failed. !! <<\n\r");
}
else
{
printf("\n\r>> !! RTC Set Time success. !! <<\n\r");
RTC_TimeShow();
/* Indicator for the RTC configuration */
RTC_WriteBackupRegister(RTC_BKP_DR0, 0x32F2);
}
tmp_hh = 0xFF;
tmp_mm = 0xFF;
tmp_ss = 0xFF;
/* Disable the Alarm A */
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
printf("\n\r==============Alarm A Settings=====================================\n\r");
RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_H12_AM;
printf(" Please Set Alarm Hours:\n\r");
while (tmp_hh == 0xFF)
{
tmp_hh = USART_Scanf(23);
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = tmp_hh;
}
printf(" %0.2d\n\r", tmp_hh);
printf(" Please Set Alarm Minutes:\n\r");
while (tmp_mm == 0xFF)
{
tmp_mm = USART_Scanf(59);
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = tmp_mm;
}
printf(" %0.2d\n\r", tmp_mm);
printf(" Please Set Alarm Seconds:\n\r");
while (tmp_ss == 0xFF)
{
tmp_ss = USART_Scanf(59);
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = tmp_ss;
}
printf(" %0.2d", tmp_ss);
/* Set the Alarm A */
RTC_AlarmStructure.RTC_AlarmDateWeekDay = RTC_Weekday_Monday;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay;
/* Configure the RTC Alarm A register */
RTC_SetAlarm(RTC_Format_BIN, RTC_Alarm_A, &RTC_AlarmStructure);
printf("\n\r>> !! RTC Set Alarm success. !! <<\n\r");
RTC_AlarmShow();
/* Enable the RTC Alarm A Interrupt */
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
/* Enable the alarm A */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
}
/**
* @brief This function configures the system to enter Standby mode with RTC
* clocked by LSI for current consumption measurement purpose.
* STANDBY Mode with RTC clocked by LSI
* ========================================
* - RTC Clocked by LSI
* - IWDG OFF
* - Automatic Wakeup using RTC
* @param None
* @retval None
*/
void StandbyRTCMode_Measure(void)
{
RTC_InitTypeDef RTC_InitStructure;
RTC_AlarmTypeDef RTC_AlarmStructure;
RTC_TimeTypeDef RTC_TimeStructure;
/* Allow access to RTC */
PWR_BackupAccessCmd(ENABLE);
/* The RTC Clock may varies due to LSI frequency dispersion. */
/* 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);
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24;
RTC_InitStructure.RTC_AsynchPrediv = 0x7F;
RTC_InitStructure.RTC_SynchPrediv = 0x0138;
RTC_Init(&RTC_InitStructure);
/* Set the alarm X+5s */
RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_H12_AM;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = 0x01;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = 0x00;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = 0x08;
RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay;
RTC_SetAlarm(RTC_Format_BCD, RTC_Alarm_A, &RTC_AlarmStructure);
/* Enable RTC Alarm A Interrupt */
RTC_ITConfig(RTC_IT_ALRA, ENABLE);
/* Enable the alarm */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
/* Set the time to 01h 00mn 00s AM */
RTC_TimeStructure.RTC_H12 = RTC_H12_AM;
RTC_TimeStructure.RTC_Hours = 0x01;
RTC_TimeStructure.RTC_Minutes = 0x00;
RTC_TimeStructure.RTC_Seconds = 0x00;
RTC_SetTime(RTC_Format_BCD, &RTC_TimeStructure);
/* Clear Wakeup flag */
PWR_ClearFlag(PWR_FLAG_WU);
RTC_ClearFlag(RTC_FLAG_ALRAF);
/* Request to enter STANDBY mode (Wake Up flag is cleared in PWR_EnterSTANDBYMode function) */
PWR_EnterSTANDBYMode();
/* Infinite loop */
while (1)
{
}
}