Energy Driven Computing - University of Southampton
This library allows any user to use their Mbed project with a transient energy source( e.g. windturbine, solar power).
Dependencies: mbed
Fork of
Hibernus
by 
Bogdan Lazarescu
This library allows any user to use their Mbed project with a transient energy source( e.g. windturbine, solar power). You can do this by simply import the "hibernus.h" header file, and call the "Hibernus()" method at the beginning of you main program. In case of a power loss the state of your programm will be saved to the nonvolatile memory and it will be resumed from the same point as soon as there is enough power for the board to run properly. If the power drops down, the internal capacitance of the system is used to save a snapshot of your program into the flash memory, and the board goes in a low power mode (sleep or deepsleep). In order to detect a power loss, the library uses an analog comparator which can be internal (eg Freescale KL 05Z has an internal comparator which can be used ), or external (on LPC11U24 there is no internal comparator) via a GPIO interrupt. For more details see the code comments and the attached example main.cpp file.
This library use "IAP" library, in order to write the required data to the flash nonvolatile memory.
The library can be easily adapted to work with other boards, from different manufactures, which have support for Mbed. In order to adapt this library and use it on your board, the write to flash methods have to be changed. Some changes listed below are required because of the platform dependent parameters of each board. All required changes have to be applied to the "config.h" and "config.cpp" files.
- The "erase_flags_memory()", "copyRamToFlash()", "restore_flags()", "setFlag()" and " isFlagSet()" methods have to be modified in order to use the right Flash IAP of your board.
- The wake up and hibernate interrupts have to be modified in order to be trigghered when the voltage drops down or rise. If you use an internal comparator, it should trigger and interrupt whenever the power drops(e.g see CMP0_IRQHandler() method writtend for KL05Z at https://developer.mbed.org/users/BogdanL/code/Hibernus-KL05Z/ ) . At that time a snapshot have to be saved and the board sent to sleep. Another interrupt have to be triggered when the power comes back(see "LLW_IRQHandler()" at https://developer.mbed.org/users/BogdanL/code/Hibernus-KL05Z ) . This have to wake up the board and resume de computation. In you use an external comparator two GPIO interrupts are used. One of them (for LPC11U24 see "FLEX_INT1_IRQHandler()" ) is used to save the snapshot when the power drops down, and the other one (for LPC11U24 see "FLEX_INT0_IRQHandler()" ) is used to wake up the board.
- For each board, the right Sleep mode have to be chosen. Also the interrups and the comparator have to be properly set, in order to be triggered as desired. For a good example see "configure_VR_gpio_interrupt()" and "configure_VH_gpio_interrupt()" that are used to set up the Restore and Hibernate interrupts on LPC11U24 board, that uses an external comparator.
- In the "config.h" file, the two arrays, "REG_Addresses_4B[]" and "REG_Addresses_4B[]" have to be populated with the addresses of the 1 Byte and 4Bytes peripheral registers that are used by your project. Different boards have different modules that use different peripheral registers. The addresses of the registers can be found in the Reference Manual of each board, and will be used in order to save and later restore the content of the registers. Also the number of used registers, "No_Of_4B_Peripheral_Reg", No_Of_1B_Peripheral_Reg, have to be updated with the correct number of used registers.
- At the top of "config.h" header file, specific board parameters have to be fixed: RAM start address(RAM_1_Address), Flash start address(FLASH_Start), RAM size(RAM_Size), Flash size(flash_Size) and the flash sector size(sector_Size).
Revision 0:f9a13d4b41f3, committed 2017-09-08
- Comitter:
- BogdanL
- Date:
- Fri Sep 08 18:01:22 2017 +0000
- Commit message:
- First Version of Hibernus Library;
Changed in this revision
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Drivers/Driver_KL05Z.cpp Fri Sep 08 18:01:22 2017 +0000
@@ -0,0 +1,114 @@
+#include "config.h"
+#ifdef KL05Z
+#include "Driver_KL05Z.h"
+#include "hibernus.h"
+Serial pr(USBTX, USBRX);
+volatile unsigned int dummyread1; // Variable used for serialization
+
+//inerrupt triggered by comparator whenever the power drops under the treshold value
+extern "C" void CMP0_IRQHandler() //To make sure the compiler sees handler, need to declare it as extern (https://developer.mbed.org/forum/mbed/topic/419/?page=1#comment-2126)
+{
+ CMP0->SCR |= CMP_SCR_CFF_MASK | CMP_SCR_CFR_MASK; // Clear CMP0 flags
+ dummyread1 = CMP0->SCR; // Read back for serialization
+
+ //call hibernate procedure directly with the three parameters (don't store them in a variable and then call the method with them,
+ //the store procedure changes the stackpointer and the program counter)
+ // pram1 = StackPointer = SP, param2 = LinkRegister = LR, param3 = ProgramCounter = PC
+ // call hibernate(param1, param2, param3) then the voltage drops under the low(hibernate) treshold
+ hibernate((_SP+0x28),*((unsigned int*)(_SP+0x1C)),*((unsigned int*)(_SP+0x20)));
+
+}
+
+extern "C" void LLW_IRQHandler(){ //interrupt triggered to wake up the board from sleep mode
+
+ CMP0->SCR |= CMP_SCR_CFF_MASK | CMP_SCR_CFR_MASK; // Clear CMP0 flags
+ dummyread1 = CMP0->SCR; // Read back for serialization
+ NVIC_ClearPendingIRQ(CMP0_IRQn); // Clear pending CMP0 interrupt so that the CMP_IRQ is not entered
+
+ recovery_no_power_loss(); //check if you are recovering after no power loss, and if so, configure VH interrupt
+}
+
+void Comparator_Setup(){
+
+ NVIC_SetPriority(CMP0_IRQn, 1); // Lower the CMP0 interrupt priority from 0 to 1 (smaller number = higher priority)
+ NVIC_EnableIRQ(CMP0_IRQn); // Enable CMP0 interrupts in NVIC
+
+ SIM->SCGC4 |= SIM_SCGC4_CMP_MASK; // Enable comparator module clock
+ LLWU->ME |= LLWU_ME_WUME1_MASK; // Enable CMP0 as a LLWU source
+ PMC->REGSC |= PMC_REGSC_BGEN_MASK | // Allow bangap buffer in low power operation
+ PMC_REGSC_BGBE_MASK; // Enable bandgap buffer for +1V reference (CMP0_IN6)
+
+ // Comparator in sampled, filtered mode 4B
+ CMP0->CR0 = 0x22; // Hysteresis level 2 (20mV) and 2 consecutive filter samples must agree
+ CMP0->CR1 = 0x00; // Low-speed compare, non-inverted output, use filtered output and disable comparator output pin PTA2
+ CMP0->FPR = 0x01; // Filter sample period = 1 bus clock cycle
+ CMP0->SCR = 0x06; // Disable all interrupts and clear flags
+ CMP0->DACCR = 0x40; // Disable DAC, Vdd is 6-bit reference, threshold set to zero
+ CMP0->MUXCR = 0x3E; // CMP0_IN7 (DAC) to V+ channel and CMP0_IN6 (+1V bandgap) to V- 3E
+}
+
+void Enter_LLS(){
+
+ Comparator_Setup();
+ CMP0->DACCR = 0xDA; // Enable DAC, Vdd is 6-bit reference, threshold set to P3V3 = +2.37V (V_R)
+ CMP0->SCR = 0x16; // Enable rising edge interrupt and clear flags
+ CMP0->CR1 |= CMP_CR1_EN_MASK; // Enable comparator module
+
+ NVIC_EnableIRQ(LLW_IRQn); // Enable LLW interrupts in NVIC
+ MCG->C6 &= ~(MCG_C6_CME_MASK); // DIsable all clock monitors
+ SCB->SCR = 1<<SCB_SCR_SLEEPDEEP_Pos; // Set the SLEEPDEEP bit for stop mode
+
+ SMC->PMPROT = SMC_PMPROT_ALLS_MASK; // Allow LLS power modes
+ SMC->PMCTRL &= ~(SMC_PMCTRL_STOPM_MASK); // Serialisation
+ SMC->PMCTRL = SMC_PMCTRL_STOPM(0x3); // Select LLS as desired power mode
+ dummyread1 = SMC->PMCTRL; // Read back for serialisation
+
+ __WFI(); // Stop executing instructions and enter LLS (wait for interrupt)
+}
+
+void configure_VH_comparator_interrupt(){
+ Comparator_Setup();
+ CMP0->DACCR = 0xDC; // Enable DAC, Vdd is 6-bit reference, threshold set to P3V3 = +2.21V (V_H)
+ CMP0->SCR = 0x0E; // Enable falling edge interrupt and clear flags
+ CMP0->CR1 |= CMP_CR1_EN_MASK; // Enable comparator module
+}
+
+void configure_VR_comparator_interrupt(){
+ CMP0->DACCR = 0xDA; // Enable DAC, Vdd is 6-bit reference, threshold set to P3V3 = +2.37V (V_R)
+ CMP0->SCR = 0x16; // Enable all interrupts and clear flags
+ CMP0->CR1 |= CMP_CR1_EN_MASK; // Enable comparator module
+}
+
+void setFlag(volatile unsigned int* add){
+ const unsigned int set = Flag_set;
+ program_flash(*add,(char*)&set,4); //if the flags are stored in flash, use this line
+}
+
+bool isFlagSet(volatile unsigned int* add){
+ if( *(unsigned int *)(*add) == Flag_set) return true;
+ return false;
+}
+
+void erase_flags_memory(){
+ if(!SaveFlagsInFlash) { //if the flags are stored in RAM, their value have to be clanged to the "erased" value ("Flag_erase")
+ *getFlag_1() = Flag_erase;
+ *getFlag_2() = Flag_erase;
+ *getFlag_3() = Flag_erase;
+ *getFlag_4() = Flag_erase;
+ }else{ //if the flags are stored in Flash, their secvtor have to be erased
+ erase_sector(Flash_Flags_Sector_Start);
+ }
+}
+//erase the flash memory needed to save the whole RAM content
+void erase_flash_secors_for_RAM(){
+ int i;
+ for(i = 2; i<= 2+ramToFlash_sectors_number; i++) //start the erase from the second last block, the first is used for flags
+ erase_sector(flash_end-i*sector_Size);
+}
+
+void copyRamToFlash(){
+ // Erase flash sectors o save the RAM content
+ erase_flash_secors_for_RAM();
+ program_flash(flash_ramSection_start, (char*) RAM_Start, RAM_Size); // Copy all the RAM to flash
+}
+#endif
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Drivers/Driver_KL05Z.h Fri Sep 08 18:01:22 2017 +0000
@@ -0,0 +1,99 @@
+#ifndef CONFIG_H_
+#define CONFIG_H_
+#ifdef KL05Z
+#include "mbed.h"
+#include "FreescaleIAP.h"
+
+#define HasInternalComparator 1 //Set on 1 if there is an internal comparator 0 otherwise
+#define SaveFlagsInFlash 1 //set on 1 if there is enough Flash memory available for the flags to have their own flash sector, 0 otherwise
+ //if there is not enough flash memory, the flags will be saved in RAM memory
+
+// RAM addresses split in 1 KB sectors
+#define RAM_Start 0x1FFFFC00
+#define FLASH_Start 0x00000000
+#define RAM_Size 4096
+#define flash_Size flash_size() //32K flash
+#define sector_Size SECTOR_SIZE //4K sector size
+#define Flash_Flags_Sector_Start (flash_end -1*sector_Size)
+
+#define No_Of_4B_Peripheral_Reg 18
+#define No_Of_1B_Peripheral_Reg 8
+
+const unsigned int REG_Addresses_4B[83] = // Constant peripheral register addresses which are 4 bytes in size
+ {
+ (unsigned int)&FPTA->PDOR,(unsigned int)&FPTA->PDDR,(unsigned int)&FPTB->PDOR,(unsigned int)&FPTB->PDDR,
+ //0x4000F000, 0x4000F014, 0x4000F040, 0x4000F054, // GPIO controller aliased to ox400FF000
+ (unsigned int)&SIM->SOPT1,(unsigned int)&SIM->SOPT1CFG,(unsigned int)&SIM->SOPT2,(unsigned int)&SIM->SOPT4,
+ (unsigned int)&SIM->SOPT5,(unsigned int)&SIM->SOPT7,(unsigned int)&SIM->SCGC4,(unsigned int)&SIM->SCGC5,
+ (unsigned int)&SIM->SCGC6,(unsigned int)&SIM->SCGC7,(unsigned int)&SIM->CLKDIV1,(unsigned int)&SIM->FCFG1,
+ (unsigned int)&SIM->COPC,
+ //0x40047000, 0x40047004, 0x40048004, 0x4004800C, 0x40048010, 0x40048018, 0x40048034, 0x40048038, 0x4004803C, 0x40048040,
+ //0x40048044, 0x4004804C, 0x40048100, // SIM
+ (unsigned int)&PORTA->PCR[0],(unsigned int)&PORTA->PCR[1],(unsigned int)&PORTA->PCR[2],(unsigned int)&PORTA->PCR[3],
+ (unsigned int)&PORTA->PCR[4],(unsigned int)&PORTA->PCR[5],(unsigned int)&PORTA->PCR[6],(unsigned int)&PORTA->PCR[7],
+ (unsigned int)&PORTA->PCR[8],(unsigned int)&PORTA->PCR[9],(unsigned int)&PORTA->PCR[10],(unsigned int)&PORTA->PCR[11],
+ (unsigned int)&PORTA->PCR[12],(unsigned int)&PORTA->PCR[13],(unsigned int)&PORTA->PCR[14],(unsigned int)&PORTA->PCR[15],
+ (unsigned int)&PORTA->PCR[16],(unsigned int)&PORTA->PCR[17],(unsigned int)&PORTA->PCR[18],(unsigned int)&PORTA->PCR[19],
+ (unsigned int)&PORTA->PCR[20],(unsigned int)&PORTA->PCR[21],(unsigned int)&PORTA->PCR[22],(unsigned int)&PORTA->PCR[23],
+ (unsigned int)&PORTA->PCR[24],(unsigned int)&PORTA->PCR[25],(unsigned int)&PORTA->PCR[26],(unsigned int)&PORTA->PCR[27],
+ (unsigned int)&PORTA->PCR[28],(unsigned int)&PORTA->PCR[29],(unsigned int)&PORTA->PCR[30],(unsigned int)&PORTA->PCR[31],
+ //0x40049000, 0x40049004, 0x40049008, 0x4004900C, 0x40049010, 0x40049014, 0x40049018, 0x4004901C, 0x40049020, 0x40049024,
+ //0x40049028, 0x4004902C, 0x40049030, 0x40049034, 0x40049038, 0x4004903C, 0x40049040, 0x40049044, 0x40049048, 0x4004904C,
+ //0x40049050, 0x40049054, 0x40049058, 0x4004905C, 0x40049060, 0x40049064, 0x40049068, 0x4004906C, 0x40049070, 0x40049074,
+ //0x40049078, 0x4004907C, // Port A multiplexing control
+ (unsigned int)&PORTB->PCR[0],(unsigned int)&PORTB->PCR[1],(unsigned int)&PORTB->PCR[2],(unsigned int)&PORTB->PCR[3],
+ (unsigned int)&PORTB->PCR[4],(unsigned int)&PORTB->PCR[5],(unsigned int)&PORTB->PCR[6],(unsigned int)&PORTB->PCR[7],
+ (unsigned int)&PORTB->PCR[8],(unsigned int)&PORTB->PCR[9],(unsigned int)&PORTB->PCR[10],(unsigned int)&PORTB->PCR[11],
+ (unsigned int)&PORTB->PCR[12],(unsigned int)&PORTB->PCR[13],(unsigned int)&PORTB->PCR[14],(unsigned int)&PORTB->PCR[15],
+ (unsigned int)&PORTB->PCR[16],(unsigned int)&PORTB->PCR[17],(unsigned int)&PORTB->PCR[18],(unsigned int)&PORTB->PCR[19],
+ (unsigned int)&PORTB->PCR[20],(unsigned int)&PORTB->PCR[21],(unsigned int)&PORTB->PCR[22],(unsigned int)&PORTB->PCR[23],
+ (unsigned int)&PORTB->PCR[24],(unsigned int)&PORTB->PCR[25],(unsigned int)&PORTB->PCR[26],(unsigned int)&PORTB->PCR[27],
+ (unsigned int)&PORTB->PCR[28],(unsigned int)&PORTB->PCR[29],(unsigned int)&PORTB->PCR[30],(unsigned int)&PORTB->PCR[31],
+ //0x4004A000, 0x4004A004, 0x4004A008, 0x4004A00C, 0x4004A010, 0x4004A014, 0x4004A018, 0x4004A01C, 0x4004A020, 0x4004A024,
+ //0x4004A028, 0x4004A02C, 0x4004A030, 0x4004A034, 0x4004A038, 0x4004A03C, 0x4004A040, 0x4004A044, 0x4004A048, 0x4004A04C,
+ //0x4004A050, 0x4004A054, 0x4004A058, 0x4004A05C, 0x4004A060, 0x4004A064, 0x4004A068, 0x4004A06C, 0x4004A070, 0x4004A074,
+ //0x4004A078, 0x4004A07C, // Port B multiplexing control
+ (unsigned int)&MCM->PLACR,(unsigned int)&MCM->CPO
+ //0xF000300C, 0xF0003040 // MCM
+ };
+
+const unsigned int REG_Addresses_1B[30] = // Constant peripheral register addresses which are 1 byte in size
+ {
+ (unsigned int)&MCG->C1,(unsigned int)&MCG->C2,(unsigned int)&MCG->C3,(unsigned int)&MCG->C4,
+ (unsigned int)&MCG->C6,(unsigned int)&MCG->SC,(unsigned int)&MCG->ATCVH,(unsigned int)&MCG->ATCVL,
+ //0x40064000, 0x40064001, 0x40064002, 0x40064003, 0x40064005, 0x40064008, 0x4006400A, 0x4006400B, // MCG
+ (unsigned int)&OSC0->CR,
+ //0x40065000, // Oscillator
+ (unsigned int)&UART0->BDH,(unsigned int)&UART0->BDL,(unsigned int)&UART0->C1,(unsigned int)&UART0->C2,
+ (unsigned int)&UART0->S1,(unsigned int)&UART0->S2,(unsigned int)&UART0->C3,(unsigned int)&UART0->D,
+ (unsigned int)&UART0->MA1,(unsigned int)&UART0->MA2,(unsigned int)&UART0->C4,(unsigned int)&UART0->C5,
+ //0x4006A000, 0x4006A001, 0x4006A002, 0x4006A003, 0x4006A004, 0x4006A005, 0x4006A006, 0x4006A007, 0x4006A008, 0x4006A009,
+ //0x4006A00A, 0x4006A00B, // UART0
+ (unsigned int)&PMC->LVDSC1,(unsigned int)&PMC->LVDSC2,(unsigned int)&PMC->REGSC,
+ //0x4007D000, 0x4007D001, 0x4007D002, // PMC
+ (unsigned int)&SMC->PMPROT,(unsigned int)&SMC->PMCTRL,(unsigned int)&SMC->STOPCTRL,(unsigned int)&SMC->PMSTAT,
+ //0x4007E000, 0x4007E001, 0x4007E002, 0x4007E003, // SMC
+ (unsigned int)&RCM->RPFC,(unsigned int)&RCM->RPFW
+ //0x4007F004, 0x4007F005 // RCM
+ };
+
+#if HasInternalComparator == 1
+ void configure_VR_comparator_interrupt(void);
+ void configure_VH_comparator_interrupt(void);
+ void Comparator_Setup(void);
+#else
+ extern "C" void FLEX_INT0_IRQHandler(void);
+ extern "C" void FLEX_INT1_IRQHandler(void);
+ void configure_VH_gpio_interrupt(void);
+ void configure_VR_gpio_interrupt(void);
+#endif
+
+void erase_flags_memory(void);
+void restore_flags(void);
+void Enter_LLS(void);
+void setFlag(volatile unsigned int*);
+bool isFlagSet(volatile unsigned int*);
+void copyRamToFlash(void);
+
+#endif
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Drivers/Driver_LPC11U24.cpp Fri Sep 08 18:01:22 2017 +0000
@@ -0,0 +1,151 @@
+/** Hibernus Library
+ * University of Southampton 2017
+ *
+ * Open-source liberary that enable any of your Mbed project work with transient enegy sources.
+ * In order to use this library include the "hibernus.h" header file, and use the "Hibernus()" method at the beginning of you main funtion.
+ * For more details and example see the "main.cpp" exampe file, and the attached documnetation
+ *
+ *
+ * Released under the MIT License: http://mbed.org/license/mit
+ */
+#ifdef LPC11U24
+#include "Driver_LPC11U24.h"
+#include "hibernus.h"
+#include "config.h"
+
+IAP iap;
+Serial pc1(USBTX, USBRX);
+
+void Enter_LLS(){
+ configure_VR_gpio_interrupt();
+
+ LPC_PMU->PCON |= 0x1;
+ LPC_SYSCON->PINTSEL[0] = 0x02; //configure pin P0_2 as interupt source
+ LPC_SYSCON->PDRUNCFG &= ~(1<<1);
+ LPC_SYSCON->STARTERP0 |= (1<<0); //Config chanel as wake up interrupt
+ LPC_SYSCON->PDAWAKECFG &= ~((1<<0)|(1<<1)|(1<<2)|(1<<5)|(1<<7)); //wake up all needed modules after recovering from deepslep mode
+ NVIC_SetPriority(FLEX_INT0_IRQn,0);
+ NVIC_EnableIRQ(FLEX_INT0_IRQn);
+ NVIC_SetPriority(FLEX_INT0_IRQn,0);
+
+ //Go to deep Sleep mode ---->
+ SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk; //choose Deep Sleep as power mode
+ __WFI(); // Stop executing instructions and enter Deep Sleep mode
+}
+
+//if there is no internal Coomparator define 2 GPIO interrupts to wake up and sleep
+
+void configure_VR_gpio_interrupt(){
+ LPC_GPIO->DIR[0] |= 1<<2; //set pin P0_2 as input //generate interrupt for VR
+
+ LPC_SYSCON->SYSAHBCLKCTRL |= (1<<6);
+ LPC_SYSCON->SYSAHBCLKCTRL |= (1<<16);
+ LPC_IOCON->PIO0_2 = (0x0|(0x2<<3)); //enable pullup
+ LPC_SYSCON->SYSAHBCLKCTRL |= (1<<19); //System enable peripheral clock
+ LPC_SYSCON->PINTSEL[0] = 0x2; //configure interrupt chanel for the GPIO pin is syscon block
+
+ LPC_GPIO_PIN_INT->ISEL &= ~(1<<0); //set the interrupt mode for the pin0 to be Level Sensitive
+ LPC_GPIO_PIN_INT->IENF |= (1<<0); //enable the level sensitive interrupt on pin P0_2
+
+ LPC_SYSCON->STARTERP0 |= (1<<0); //config chanel as wake up interrupt is Syscon block
+
+ __enable_irq();
+ NVIC_EnableIRQ(FLEX_INT0_IRQn);
+ NVIC_SetPriority(FLEX_INT0_IRQn,0); //Set a higher prioroty for wake up interrupt, to be able to interrupt the sleep interrupt
+}
+
+void configure_VH_gpio_interrupt(){
+ LPC_GPIO->DIR[0] |= 1<<8; //set pin P0_8 as input //generate interrupt for VH
+
+ LPC_SYSCON->SYSAHBCLKCTRL |= (1<<6);
+ LPC_SYSCON->SYSAHBCLKCTRL |= (1<<16);
+ LPC_IOCON->PIO0_8 = (0x0|(0x2<<3)); //choose first pin function and enable pullup
+ LPC_SYSCON->SYSAHBCLKCTRL |= (1<<19); //System enable peripheral clock
+ LPC_SYSCON->PINTSEL[1] = (uint32_t)8; //configure interrupt chanel for the GPIO pin is syscon block
+
+ LPC_GPIO_PIN_INT->ISEL &= ~(1<<1); //set the interrupt mode for the pin1 to be Level Sensitive
+ LPC_GPIO_PIN_INT->IENF |= (1<<1); //enable the level sensitive interrupt on pin P0_8
+
+ __enable_irq();
+ NVIC_EnableIRQ(FLEX_INT1_IRQn);
+ NVIC_SetPriority(FLEX_INT1_IRQn,2); //Set a lower priority for the sleep interrupt, in order to be possible for the wake up interrupt to interrupt it
+}
+
+//the interrupt triggered by the GPIO/INternal Comparator where the snapshot is saved
+extern "C" void FLEX_INT1_IRQHandler(){ //To make sure the compiler sees handler, need to declare it as extern (https://developer.mbed.org/forum/mbed/topic/419/?page=1#comment-2126)
+ pc1.printf(" ",isFlagSet(getFlag_1()),isFlagSet(getFlag_2()),isFlagSet(getFlag_3()),isFlagSet(getFlag_4()));
+
+ hibernate((_SP+0x40),*(unsigned int*)(_SP+0x34),*(unsigned int*)(_SP+0x38));
+
+ //clear interupt status register
+ LPC_GPIO_PIN_INT->IST |=((1<<0)|(1<<1));
+ //delete any sleep interupts that came during the sleep
+ NVIC_ClearPendingIRQ(FLEX_INT1_IRQn);
+}
+
+//ISR for wakeing up the core and seting the interrupt for Hibernate procedure
+extern "C" void FLEX_INT0_IRQHandler(){ //To make sure the compiler sees handler, need to declare it as extern (https://developer.mbed.org/forum/mbed/topic/419/?page=1#comment-2126)
+ NVIC_ClearPendingIRQ(FLEX_INT0_IRQn);
+
+ recovery_no_power_loss(); //check if you are recovering after no power loss, and if so, configure VH interrupt
+
+ //clear interupt status register
+ LPC_GPIO_PIN_INT->IST |= (1<<0);
+}
+
+//used to restore the flags values from Flash to RAM
+void restore_flags(){
+ if(!SaveFlagsInFlash){
+ *getFlag_1() = *(unsigned int*)(flash_ramSection_start+Fixed_Add_Vars_Offset);
+ *getFlag_2() = *(unsigned int*)(flash_ramSection_start+Fixed_Add_Vars_Offset+0x4);
+ *getFlag_3() = *(unsigned int*)(flash_ramSection_start+Fixed_Add_Vars_Offset+0x8);
+ *getFlag_4() = *(unsigned int*)(flash_ramSection_start+Fixed_Add_Vars_Offset+0xC);
+ }
+}
+
+//mark a flag as "SET"
+void setFlag(volatile unsigned int* add){
+ #if SaveFlagsInFlash == 1
+ const unsigned int set = Flag_set;
+ program_flash(*add,(char*)&set,4); //if the flags are stored in flash, use this line
+ #else
+ *add = Flag_set;
+ #endif
+
+}
+
+//check if a flag is SET or CLEAR
+bool isFlagSet(volatile unsigned int* add){
+ #if SaveFlagsInFlash == 1
+ if( *(unsigned int *)(*add) == Flag_set) return true;
+ return false;
+ #else
+ if(*add == Flag_set ) return true;
+ return false;
+ #endif
+}
+
+//Clear the memory area where the flags are saved
+void erase_flags_memory(){
+ #if SaveFlagsInFlash == 0 //if the flags are stored in RAM, their value have to be clanged to the "erased" value ("Flag_erase")
+ *getFlag_1() = Flag_erase;
+ *getFlag_2() = Flag_erase;
+ *getFlag_3() = Flag_erase;
+ *getFlag_4() = Flag_erase;
+ #else //if the flags are stored in Flash, their secvtor have to be erased
+ erase_sector(Flash_Flags_Sector_Start);
+ #endif
+}
+
+//copy the whole content of RAM into the flash
+void copyRamToFlash(){
+ // Erase flash sectors o save the RAM content
+ int g3=iap.prepare(6,7);
+ int g4=iap.erase(6,7);
+
+ // Copy all the RAM to flash
+ int g0 = iap.prepare(6,7);
+ int g1=iap.write((char*)RAM_Start,(char*)flash_ramSection_start,RAM_Size/2);
+ g1+=iap.write((char*)RAM_Start+(RAM_Size/2),(char*)flash_ramSection_start+(RAM_Size/2),(RAM_Size/2));
+}
+#endif
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Drivers/Driver_LPC11U24.h Fri Sep 08 18:01:22 2017 +0000
@@ -0,0 +1,62 @@
+/** Hibernus Library
+ * University of Southampton 2017
+ *
+ * Open-source liberary that enable any of your Mbed project work with transient enegy sources.
+ * In order to use this library include the "hibernus.h" header file, and use the "Hibernus()" method at the beginning of you main funtion.
+ * For more details and example see the "main.cpp" exampe file, and the attached documnetation
+ *
+ *
+ * Released under the MIT License: http://mbed.org/license/mit
+ */
+#ifndef CONFIG_H_
+#define CONFIG_H_
+#ifdef LPC11U24
+#include "mbed.h"
+#include "IAP.h"
+
+/////for LPC11U24
+#define RAM_Start 0x10000000
+#define FLASH_Start 0x00000000
+#define RAM_Size 8192
+#define flash_Size 32768 //32K flash
+#define sector_Size FLASH_SECTOR_SIZE //4K sector size
+
+#define No_Of_4B_Peripheral_Reg 10
+#define No_Of_1B_Peripheral_Reg 0
+
+const unsigned int REG_Addresses_4B[83] = {
+(unsigned int)&LPC_GPIO_PIN_INT->ISEL, /*!< (@ 0x4004C000) Pin Interrupt Mode register */
+(unsigned int)&LPC_GPIO_PIN_INT->IENR, /*!< (@ 0x4004C004) Pin Interrupt Enable (Rising) register */
+(unsigned int)&LPC_GPIO_PIN_INT->SIENR, /*!< (@ 0x4004C008) Set Pin Interrupt Enable (Rising) register */
+(unsigned int)&LPC_GPIO_PIN_INT->CIENR, /*!< (@ 0x4004C00C) Clear Pin Interrupt Enable (Rising) register */
+(unsigned int)&LPC_GPIO_PIN_INT->IENF, /*!< (@ 0x4004C010) Pin Interrupt Enable Falling Edge / Active Level register */
+(unsigned int)&LPC_GPIO_PIN_INT->SIENF, /*!< (@ 0x4004C014) Set Pin Interrupt Enable Falling Edge / Active Level register */
+(unsigned int)&LPC_GPIO_PIN_INT->CIENF, /*!< (@ 0x4004C018) Clear Pin Interrupt Enable Falling Edge / Active Level address */
+(unsigned int)&LPC_GPIO_PIN_INT->RISE, /*!< (@ 0x4004C01C) Pin Interrupt Rising Edge register */
+(unsigned int)&LPC_GPIO_PIN_INT->FALL, /*!< (@ 0x4004C020) Pin Interrupt Falling Edge register */
+(unsigned int)&LPC_GPIO_PIN_INT->IST,
+};
+
+const unsigned int REG_Addresses_1B[30] = {};
+
+#if HasInternalComparator == 1
+ void configure_VR_comparator_interrupt(void);
+ void configure_VH_comparator_interrupt(void);
+ void Comparator_Setup(void);
+#else
+ extern "C" void FLEX_INT0_IRQHandler(void);
+ extern "C" void FLEX_INT1_IRQHandler(void);
+ void configure_VH_gpio_interrupt(void);
+ void configure_VR_gpio_interrupt(void);
+#endif
+
+void erase_flags_memory(void);
+void restore_flags(void);
+void Enter_LLS(void);
+void setFlag(volatile unsigned int*);
+bool isFlagSet(volatile unsigned int*);
+void copyRamToFlash(void);
+
+#endif
+#endif
+
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Drivers/asm_restore_KL05Z.s Fri Sep 08 18:01:22 2017 +0000 @@ -0,0 +1,12 @@ + AREA asm_func, CODE, READONLY +; Export my_asm function location so that C compiler can find it and link + EXPORT asm_restoree +asm_restoree + + LDR R2, =0x1FFFFC50 // Use R2 as auxiliary register (address of RAM sector 3) + + LDR R1, [R2] // Load R1 with value of R13 (SP) stored in RAM + MOV SP, R1 // Copy value of R1 into R13 (SP) + + BX LR +END
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Drivers/asm_restore_LPC11U24.s Fri Sep 08 18:01:22 2017 +0000 @@ -0,0 +1,13 @@ + AREA asm_func, CODE, READONLY +; Export my_asm function location so that C compiler can find it and link + EXPORT asm_restore +asm_restore + + LDR R2, =0x10000050 // Use R2 as auxiliary register (address of RAM sector 3) + + LDR R1, [R2] // Load R1 with value of R13 (SP) stored in RAM + MOV SP, R1 // Copy value of R1 into R13 (SP) + + BX LR +END + \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/config.h Fri Sep 08 18:01:22 2017 +0000 @@ -0,0 +1,4 @@ +#define HasInternalComparator 0 //Set on 1 if there is an internal comparator 0 otherwise +#define SaveFlagsInFlash 0 //set on 1 if there is enough Flash memory available for the flags to have their own flash sector, 0 otherwise + //if there is not enough flash memory, the flags will be saved in RAM memory +#define LPC11U24 \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hibernus.cpp Fri Sep 08 18:01:22 2017 +0000
@@ -0,0 +1,249 @@
+/** Hibernus Library
+ * University of Southampton 2017
+ *
+ * Open-source liberary that enable any of your Mbed project work with transient enegy sources.
+ * In order to use this library include the "hibernus.h" header file, and use the "Hibernus()" method at the beginning of you main funtion.
+ * For more details and example see the "main.cpp" exampe file, and the attached documnetation
+ *
+ *
+ * Released under the MIT License: http://mbed.org/license/mit
+ */
+#include "hibernus.h"
+#include "mbed.h"
+#include "config.h"
+#ifdef LPC11U24
+ #include "Driver_LPC11U24.h"
+#endif
+#ifdef KL05Z
+ #include "Driver_KL05Z.h"
+#endif
+
+//11 variables stored at fixed addresses at the beginning of the RAM
+#if SaveFlagsInFlash == 0
+volatile unsigned int FLAG_1 __attribute__((at(RAM_Start+Fixed_Add_Vars_Offset)));// = Flash_Flags_Sector_Start;
+volatile unsigned int FLAG_2 __attribute__((at(RAM_Start+Fixed_Add_Vars_Offset+ 0x4)));// = Flash_Flags_Sector_Start + 0x4;
+volatile unsigned int FLAG_3 __attribute__((at(RAM_Start+Fixed_Add_Vars_Offset+ 0x8)));// = Flash_Flags_Sector_Start + 0x8;
+volatile unsigned int FLAG_4 __attribute__((at(RAM_Start+Fixed_Add_Vars_Offset+ 0xC)));// = Flash_Flags_Sector_Start + 0xC;
+#else
+volatile unsigned int FLAG_1 __attribute__((at(RAM_Start+Fixed_Add_Vars_Offset))) = Flash_Flags_Sector_Start;
+volatile unsigned int FLAG_2 __attribute__((at(RAM_Start+Fixed_Add_Vars_Offset+ 0x4))) = Flash_Flags_Sector_Start + 0x4;
+volatile unsigned int FLAG_3 __attribute__((at(RAM_Start+Fixed_Add_Vars_Offset+ 0x8))) = Flash_Flags_Sector_Start + 0x8;
+volatile unsigned int FLAG_4 __attribute__((at(RAM_Start+Fixed_Add_Vars_Offset+ 0xC))) = Flash_Flags_Sector_Start + 0xC;
+#endif
+
+volatile unsigned int CoreReg_SP __attribute__((at(RAM_Start+Fixed_Add_Vars_Offset+0x10)));
+volatile unsigned int CoreReg_LR __attribute__((at(RAM_Start+Fixed_Add_Vars_Offset+0x14)));
+volatile unsigned int CoreReg_PC __attribute__((at(RAM_Start+Fixed_Add_Vars_Offset+0x18)));
+
+volatile unsigned int n __attribute__((at(RAM_Start+Fixed_Add_Vars_Offset+0x1C))); // Variable used for counting in loops (4 bytes) stored at RAM address (RamStart+0x54)
+volatile unsigned char i __attribute__((at(RAM_Start+Fixed_Add_Vars_Offset+0x20))); // Variable used for counting in loops (1 byte) stored at RAM address (RamStart+0x58)
+
+volatile unsigned int *FLASH_ptr_4B __attribute__((at(RAM_Start+Fixed_Add_Vars_Offset+0x24))); // Pointer that points to flash (4 bytes) stored at RAM address (RamStart+0x5C)
+volatile unsigned int *RAM_ptr __attribute__((at(RAM_Start+Fixed_Add_Vars_Offset+0x28))); // Pointer that points to RAM (4 bytes) stored at RAM address (RamStart+0x60)
+// Arrays used to store the contents of the peripheral registers
+volatile unsigned int dum __attribute__((at(RAM_Start+Fixed_Add_Vars_Offset+0x2C))) = 0x1234FFFF;
+volatile unsigned int REG_Array_4B[No_Of_4B_Peripheral_Reg] __attribute__((at(RAM_Start+Fixed_Add_Vars_Offset+0x30)));;
+volatile unsigned char REG_Array_1B[No_Of_1B_Peripheral_Reg] __attribute__((at(RAM_Start+Fixed_Add_Vars_Offset+0x30+4*No_Of_4B_Peripheral_Reg)));;
+
+volatile unsigned int dummyread; // Variable used for serialization
+
+void Hibernus(){
+ //pc1.printf("flags %x %x ",((unsigned int*)(RAM_Start +Fixed_Add_Vars_Offset+ Fixed_Add_Vars_Size))+(int)((RAM_Size-Fixed_Add_Vars_Offset-Fixed_Add_Vars_Size)/4),&dum);
+ #if SaveFlagsInFlash == 0
+ restore_flags();
+ #endif
+
+ if( isFlagSet(&FLAG_2) && isFlagSet(&FLAG_3) && isFlagSet(&FLAG_4)) // Enter this only after complete shut down
+ {
+ erase_flags_memory();
+ setFlag(&FLAG_1);
+ setFlag(&FLAG_4);
+ }
+
+ if(isFlagSet(&FLAG_1)||isFlagSet(&FLAG_2)||isFlagSet(&FLAG_3)||isFlagSet(&FLAG_4))
+ {
+ __enable_irq(); // Enable interrupts
+ Enter_LLS(); // Enter LLS mode
+ }
+
+ if(!isFlagSet(&FLAG_1)) // If *FLAG_1 is not already set (first time waking up)
+ {
+ erase_flags_memory();
+ setFlag(&FLAG_2);
+
+ #if HasInternalComparator == 1
+ configure_VH_comparator_interrupt();
+ #else
+ configure_VH_gpio_interrupt();
+ #endif
+ __enable_irq(); // Enable interrupts
+ }
+ else{
+ if(isFlagSet(&FLAG_4))
+ {
+ #if HasInternalComparator == 1
+ configure_VH_comparator_interrupt();
+ #else
+ configure_VH_gpio_interrupt();
+ #endif
+
+ erase_flags_memory();
+ setFlag(&FLAG_2);
+ restore();
+ }
+ }
+}
+
+void Save_RAM_Regs(){
+ //Copy the peripheral registers to RAM
+ for(n=0; n<No_Of_4B_Peripheral_Reg;n++){
+ REG_Array_4B[n] = *(unsigned int*)REG_Addresses_4B[n];
+ }
+ for(n=0; n<No_Of_1B_Peripheral_Reg;n++){
+ REG_Array_1B[n] = *(unsigned int*)REG_Addresses_1B[n];
+ }
+
+ //copy all the ram to flash
+ copyRamToFlash();
+}
+
+void Restore_Regs(){
+ //Restore peripheral registers from RAM, After the ram content was copied back from flash, after a restore
+ for(n=0; n<No_Of_4B_Peripheral_Reg; n++){
+ *(unsigned int*) REG_Addresses_4B[n] = REG_Array_4B[n];
+ }
+
+ for(i=0; i<No_Of_1B_Peripheral_Reg; i++){
+ *(unsigned char*) REG_Addresses_1B[i] = REG_Array_1B[i];
+ }
+}
+
+void hibernate(volatile unsigned int Rsp, volatile unsigned int Rlr, volatile unsigned int Rpc){
+
+ if(isFlagSet(&FLAG_2)&& isFlagSet(&FLAG_3) && isFlagSet(&FLAG_4)) // Enter this only after complete shut down
+ {
+ erase_flags_memory(); // Erase flash sector used to save the flags
+ setFlag(&FLAG_1);
+ setFlag(&FLAG_4);
+ }
+
+ if(isFlagSet(&FLAG_2))
+ {
+ // Hibernate procedure
+ __disable_irq(); // Disable interrupts
+
+ //save the core registers
+ CoreReg_SP = Rsp; // 40 for hibernate function 38 otherwsie
+ CoreReg_LR = Rlr; // 34 for hibernate function 2C otherwise
+ CoreReg_PC = Rpc; // 38 for hibernate function 30 otherwise
+
+
+ #if HasInternalComparator == 1
+ Save_RAM_Regs();
+
+ setFlag(&FLAG_3);
+ setFlag(&FLAG_4);
+
+ Comparator_Setup();
+ configure_VH_comparator_interrupt();
+ #else
+ setFlag(getFlag_3());
+ setFlag(getFlag_4());
+
+ Save_RAM_Regs();
+ configure_VH_gpio_interrupt();
+ #endif
+
+ __enable_irq(); // Enable interrupts
+
+ Enter_LLS(); // Enter LLS mode
+ }
+}
+
+void restore(){
+ // Restore procedure
+ __disable_irq(); // Disable interrupts
+
+ erase_flags_memory();
+ setFlag(&FLAG_2);
+
+ //Restore peripheral registers
+ Restore_Regs();
+
+ //Restore RAM
+ FLASH_ptr_4B = (unsigned int*) (flash_ramSection_start);
+ RAM_ptr = (unsigned int*) (RAM_Start);
+
+ //Copy RAM until where the pointers and loop variables are stored
+ //divide it by 4 because the copy is done word by word but byte by byte
+ for(n=0; n<(Fixed_Add_Vars_Offset/4); n++){
+ *(RAM_ptr + n) = *(FLASH_ptr_4B + n);
+ }
+
+ //skip the Core reg and fixed address variables
+ FLASH_ptr_4B = (unsigned int*)(flash_ramSection_start +Fixed_Add_Vars_Offset+ Fixed_Add_Vars_Size);
+ RAM_ptr = (unsigned int*)(RAM_Start +Fixed_Add_Vars_Offset+ Fixed_Add_Vars_Size);
+
+ //copy the rest of the RAM
+ //(RAM_Size-Fixed_Add_Vars_Offset-Fixed_Add_Vars_Size) is the siz eof the rest of the ram that have to be copied
+ //divide it by 4 because the copy is done word by word but byte by byte
+ for(n=1; n<(RAM_Size-Fixed_Add_Vars_Offset-Fixed_Add_Vars_Size)/4; n++){
+ *(RAM_ptr + n) = *(FLASH_ptr_4B + n);
+ }
+
+ //copy the 3 core registers from flash o ram
+ CoreReg_SP=*(unsigned int*)(flash_ramSection_start+Fixed_Add_Vars_Offset+0x10);
+ CoreReg_LR=*(unsigned int*)(flash_ramSection_start+Fixed_Add_Vars_Offset+0x14);
+ CoreReg_PC=*(unsigned int*)(flash_ramSection_start+Fixed_Add_Vars_Offset+0x18);
+
+ #if SaveFlagsInFlash == 1 //if the flags are stored in their own flash sector, their default value(the flags address in their flash sector) have to be restored
+ //otherwise, their value has to be unchanged, there is no need for restore
+ FLAG_1 =*(unsigned int*)(flash_ramSection_start+Fixed_Add_Vars_Offset);
+ FLAG_2 =*(unsigned int*)(flash_ramSection_start+Fixed_Add_Vars_Offset +0x4);
+ FLAG_3 =*(unsigned int*)(flash_ramSection_start+Fixed_Add_Vars_Offset +0x8);
+ FLAG_4 =*(unsigned int*)(flash_ramSection_start+Fixed_Add_Vars_Offset +0xC);
+ #else
+ configure_VH_gpio_interrupt();
+ #endif
+
+ __enable_irq(); // Enable interrupts
+
+ asm_restore(); // Restore the SP
+ _LR = CoreReg_LR; // Restore the LR
+ _PC = CoreReg_PC; // Restore the PC
+}
+
+//use to check if you recover from a sleep without power loss
+//is so, don't restore, and just set the VH interrupt
+void recovery_no_power_loss(){
+
+ if(isFlagSet(getFlag_3())){ // Enter after hibernation with no power loss
+ #if HasInternalComparator == 1
+ configure_VH_comparator_interrupt();
+ #else
+ configure_VH_gpio_interrupt();
+ #endif
+
+ erase_flags_memory(); // Erase flash sector used to save the flags
+ setFlag(getFlag_2());
+
+ __enable_irq(); // Enable interrupts
+ }
+}
+extern "C" volatile unsigned int* getFlag_1(){
+ return &FLAG_1;
+}
+
+extern "C" volatile unsigned int* getFlag_2(){
+ return &FLAG_2;
+}
+
+extern "C" volatile unsigned int* getFlag_3(){
+ return &FLAG_3;
+}
+
+extern "C" volatile unsigned int* getFlag_4(){
+ return &FLAG_4;
+}
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hibernus.h Fri Sep 08 18:01:22 2017 +0000
@@ -0,0 +1,43 @@
+/** Hibernus Library
+ * University of Southampton 2017
+ *
+ * Open-source liberary that enable any of your Mbed project work with transient enegy sources.
+ * In order to use this library include the "hibernus.h" header file, and use the "Hibernus()" method at the beginning of you main funtion.
+ * For more details and example see the "main.cpp" exampe file, and the attached documnetation
+ *
+ *
+ * Released under the MIT License: http://mbed.org/license/mit
+ */
+#ifndef HIBERNUS_H_
+#define HIBERNUS_H_
+
+#define Fixed_Add_Vars_Offset 0x40 //the Offset added to the first address of RAM, in order to compute the address of first fixed Add variable
+#define Fixed_Add_Vars_Size 0x28 //size of the all fixed address variables (0x28 = 44(dec) = 4Bytes*(4 flags+3CoreReg+4LoopVar))
+#define flash_end (FLASH_Start + flash_Size)
+#define ramToFlash_sectors_number (RAM_Size / sector_Size) //how many flash sectors do we have to erase, before saving the RAM content to flash
+#define flash_ramSection_start (flash_end - RAM_Size-SaveFlagsInFlash *sector_Size)
+
+// Declare register integers for the SP, LR, and PC
+register volatile unsigned int _SP __asm("r13");
+register volatile unsigned int _LR __asm("r14");
+register volatile unsigned int _PC __asm("r15");
+
+// Value written to non-volatile flags to indicate that they are set or not
+#define Flag_set 0xFFFF0000
+#define Flag_erase 0xFFFFFFFF
+
+// Declare external assembly language function (in a *.s file)
+extern "C" void asm_restore(void);
+extern "C" volatile unsigned int* getFlag_1(void);
+extern "C" volatile unsigned int* getFlag_2(void);
+extern "C" volatile unsigned int* getFlag_3(void);
+extern "C" volatile unsigned int* getFlag_4(void);
+
+void Hibernus(void);
+void Save_RAM_Regs(void);
+void Restore_Regs(void);
+void restore(void);
+void hibernate(volatile unsigned int sp, volatile unsigned int lr, volatile unsigned int pc);
+void recovery_no_power_loss(void);
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp Fri Sep 08 18:01:22 2017 +0000
@@ -0,0 +1,42 @@
+/** Hibernus Library
+ * University of Southampton 2017
+ *
+ * Open-source liberary that enable any of your Mbed project work with transient enegy sources.
+ * In order to use this library include the "hibernus.h" header file, and use the "Hibernus()" method at the beginning of you main funtion.
+ * For more details and example see the "main.cpp" exampe file, and the attached documnetation
+ *
+ *
+ * Released under the MIT License: http://mbed.org/license/mit
+ */
+#include "hibernus.h"
+#include "mbed.h"
+
+DigitalOut bit0(LED1);
+DigitalOut bit1(LED2);
+DigitalOut bit2(LED3);
+DigitalOut bit3(LED4);
+
+int main()
+{
+ int c;
+ Hibernus();
+ while(1) // Binary counter
+ {
+ bit0 = 0; bit1 = 0; bit2 = 0; bit3 = 0; for(c = 0; c<2000000; c++); // 0
+ bit0 = 1; bit1 = 0; bit2 = 0; bit3 = 0; for(c = 0; c<2000000; c++); // 1
+ bit0 = 0; bit1 = 1; bit2 = 0; bit3 = 0; for(c = 0; c<2000000; c++); // 2
+ bit0 = 1; bit1 = 1; bit2 = 0; bit3 = 0; for(c = 0; c<2000000; c++); // 3
+ bit0 = 0; bit1 = 0; bit2 = 1; bit3 = 0; for(c = 0; c<2000000; c++); // 4
+ bit0 = 1; bit1 = 0; bit2 = 1; bit3 = 0; for(c = 0; c<2000000; c++); // 5
+ bit0 = 0; bit1 = 1; bit2 = 1; bit3 = 0; for(c = 0; c<2000000; c++); // 6
+ bit0 = 1; bit1 = 1; bit2 = 1; bit3 = 0; for(c = 0; c<2000000; c++); // 7
+ bit0 = 0; bit1 = 0; bit2 = 0; bit3 = 1; for(c = 0; c<2000000; c++); // 8
+ bit0 = 1; bit1 = 0; bit2 = 0; bit3 = 1; for(c = 0; c<2000000; c++); // 9
+ bit0 = 0; bit1 = 1; bit2 = 0; bit3 = 1; for(c = 0; c<2000000; c++); // 10
+ bit0 = 1; bit1 = 1; bit2 = 0; bit3 = 1; for(c = 0; c<2000000; c++); // 11
+ bit0 = 0; bit1 = 0; bit2 = 1; bit3 = 1; for(c = 0; c<2000000; c++); // 12
+ bit0 = 1; bit1 = 0; bit2 = 1; bit3 = 1; for(c = 0; c<2000000; c++); // 13
+ bit0 = 0; bit1 = 1; bit2 = 1; bit3 = 1; for(c = 0; c<2000000; c++); // 14
+ bit0 = 1; bit1 = 1; bit2 = 1; bit3 = 1; for(c = 0; c<2000000; c++); // 15
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mbed.bld Fri Sep 08 18:01:22 2017 +0000 @@ -0,0 +1,1 @@ +https://mbed.org/users/mbed_official/code/mbed/builds/a330f0fddbec \ No newline at end of file
Repository toolbox
| Export to desktop IDE |
| Build repository |
Repository details
| Type: | Program |
|---|---|
| Mbed OS support: | Mbed 2 deprecated |
| Created: | 10 Oct 2017 |
| Imports: | 12 |
| Forks: | 0 |
| Commits: | 1 |
| Dependents: | 0 |
| Dependencies: | 1 |
| Followers: | 6 |
