Wake-up timer library to wake from deepsleep/power-down
Dependencies: LPC1114_WakeInterruptIn
Dependents: LPC812_Sleep_HelloWorld KL05Z_DCF77_RTC_Clock LPC1114_data_logger mBuinoBlinky ... more
Supported Targets
- LPC812
- LPC11u24
- LPC1114
- All mbed Freescale targets
- All mbed STM targets except the F1 series
Please read the target specific comments below. A general small warning: If you have other interrupts enabled, and they request attention after the WakeUp interrupt is set, but before deepsleep is entered, and these take long to handle, it is possible that the WakeUp interrupt is handled before you enter deepsleep. In that case there is no interrupt anymore which should wake it from deepsleep.
Example code
// Depending on the LED connections either the LED is off the 2 seconds // the target spends in deepsleep(), and on for the other second. Or it is inverted #include "mbed.h" #include "WakeUp.h" DigitalOut myled(LED1); int main() { //The low-power oscillator can be quite inaccurate on some targets //this function calibrates it against the main clock WakeUp::calibrate(); while(1) { //Set LED to zero myled = 0; //Set wakeup time for 2 seconds WakeUp::set_ms(2000); //Enter deepsleep, the program won't go beyond this point until it is woken up deepsleep(); //Set LED for 1 second to one myled = 1; wait(1); } }
Target comments
All targets use different implementations, some of these have some things that need to be taken into account. If your target is supported but not listed here, then there is nothing relevant to mention.
Core M3/M4 microcontrollers
These microcontrollers cannot wake from deepsleep while they are being debugged. Core M0s can, although their power consumption is very high while being debugged. Generally to exit debug mode you need to power cycle the microcontroller, while making sure the debugger isn't powercycled as well.
On NUCLEO boards you can for example break the connection to the target IC with a jumper, which does this. Most Freescale boards have a USB connector for the target IC (in addition to the SDA USB). If you use this one to power the board, the debugger should not get powered.
KLxx
These targets (such as the KL25z, KL05z, etc) use the same LPTMR for both WakeUp and for ticker generation. The WakeUp code is nice, and it will backup the old values when being set, and restore those after waking up, allowing you to continue using your ticker, and a ticker which was already set will continue again. However you are not allowed to set a new ticker after you already set WakeUp, since this will give clashes. Do you for whatever reason need to do it (for example you set WakeUp, and then you wake using an InteruptIn), you can disable the WakeUp timer and restore the ticker functionality by setting WakeUp for 0 seconds.
LPC11u24
This target uses the watchdog timer to generate the necesary interrupts to wake from deepsleep. The reset functionality of the timer is disabled, so you don't need to worry about that. However the library won't work if other code also uses the watchdog timer. Most likely the result is unpredictable.
STM
For STM targets the library uses the RTC of these targets. The calibration subroutine is not (yet) implemented, since it assumes that an RTC is quite accurate (which might not be true if it runs as by default on an internal RC oscillator). Currently it keeps the RTC in the default settings of the mbed code. Due to the nature of these settings the maximum time resolution this lib can achieve on those targets is, depending on if a 32kHz crystal is fitted, 3-4ms, instead of the 1ms of other targets.
Also it might not compile for your specific target even though it has an RTC. In that case send me a message (or you can also look yourself). The required interrupt vector changes place and name depending on the target, and it could be that another define needs to be added for your target.
LPC1114
The LPC1114 is special. Not in a good way special. It lacks any kind of regular low-power timer/RTC/WDT which is suitable to wake it from deepsleep mode. What the library does instead is that when the WakeUp command is called, it sets the entire main clock of the device to the watchdog oscillator (at 20kHz). Clock gating is used to disable all peripherals except one timer, this timer then is used to create a pulse on an output pin. Connected to this output pin is an external interrupt, which wakes the device, and restores the original settings.
The first thing this means is that you need an unused pin. Currently by default it is set for dp24 (P0_1), if you don't add anything this pin is used. You can remap this in your code to pins dp1 (P0_8) and dp2 (P0_9):
//Add the following global variable to any .cpp file (generally your main.cpp). PinName WakeUpPin = dp2; //Or dp1/dp24. If this line is not included it will default to dp24
While this pin generates a pulse, other pwm outputs on the same peripheral which are active will keep running (although very slowly).
The second, and also important part, is that you should NOT set it to immediatly start a timer and enter deepsleep after a reset. Add a wait of a few seconds (random amount) in between (or just other code). When it runs at 20kHz it will refuse to be reprogrammed by the Switch Science LPC1114 mbed board, and I can do the educated guess that ISP programming via the UART also isn't going to work. If you add a wait at the start there is no problem.
Did you ignore my advice and got your LPC1114 bricked? Don't worry (too much), I managed to unbrick all mine again. I used uVision 5, export an LPC1114 project from mbed to have correct device settings. In Project > Options for Target > Debug > Use debugger: CMSIS-DAP > Settings you can change debugger settings. Playing with these can help (I haven't found yet what is required exactly). Now from Flash you can do erase/download. This is giving errors for me. Doesn't matter, what is important is that if you do the right thing (if your code blinks an LED for example that is useful), the code will stop running. Either the uC is set in permanent reset (faint glow of LEDs connected to ground), or it just stops running. At this point you can drag an drop program it again.
The calibrate function requires dp24, regardless of which pin is set as the WakeUpPin. After calibration you can use set it to do something else, however during calibration it needs to be able to toggle.
Device/WakeUp_STM_RTC.cpp
- Committer:
- Sissors
- Date:
- 2017-06-14
- Revision:
- 23:69a0c843e4bd
- Parent:
- 20:68f2ee917691
File content as of revision 23:69a0c843e4bd:
#ifdef TARGET_STM #include "WakeUp.h" #include "rtc_api.h" #define BYTE2BCD(byte) ((byte % 10) | ((byte / 10) << 4)) //Most things are pretty similar between the different STM targets. //Only the IRQ number the alarm is connected to differs. Any errors //with RTC_IRQn/RTC_Alarm_IRQn in them are related to this #if defined(TARGET_M4) || defined(TARGET_M3) #define RTC_IRQ RTC_Alarm_IRQn #else #define RTC_IRQ RTC_IRQn #endif // Some things to handle Disco L476VG (and similar ones) #if defined(TARGET_STM32L4) #define IMR IMR1 #define EMR EMR1 #define RTSR RTSR1 #define FTSR FTSR2 #define PR PR1 #endif //Disabling the Backup Powerdomain does not seem to work nicely anymore if you want to use other RTC functions afterwards. //For now I have disabled it in code, if you find WakeUp increases your powerconsumption, try enabling it again (code is still there, just commented) Callback<void()> WakeUp::callback; void WakeUp::set_ms(uint32_t ms) { if (!rtc_isenabled()) { //Make sure RTC is running rtc_init(); wait_us(250); //The f401 seems to want a delay after init } //PWR->CR |= PWR_CR_DBP; //Enable power domain RTC->WPR = 0xCA; //Disable RTC write protection RTC->WPR = 0x53; //Alarm must be disabled to change anything RTC->CR &= ~RTC_CR_ALRAE; while(!(RTC->ISR & RTC_ISR_ALRAWF)); if (ms == 0) { //Just disable alarm //PWR->CR &= ~PWR_CR_DBP; //Disable power domain RTC->WPR = 0xFF; //Enable RTC write protection return; } //RTC prescaler + calculate how many sub-seconds should be added uint32_t prescaler = (RTC->PRER & 0x7FFF) + 1; uint32_t subsecsadd = ((ms % 1000) * prescaler) / 1000; if ((ms < 1000) && (subsecsadd < 2)) subsecsadd = 2; //At least 2 subsecs delay to be sure interrupt is called __disable_irq(); //At this point we don't want IRQs anymore //Get current time uint32_t subsecs = RTC->SSR; time_t secs = rtc_read(); //Calculate alarm values //Subseconds is countdown, so substract the 'added' sub-seconds and prevent underflow if (subsecs < subsecsadd) { subsecs += prescaler; secs++; } subsecs -= subsecsadd; //Set seconds correctly secs += ms / 1000; struct tm *timeinfo = localtime(&secs); //Enable rising edge EXTI interrupt of the RTC EXTI->IMR |= RTC_EXTI_LINE_ALARM_EVENT; EXTI->EMR &= ~RTC_EXTI_LINE_ALARM_EVENT; EXTI->RTSR |= RTC_EXTI_LINE_ALARM_EVENT; EXTI->FTSR &= ~RTC_EXTI_LINE_ALARM_EVENT; //Calculate alarm register values uint32_t alarmreg = 0; alarmreg |= BYTE2BCD(timeinfo->tm_sec) << 0; alarmreg |= BYTE2BCD(timeinfo->tm_min) << 8; alarmreg |= BYTE2BCD(timeinfo->tm_hour) << 16; alarmreg |= BYTE2BCD(timeinfo->tm_mday) << 24; //Enable RTC interrupt RTC->ALRMAR = alarmreg; RTC->ALRMASSR = subsecs | RTC_ALRMASSR_MASKSS; //Mask no subseconds RTC->CR |= RTC_CR_ALRAE | RTC_CR_ALRAIE; //Enable Alarm RTC->WPR = 0xFF; //Enable RTC write protection //PWR->CR &= ~PWR_CR_DBP; //Disable power domain __enable_irq(); //Alarm is set, so irqs can be enabled again //Enable everything else NVIC_SetVector(RTC_IRQ, (uint32_t)WakeUp::irq_handler); NVIC_EnableIRQ(RTC_IRQ); } void WakeUp::irq_handler(void) { //Clear RTC + EXTI interrupt flags //PWR->CR |= PWR_CR_DBP; //Enable power domain RTC->ISR &= ~RTC_ISR_ALRAF; RTC->WPR = 0xCA; //Disable RTC write protection RTC->WPR = 0x53; RTC->CR &= ~RTC_CR_ALRAE; RTC->WPR = 0xFF; //Enable RTC write protection EXTI->PR = RTC_EXTI_LINE_ALARM_EVENT; //PWR->CR &= ~PWR_CR_DBP; //Disable power domain callback.call(); } void WakeUp::calibrate(void) { //RTC, we assume it is accurate enough without calibration } #endif