void __lcd_init()
{
/* Initialize segment LCD. */
SegmentLCD_Init(false);
/* Turn all LCD segments off. */
SegmentLCD_AllOff();
}
/**************************************************************************//**
* @brief RTC_IRQHandler
* Interrupt Service Routine for RTC Interrupt Line
*****************************************************************************/
void RTC_IRQHandler(void)
{
/* Clear interrupt flag */
RTC_IntClear(RTC_IFS_COMP0);
/* Disable RTC */
RTC_Enable(false);
/* Turn off all segments */
SegmentLCD_AllOff();
/* Disable LCD to avoid excessive current consumption */
LCD_Enable(false);
/* Wait until SYNCBUSY_CTRL flag is cleared. */
LCD_SyncBusyDelay(LCD_SYNCBUSY_CTRL);
/* Disable clock for LCD. */
CMU_ClockEnable(cmuClock_LCD, false);
}
/**************************************************************************//**
* @brief Main function.
*****************************************************************************/
int main( void )
{
int i;
MPU_RegionInit_TypeDef flashInit = MPU_INIT_FLASH_DEFAULT;
MPU_RegionInit_TypeDef sramInit = MPU_INIT_SRAM_DEFAULT;
MPU_RegionInit_TypeDef peripheralInit = MPU_INIT_PERIPHERAL_DEFAULT;
/* Chip alignment */
CHIP_Init();
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Enable LCD without voltage boost */
SegmentLCD_Init( false );
SegmentLCD_AllOff();
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, 1);
SegmentLCD_Symbol(LCD_SYMBOL_EFM32, 1);
GpioInit();
RTCDRV_Setup( cmuSelect_LFXO, cmuClkDiv_32);
ScrollText( " MPU DEMO PRESS Pb0 OR Pb1 "
"TO GENERATE MPU EXCEPTIONS " );
MPU_Disable();
/* Flash memory */
MPU_ConfigureRegion( &flashInit );
/* SRAM */
MPU_ConfigureRegion( &sramInit );
/* SRAM, a 4k part with priviledged only access, this regions settings */
/* will override those of the previous region */
sramInit.regionNo = 2;
sramInit.baseAddress = RAM_MEM_BASE + 0x2000;
sramInit.size = mpuRegionSize4Kb;
sramInit.accessPermission = mpuRegionApPRw;
MPU_ConfigureRegion( &sramInit );
/* LCD, priviledged only access */
peripheralInit.regionNo = 3;
peripheralInit.baseAddress = LCD_BASE;
peripheralInit.size = mpuRegionSize128b;
peripheralInit.accessPermission = mpuRegionApPRw;
MPU_ConfigureRegion( &peripheralInit );
MPU_Enable( MPU_CTRL_PRIVDEFENA ); /* Full access to default memory map */
/* in priviledged state */
i = 0;
while ( 1 )
{
SegmentLCD_Number( i ); /* Count on numeric diplay */
i = ( i + 1 ) % 101;
RTCDRV_Delay( 150 , false);
if ( PB0_PUSHED() )
{
BullsEye( 1 );
/* Generate an access violation in internal SRAM */
__set_CONTROL( 1 ); /* Enter User (unpriviledged) state */
*(volatile uint32_t *)(RAM_MEM_BASE + 0x2000) = 1;
BullsEye( 0 );
}
if ( PB1_PUSHED() )
{
BullsEye( 1 );
/* Generate an access violation in LCD peripheral */
__set_CONTROL( 1 ); /* Enter User (unpriviledged) state */
BullsEye( 0 );
}
}
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
/* Chip errata */
CHIP_Init();
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Initialize LCD controller without boost */
SegmentLCD_Init(false);
/* Disable all segments */
SegmentLCD_AllOff();
/* Copy contents of the userpage (flash) into the userData struct */
memcpy((void *) &userData, (void *) USERPAGE, sizeof(UserData_TypeDef));
/* Special case for uninitialized data */
if (userData.number > 10000)
userData.number = 0;
if (userData.numWrites == 0xFFFFFFFF)
userData.numWrites = 0;
/* Display the number */
SegmentLCD_Number(userData.number);
/* Setup GPIO interrupts. PB0 to increase number, PB1 to save to flash */
gpioSetup();
/* No save has occured yet */
recentlySaved = false;
/* Main loop - just scroll informative text describing the current state of
* the system */
while (1)
{
switch (currentError)
{
case mscReturnInvalidAddr:
ScrollText(" ERROR: INVALID ADDRESS ");
break;
case mscReturnLocked:
ScrollText(" ERROR: USER PAGE IS LOCKED ");
break;
case mscReturnTimeOut:
ScrollText(" ERROR: TIMEOUT OCCURED ");
break;
case mscReturnUnaligned:
ScrollText(" ERROR: UNALIGNED ACCESS ");
default:
if (recentlySaved)
{
recentlySaved = false;
SegmentLCD_Number(userData.numWrites);
ScrollText(" SAVE NUMBER ");
}
else
{
SegmentLCD_Number(userData.number);
ScrollText(" PRESS PB0 TO INCREASE NUMBER. PB1 TO SAVE TO INTERNAL FLASH ");
}
break;
}
}
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
SYSTEM_ChipRevision_TypeDef revision;
char string[8];
int i;
uint32_t temp;
/* Chip revision alignment and errata fixes */
CHIP_Init();
/* Initialize DVK board register access */
BSP_Init(BSP_INIT_DEFAULT);
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
CMU_ClockEnable(cmuClock_HFPER, true);
CMU_ClockEnable(cmuClock_ADC0, true);
CMU_ClockEnable(cmuClock_GPIO, true);
/* Initialize LCD controller without boost */
SegmentLCD_Init(false);
SegmentLCD_AllOff();
/* Check for revision after revision B. Chips with revision earlier than */
/* Revision C has known problems with the internal temperature sensor. */
/* Display a warning in this case */
SYSTEM_ChipRevisionGet(&revision);
if (revision.minor < 2)
{
SegmentLCD_Write("WARNING");
RTCDRV_Trigger(2000, NULL);
EMU_EnterEM2(true);
SegmentLCD_Write("REV C+");
RTCDRV_Trigger(2000, NULL);
EMU_EnterEM2(true);
SegmentLCD_Write("REQUIRD");
RTCDRV_Trigger(2000, NULL);
EMU_EnterEM2(true);
}
/* Enable board control interrupts */
BSP_InterruptDisable(0xffff);
BSP_InterruptFlagsClear(0xffff);
BSP_InterruptEnable(BC_INTEN_JOYSTICK);
temperatureIRQInit();
/* Setup ADC for sampling internal temperature sensor. */
setupSensor();
/* Main loop - just read temperature and update LCD */
while (1)
{
/* Start one ADC sample */
ADC_Start(ADC0, adcStartSingle);
/* Wait in EM1 for ADC to complete */
EMU_EnterEM1();
/* Read sensor value */
temp = ADC_DataSingleGet(ADC0);
/* Convert ADC sample to Fahrenheit / Celsius and print string to display */
if (showFahrenheit)
{
/* Show Fahrenheit on alphanumeric part of display */
i = (int)(convertToFahrenheit(temp) * 10);
snprintf(string, 8, "%2d,%1d%%F", (i/10), i%10);
/* Show Celsius on numeric part of display */
i = (int)(convertToCelsius(temp) * 10);
SegmentLCD_Number(i*10);
SegmentLCD_Symbol(LCD_SYMBOL_DP10, 1);
}
else
{
/* Show Celsius on alphanumeric part of display */
i = (int)(convertToCelsius(temp) * 10);
snprintf(string, 8, "%2d,%1d%%C", (i/10), i%10);
/* Show Fahrenheit on numeric part of display */
i = (int)(convertToFahrenheit(temp) * 10);
SegmentLCD_Number(i*10);
SegmentLCD_Symbol(LCD_SYMBOL_DP10, 1);
}
SegmentLCD_Write(string);
/* Sleep for 2 seconds in EM 2 */
RTCDRV_Trigger(2000, NULL);
EMU_EnterEM2(true);
}
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
/* Chip errata */
CHIP_Init();
/* Use 32MHZ HFXO as core clock frequency*/
CMU_ClockSelectSet(cmuClock_HF, cmuSelect_HFXO);
/* Enable clock for HF peripherals */
CMU_ClockEnable(cmuClock_HFPER, true);
/* Enabling clock to USART0*/
CMU_ClockEnable(cmuClock_USART0, true);
/* Enable clock for GPIO module (required for pin configuration) */
CMU_ClockEnable(cmuClock_GPIO, true);
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Setup SysTick Timer for 1 msec interrupts */
if (SysTick_Config(CMU_ClockFreqGet(cmuClock_CORE) / 1000)) while (1) ;
/* Enable LCD without voltage boost */
SegmentLCD_Init(false);
/* Enable all segments */
SegmentLCD_AllOff();
SegmentLCD_Write("GPS!");
Delay(2000);
SegmentLCD_AllOff();
/* Initialization of GPS */
GPS_Initialization();
SegmentLCD_Write("SD!");
Delay(2000);
SegmentLCD_AllOff();
/* Initialization of SDCARD */
SDCARD_Initialization();
SegmentLCD_AllOff();
SegmentLCD_Write("DONE!");
Delay(2000);
SegmentLCD_AllOff();
/* Infinite loop with test pattern. */
while (1)
{
/* Wait for data in sleep mode */
GPS_WaitForData(&gpsData);
/* Save it on SDCARD */
SDCARD_Save(&gpsData);
/* Indicate on LCD */
LCD_Show();
}
}
/***************************************************************************//**
* @fn LCD_Show
* @brief Indicate positive saved data on SDCARD
*******************************************************************************/
void LCD_Show()
{
SegmentLCD_Write("GOT!");
Delay(200);
SegmentLCD_AllOff();
}
void lcd_clear()
{
SegmentLCD_AllOff();
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
I2C_Init_TypeDef i2cInit = I2C_INIT_DEFAULT;
TEMPSENS_Temp_TypeDef temp;
/* Define previous temp to invalid, just to ensure update first time */
TEMPSENS_Temp_TypeDef prevTemp = { 1000, 0};
int prevShowFahrenheit = showFahrenheit;
/* Chip revision alignment and errata fixes */
CHIP_Init();
/* Initialize DVK board register access */
BSP_Init(BSP_INIT_DEFAULT);
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Initialize LCD controller without boost */
SegmentLCD_Init(false);
SegmentLCD_AllOff();
/* Enable board control interrupts */
BSP_InterruptDisable(0xffff);
BSP_InterruptFlagsClear(0xffff);
BSP_InterruptEnable(BC_INTEN_JOYSTICK);
temperatureIRQInit();
/* Initialize I2C driver, using standard rate. Devices on DVK itself */
/* supports fast mode, but in case some slower devices are added on */
/* prototype board, we use standard mode. */
I2CDRV_Init(&i2cInit);
/* Main loop - just read temperature and update LCD */
while (1)
{
if (TEMPSENS_TemperatureGet(I2C0,
TEMPSENS_DK_ADDR,
&temp) < 0)
{
SegmentLCD_Write("ERROR");
/* Enter EM2, no wakeup scheduled */
EMU_EnterEM2(true);
}
/* Update LCD display if any change. This is just an example of how */
/* to save some energy, since the temperature normally is quite static. */
/* The compare overhead is much smaller than actually updating the display. */
if ((prevTemp.i != temp.i) ||
(prevTemp.f != temp.f) ||
(prevShowFahrenheit != showFahrenheit))
{
temperatureUpdateLCD(&temp);
}
prevTemp = temp;
prevShowFahrenheit = showFahrenheit;
/* Read every 2 seconds which is more than it takes worstcase to */
/* finish measurement inside sensor. */
RTCDRV_Trigger(2000, NULL);
EMU_EnterEM2(true);
}
}
/**************************************************************************//**
* @brief LCD Test Routine, shows various text and patterns
*****************************************************************************/
void Test(void)
{
int i, numberOfIterations = 0;
/* Initialize GPIO */
GPIO_IRQInit();
/* Initialize RTC */
RTCDRV_Setup(cmuSelect_LFRCO, cmuClkDiv_32);
/* Loop through funny pattern */
while (1)
{
SegmentLCD_AllOff();
#if VBOOST_SUPPORT
checkVoltage();
#endif
if (emMode != DEMO_MODE_NONE)
{
SegmentLCD_Symbol(LCD_SYMBOL_PAD0, 1);
SegmentLCD_Symbol(LCD_SYMBOL_PAD1, 1);
}
else
{
for (i = 100; i > 0; i--)
{
SegmentLCD_Number(i);
EM2Sleep(10);
}
SegmentLCD_NumberOff();
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, 1);
SegmentLCD_Symbol(LCD_SYMBOL_EFM32, 1);
SegmentLCD_Write(" TINY ");
EM2Sleep(500);
SegmentLCD_Write(" Gecko ");
EM2Sleep(1000);
SegmentLCD_AllOn();
EM2Sleep(1000);
SegmentLCD_AllOff();
}
if (emMode != DEMO_MODE_NONE)
{
SegmentLCD_Symbol(LCD_SYMBOL_PAD0, 1);
SegmentLCD_Symbol(LCD_SYMBOL_PAD1, 1);
}
else
{
SegmentLCD_Write("OOOOOOO");
EM2Sleep(62);
SegmentLCD_Write("XXXXXXX");
EM2Sleep(62);
SegmentLCD_Write("+++++++");
EM2Sleep(62);
SegmentLCD_Write("@@@@@@@");
EM2Sleep(62);
SegmentLCD_Write("ENERGY ");
EM2Sleep(250);
SegmentLCD_Write("@@ERGY ");
EM2Sleep(62);
SegmentLCD_Write(" @@RGY ");
EM2Sleep(62);
SegmentLCD_Write(" M@@GY ");
EM2Sleep(62);
SegmentLCD_Write(" MI@@Y ");
EM2Sleep(62);
SegmentLCD_Write(" MIC@@ ");
EM2Sleep(62);
SegmentLCD_Write(" MICR@@");
EM2Sleep(62);
SegmentLCD_Write(" MICRO@");
EM2Sleep(62);
SegmentLCD_Write(" MICRO ");
EM2Sleep(250);
SegmentLCD_Write("-EFM32-");
EM2Sleep(250);
/* Various eye candy */
SegmentLCD_AllOff();
if (emMode != DEMO_MODE_NONE)
{
SegmentLCD_Symbol(LCD_SYMBOL_PAD0, 1);
SegmentLCD_Symbol(LCD_SYMBOL_PAD1, 1);
}
for (i = 0; i < 8; i++)
{
SegmentLCD_Number(numberOfIterations + i);
SegmentLCD_ARing(i, 1);
EM2Sleep(20);
}
for (i = 0; i < 8; i++)
{
SegmentLCD_Number(numberOfIterations + i);
SegmentLCD_ARing(i, 0);
EM2Sleep(100);
}
for (i = 0; i < 5; i++)
{
SegmentLCD_Number(numberOfIterations + i);
SegmentLCD_Battery(i);
SegmentLCD_EnergyMode(i, 1);
EM2Sleep(100);
SegmentLCD_EnergyMode(i, 0);
EM2Sleep(100);
}
SegmentLCD_Symbol(LCD_SYMBOL_ANT, 1);
for (i = 0; i < 4; i++)
{
SegmentLCD_EnergyMode(i, 1);
EM2Sleep(100);
}
SegmentLCD_Symbol(LCD_SYMBOL_ANT, 0);
SegmentLCD_Battery(0);
}
/* Energy Modes */
SegmentLCD_NumberOff();
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, 1);
SegmentLCD_Symbol(LCD_SYMBOL_EFM32, 1);
if ((emMode != DEMO_MODE_EM3) && (emMode != DEMO_MODE_EM4))
{
ScrollText("Energy Mode demo, Press PB0 for EM3 or PB1 for EM4 ");
}
SegmentLCD_Write(" EM0 ");
SegmentLCD_Number(0);
SegmentLCD_EnergyMode(0, 1);
SegmentLCD_EnergyMode(1, 1);
SegmentLCD_EnergyMode(2, 1);
SegmentLCD_EnergyMode(3, 1);
SegmentLCD_EnergyMode(4, 1);
RTCDRV_Delay(4000, false);
SegmentLCD_Write(" EM1 ");
SegmentLCD_Number(1111);
SegmentLCD_EnergyMode(0, 0);
EM1Sleep(4000);
SegmentLCD_Write(" EM2 ");
SegmentLCD_Number(2222);
SegmentLCD_EnergyMode(1, 0);
EM2Sleep(4000);
/* Check if somebody has pressed one of the buttons */
if (emMode == DEMO_MODE_EM3)
{
ScrollText("Going down to EM3, press PB0 to wake up ");
SegmentLCD_Write(" EM3 ");
SegmentLCD_Number(3333);
RTCDRV_Delay(1000, false);
/* Wake up on GPIO interrupt */
EM3Sleep();
SegmentLCD_Number(0000);
SegmentLCD_Write("--EM0--");
RTCDRV_Delay(500, false);
SegmentLCD_Symbol(LCD_SYMBOL_PAD0, 0);
SegmentLCD_Symbol(LCD_SYMBOL_PAD1, 0);
emMode = DEMO_MODE_NONE;
}
/* Check if somebody's joystick down */
if (emMode == DEMO_MODE_EM4)
{
ScrollText("Going down to EM4, press reset to restart ");
SegmentLCD_Write(" EM4 ");
SegmentLCD_Number(4444);
RTCDRV_Delay(1000, false);
/* Wake up on reset */
EM4Sleep();
}
SegmentLCD_EnergyMode(0, 0);
SegmentLCD_EnergyMode(1, 0);
SegmentLCD_EnergyMode(2, 0);
SegmentLCD_EnergyMode(3, 0);
SegmentLCD_EnergyMode(4, 0);
/* Scrolltext */
ScrollText(stext);
/* Blink and animation featurs */
BlinkTest();
numberOfIterations++;
}
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
uint8_t prod_rev;
char string[8];
int i;
uint32_t temp;
uint32_t temp_offset;
/* Chip errata */
CHIP_Init();
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Enable peripheral clocks */
CMU_ClockEnable(cmuClock_HFPER, true);
CMU_ClockEnable(cmuClock_ADC0, true);
/* Initialize RTC timer. */
RTCDRV_Init();
RTCDRV_AllocateTimer( &xTimerForWakeUp);
/* Initialize LCD controller without boost */
SegmentLCD_Init(false);
SegmentLCD_AllOff();
/* This is a work around for Chip Rev.D Errata, Revision 0.6. */
/* Check for product revision 16 and 17 and set the offset */
/* for ADC0_TEMP_0_READ_1V25. */
prod_rev = (DEVINFO->PART & _DEVINFO_PART_PROD_REV_MASK) >> _DEVINFO_PART_PROD_REV_SHIFT;
if( (prod_rev == 16) || (prod_rev == 17) )
{
temp_offset = 112;
}
else
{
temp_offset = 0;
}
/* Enable board control interrupts */
gpioSetup();
/* Setup ADC for sampling internal temperature sensor. */
setupSensor();
/* Main loop - just read temperature and update LCD */
while (1)
{
/* Start one ADC sample */
ADC_Start(ADC0, adcStartSingle);
/* Wait in EM1 for ADC to complete */
EMU_EnterEM1();
/* Read sensor value */
/* According to rev. D errata ADC0_TEMP_0_READ_1V25 should be decreased */
/* by the offset but it is the same if ADC reading is increased - */
/* reference manual 28.3.4.2. */
temp = ADC_DataSingleGet(ADC0) + temp_offset;
/* Convert ADC sample to Fahrenheit / Celsius and print string to display */
if (showFahrenheit)
{
/* Show Fahrenheit on alphanumeric part of display */
i = (int)(convertToFahrenheit(temp) * 10);
snprintf(string, 8, "%2d,%1d%%F", (i/10), abs(i%10));
/* Show Celsius on numeric part of display */
i = (int)(convertToCelsius(temp) * 10);
SegmentLCD_Number(i*10);
SegmentLCD_Symbol(LCD_SYMBOL_DP10, 1);
SegmentLCD_Symbol(LCD_SYMBOL_DEGC, 1);
SegmentLCD_Symbol(LCD_SYMBOL_DEGF, 0);
}
else
{
/* Show Celsius on alphanumeric part of display */
i = (int)(convertToCelsius(temp) * 10);
snprintf(string, 8, "%2d,%1d%%C", (i/10), abs(i%10));
/* Show Fahrenheit on numeric part of display */
i = (int)(convertToFahrenheit(temp) * 10);
SegmentLCD_Number(i*10);
SegmentLCD_Symbol(LCD_SYMBOL_DP10, 1);
SegmentLCD_Symbol(LCD_SYMBOL_DEGC, 0);
SegmentLCD_Symbol(LCD_SYMBOL_DEGF, 1);
}
SegmentLCD_Write(string);
/* Sleep for 2 seconds in EM 2 */
RTCDRV_StartTimer( xTimerForWakeUp, rtcdrvTimerTypeOneshot, 2000, NULL, NULL);
EMU_EnterEM2(true);
}
}
void lcd_all_off()
{
SegmentLCD_AllOff();
}
/**************************************************************************//**
* @brief LCD Test Routine, shows various text and patterns
*****************************************************************************/
void Test(void)
{
int i, numberOfIterations = 0;
/* Initialize GPIO */
GPIO_IRQInit();
/* Loop through funny pattern */
while (1)
{
SegmentLCD_AllOff();
if (emMode == DEMO_MODE_NONE)
{
for (i = 100; i > 0; i--)
{
SegmentLCD_Number(i);
EM2Sleep(10);
}
SegmentLCD_NumberOff();
SegmentLCD_Symbol(LCD_SYMBOL_OLIMEX, 1);
SegmentLCD_Write(" Gecko ");
EM2Sleep(1000);
SegmentLCD_AllOn();
EM2Sleep(1000);
SegmentLCD_AllOff();
SegmentLCD_Write("OPENOCD");
EM2Sleep(2000);
SegmentLCD_Write("GDB");
EM2Sleep(2000);
SegmentLCD_Write("DONE");
EM2Sleep(2000);
SegmentLCD_Write("XXXXXXX");
EM2Sleep(500);
SegmentLCD_Write("-EFM32-");
EM2Sleep(2000);
/* Various eye candy */
SegmentLCD_AllOff();
for (i = 0; i < 17; i++)
{
SegmentLCD_LowerNumber( i);
SegmentLCD_Battery(i);
SegmentLCD_UnsignedHex(numberOfIterations +i);
EM2Sleep(200);
}
SegmentLCD_Symbol(LCD_SYMBOL_ARR_UP, 1);
EM2Sleep(200);
SegmentLCD_Symbol(LCD_SYMBOL_ARR_DN, 1);
EM2Sleep(200);
SegmentLCD_Symbol(LCD_SYMBOL_ARR_L, 1);
EM2Sleep(200);
SegmentLCD_Symbol(LCD_SYMBOL_ARR_R, 1);
EM2Sleep(200);
SegmentLCD_Symbol(LCD_SYMBOL_MINUS, 1);
SegmentLCD_Symbol(LCD_SYMBOL_PLUS, 1);
EM2Sleep(100);
SegmentLCD_Symbol(LCD_SYMBOL_u, 1);
SegmentLCD_Symbol(LCD_SYMBOL_m, 1);
SegmentLCD_Symbol(LCD_SYMBOL_H, 1);
SegmentLCD_Symbol(LCD_SYMBOL_F, 1);
EM2Sleep(200);
SegmentLCD_Symbol(LCD_SYMBOL_2COL, 1);
SegmentLCD_Symbol(LCD_SYMBOL_3COL, 1);
SegmentLCD_Symbol(LCD_SYMBOL_4COL, 1);
SegmentLCD_Symbol(LCD_SYMBOL_5COL, 1);
SegmentLCD_Symbol(LCD_SYMBOL_6COL, 1);
SegmentLCD_Symbol(LCD_SYMBOL_10COL, 1);
SegmentLCD_Symbol(LCD_SYMBOL_1DP, 1);
SegmentLCD_Symbol(LCD_SYMBOL_2DP, 1);
SegmentLCD_Symbol(LCD_SYMBOL_3DP, 1);
SegmentLCD_Symbol(LCD_SYMBOL_4DP, 1);
SegmentLCD_Symbol(LCD_SYMBOL_5DP, 1);
SegmentLCD_Symbol(LCD_SYMBOL_6DP, 1);
SegmentLCD_Symbol(LCD_SYMBOL_8DP, 1);
SegmentLCD_Symbol(LCD_SYMBOL_10DP, 1);
SegmentLCD_Symbol(LCD_SYMBOL_11DP, 1);
EM2Sleep(800);
SegmentLCD_AllOff();
/* Energy Modes */
SegmentLCD_Number(0);
SegmentLCD_Battery(0);
SegmentLCD_Write(" EM0 ");
RTCDRV_Delay(2000, false);
SegmentLCD_Number(1111);
SegmentLCD_Battery(1);
SegmentLCD_Write(" EM1 ");
EM1Sleep(2000);
SegmentLCD_Number(2222);
SegmentLCD_Battery(2);
SegmentLCD_Write(" EM2 ");
EM2Sleep(2000);
ScrollText("Energy Mode demo, Press BUT2 for EM3 or BUT1 for EM4 ");
EM2Sleep(500);
SegmentLCD_Write("PRESS x");
EM2Sleep(2000);
}
/* Check if somebody has pressed one of the buttons */
if (emMode == DEMO_MODE_EM3)
{
SegmentLCD_Number(3333);
SegmentLCD_Battery(3);
SegmentLCD_Arrows(0, 1); //arrow down, go to sleep in EM3
ScrollText("Going down to EM3, press BUT2 to wake up ");
SegmentLCD_Write(" EM3 ");
RTCDRV_Delay(1000, false);
/* Wake up on GPIO interrupt */
EM3Sleep();
SegmentLCD_Battery(0);
SegmentLCD_Arrows(0, 0); //arrow down off
SegmentLCD_Arrows(2, 1); //arrow up, wakeup from sleep in EM3
SegmentLCD_Write("wakeup");
RTCDRV_Delay(1500, false);
SegmentLCD_Arrows(2, 0); //arrow up off
SegmentLCD_Battery(0);
SegmentLCD_Number(0000);
SegmentLCD_Write("--EM0--");
RTCDRV_Delay(500, false);
}
/* Check if somebody's joystick down */
if (emMode == DEMO_MODE_EM4)
{
SegmentLCD_Number(4444);
SegmentLCD_Battery(4);
SegmentLCD_Arrows(0, 1); //arrow down, go to sleep in EM4
ScrollText("Going down to EM4, press reset to restart ");
SegmentLCD_Write(" EM4 ");
RTCDRV_Delay(1000, false);
/* Wake up on reset */
EM4Sleep();
}
/* Scrolltext */
ScrollText(stext);
numberOfIterations++;
}
}
