/****************************************************************************** * @brief Main function *****************************************************************************/ int main(void) { /* Initialize chip */ CHIP_Init(); /* Enable code view */ setupSWO(); /* Initialize LCD */ SegmentLCD_Init(false); /* Enable the HFPER clock */ CMU_ClockEnable(cmuClock_HFPER, true); /* Configure RTC and GPIO */ rtc_setup(); gpio_setup(); /* Stay in this loop forever */ while (1) { /* Wait for Push Button 1 to be pressed */ while (GPIO_PinInGet(PB0_PORT, PB0_PIN)) ; /* and released, so that we do not exit the while loop below immediately */ while (!GPIO_PinInGet(PB0_PORT, PB0_PIN)) ; /* Reset time */ time = 0; /* Disable LCD */ LCD_Enable(true); /* Update time until Push Button 1 is pressed again */ while (1) { if (RTC_CounterGet() == 0) { SegmentLCD_Number(++time); } if (!GPIO_PinInGet(PB0_PORT, PB0_PIN)) break; } /* Delay while showing the result on the LCD */ for (uint32_t delay = 0; delay < 30; delay++) { /* Wait for the RTC to overflow once */ while (RTC_CounterGet() != 0) ; while (RTC_CounterGet() == 0) ; } /* Disable LCD */ LCD_Enable(false); } }
/** \brief the main function of the project * check current state and switch apps respectively * \param * \param * \return * */ int main(void) { /* Chip errata */ CHIP_Init(); /* If first word of user data page is non-zero, enable eA Profiler trace */ BSP_TraceProfilerSetup(); //////////////////////////////////////////////////////////////////////// setupSWO(); /* Initialize LED driver */ BSP_LedsInit(); initButtons(); initClock(); initActivity(); initVariables(); SegmentLCD_Init(false); /* Enable LCD without voltage boost */ state = main_screen; /* Infinite blink loop */ while (1) { //NOTE maybe button A(change state) must be checked here if(screen_notification == true) // don't update screen until user reaction { EMU_EnterEM2(true); button = NO_BUTTON; } else { switch (state) { case main_screen: mainScreenApp(); break; case pomodoro_screen: pomodoroApp(); break; case activity_screen: activityApp(); break; case time_setup_screen: setupTimeApp(); break; case alarm_setup_screen: setupAlarmApp(); break; } } } }
/**************************************************************************//** * @brief Main function *****************************************************************************/ int main(void) { /* Initialize chip */ CHIP_Init(); setupSWO(); /* Enable HFXO */ CMU_OscillatorEnable(cmuOsc_HFXO, true, true); /* Switch HFCLK to HFXO */ CMU_ClockSelectSet(cmuClock_HF, cmuSelect_HFXO); /* Turn off HFRCO */ CMU_OscillatorEnable(cmuOsc_HFRCO, false, false); BSP_LedsInit(); while (1) { /* Blink led three times, with a factor 1 million delay */ blink_led(1000000, 3); /* Turn on LFRCO */ CMU_OscillatorEnable(cmuOsc_LFRCO, true, true); /* Select LFRCO */ CMU_ClockSelectSet(cmuClock_HF, cmuSelect_LFRCO); /* Maximum prescaling for smalles frequency (64 Hz) */ CMU_ClockDivSet(cmuClock_CORE, cmuClkDiv_512); /* Turn off HFXO */ CMU_OscillatorEnable(cmuOsc_HFXO, false, false); /* Blink led three times, with a factor 1 delay */ blink_led(1, 3); /* Turn on HFXO */ CMU_OscillatorEnable(cmuOsc_HFXO, true, true); /* Select HFXO */ CMU_ClockSelectSet(cmuClock_HF, cmuSelect_HFXO); /* No prescaling for maximum clock frequency (32 MHz) */ CMU_ClockDivSet(cmuClock_CORE, cmuClkDiv_1); /* Turn off LFRCO */ CMU_OscillatorEnable(cmuOsc_LFRCO, false, false); } }
/**************************************************************************//** * @brief Main function *****************************************************************************/ int main(void) { /* Initialize chip */ CHIP_Init(); setupSWO(); BSP_LedsInit(); /* Enable clock for GPIO module */ CMU_ClockEnable(cmuClock_GPIO, true); /* Configure interrupt for Push Button 0 */ GPIO_PinModeSet(PB0_PORT, PB0_PIN, gpioModeInput, 1); #if defined(_EFM32_GIANT_FAMILY) NVIC_EnableIRQ(GPIO_ODD_IRQn); #else NVIC_EnableIRQ(GPIO_EVEN_IRQn); #endif GPIO_IntConfig(PB0_PORT, PB0_PIN, false, true, true); /* By turning on retention in EM4, the state of the GPIO pins * can be retained in all energy modes */ GPIO->CTRL = GPIO_CTRL_EM4RET; /* Uncomment to drive LED in all energy modes */ /* BSP_LedSet(0);*/ while (1) { switch (STATE) { case EM0: break; case EM1: EMU_EnterEM1(); break; case EM2: EMU_EnterEM2(true); break; case EM3: EMU_EnterEM3(true); case EM4: EMU_EnterEM4(); break; } } }
/* ********************************************************************************************************* * 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) { #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 "uC/OS-II, The Real-Time Kernel". */ OSInit(); /* Create the start task */ OSTaskCreateExt((void (*)(void *)) App_TaskStart, (void *) 0, (OS_STK *)&App_TaskStartStk[APP_CFG_TASK_START_STK_SIZE - 1], (INT8U ) APP_CFG_TASK_START_PRIO, (INT16U ) APP_CFG_TASK_START_PRIO, (OS_STK *)&App_TaskStartStk[0], (INT32U ) APP_CFG_TASK_START_STK_SIZE, (void *) 0, #ifdef __ICCARM__ /* IAR port */ (INT16U )(OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR | OS_TASK_OPT_SAVE_FP)); #else (INT16U )(OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR)); #endif #if (OS_TASK_NAME_EN > 0) OSTaskNameSet(APP_CFG_TASK_START_PRIO, "Start", &err); #endif /* 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) ; }
/***************************************************************************//** * @brief * Initialize the board. * * @details * * @note * ******************************************************************************/ void rt_hw_board_init(void) { /* Chip errata */ CHIP_Init(); /* NVIC Configuration */ NVIC_Configuration(); /* Configure external oscillator */ SystemHFXOClockSet(EFM32_HFXO_FREQUENCY); setupSWO(); /* Configure the SysTick */ SysTick_Configuration(); rt_hw_driver_init(); }
/* ********************************************************************************************************* * 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) { OS_ERR err = OS_ERR_NONE; /* Disable all interrupts until we are ready to accept * them. */ CPU_IntDis(); /* Chip errata */ CHIP_Init(); /* setup SW0 for energyAware Profiler */ setupSWO(); /* Initialize "uC/OS-III, The Real-Time Kernel". */ OSInit(&err); /* Create the start task */ OSTaskCreate((void *)&AppTaskStartTCB, /* pointer to TCB */ (CPU_CHAR *) "Start", /* task name, text */ (void (*)(void *)) App_TaskStart, /* function pointer to task */ (void *) 0U, /* pointer to optional data */ (CPU_INT08U ) APP_CFG_TASK_START_PRIO, /* priority */ (CPU_STK *) App_TaskStartStk, /* stack base ptr */ (CPU_STK_SIZE )(APP_CFG_TASK_START_STK_SIZE / 10U), /* stack limit */ (CPU_STK_SIZE ) APP_CFG_TASK_START_STK_SIZE, /* stack size */ (OS_MSG_QTY ) 0U, /* q size */ (OS_TICK ) 0U, /* round robin time tick */ (void *) 0U, /* p ext */ (OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR), /* options */ (OS_ERR *)&err); /* Setup the idle task */ OS_AppIdleTaskHookPtr = (OS_APP_HOOK_VOID)App_TaskIdleHook; /* Start multitasking (i.e. give control to uC/OS-III). */ OSStart(&err); /* OSStart() never returns, serious error had occured if * code execution reached this point */ while(1U) ; }
/**************************************************************************//** * @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); } } }
/* ********************************************************************************************************* * 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) ; }
/**************************************************************************//** * @brief Main function *****************************************************************************/ int main(void) { bool redraw = false; bool prevRedraw = false; EMSTATUS status; volatile int i; /* Chip revision alignment and errata fixes */ CHIP_Init(); /* Initialize DVK board register access */ BSP_Init(BSP_INIT_DEFAULT); /* If first word of user data page is non-zero, enable eA Profiler trace */ BSP_TraceProfilerSetup(); /* Initialize DVK interrupt enable */ DVK_IRQInit(); /* Initialize GPIO interrupt */ GPIO_IRQInit(); /* Clear LEDs */ BSP_LedsSet(0x0000); setupSWO(); /* Wait until we have control over display */ while(!redraw) { redraw = TFT_AddressMappedInit(); } /* Init graphics context - abort on failure */ status = GLIB_contextInit(&gc); if (status != GLIB_OK) while (1) ; /* Update TFT display forever */ while (1) { /* Check if we should control TFT display instead of AEM/board controller */ redraw = TFT_AddressMappedInit(); if(redraw) { /* This indicated a BC -> EFM control transfer */ if(prevRedraw != redraw) { /* Update information message */ gc.foregroundColor = GLIB_rgbColor(200, 200, 200); gc.backgroundColor = GLIB_rgbColor(0, 0, 0); GLIB_drawString(&gc, description[0], strlen(description[0]), 0, 0, 1); GLIB_drawString(&gc, description[1], strlen(description[1]), 0, 8, 1); GLIB_drawString(&gc, description[2], strlen(description[2]), 0, 24, 1); GLIB_drawString(&gc, description[3], strlen(description[3]), 0, 40, 1); GLIB_drawString(&gc, description[4], strlen(description[4]), 0, 48, 1); GLIB_drawString(&gc, description[5], strlen(description[5]), 0, 64, 1); GLIB_drawString(&gc, description[6], strlen(description[6]), 0, 72, 1); gc.foregroundColor = GLIB_rgbColor(200, 200, 100); GLIB_drawString(&gc, description[7], strlen(description[7]), 0, 88, 1); GLIB_drawString(&gc, description[8], strlen(description[8]), 0, 104, 1); } /* Update selected demo */ gc.foregroundColor = GLIB_rgbColor(100, 200, 100); gc.backgroundColor = GLIB_rgbColor(50, 50, 50); GLIB_drawString(&gc, eModeDesc[eModeDemo], strlen(eModeDesc[eModeDemo]), 40, 150, 1); } else { /* No need to refresh display when BC is active */ } prevRedraw = redraw; if(runDemo) { gc.foregroundColor = GLIB_rgbColor(50, 50, 50); gc.backgroundColor = GLIB_rgbColor(100, 200, 100); GLIB_drawString(&gc, eModeDesc[eModeDemo], strlen(eModeDesc[eModeDemo]), 40, 150, 1); for(i=0; i<14000; i++) ; break; } } /* Run demo */ switch(eModeDemo) { case 0: Demo_Primes(cmuSelect_HFXO, (CMU_HFRCOBand_TypeDef) 0); break; case 1: Demo_EM1(cmuSelect_HFXO, (CMU_HFRCOBand_TypeDef) 0); break; case 2: Demo_Primes(cmuSelect_HFRCO, cmuHFRCOBand_14MHz); break; case 3: Demo_EM1(cmuSelect_HFRCO, cmuHFRCOBand_14MHz); break; case 4: Demo_EM2(); break; case 5: Demo_EM2_RTC(); break; case 6: Demo_EM3(); break; case 7: Demo_EM3_GPIO(); break; case 8: Demo_EM4(); break; default: while(1); } return 0; }
/**************************************************************************//** * @brief RTC Setup * Produce an interrupt every second *****************************************************************************/ void rtc_setup(void) { /* Starting LFXO and waiting until it is stable */ CMU_OscillatorEnable(cmuOsc_LFXO, true, true); /* Routing the LFXO clock to the RTC */ CMU_ClockSelectSet(cmuClock_LFA, cmuSelect_LFXO); CMU_ClockEnable(cmuClock_RTC, true); /* Enabling clock to the interface of the low energy modules */ CMU_ClockEnable(cmuClock_CORELE, true); const RTC_Init_TypeDef rtcInit = { .enable = true, .debugRun = false, .comp0Top = true, }; RTC_Init(&rtcInit); /* Produce interrupt every second */ RTC_CompareSet(0, 32768); /* Enable interrupt for compare register 0 */ RTC_IntEnable(RTC_IFC_COMP0); /* Enabling interrupt from RTC */ NVIC_EnableIRQ(RTC_IRQn); } /**************************************************************************//** * @brief Main function *****************************************************************************/ int main(void) { /* Initialize chip */ CHIP_Init(); /* Enable code view */ setupSWO(); /* Configure peripherals */ rtc_setup(); BSP_LedsInit(); while (1) { switch (STATE) { case EM0: break; case EM1: EMU_EnterEM1(); break; case EM2: EMU_EnterEM2(true); break; } } }