Other Parts Discussed in Thread: MSP-EXP430FR6989,
Hi,
This question is related to the power consumption of our device with the application we have created for it.
Our initial development was done on the Launchpad MSP-EXP430FR6989.
Our custom board is developed around MSP430FR5989.
The low power mode test was created to verify that the Time Event Interrupt of the RTC_C will wake up the system and resume operation after the sleep period
the test then consists in:
a) program RTC_C for a time event interrupt for each of the possible time interval minute, hour, noon and midnight.
b) enter the LPM3.5
c) upon return notify user that the time event has occurred.
The code snippets below should show what we are trying to do.
======================================= Test Function ============================================================
/*
* Notes
*/
void testTimeEventMinute(void)
{
uint16_t count = 0;
uint8_t answer;
log_print(LOG_ALWAYS,"%s\n\r", __FUNCTION__);
static Calendar cm =
{
0, //! Seconds of minute between 0-59
0, //! Minutes of hour between 0-59
14, //! Hour of day between 0-23
3, //! Day of week between 0-6
16, //! Day of month between 1-31
6, //! Month between 1-12
2020 //! Year between 0-4095
};
test_event_minute_continue = true;
/*
* Clear all interrupts from Calendar Module
* before making decision about notifications
*/
CM_clearInterrupt(RTC_C_TIME_EVENT_INTERRUPT |
RTC_C_CLOCK_READ_READY_INTERRUPT |
RTC_C_CLOCK_ALARM_INTERRUPT);
/*
* Disable all interrupts from Calendar Module
* before making decision about notifications
*/
CM_disableInterrupt(RTC_C_TIME_EVENT_INTERRUPT |
RTC_C_CLOCK_READ_READY_INTERRUPT |
RTC_C_CLOCK_ALARM_INTERRUPT);
/*
* Initialize the Calendar Manager
*/
CM_init(&cm);
/*
* Notified every time a minute has elapsed
*/
CM_registerEvent(RTC_C_CALENDAREVENT_MINUTECHANGE);
/*
* Generate interrupt on time events
*/
CM_enableInterrupt(RTC_C_TIME_EVENT_INTERRUPT );
/*
* Start the Calendar
*/
CM_start();
// Ask user if he wants to go to deep sleep
// waiting for this event
mp_print(BACK_CHANNEL,"%s\n\r","Do you want to go to Low Power Mode waiting for this event (y/n)? ");
answer = mp_getchar(BACK_CHANNEL);
mp_print(BACK_CHANNEL,"%s %c\n\r","Your ANSWER ->", answer);
while (test_event_minute_continue == true)
{
if (answer == 'y')
{
/*
* Enter Low Power Mode with interrupts enabled
*/
__enable_interrupt();
// this code for deep sleep - does work but cannot debug through it yet
log_print(LOG_ALWAYS,"%s going to deep sleep\n\r", __FUNCTION__);
ctpl_enterLpm35(CTPL_DISABLE_RESTORE_ON_RESET); <------------------------------------ HERE we enter the deep sleep mode
log_print(LOG_ALWAYS,"%s returned from deep sleep\n\r", __FUNCTION__); <--------------------- We never returned from Deep Sleep (code was working for MSP430FR6989)
}
count++;
if (count == 0)
{
mp_print(BACK_CHANNEL,".");
LED_toggle(1);
}
/*
* Check if event Second was triggered
*/
unsigned long val = 0;
val = BIT_CHK(eventBitmap, rtcReadyInterruptTriggered);
if (val == 1)
{
/*
* Log the per Second Interrupt event
*/
mp_print(BACK_CHANNEL,"Interrupt for SECOND was triggered\n\r");
/*
* Ask calendar manager to handle the event
*/
CM_handleSecondEvent();
}
/*
* Check if the event Minute was triggered
*/
val = BIT_CHK(eventBitmap, rtcTimeEventMinuteInterruptTriggered);
if ( val == 1)
{
mp_print(BACK_CHANNEL,"Interrupt for MINUTE was triggered\n\r");
/*
* let the test event handler process the event
*/
test_handleMinuteEvent();
}
/*
* Check if the event Hour was triggered
*/
val = BIT_CHK(eventBitmap, rtcTimeEventHourInterruptTriggered);
if ( val == 1)
{
mp_print(BACK_CHANNEL,"Interrupt for Hour was triggered\n\r");
/*
* let the test event handler process the event
*/
test_handleHourEvent();
}
/*
* Check if the event Noon was triggered
*/
val = BIT_CHK(eventBitmap, rtcTimeEventNoonInterruptTriggered);
if ( val == 1)
{
mp_print(BACK_CHANNEL,"Interrupt for Noon was triggered\n\r");
/*
* let the test event handler process the event
*/
test_handleNoonEvent();
}
/*
* Check if the event Midnight was triggered
*/
val = BIT_CHK(eventBitmap, rtcTimeEventMidnightInterruptTriggered);
if ( val == 1)
{
mp_print(BACK_CHANNEL,"Interrupt for Midnight was triggered\n\r");
/*
* let the test event handler process the event
*/
test_handleMidnightEvent();
}
}
log_print(LOG_ALWAYS,"%s Complete\n\r", __FUNCTION__);
return;
}
=======================================calendarManager Code =======================================
/*! \file calendarManager.c
\brief Implementation of the calendar management module
This file contains the code for the implementation
of the calendar management functionality of the MightyPuffer Device
*/
/*
*==============================
* calendarManager.c
*
* Created on: Jan 30, 2020
* Author: first
*==============================
*/
#include "calendarManager.h" /*!< calendar manager definitions and function prototypes */
/*
* Notes:
*/
void CM_init(Calendar *cm)
{
log_print(LOG_ALWAYS,"%s\n\r", __FUNCTION__);
RTC_C_initCalendar(RTC_C_BASE, cm, RTC_C_FORMAT_BINARY);
return;
}
/*
* Notes:
*/
void CM_start(void)
{
log_print(LOG_ALWAYS,"%s\n\r", __FUNCTION__);
RTC_C_startClock(RTC_C_BASE);
return;
}
/*
* Notes:
*/
void CM_stop(void)
{
log_print(LOG_ALWAYS,"%s\n\r", __FUNCTION__);
RTC_C_holdClock(RTC_C_BASE);
return;
}
/*
* Notes
*/
void CM_getTime(Calendar *cm)
{
Calendar wrkCm;
log_print(LOG_ALWAYS,"%s\n\r", __FUNCTION__);
wrkCm = RTC_C_getCalendarTime(RTC_C_BASE); /*!< Tell driverlib module RTC_C to do the work */
cm->Seconds = wrkCm.Seconds; /*!< */
cm->Minutes = wrkCm.Minutes; /*!< */
cm->Hours = wrkCm.Hours; /*!< */
cm->DayOfWeek = wrkCm.DayOfWeek; /*!< */
cm->DayOfMonth = wrkCm.DayOfMonth; /*!< */
cm->Month = wrkCm.Month; /*!< */
cm->Year = wrkCm.Year; /*!< */
return;
}
/*
* Notes:
*/
void CM_registerEvent(uint16_t eventToRegister)
{
log_print(LOG_ALWAYS,"%s\n\r", __FUNCTION__);
RTC_C_setCalendarEvent(RTC_C_BASE, eventToRegister); /*!< Tell driverlib module RTC_C to do the work */
return;
}
/*
* Notes:
*/
void CM_enableInterrupt(uint8_t interruptsToEnable)
{
log_print(LOG_ALWAYS,"%s\n\r", __FUNCTION__);
RTC_C_enableInterrupt(RTC_C_BASE, interruptsToEnable); /*!< Tell driverlib module RTC_C to do the work */
return;
}
/*
* Notes:
*/
void CM_clearInterrupt(uint8_t interruptsToClear)
{
log_print(LOG_ALWAYS,"%s\n\r", __FUNCTION__);
RTC_C_clearInterrupt(RTC_C_BASE, interruptsToClear); /*!< Tell driverlib module RTC_C to do the work */
return;
}
/*
* Notes:
*/
void CM_disableInterrupt(uint8_t interruptsToDisable)
{
log_print(LOG_ALWAYS,"%s\n\r", __FUNCTION__);
RTC_C_disableInterrupt(RTC_C_BASE, interruptsToDisable); /*!< Tell driverlib module RTC_C to do the work */
return;
}
/*
* Notes:
*/
void CM_registerAlarm(RTC_C_configureCalendarAlarmParam *alarms)
{
log_print(LOG_ALWAYS,"%s\n\r", __FUNCTION__);
RTC_C_configureCalendarAlarm(RTC_C_BASE, alarms); /*!< Tell driverlib module RTC_C to do the work */
return;
}
/*
* Notes:
*/
CM_status_e CM_compareDate(MP_date_t *nowDate, MP_date_t *thenDate)
{
CM_status_e status = CM_SUCCESS;
log_print(LOG_ALWAYS,"%s\n\r", __FUNCTION__);
/*
* Compare the month
*/
if ( nowDate->mp_mon == thenDate->mp_mon )
{
/*
* Compare the day
*/
if (nowDate->mp_mday == thenDate->mp_mday)
{
status = CM_DATE_NOW_EQU_THEN;
}
else
{
/*
* Compare the day
*/
if (nowDate->mp_mday < thenDate->mp_mday)
{
status = CM_DATE_NOW_LE_THEN;
}
else
{
status = CM_DATE_NOW_GT_THEN;
}
}
}
else
{
/*
* Compare the month
*/
if ( nowDate->mp_mon < thenDate->mp_mon )
{
status = CM_DATE_NOW_LE_THEN;
}
else
{
status = CM_DATE_NOW_GT_THEN;
}
}
return status;
}
/*
* Notes:
* comparison is on HH:MM
* the seconds are not considered in this comparison
* this is however our current approach
*/
CM_status_e CM_compare Time(MP_time_t *nowTime, MP_time_t *thenTime)
{
CM_status_e status = CM_SUCCESS;
log_print(LOG_ALWAYS,"Entering: %s\n\r", __FUNCTION__);
/*
*
* Compare the hour
*/
if ( nowTime->mp_hour == thenTime->mp_hour )
{
/*
* Compare the minute
*/
if ( nowTime->mp_min == thenTime->mp_min)
{
status = CM_TIME_NOW_EQU_THEN;
}
else
{
/*
* Compare the minute
*/
if (nowTime->mp_min < thenTime->mp_min)
{
status = CM_TIME_NOW_LE_THEN;
}
else
{
status = CM_TIME_NOW_LE_THEN;
}
}
}
else
{
/*
* Compare the hour
*/
if ( nowTime->mp_hour < thenTime->mp_hour )
{
status = CM_TIME_NOW_LE_THEN;
}
else
{
status = CM_TIME_NOW_GT_THEN;
}
}
return status;
}
/*
* Notes:
*/
void CM_handleSecondEvent(void)
{
eventBitmap = BIT_CLR(eventBitmap, rtcReadyInterruptTriggered);
}
/*
* Notes:
*/
void CM_handleMinuteEvent(void)
{
log_print(LOG_ALWAYS,"Entering: %s\n\r", __FUNCTION__);
eventBitmap = BIT_CLR(eventBitmap, rtcTimeEventMinuteInterruptTriggered);
}
/*
* Notes:
*/
void CM_handleHourEvent(void)
{ log_print(LOG_ALWAYS,"Entering: %s\n\r", __FUNCTION__);
eventBitmap = BIT_CLR(eventBitmap, rtcTimeEventHourInterruptTriggered);
}
/*
* Notes:
*
* In the treatment of the midnight event
* we acquire the current date and time
* and perform a date comparaison
*
*/
void CM_handleMidnightEvent(void)
{
MP_status_e status = MP_SUCCESS; /*!< */
CM_status_e compareStatus = CM_SUCCESS; /*!< */
CM_status_e compareStatus1 = CM_SUCCESS; /*!< */
MP_date_t activationDate = {0}; /*!< */
MP_date_t todayDate = {0}; /*!< */
MP_date_t endOfSeasonDate = {0}; /*!< */
Calendar now = {0}; /*!< */
uint16_t seasonWindow = 0; /*!< */
log_print(LOG_ALWAYS,"Entering: %s\n\r", __FUNCTION__);
/*
* Retrieve the season window
*/
status = PC_retrieveSeasonWindow(&seasonWindow);
if (status != MP_SUCCESS)
{
log_print(LOG_ALWAYS," %s - Error detected\n\r", __FUNCTION__);
return;
}
/*
* Get the time of now from the Calendar Manager Hardware
* We may change this to use the second interrupt to
* capture the date and time of now
*/
CM_getTime(&now); /*!< */
/*
* Get only the date portion
*/
todayDate.mp_year = now.Year;
todayDate.mp_mon |= now.Month;
todayDate.mp_mday |= now.DayOfMonth;
/*
* Retrieve the activation date from the
* active puffing protocol
*/
status = PC_retrieveActivationDate( &activationDate);
if ( status == MP_SUCCESS)
{
/*
* Compare the date of today with the activation date
*/
compareStatus = CM_compareDate(&todayDate, &activationDate);
switch (compareStatus)
{
case CM_DATE_NOW_EQU_THEN:
log_print(LOG_ALWAYS,"%s We are at the activation date\n\r", __FUNCTION__);
eventBitmap = BIT_SET(eventBitmap,activationDateReached);
break;
case CM_DATE_NOW_LE_THEN:
log_print(LOG_ALWAYS,"%s We are before the activation date\n\r", __FUNCTION__);
eventBitmap = BIT_SET(eventBitmap,activationDateNotYetReached);
break;
case CM_DATE_NOW_GT_THEN:
log_print(LOG_ALWAYS,"%s We are after the activation date\n\r", __FUNCTION__);
/*
* now we need to see if we are still in season of outside
* of the season window.
* This is done by comparing the date of today with
* the date computed by activation date + season
*/
addDays((int)activationDate.mp_mday,
(int)activationDate.mp_mon,
(int)activationDate.mp_year,
seasonWindow,
&endOfSeasonDate.mp_mday,
&endOfSeasonDate.mp_mon,
&endOfSeasonDate.mp_year );
/*
* Compare the date of today with the end of season date
*/
compareStatus1 = CM_compareDate(&todayDate, &endOfSeasonDate);
switch (compareStatus1)
{
case CM_DATE_NOW_EQU_THEN:
/*
* We have just reach the end of the season
*
*/
case CM_DATE_NOW_GT_THEN:
/*
* Whave passed the end of of the season
*/
eventBitmap = BIT_SET(eventBitmap, activationDatePassed);
/*
*
* We need to modify the activation date by increasing
* the year by the number of year between today and the
* year after the end of the season
*/
activationDate.mp_year++;
status = PC_AdjustActivationDate(&activationDate);
if (status != MP_SUCCESS)
{
log_print(LOG_ALWAYS," %s - Error detected\n\r", __FUNCTION__);
return;
}
break;
case CM_DATE_NOW_LE_THEN:
/*
* We are still in the season
* the normal processing can take place
*
*/
eventBitmap = BIT_SET(eventBitmap, dateStillInSeason);
break;
}
}
}
/*
* Clear the event
*/
eventBitmap = BIT_CLR(eventBitmap, rtcTimeEventMidnightInterruptTriggered);
return;
}
/*
* Notes:
*/
void CM_handleNoonEvent(void)
{
log_print(LOG_ALWAYS,"Entering: %s\n\r", __FUNCTION__);
eventBitmap = BIT_CLR(eventBitmap, rtcTimeEventNoonInterruptTriggered);
}
/*
* Notes:
*/
void CM_hanleAlarm(void)
{
log_print(LOG_ALWAYS,"Entering: %s\n\r", __FUNCTION__);
eventBitmap = BIT_CLR(eventBitmap, rtcAlarmInterruptTriggered);
}
/*
*==================================
* Interrupts Service Routine (ISR)
*==================================
*/
#if defined(__TI_COMPILER_VERSION__) || defined(__IAR_SYSTEMS_ICC__)
#pragma vector=RTC_VECTOR
__interrupt
#elif defined(__GNUC__)
__attribute__((interrupt(RTC_VECTOR)))
#endif
/**
* This is the interrupt service routine ( ISR)
* for the Internal RTC_C calendar
* At least six sources for interrupts are available, namely
*
* RT0PSIFG:
* ========
* RT0PSIFG can be used to generate interrupt intervals selectable by the RT0IP bits.
* RT0PS is sourced with low-frequency oscillator clock at 32768 Hz,
* so intervals of
* 16384 Hz,
* 8192 Hz,
* 4096 Hz,
* 2048 Hz,
* 1024 Hz,
* 512 Hz,
* 256 Hz,
* or 128 Hz
* are possible.
* Setting the RT0PSIE bit enables the interrupt.
*
* RT1PSIFG:
* ========
* RT1PSIFG can be used to generate interrupt intervals selectable by the RT1IP bits.
* RT1PS is sourced with the output of RT0PS, which is 128 Hz (32768/256 Hz).
* Therefore, intervals of
* 64 Hz,
* 32 Hz,
* 16 Hz,
* 8 Hz,
* 4 Hz,
* 2 Hz,
* 1 Hz,
* or 0.5 Hz
* are possible.
* Setting the RT1PSIE bit enables the interrupt.
*
*
* RTCRDYIFG:
* =========
*
* The RTCRDY bit sources the real-time clock interrupt, RTCRDYIFG, and is useful in synchronizing the
* read of time registers with the system clock. Setting the RTCRDYIE bit enables the interrupt.
*
* An easy way to safely read the real-time clock registers is to use the RTCRDYIFG interrupt flag.
*
* Setting RTCRDYIE enables the RTCRDYIFG interrupt.
*
* When enabled, an interrupt is generated based on the rising edge of the RTCRDY bit,
* causing the RTCRDYIFG to be set.
*
* At this point, the application has nearly a complete second to safely read any or all of the real-time clock registers.
*
* This synchronization process prevents reading the time value during transition.
* The RTCRDYIFG flag is reset automatically when the interrupt is serviced or can be reset with software.
*
*
* RTCTEVIFG:
*
* RTCAIFG:
*
* RTCOFIFG:
*
* These flags are prioritized and combined to source a single
* interrupt vector.
* The interrupt vector register (RTCIV) is used to determine which flag requested an
* interrupt.
*/
void RTC_ISR (void)
{
switch (__even_in_range(RTCIV, RTCIV_RT1PSIFG))
{
/*
* Vector 0
* No Interrupt
*/
case RTCIV_NONE:
{
RTC_C_clearInterrupt(RTC_C_BASE, RTC_C_TIME_EVENT_INTERRUPT);
HWREG8(RTC_C_BASE + OFS_RTCCTL0_L) &= ~RTCTEVIFG;
_no_operation();
}
break;
/*
* Vector 2
* RTCOFIFG
* 32-kHz crystal oscillator fault interrupt flag.
* This interrupt can be used as LPM3.5 wake-up event.
* It also indicates a clock failure during backup operation.
* 0b = No interrupt pending
* 1b = Interrupt pending.
* A 32-kHz crystal oscillator fault occurred after last reset.
*/
case RTCIV_RTCOFIFG:
{
RTC_C_clearInterrupt(RTC_C_BASE, RTC_C_OSCILLATOR_FAULT_INTERRUPT);
_no_operation();
}
break;
/*
* Vector 4
* RTCRDYIFG
* This vector correspond to
* RTC_C_CLOCK_READ_READY_INTERRUPT
* Real-time clock ready interrupt flag
* 0b = RTC cannot be read safely
* 1b = RTC can be read safely
*
*/
case RTCIV_RTCRDYIFG:
{
/*
* Interrupt every second
*/
eventBitmap = BIT_SET(eventBitmap, rtcReadyInterruptTriggered);
RTC_C_clearInterrupt(RTC_C_BASE, RTC_C_CLOCK_READ_READY_INTERRUPT);
}
break;
/*
* Vector 6
* RTCEVIFG
*/
case RTCIV_RTCTEVIFG:
{
/*
* Real-time clock time event interrupt flag.
* In modules supporting LPM3.5 this interrupt
* can be used as LPM3.5 wake-up event.
* 0b = No time event occurred
* 1b = Time event occurred
*/
/*
* We use Calendar Mode (RTCMODE =1)
*
* Read Register control 1 bit 0 an 1
* 1-0 RTCTEVx RW 0h Real-time clock time event
* 00b = Minute changed
* 01b = Hour changed
* 10b = Every day at midnight (00:00)
* 11b = Every day at noon (12:00)
*/
switch(HWREG8(RTC_C_BASE + OFS_RTCCTL13_L ) & RTCTEV_3 )
{
case RTCTEV__MIN:
{
/*
* Interrupts every minute
*/
eventBitmap = BIT_SET(eventBitmap, rtcTimeEventMinuteInterruptTriggered);
RTC_C_clearInterrupt(RTC_C_BASE, RTC_C_TIME_EVENT_INTERRUPT);
}
break;
case RTCTEV__HOUR:
{
/*
* Interrupts every hour
*/
eventBitmap = BIT_SET(eventBitmap, rtcTimeEventHourInterruptTriggered);
RTC_C_clearInterrupt(RTC_C_BASE, RTC_C_TIME_EVENT_INTERRUPT);
}
break;
/*
* Interrupt every day at midnight
*/
case RTCTEV__0000:
{
eventBitmap = BIT_SET(eventBitmap, rtcTimeEventMidnightInterruptTriggered);
RTC_C_clearInterrupt(RTC_C_BASE, RTC_C_TIME_EVENT_INTERRUPT);
}
break;
/*
* Interrupt every day at noon
*/
case RTCTEV__1200:
{
eventBitmap = BIT_SET(eventBitmap, rtcTimeEventNoonInterruptTriggered);
RTC_C_clearInterrupt(RTC_C_BASE, RTC_C_TIME_EVENT_INTERRUPT);
}
break;
default:
{
RTC_C_clearInterrupt(RTC_C_BASE, RTC_C_TIME_EVENT_INTERRUPT);
RTC_C_disableInterrupt(RTC_C_BASE, RTC_C_TIME_EVENT_INTERRUPT);
}
break;
}
}
break;
/*
* Vector 8
* RTCAIFG
*/
case RTCIV_RTCAIFG:
{
eventBitmap = BIT_SET(eventBitmap, rtcAlarmInterruptTriggered);
RTC_C_clearInterrupt(RTC_C_BASE, RTC_C_CLOCK_ALARM_INTERRUPT);
}
break;
/*
* Vector A
* RT0PSIFG
*/
case RTCIV_RT0PSIFG:
{
_no_operation();
}
break;
/*
* Vector C
* RT1PSIFG
*/
case RTCIV_RT1PSIFG:
{
_no_operation();
}
break;
/*
* Default Case
*/
default:
{
_no_operation();
}
break;
}
}
/* End of module calendarManager.c */
In the debugging session below we are about to enter the LPM3.5
putting a breakpoint at line 138 and resuming execution
will actually enter the deep sleep.
The debugger indicate
