/**************************************************************************//**
* @brief GPIO Interrupt handler
*****************************************************************************/
void GPIO_EVEN_IRQHandler(void)
{
uint16_t joystick;
/* Clear interrupt */
BSP_InterruptFlagsClear(BC_INTEN_JOYSTICK);
GPIO_IntClear(1 << 14);
/* Read and store joystick activity */
joystick = BSP_JoystickGet();
/* One bit for each direction left/right/up/down + button */
switch (joystick)
{
case JOY_MODE_BUTTON:
emMode = JOY_MODE_NONE;
BSP_LedsSet(0x0000);
SegmentLCD_Symbol(LCD_SYMBOL_PAD0, 0);
SegmentLCD_Symbol(LCD_SYMBOL_PAD1, 0);
break;
case JOY_MODE_EM3:
case JOY_MODE_EM4:
emMode = joystick;
BSP_LedsSet(0xffff);
SegmentLCD_Symbol(LCD_SYMBOL_PAD0, 1);
SegmentLCD_Symbol(LCD_SYMBOL_PAD1, 1);
break;
default:
break;
}
}
void lcd_write_number(int value)
{
SegmentLCD_Symbol(LCD_SYMBOL_DP10, 0);
SegmentLCD_Symbol(LCD_SYMBOL_DEGC, 0);
SegmentLCD_Symbol(LCD_SYMBOL_DEGF, 0);
SegmentLCD_Number(value);
}
/**************************************************************************//**
* @brief LCD Blink Test
*****************************************************************************/
void BlinkTest(void)
{
SegmentLCD_EnergyMode(0, 1);
SegmentLCD_EnergyMode(1, 1);
SegmentLCD_EnergyMode(2, 1);
SegmentLCD_EnergyMode(3, 1);
SegmentLCD_EnergyMode(4, 1);
/* 2 minutes to midnight */
SegmentLCD_Number(2358);
SegmentLCD_Symbol(LCD_SYMBOL_COL10, 1);
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, 1);
SegmentLCD_Symbol(LCD_SYMBOL_EFM32, 1);
SegmentLCD_Write(" EFM32 ");
LCD_BlinkEnable(true);
LCD_SyncBusyDelay(0xFFFFFFFF) ;
EM2Sleep(2000);
SegmentLCD_EnergyMode(4, 0);
EM2Sleep(62);
SegmentLCD_EnergyMode(3, 0);
EM2Sleep(62);
SegmentLCD_EnergyMode(2, 0);
EM2Sleep(62);
SegmentLCD_EnergyMode(1, 0);
EM2Sleep(62);
SegmentLCD_EnergyMode(0, 0);
LCD_BlinkEnable(false);
LCD_SyncBusyDelay(0xFFFFFFFF);
}
/**************************************************************************//**
* @brief LCD Blink Test
*****************************************************************************/
void BlinkTest(void)
{
SegmentLCD_EnergyMode(0, 1);
SegmentLCD_EnergyMode(1, 1);
SegmentLCD_EnergyMode(2, 1);
SegmentLCD_EnergyMode(3, 1);
SegmentLCD_EnergyMode(4, 1);
/* 2 minutes to midnight */
SegmentLCD_Number(2358);
SegmentLCD_Symbol(LCD_SYMBOL_COL10, 1);
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, 1);
SegmentLCD_Symbol(LCD_SYMBOL_EFM32, 1);
SegmentLCD_Write(" EFM32 ");
LCD->BACTRL |= LCD_BACTRL_BLINKEN;
while (LCD->SYNCBUSY) ;
EM2Sleep(2000);
SegmentLCD_EnergyMode(4, 0);
EM2Sleep(62);
SegmentLCD_EnergyMode(3, 0);
EM2Sleep(62);
SegmentLCD_EnergyMode(2, 0);
EM2Sleep(62);
SegmentLCD_EnergyMode(1, 0);
EM2Sleep(62);
SegmentLCD_EnergyMode(0, 0);
LCD->BACTRL &= ~LCD_BACTRL_BLINKEN;
while (LCD->SYNCBUSY) ;
}
/**************************************************************************//**
* @brief Update LCD with temperature
* @param[in] temp Temperature to display.
*****************************************************************************/
void temperatureUpdateLCD(TEMPSENS_Temp_TypeDef *temp)
{
char text[8];
TEMPSENS_Temp_TypeDef dtemp;
/* Work with local copy in case conversion to Fahrenheit is required */
dtemp = *temp;
memset(text, ' ', sizeof(text) - 1);
text[sizeof(text) - 1] = 0;
if (SHOW_FAHRENHEIT)
{
text[5] = 'F';
TEMPSENS_Celsius2Fahrenheit(&dtemp);
}
else
{
text[5] = 'C';
}
/* Round temperature to nearest 0.5 */
if (dtemp.f >= 0)
{
dtemp.i += (dtemp.f + 2500) / 10000;
dtemp.f = (((dtemp.f + 2500) % 10000) / 5000) * 5000;
}
else
{
dtemp.i += (dtemp.f - 2500) / 10000;
dtemp.f = (((dtemp.f - 2500) % 10000) / 5000) * 5000;
}
/* 100s */
if (abs(dtemp.i) >= 100)
text[0] = '0' + (abs(dtemp.i) / 100);
/* 10s */
if (abs(dtemp.i) >= 10)
text[1] = '0' + ((abs(dtemp.i) % 100) / 10);
/* 1s */
text[2] = '0' + (abs(dtemp.i) % 10);
/* 0.1s */
text[3] = '0' + (abs(dtemp.f) / 1000);
SegmentLCD_Write(text);
SegmentLCD_Symbol(LCD_SYMBOL_DP4, 1);
if ((dtemp.i < 0) || (dtemp.f < 0))
{
SegmentLCD_Symbol(LCD_SYMBOL_MINUS, 1);
}
else
{
SegmentLCD_Symbol(LCD_SYMBOL_MINUS, 0);
}
}
/**************************************************************************//**
* @brief GPIO Interrupt handler (PD8)
*****************************************************************************/
void GPIO_EVEN_IRQHandler(void)
{
GPIO_IntClear(1 << 8);
SegmentLCD_Symbol(LCD_SYMBOL_PAD0, 1);
SegmentLCD_Symbol(LCD_SYMBOL_PAD1, 1);
emMode = DEMO_MODE_EM3;
}
void lcd_write_temperature(int temperature, bool celcius)
{
SegmentLCD_Number(temperature);
SegmentLCD_Symbol(LCD_SYMBOL_DP10, 1);
if (celcius)
SegmentLCD_Symbol(LCD_SYMBOL_DEGC, 1);
else
SegmentLCD_Symbol(LCD_SYMBOL_DEGF, 1);
}
void checkVoltage(void)
{
bool vboost;
/* Initialize voltage comparator, to check supply voltage */
VDDCHECK_Init();
/* Check if voltage is below 3V, if so use voltage boost */
if (VDDCHECK_LowVoltage(2.9))
{
vboost = true;
}
else
{
vboost = false;
}
/* Disable Voltage Comparator */
VDDCHECK_Disable();
if (vboost != oldBoost)
{
SegmentLCD_Init(vboost);
/* Use Antenna symbol to signify enabling of vboost */
SegmentLCD_Symbol(LCD_SYMBOL_ANT, vboost);
oldBoost = vboost;
}
}
/**************************************************************************//**
* @brief Update clock and wait in EM2 for RTC tick.
*****************************************************************************/
void clockLoop(void)
{
LCD_FrameCountInit_TypeDef frameInit;
LCD_AnimInit_TypeDef animInit;
/* Write Gecko and display, and light up the colon between hours and minutes. */
SegmentLCD_Symbol(LCD_SYMBOL_COL10, 1);
SegmentLCD_Write("Wonder");
/* Setup frame counter */
frameInit.enable = true; /* Enable framecounter */
frameInit.top = 15; /* Generate event every 15 frames. */
frameInit.prescale = lcdFCPrescDiv1; /* No prescaling */
LCD_FrameCountInit(&frameInit);
/* Animate half ring - by special board design it is possible to achieve */
/* "slide in/slide out" effect */
animInit.enable = true; /* Enable animation after initialization. */
animInit.AReg = 0x00; /* Initial A register value */
animInit.BReg = 0x0F; /* Initial B register value */
animInit.AShift = lcdAnimShiftLeft; /* Shift A register left */
animInit.BShift = lcdAnimShiftLeft; /* Shift B register left */
animInit.animLogic = lcdAnimLogicOr; /* Enable segment if A or B */
animInit.startSeg = 8; /* Initial animation segment */
LCD_AnimInit(&animInit);
while (1)
{
checkVoltage();
SegmentLCD_Number(hours * 100 + minutes);
EMU_EnterEM2(true);
}
}
/**************************************************************************//**
* @brief GPIO Interrupt handler (PB11)
*****************************************************************************/
void GPIO_ODD_IRQHandler(void)
{
GPIO_IntClear(1 << 11);
if (inEM3)
{
emMode = DEMO_MODE_NONE;
SegmentLCD_Symbol(LCD_SYMBOL_PAD0, 0);
SegmentLCD_Symbol(LCD_SYMBOL_PAD1, 0);
}
else
{
emMode = DEMO_MODE_EM4;
SegmentLCD_Symbol(LCD_SYMBOL_PAD0, 1);
SegmentLCD_Symbol(LCD_SYMBOL_PAD1, 1);
}
}
/**************************************************************************//**
* @brief RTC Handler
* Interrupt Service Routine for Real Time Counter
*****************************************************************************/
void flashTransferComplete(unsigned int channel, bool primary, void *user)
{
/* Clearing flag to indicate that transfer is complete */
flashTransferActive = false;
/* Indicate that the transfer is complete */
SegmentLCD_Symbol(LCD_SYMBOL_ANT, true);
/* Output the finished message */
SegmentLCD_Write(ramBuffer);
}
void setup_lcd()
{
// Enable LCD without voltage boost
SegmentLCD_Init(false);
// Turn on the colon in the time display
SegmentLCD_Symbol(LCD_SYMBOL_COL10, 1);
display_time(0,0);
SegmentLCD_Write("OFF");
blink(TIME);
}
/**************************************************************************//**
* @brief main - the entrypoint after reset.
*****************************************************************************/
int main( void )
{
CHIP_Init();
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
CMU_ClockSelectSet( cmuClock_HF, cmuSelect_HFXO );
CMU_OscillatorEnable(cmuOsc_LFXO, true, false);
/* Initialize LCD driver */
SegmentLCD_Init(false);
SegmentLCD_Write("usbcomp");
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, true);
/* Initialize LED driver */
BSP_LedsInit();
/* Initialize SLEEP driver, no calbacks are used */
SLEEP_Init(NULL, NULL);
#if (configSLEEP_MODE < 3)
/* do not let to sleep deeper than define */
SLEEP_SleepBlockBegin((SLEEP_EnergyMode_t)(configSLEEP_MODE + 1));
#endif
/* Parameters value for taks*/
static LedTaskParams_t parametersToTask1 = { 1000 / portTICK_RATE_MS, 0 };
static LedTaskParams_t parametersToTask2 = { 500 / portTICK_RATE_MS, 1 };
static AdcTaskParams_t parametersToAdc =
{
.adcChannelsMask = 0x32,
.uPrsChannel = 5,
.uSampleRate = 1,
.uTimer = 3
};
/*Create two task for blinking leds*/
xTaskCreate( UsbCDCTask, "UsbCDC", STACK_SIZE_FOR_TASK, NULL, TASK_PRIORITY, NULL);
// xTaskCreate( LedTask, (const char *) "LedBlink1", STACK_SIZE_FOR_TASK, ¶metersToTask1, TASK_PRIORITY, NULL);
// xTaskCreate( LedTask, (const char *) "LedBlink2", STACK_SIZE_FOR_TASK, ¶metersToTask2, TASK_PRIORITY, NULL);
xTaskCreate( vAdcTask, "ADC", STACK_SIZE_FOR_TASK, ¶metersToAdc, TASK_PRIORITY + 1, NULL);
xTaskCreate( vDacTask, "DAC", STACK_SIZE_FOR_TASK, NULL, TASK_PRIORITY, NULL);
xTaskCreate( vEchoTask, "echo", STACK_SIZE_FOR_TASK, NULL, TASK_PRIORITY, NULL);
NVIC_SetPriority(USB_IRQn, 7);
NVIC_SetPriority(ADC0_IRQn, 7);
vTaskStartScheduler();
}
/**************************************************************************//**
* @brief GPIO Interrupt Handler
*****************************************************************************/
void GPIO_IRQHandler_2(void)
{
/* Get the interrupt source, either Push Button 2 (pin B11) or pin D3 */
uint32_t interrupt_source = GPIO_IntGet();
/* Push Button 2 (pin B11) */
if (interrupt_source & (1 << PB1_PIN))
{
GPIO_IntClear(1 << PB1_PIN);
SegmentLCD_Write("Clear");
time = 0;
enableCount = false;
SegmentLCD_Number(time);
}
/* Pin D3 - channel 3 => 2^3 */
if (interrupt_source & (1 << 3))
{
/* Operations can be made atomic, i.e. it cannot be interrupted by
* interrupts with higher priorities, by disabling iterrupts. Uncomment
* __disable_irq(); and __enable_irq(); to see how the update of the time
* is delayed by the dummy loop below.*/
/* __disable_irq(); */
/* Toggle enableGecko */
if (enableGecko)
enableGecko = false;
else
enableGecko = true;
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, enableGecko);
/* This dummy loop is intended to illustrate the different levels of
* priority. The timer will continue to update the LCD display, but
* interrupts produced by Push Button 1 and 2 will not be served until
* after this function has finished. */
for (uint32_t tmp = 0; tmp < 2000000; tmp++) ;
GPIO_IntClear(1 << 3);
/* Enable interrupts again */
/* __enable_irq(); */
}
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
uint32_t j;
/* Chip errata */
CHIP_Init();
/* Select clock source for HF clock. */
CMU_ClockSelectSet(cmuClock_HF, cmuSelect_HFXO);
/* Prescale the core clock -> HF/4 = 32/4 = 8Mhz */
CMU_ClockDivSet(cmuClock_CORE, cmuClkDiv_4);
/* Configure push button interrupts. */
gpioSetup();
/* configure SWO output for debugging. */
setupSWO();
/* Init Segment LCD without boost. */
SegmentLCD_Init(false);
/* Turn on relevant symbols on the LCD. */
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, true);
/* Print welcome text on the LCD. */
SegmentLCD_Write("HiJack");
/* Init the HiJack interface. */
HIJACK_Init(NULL);
/* While loop sending a range of values upon wakeup. */
while(1){
for(j = 0;j<254;j++){
HIJACK_ByteTx(j);
Delay(10000);
}
}
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
int value, delayCount = 0, hfrcoband = 0;
float current, voltage;
bool vboost;
char buffer[8];
/* Chip errata */
CHIP_Init();
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Initialize board support package */
BSP_Init(BSP_INIT_BCC);
/* Setup SysTick Timer for 1 msec interrupts */
if (SysTick_Config(SystemCoreClockGet() / 1000)) while (1) ;
/* Initialize voltage comparator, to check supply voltage */
VDDCHECK_Init();
/* Check if voltage is below 3V, if so use voltage boost */
if (VDDCHECK_LowVoltage(2.9))
{
vboost = true;
}
else
{
vboost = false;
}
/* Disable Voltage Comparator */
VDDCHECK_Disable();
/* Initialize segment LCD */
SegmentLCD_Init(vboost);
/* Infinite loop */
while (1)
{
/* Read and display current */
current = BSP_CurrentGet();
value = (int)(1000 * current);
/* Check that we fall within displayable value */
if ((value > 0) && (value < 10000))
{
SegmentLCD_Number(value);
}
else
{
SegmentLCD_Number(-1);
}
/* Alternate between voltage and clock frequency */
if (((delayCount / 10) & 1) == 0)
{
voltage = BSP_VoltageGet();
value = (int)(voltage * 100);
SegmentLCD_Symbol(LCD_SYMBOL_DP6, 1);
sprintf(buffer, "Volt%3d", value);
SegmentLCD_Write(buffer);
}
else
{
SegmentLCD_Symbol(LCD_SYMBOL_DP6, 0);
sprintf(buffer, "%3u MHz", (int)(SystemCoreClockGet() / 1000000));
SegmentLCD_Write(buffer);
}
/* After 5 seconds, use another HFRCO band */
if (delayCount % 50 == 0)
{
switch (hfrcoband)
{
case 0:
CMU_HFRCOBandSet(cmuHFRCOBand_11MHz);
break;
case 1:
CMU_HFRCOBandSet(cmuHFRCOBand_14MHz);
break;
case 2:
CMU_HFRCOBandSet(cmuHFRCOBand_21MHz);
break;
default:
CMU_HFRCOBandSet(cmuHFRCOBand_28MHz);
/* Restart iteartion */
hfrcoband = -1;
break;
}
hfrcoband++;
/* Recalculate delay tick count and baudrate generation */
if (SysTick_Config(SystemCoreClockGet() / 1000)) while (1) ;
BSP_Init(BSP_INIT_BCC);
}
Delay(100);
delayCount++;
}
}
/*
*********************************************************************************************************
* main()
*
* Description : This is the standard entry point for C code. It is assumed that your code will call
* main() once you have performed all necessary initialization.
*
* Argument(s) : none.
*
* Return(s) : none.
*********************************************************************************************************
*/
int main(void)
{
uint16_t osVersion1, osVersion2, osVersion3;
#if (OS_TASK_NAME_EN > 0)
CPU_INT08U err;
#endif
/* Disable all interrupts until we are ready to accept
* them. */
CPU_IntDis();
/* Chip errata */
CHIP_Init();
/* setup SW0 for energyAware Profiler */
setupSWO();
/* Initialize BSP functions */
BSPOS_Init();
/* Initialize "uC/OS-II, The Real-Time Kernel". */
OSInit();
/* Initialize the uC/OS-II ticker */
OS_CPU_SysTickInit(CMU_ClockFreqGet(cmuClock_HFPER)/OS_TICKS_PER_SEC);
#if (OS_TASK_STAT_EN > 0)
/* Determine CPU capacity */
OSStatInit();
#endif
/* Create application tasks */
App_TaskCreate();
/* Create application mailboxes */
App_MailboxCreate();
/* Initialize LCD */
SegmentLCD_Init(true);
/* Turn gecko symbol ON */
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, 1);
/* Turn EFM32 symbol ON */
SegmentLCD_Symbol(LCD_SYMBOL_EFM32, 1);
/* Write welcome message on LCD */
SegmentLCD_Write("uC/OS-2");
/* As USART connectors are not available on the STK by default,
* therefore printf() functions are turned off.
* Uncomment the macro definition in includes.h if serial
* is connected to your STK board (USART1 or LEUART0)! */
#ifdef USART_CONNECTED
/* Initialize */
RETARGET_SerialInit();
RETARGET_SerialCrLf(1);
osVersion3 = OSVersion();
osVersion1 = osVersion3 / 10000;
osVersion3 -= osVersion1 * 10000;
osVersion2 = osVersion3 / 100;
osVersion3 -= osVersion2 * 100;
osVersion3 %= 100;
/* Write welcome message on serial */
printf("\n*****************************************************************************");
printf("\n uC/OS-II v%d.%02d.%02d on Silicon Labs EFM32TG STK ",
osVersion1, osVersion2, osVersion3 );
printf("\n Demo Application \n");
printf("\n uC/OS-II ");
printf("\n \"The real time kernel\" ");
printf("\n www.micrium.com ");
printf("\n\n is running on ");
printf("\n\n Silicon Labs EFM32 ");
printf("\n \"The world's most energy friendly microcontrollers\" ");
printf("\n www.silabs.com \n");
printf("\nDescription:");
printf("\nTask1: LED blink task");
printf("\nTask2: Receives characters from serial and posts message to Task3");
printf("\nTask3: Receives message from Task2 and writes it on LCD and serial ");
printf("\n*****************************************************************************\n");
printf("\nStart typing...\n");
#endif /* end of #ifndef USART_CONNECTED */
/* Start multitasking (i.e. give control to uC/OS-II). */
OSStart();
/* OSStart() never returns, serious error had occured if
* code execution reached this point */
while(1) ;
}
/*
*********************************************************************************************************
* AppTaskStart()
*
* Description : The startup task. The uC/OS-III ticker should only be initialize once multitasking starts.
*
* Argument(s) : p_arg Argument passed to 'AppTaskStart()' by 'OSTaskCreate()'.
*
* Return(s) : none.
*
* Note(s) : (1) The first line of code is used to prevent a compiler warning because 'p_arg' is not
* used. The compiler should not generate any code for this statement.
*
* (2) Interrupts are enabled once the task starts because the I-bit of the CCR register was
* set to 0 by 'OSTaskCreate()'.
*********************************************************************************************************
*/
static void App_TaskStart(void *p_arg)
{
uint16_t osVersion1, osVersion2, osVersion3;
OS_ERR err = OS_ERR_NONE;
(void)p_arg; /* Note(1) */
/* Initialize BSP functions */
BSPOS_Init();
/* Initialize the uC/OS-III ticker */
OS_CPU_SysTickInit(OS_CPU_SysTickClkFreq() / OS_CFG_TICK_RATE_HZ);
#if (OS_TASK_STAT_EN > 0U)
/* Determine CPU capacity */
OSStatInit();
#endif
/* Create application tasks */
App_TaskCreate();
/* Create application mailboxes */
App_MailboxCreate();
/* Initialize LCD */
SegmentLCD_Init(true);
/* Turn gecko symbol ON */
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, 1);
/* Turn EFM32 symbol ON */
SegmentLCD_Symbol(LCD_SYMBOL_EFM32, 1);
/* Write welcome message on LCD */
SegmentLCD_Write("uC/OS-3");
/* As USART connectors are not available on the STK by default,
* therefore printf() functions are turned off.
* Uncomment the macro definition in includes.h if serial
* is connected to your STK board (USART1 or LEUART0)! */
#ifdef USART_CONNECTED
/* Initialize serial port */
RETARGET_SerialInit();
RETARGET_SerialCrLf(1);
osVersion3 = OSVersion( &err );
osVersion1 = osVersion3 / 10000;
osVersion3 -= osVersion1 * 10000;
osVersion2 = osVersion3 / 100;
osVersion3 -= osVersion2 * 100;
osVersion3 %= 100;
/* Write welcome message on serial */
printf("\n*****************************************************************************");
printf("\n uC/OS-III v%d.%02d.%02d on Energy Micro EFM32 STK ",
osVersion1, osVersion2, osVersion3 );
printf("\n Demo Application \n");
printf("\n uC/OS-III ");
printf("\n \"The real time kernel\" ");
printf("\n www.micrium.com ");
printf("\n\n is running on ");
printf("\n\n Energy Micro EFM32 ");
printf("\n \"The world's most energy friendly microcontrollers\" ");
printf("\n www.energymicro.com \n");
printf("\nDescription:");
printf("\nTask1: LED blink task");
printf("\nTask2: Receives characters from serial and posts message to Task3");
printf("\nTask3: Receives message from Task2 and writes it on LCD and serial.");
printf("\n*****************************************************************************\n");
printf("\nStart typing...\n");
#endif /* end of #ifndef USART_CONNECTED */
/* Suspend this task as it is only used once in one Reset cycle */
OSTaskSuspend(&AppTaskStartTCB, &err);
/* Error had occured if code execution reached this point as suspend calls the scheduler
* that performs a context switch */
while (1U) ;
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
int i = 0;
uint16_t temp_humid_sensor;
float rel_humidity, dew_point;
char buffer_humid[10];
// char buffer_voltage[10];
// char light_level[10];
/* Chip errata */
CHIP_Init();
/* If first word of user data page is non-zero, enable eA Profiler trace */
TRACE_ProfilerSetup();
/* Setup SysTick Timer for 1 msec interrupts */
if (SysTick_Config(CMU_ClockFreqGet(cmuClock_CORE) / 1000)) while (1) ;
/* Disable usart0 clock, it is enabled by default in gecko series mcu's. */
CMU_ClockEnable(cmuClock_USART0, false);
/* Infinite blink loop with main state machine */
state = RESET;
while (1)
{
// state machine
switch(state){
case RESET: // RESET state check for vital HW functions
if(1){
// todo all checks
i = 0;
state = INIT;
}
else
state = RESET;
break;
case INIT: // INIT state initialize all necessary peripherials
if(1){
i = i + 1;
/* Enable clocks. */
CMU_ClockEnable(cmuClock_GPIO, true);
CMU_ClockEnable(cmuClock_I2C0, true);
/* Configure PB9, PB10 pin interrupt on falling edge do not enable yet. */
GPIO_PinModeSet(gpioPortB, 9, gpioModeInput, 0);
GPIO_PinModeSet(gpioPortB, 10, gpioModeInput, 0);
GPIO_IntConfig(gpioPortB, 9, false, true, true);
GPIO_IntConfig(gpioPortB, 10, false, true, true);
HumiditySensorInit();
LED_Init(); /* Initialize LED driver */
LED_Set(0);
/* Enable LCD without voltage boost */
SegmentLCD_Init(false); /* Init LCD driver */
SegmentLCD_Write("ST: INIT");
Delay(500);
SegmentLCD_Number(i);
Delay(500);
state = IDLE;
}
else
state = INIT;
break;
case IDLE:
if(1){
i = i + 1;
SegmentLCD_Write("ST: IDLE");
Delay(500);
SegmentLCD_Number(i);
Delay(500);
// while idle check humidity and temp paramters
rel_humidity = ReadHumiditySensor();
dew_point = getDewPoint();
/* Get temperature from humidity sensor, notice that both pressure sensor and */
/* humidity sensor has built in temperature sensors, since dewpoint and pressure */
/* is dependent on the temperature close to the sensor it gives the most accurate */
/* results to use the built in temperature sensor in each device. */
temp_humid_sensor = getTemperatureHumidSensor();
state = RX_STATE;
}
else
state = IDLE;
break;
case RX_STATE :
if(1){
i = i + 1;
SegmentLCD_Write("ST: Rx");
Delay(500);
SegmentLCD_Number(i);
Delay(500);
SegmentLCD_Symbol(LCD_SYMBOL_ANT, 1);
state = TX_STATE;
}
else
state = RX_STATE;
break;
case TX_STATE:
if(1){
i = i + 1;
SegmentLCD_Write("ST: TX");
Delay(500);
SegmentLCD_Number(i);
Delay(500);
SegmentLCD_Symbol(LCD_SYMBOL_ANT, 1);
state = ERROR;
}
else
state = TX_STATE;
break;
case ERROR:
if(1){
i = i + 1;
SegmentLCD_Write("ST: ERR");
Delay(500);
SegmentLCD_Number(i);
Delay(500);
state = IDLE;
}
else
state = ERROR;
break;
}
LED_Toggle(0);
LED_Toggle(1);
Delay(1000);
}
}
void lcd_show_antenna(int show)
{
SegmentLCD_Symbol(LCD_SYMBOL_ANT, show);
}
/**************************************************************************//**
* @brief Callback function lighting the "Antenna symbol"
*****************************************************************************/
void RtcTrigger(void)
{
/* Just a few No-OPerations to have a place to put a breakpoint */
SegmentLCD_Symbol(LCD_SYMBOL_EFM32, 1);
}
/**************************************************************************//**
* @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 Update LCD with temperature
* @param[in] temp Temperature to display.
*****************************************************************************/
void temperatureUpdateLCD(TEMPSENS_Temp_TypeDef *temp)
{
char text[8];
TEMPSENS_Temp_TypeDef dtemp;
/* Work with local copy in case conversion to Fahrenheit is required */
dtemp = *temp;
/* Show Gecko if debugger is attached. Energy modes do not behave as */
/* expected when using the debugger. */
if (DBG_Connected())
{
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, 1);
}
else
{
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, 0);
}
memset(text, ' ', sizeof(text) - 1);
text[sizeof(text) - 1] = 0;
if (showFahrenheit)
{
text[5] = 'F';
TEMPSENS_Celsius2Fahrenheit(&dtemp);
}
else
{
text[5] = 'C';
}
/* Round temperature to nearest 0.5 */
if (dtemp.f >= 0)
{
dtemp.i += (dtemp.f + 2500) / 10000;
dtemp.f = (((dtemp.f + 2500) % 10000) / 5000) * 5000;
}
else
{
dtemp.i += (dtemp.f - 2500) / 10000;
dtemp.f = (((dtemp.f - 2500) % 10000) / 5000) * 5000;
}
/* 100s */
if (abs(dtemp.i) >= 100)
text[0] = '0' + (abs(dtemp.i) / 100);
/* 10s */
if (abs(dtemp.i) >= 10)
text[1] = '0' + ((abs(dtemp.i) % 100) / 10);
/* 1s */
text[2] = '0' + (abs(dtemp.i) % 10);
/* 0.1s */
text[3] = '0' + (abs(dtemp.f) / 1000);
SegmentLCD_Write(text);
SegmentLCD_Symbol(LCD_SYMBOL_DP4, 1);
if ((dtemp.i < 0) || (dtemp.f < 0))
{
SegmentLCD_Symbol(LCD_SYMBOL_MINUS, 1);
}
else
{
SegmentLCD_Symbol(LCD_SYMBOL_MINUS, 0);
}
}
/*
*********************************************************************************************************
* AppTaskStart()
*
* Description : The startup task. The uC/OS-II ticker should only be initialize once multitasking starts.
*
* Argument(s) : p_arg Argument passed to 'AppTaskStart()' by 'OSTaskCreate()'.
*
* Return(s) : none.
*
* Note(s) : (1) The first line of code is used to prevent a compiler warning because 'p_arg' is not
* used. The compiler should not generate any code for this statement.
*
* (2) Interrupts are enabled once the task starts because the I-bit of the CCR register was
* set to 0 by 'OSTaskCreate()'.
*********************************************************************************************************
*/
static void App_TaskStart(void *p_arg)
{
(void)p_arg; /* Note(1) */
uint16_t osVersion1, osVersion2, osVersion3;
/* Initialize BSP functions */
BSPOS_Init();
/* Initialize the uC/OS-II ticker */
OS_CPU_SysTickInit(CMU_ClockFreqGet(cmuClock_HFPER)/OS_TICKS_PER_SEC);
#if (OS_TASK_STAT_EN > 0)
/* Determine CPU capacity */
OSStatInit();
#endif
/* Create application mailboxes */
App_MailboxCreate();
/* Enable RS232A peripheral */
BSP_PeripheralAccess(BSP_RS232_UART, true);
/* Initialize LCD */
SegmentLCD_Init(true);
/* Turn gecko symbol ON */
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, 1);
/* Turn EFM32 symbol ON */
SegmentLCD_Symbol(LCD_SYMBOL_EFM32, 1);
/* Write welcome message on LCD */
SegmentLCD_Write("uC/OS-2");
osVersion3 = OSVersion();
osVersion1 = osVersion3 / 10000;
osVersion3 -= osVersion1 * 10000;
osVersion2 = osVersion3 / 100;
osVersion3 -= osVersion2 * 100;
osVersion3 %= 100;
/* Write welcome message on serial */
printf("\n*****************************************************************************");
printf("\n uC/OS-II v%d.%02d.%02d on Silicon Labs EFM32G_DK3550 ",
osVersion1, osVersion2, osVersion3 );
printf("\n Demo Application \n");
printf("\n uC/OS-II ");
printf("\n \"The real time kernel\" ");
printf("\n www.micrium.com ");
printf("\n\n is running on ");
printf("\n\n Silicon Labs EFM32 ");
printf("\n \"The world's most energy friendly microcontrollers\" ");
printf("\n www.silabs.com \n");
printf("\nDescription:");
printf("\nTask1: LED blink task");
printf("\nTask2: Receives characters from serial and posts message to Task3");
printf("\nTask3: Receives message from Task2 and writes it on LCD and serial.");
printf("\n*****************************************************************************\n");
printf("\nStart typing...\n");
/* Create application tasks */
App_TaskCreate();
/* Suspend this task as it is only used once in one Reset cycle */
OSTaskSuspend(APP_CFG_TASK_START_PRIO);
while (1)
{/* endless loop of Start task */
;
}
}
/**************************************************************************//**
* @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++;
}
}
/*
*********************************************************************************************************
* AppTaskStart()
*
* Description : The startup task. The uC/OS-II ticker should only be initialize once multitasking starts.
*
* Argument(s) : p_arg Argument passed to 'AppTaskStart()' by 'OSTaskCreate()'.
*
* Return(s) : none.
*
* Note(s) : (1) The first line of code is used to prevent a compiler warning because 'p_arg' is not
* used. The compiler should not generate any code for this statement.
*
* (2) Interrupts are enabled once the task starts because the I-bit of the CCR register was
* set to 0 by 'OSTaskCreate()'.
*********************************************************************************************************
*/
static void App_TaskStart(void *p_arg)
{
(void)p_arg; /* Note(1) */
uint16_t osVersion1, osVersion2, osVersion3;
/* Initialize BSP functions */
BSPOS_Init();
/* Initialize the uC/OS-II ticker */
OS_CPU_SysTickInit(CMU_ClockFreqGet(cmuClock_HFPER)/OS_TICKS_PER_SEC);
#if (OS_TASK_STAT_EN > 0)
/* Determine CPU capacity */
OSStatInit();
#endif
/* Create application tasks */
App_TaskCreate();
/* Create application mailboxes */
App_MailboxCreate();
/* Initialize LCD */
SegmentLCD_Init(true);
/* Turn gecko symbol ON */
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, 1);
/* Turn EFM32 symbol ON */
SegmentLCD_Symbol(LCD_SYMBOL_EFM32, 1);
/* Write welcome message on LCD */
SegmentLCD_Write("uC/OS-2");
/* As USART connectors are not available on the STK by default,
* therefore printf() functions are turned off.
* Uncomment the macro definition in includes.h if serial
* is connected to your STK board (USART1 or LEUART0)! */
#ifdef USART_CONNECTED
/* Initialize serial port */
RETARGET_SerialInit();
RETARGET_SerialCrLf(1);
osVersion3 = OSVersion();
osVersion1 = osVersion3 / 10000;
osVersion3 -= osVersion1 * 10000;
osVersion2 = osVersion3 / 100;
osVersion3 -= osVersion2 * 100;
osVersion3 %= 100;
/* Write welcome message on serial */
printf("\n*****************************************************************************");
printf("\n uC/OS-II v%d.%02d.%02d on Silicon Labs EFM32WG STK ",
osVersion1, osVersion2, osVersion3 );
printf("\n Demo Application \n");
printf("\n uC/OS-II ");
printf("\n \"The real time kernel\" ");
printf("\n www.micrium.com ");
printf("\n\n is running on ");
printf("\n\n Silicon Labs EFM32 ");
printf("\n \"The world's most energy friendly microcontrollers\" ");
printf("\n www.silabs.com \n");
printf("\nDescription:");
printf("\nTask1: LED blink task");
printf("\nTask2: Receives characters from serial and posts message to Task3");
printf("\nTask3: Receives message from Task2 and writes it on LCD and serial");
printf("\n*****************************************************************************\n");
printf("\nStart typing...\n");
#endif /* end of #ifndef USART_CONNECTED */
/* Suspend this task as it is only used once in one Reset cycle */
OSTaskSuspend(APP_CFG_TASK_START_PRIO);
while (1)
{/* endless loop of Start task */
;
}
}
/*
*********************************************************************************************************
* AppTaskStart()
*
* Description : The startup task. The uC/OS-III ticker should only be initialize once multitasking starts.
*
* Argument(s) : p_arg Argument passed to 'AppTaskStart()' by 'OSTaskCreate()'.
*
* Return(s) : none.
*
* Note(s) : (1) The first line of code is used to prevent a compiler warning because 'p_arg' is not
* used. The compiler should not generate any code for this statement.
*
* (2) Interrupts are enabled once the task starts because the I-bit of the CCR register was
* set to 0 by 'OSTaskCreate()'.
*********************************************************************************************************
*/
static void App_TaskStart(void *p_arg)
{
uint16_t osVersion1, osVersion2, osVersion3;
OS_ERR err = OS_ERR_NONE;
(void)p_arg; /* Note(1) */
/* Initialize BSP functions */
BSPOS_Init();
/* Initialize the uC/OS-III ticker */
OS_CPU_SysTickInit(OS_CPU_SysTickClkFreq() / OS_CFG_TICK_RATE_HZ);
#if (OS_TASK_STAT_EN > 0U)
/* Determine CPU capacity */
OSStatInit();
#endif
/* Create application tasks */
App_TaskCreate();
/* Create application mailboxes */
App_MailboxCreate();
/* Enable RS232A peripheral */
BSP_PeripheralAccess(BSP_RS232A, true);
/* Initialize Serial */
RETARGET_SerialInit();
/* Map LF to CRLF */
RETARGET_SerialCrLf(1);
/* Initialize LCD */
SegmentLCD_Init(true);
/* Turn gecko symbol ON */
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, 1);
/* Turn EFM32 symbol ON */
SegmentLCD_Symbol(LCD_SYMBOL_EFM32, 1);
/* Write welcome message on LCD */
SegmentLCD_Write("uC/OS-3");
osVersion3 = OSVersion( &err );
osVersion1 = osVersion3 / 10000;
osVersion3 -= osVersion1 * 10000;
osVersion2 = osVersion3 / 100;
osVersion3 -= osVersion2 * 100;
osVersion3 %= 100;
/* Write welcome message on serial */
printf("\n*****************************************************************************");
printf("\n uC/OS-III v%d.%02d.%02d on Energy Micro EFM32 DVK ",
osVersion1, osVersion2, osVersion3 );
printf("\n Demo Application \n");
printf("\n uC/OS-III ");
printf("\n \"The real time kernel\" ");
printf("\n www.micrium.com ");
printf("\n\n is running on ");
printf("\n\n Energy Micro EFM32 ");
printf("\n \"The world's most energy friendly microcontrollers\" ");
printf("\n www.energymicro.com \n");
printf("\nDescription:");
printf("\nTask1: LED blink task");
printf("\nTask2: Receives characters from serial and posts message to Task3");
printf("\nTask3: Receives message from Task2 and writes it on LCD and serial ");
printf("\n*****************************************************************************\n");
printf("\nStart typing...\n");
/* Suspend this task as it is only used once in one Reset cycle */
OSTaskSuspend(&AppTaskStartTCB, &err);
/* Error had occured if code execution reached this point as suspend calls the scheduler
* that performs a context switch */
while (1U) ;
}
/**************************************************************************//**
* @brief Capsense demo loop
*****************************************************************************/
void capSenseDemo(void)
{
int32_t slider;
bool oldBoost = vboost;
/* Setup RTC. */
RTCDRV_Setup(cmuSelect_LFRCO, cmuClkDiv_32);
/* Setup capSense callbacks. */
CAPLESENSE_setupCallbacks(&capSenseScanComplete, &capSenseChTrigger);
/* Main loop */
while (1)
{
switch(demoState)
{
case DEMO_SLEEP_PREPARE:
{
/* Setup LESENSE in sleep mode. */
CAPLESENSE_setupLESENSE(true);
/* Disable LCD to avoid excessive current consumption */
SegmentLCD_Disable();
/* Disable Vdd check. */
VDDCHECK_Disable();
/* Go to sleep state. */
demoState = DEMO_SLEEP;
}
break;
case DEMO_SLEEP:
{
/* Go to sleep and wait until the measurement completes. */
CAPLESENSE_Sleep();
}
break;
case DEMO_SENSE_PREPARE:
{
/* Setup LESENSE in high-accuracy sense mode. */
CAPLESENSE_setupLESENSE(false);
/* Start timeout counter. */
RTCDRV_Trigger(1000U, &capSenseTimerFired);
/* Enable vboost */
SegmentLCD_Init(vboost);
/* Go to sense state. */
demoState = DEMO_SENSE;
}
break;
case DEMO_SENSE:
{
/* Go to sleep and wait until the measurement completes. */
CAPLESENSE_Sleep();
/* Get slider position. */
slider = CAPLESENSE_getSliderPosition();
if (-1 != slider)
{
/* Reset RTC */
RTC_Enable(false);
RTC_Enable(true);
}
capSenseAringUpdate(slider);
/* Check for change in input voltage. Enable vboost if necessary */
/* Initialize voltage comparator */
VDDCHECK_Init();
/* Check if voltage is below 3V, if so use voltage boost */
if (VDDCHECK_LowVoltage(2.9))
{
vboost = true;
if (oldBoost != vboost)
{
/* Enable vboost */
SegmentLCD_Init(vboost);
/* Use antenna symbol to signify enabling of vboost */
SegmentLCD_Symbol(LCD_SYMBOL_ANT, vboost);
}
oldBoost = vboost;
}
else
{
vboost = false;
}
switch (demoMode)
{
case (DEMOMODE_SCROLLTEXT):
capSenseScrollText();
break;
case (DEMOMODE_BARS):
capSenseBars();
break;
case (DEMOMODE_VALUES):
capSenseValues();
break;
default:
break;
}
}
break;
default:
{
;
}
break;
}
}
}
/**************************************************************************//**
* @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)
{
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);
}
}