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