/**************************************************************************//** * @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); } }