/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
/* Chip revision alignment and errata fixes */
CHIP_Init();
/* Set system frequency to 1 MHz */
CMU_HFRCOBandSet(cmuHFRCOBand_1MHz);
/* Initialize LCD */
SegmentLCD_Init(false);
/* Initialize TIMER0 */
initTimer();
/* Enable Sleep-om-Exit */
SCB->SCR |= SCB_SCR_SLEEPONEXIT_Msk;
/* Initialize interrupt count */
interruptCount = 0;
/* Enter EM1 until all TIMER0 interrupts are done
* Notice that we only enter sleep once, as the MCU will fall asleep
* immediately when the ISR is done without returning to main as long as
* SLEEPONEXIT is set */
EMU_EnterEM1();
/* Signal that program is done */
SegmentLCD_Write("DONE");
while(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;
}
}
void __lcd_init()
{
/* Initialize segment LCD. */
SegmentLCD_Init(false);
/* Turn all LCD segments off. */
SegmentLCD_AllOff();
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
/* Chip errata */
CHIP_Init();
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Initialize 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
/* Initialize the LCD driver */
SegmentLCD_Init(false);
/* Create standard binary semaphore */
vSemaphoreCreateBinary(sem);
/* Create two task to show numbers from 0 to 15 */
xTaskCreate(Count, (const signed char *) "Count", STACK_SIZE_FOR_TASK, NULL, TASK_PRIORITY, NULL);
xTaskCreate(LcdPrint, (const signed char *) "LcdPrint", STACK_SIZE_FOR_TASK, NULL, TASK_PRIORITY, NULL);
/* Start FreeRTOS Scheduler */
vTaskStartScheduler();
return 0;
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
bool vboost = false;
/* 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 board specific registers */
VDDCHECK_Init();
/* Check if voltage is below 3V, if so use voltage boost */
if (VDDCHECK_LowVoltage(2.9))
vboost = true;
/* Disable Voltage Comparator */
VDDCHECK_Disable();
/* Run Energy Mode with LCD demo, see lcdtest.c */
SegmentLCD_Init(vboost);
/* Display a message if vboost is enabled */
if ( vboost )
{
SegmentLCD_Write("vboost");
RTCDRV_Delay(5000, false);
}
Test();
return 0;
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
/* Chip errata */
CHIP_Init();
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Ensure core frequency has been updated */
SystemCoreClockUpdate();
/* Init LCD with no voltage boost */
SegmentLCD_Init(oldBoost);
/* Setup RTC to generate an interrupt every minute */
rtcSetup();
/* Setup GPIO with interrupts to serve the pushbuttons */
gpioSetup();
/* Main function loop */
clockLoop();
return 0;
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
TEMPSENS_Temp_TypeDef temp;
/* Chip revision alignment and errata fixes */
CHIP_Init();
/* Initialize LCD controller without boost */
SegmentLCD_Init(false);
I2C_Tempsens_Init();
/* Main loop - just read temperature and update LCD */
while (1)
{
if (TEMPSENS_TemperatureGet(I2C0,
TEMPSENS_DVK_ADDR,
&temp) < 0)
{
SegmentLCD_Write("ERROR");
/* Enter EM2, no wakeup scheduled */
EMU_EnterEM2(true);
}
/* Update LCD display */
temperatureUpdateLCD(&temp);
/* Read every 2 seconds which is more than it takes worstcase to */
/* finish measurement inside sensor. */
RTCDRV_Trigger(2000, NULL);
EMU_EnterEM2(true);
}
}
/******************************************************************************
* @brief Main function
* The main file starts a timer and uses PRS to trigger an ADC conversion.
* It waits in EM1 until the ADC conversion is complete, then prints the
* result on the lcd.
*****************************************************************************/
int main(void)
{
/* Initialize chip */
CHIP_Init();
SegmentLCD_Init(false);
/* Enable clocks required */
CMU_ClockEnable(cmuClock_ADC0, true);
CMU_ClockEnable(cmuClock_PRS, true);
CMU_ClockEnable(cmuClock_TIMER0, true);
/* Select TIMER0 as source and TIMER0OF (Timer0 overflow) as signal (rising edge) */
PRS_SourceSignalSet(0, PRS_CH_CTRL_SOURCESEL_TIMER0, PRS_CH_CTRL_SIGSEL_TIMER0OF, prsEdgePos);
ADCConfig();
TimerConfig();
/* Stay in this loop forever */
while (1)
{
/* Enter EM1 and wait for timer triggered adc conversion */
EMU_EnterEM1();
/* Write result to LCD */
SegmentLCD_Number(adcResult);
/* Do other stuff */
int i;
for (i = 0; i < 10000; i++) ;
}
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
/* Chip errata */
CHIP_Init();
/* Ensure core frequency has been updated */
SystemCoreClockUpdate();
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Init LCD with no voltage boost */
SegmentLCD_Init(oldBoost);
/* Setup RTC to generate an interrupt every minute */
rtcSetup();
/* Enable GPIO clock */
CMU_ClockEnable(cmuClock_GPIO, true);
/* Setup GPIO interrupt to set the time */
gpioSetup();
/* Main function loop */
//clockLoop();
main_loop();
return 0;
}
/**************************************************************************//**
* @brief Sleeps in EM3 until GPIO interrupt is triggered
*****************************************************************************/
void EM3Sleep(void)
{
inEM3 = true;
SegmentLCD_Disable();
EMU_EnterEM3(true);
SegmentLCD_Init(false);
inEM3 = false;
}
/**************************************************************************//**
* @brief Sleeps in EM3 until GPIO interrupt is triggered
*****************************************************************************/
void EM3Sleep(void)
{
/* Tell AEM we're in EM3 */
BSP_EnergyModeSet(3);
SegmentLCD_Disable();
EMU_EnterEM3(true);
BSP_EnergyModeSet(0);
SegmentLCD_Init(false);
}
/******************************************************************************
* @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)
{
CHIP_Init();
/* Enable LCD without voltage boost */
SegmentLCD_Init(false);
/* Run Energy Mode with LCD demo, see lcdtest.c */
Test();
/* Never going to reach this statement. Infinte loop in Test(). */
return 0;
}// end int main (void)
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 Main function
*****************************************************************************/
int main(void)
{
/* Chip errata */
CHIP_Init();
gpioSetup();
SegmentLCD_Init(false); //init the segment lcd, bool used to check if power supply i low
rtcSetup();
leTimerSetup();
leTimerTurnOff();
/* Infinite loop */
while (1) {
EMU_EnterEM2(true);
}
}
int main(void)
{
/* Chip errata */
CHIP_Init();
/* Enable HFXO */
CMU_ClockSelectSet(cmuClock_HF, cmuSelect_HFXO);
/* Enable deboug output over UART */
RETARGET_SerialInit();
RETARGET_SerialCrLf(1);
/* Enable the segment LCD */
SegmentLCD_Init(false);
SegmentLCD_Write("USB");
printf("\nStarting USB Device...\n");
/* Set up GPIO interrupts */
gpioInit();
/* Start USB stack. Callback routines in callbacks.c will be called
* when connected to a host. */
USBD_Init(&initstruct);;
/*
* When using a debugger it is pratical to uncomment the following three
* lines to force host to re-enumerate the device.
*/
/* USBD_Disconnect(); */
/* USBTIMER_DelayMs( 1000 ); */
/* USBD_Connect(); */
while(1)
{
if ( USBD_SafeToEnterEM2() )
{
/* Enter EM2 when in suspend or disconnected */
EMU_EnterEM2(true);
}
else
{
/* When USB is active we can sleep in EM1. */
EMU_EnterEM1();
}
}
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
/* Chip errata */
CHIP_Init();
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Enable LCD without voltage boost */
SegmentLCD_Init(false);
/* Run Energy Mode with LCD demo, see lcdtest.c */
Test();
/* Never going to reach this statement. Infinte loop in Test(). */
return 0;
}
/**************************************************************************//**
* @brief
* Main function is a CMSIS RTOS thread in itself
*
* @note
* This example uses threads, memory pool and message queue to demonstrate the
* usage of these CMSIS RTOS features. In this simple example, the same
* functionality could more easily be achieved by doing everything in the main
* loop.
*****************************************************************************/
int main(void)
{
int count = 0;
/* Chip errata */
CHIP_Init();
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Initialize LED driver */
BSP_LedsInit();
/* Initialize the LCD driver */
SegmentLCD_Init(false);
/* Initialize CMSIS RTOS structures */
/* create memory pool */
mpool = osPoolCreate(osPool(mpool));
/* create msg queue */
msgBox = osMessageCreate(osMessageQ(msgBox), NULL);
/* create thread 1 */
osThreadCreate(osThread(PrintLcdThread), NULL);
/* Infinite loop */
while (1)
{
count = (count+1)&0xF;
BSP_LedsSet(count);
/* Send message to PrintLcdThread */
/* Allocate memory for the message */
lcdText_t *mptr = osPoolAlloc(mpool);
/* Set the message content */
(*mptr)[0] = count>=10 ? '1' : '0';
(*mptr)[1] = count%10 + '0';
(*mptr)[2] = '\0';
/* Send message */
osMessagePut(msgBox, (uint32_t)mptr, osWaitForever);
/* Wait now for half a second */
osDelay(500);
}
}
void main_full( void )
{
SegmentLCD_Init( false );
SegmentLCD_Write( "F'RTOS" );
/* Start all the other standard demo/test tasks. They have no particular
functionality, but do demonstrate how to use the FreeRTOS API and test the
kernel port. */
vStartDynamicPriorityTasks();
vCreateBlockTimeTasks();
vStartGenericQueueTasks( tskIDLE_PRIORITY );
vStartRecursiveMutexTasks();
vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );
vStartMathTasks( mainFLOP_TASK_PRIORITY );
vStartTimerDemoTask( mainTIMER_TEST_PERIOD );
vStartEventGroupTasks();
vStartTaskNotifyTask();
vStartInterruptSemaphoreTasks();
/* Create the register check tasks, as described at the top of this file */
xTaskCreate( prvRegTestTaskEntry1, "Reg1", configMINIMAL_STACK_SIZE, mainREG_TEST_TASK_1_PARAMETER, tskIDLE_PRIORITY, NULL );
xTaskCreate( prvRegTestTaskEntry2, "Reg2", configMINIMAL_STACK_SIZE, mainREG_TEST_TASK_2_PARAMETER, tskIDLE_PRIORITY, NULL );
/* Create the task that performs the 'check' functionality, as described at
the top of this file. */
xTaskCreate( prvCheckTask, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );
/* The set of tasks created by the following function call have to be
created last as they keep account of the number of tasks they expect to see
running. */
vCreateSuicidalTasks( mainCREATOR_TASK_PRIORITY );
/* Start the scheduler. */
vTaskStartScheduler();
/* If all is well, the scheduler will now be running, and the following
line will never be reached. If the following line does execute, then
there was insufficient FreeRTOS heap memory available for the Idle and/or
timer tasks to be created. See the memory management section on the
FreeRTOS web site for more details on the FreeRTOS heap
http://www.freertos.org/a00111.html. */
for( ;; );
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
/* Initialize chip */
CHIP_Init();
SegmentLCD_Init(true);
initRTC();
initGPIO();
/* Initial LCD content */
SegmentLCD_Number(time);
while (1)
{
/* Go to EM2 */
EMU_EnterEM2(true);
/* Wait for interrupts */
}
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
/* Chip revision alignment and errata fixes */
CHIP_Init();
/* This example does not use DVK features */
/* Setup SysTick Timer for 1 msec interrupts */
if (SysTick_Config(CMU_ClockFreqGet(cmuClock_CORE) / 1000))
{
while (1) ;
}
/* Initialize necessary clocks and controller */
SegmentLCD_Init(false);
/* Run demo */
Test();
return 0;
}
/**************************************************************************//**
* @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)
{
CHIP_Init();
// initializations
initGPIO();
/* Enable LCD without voltage boost */
SegmentLCD_Init(false);
setupSWOForPrint();
updateLCD(getCapsenseCurrent());
while (1)
{
updateGPIO();
if (getCapsensePrevious() != getCapsenseCurrent())
{
updateLCD(getCapsenseCurrent());
updateSWO();
}
}
}
/**************************************************************************//**
* @brief Main function.
*****************************************************************************/
int main( void )
{
int i;
MPU_RegionInit_TypeDef flashInit = MPU_INIT_FLASH_DEFAULT;
MPU_RegionInit_TypeDef sramInit = MPU_INIT_SRAM_DEFAULT;
MPU_RegionInit_TypeDef peripheralInit = MPU_INIT_PERIPHERAL_DEFAULT;
/* Chip alignment */
CHIP_Init();
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Enable LCD without voltage boost */
SegmentLCD_Init( false );
SegmentLCD_AllOff();
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, 1);
SegmentLCD_Symbol(LCD_SYMBOL_EFM32, 1);
GpioInit();
RTCDRV_Setup( cmuSelect_LFXO, cmuClkDiv_32);
ScrollText( " MPU DEMO PRESS Pb0 OR Pb1 "
"TO GENERATE MPU EXCEPTIONS " );
MPU_Disable();
/* Flash memory */
MPU_ConfigureRegion( &flashInit );
/* SRAM */
MPU_ConfigureRegion( &sramInit );
/* SRAM, a 4k part with priviledged only access, this regions settings */
/* will override those of the previous region */
sramInit.regionNo = 2;
sramInit.baseAddress = RAM_MEM_BASE + 0x2000;
sramInit.size = mpuRegionSize4Kb;
sramInit.accessPermission = mpuRegionApPRw;
MPU_ConfigureRegion( &sramInit );
/* LCD, priviledged only access */
peripheralInit.regionNo = 3;
peripheralInit.baseAddress = LCD_BASE;
peripheralInit.size = mpuRegionSize128b;
peripheralInit.accessPermission = mpuRegionApPRw;
MPU_ConfigureRegion( &peripheralInit );
MPU_Enable( MPU_CTRL_PRIVDEFENA ); /* Full access to default memory map */
/* in priviledged state */
i = 0;
while ( 1 )
{
SegmentLCD_Number( i ); /* Count on numeric diplay */
i = ( i + 1 ) % 101;
RTCDRV_Delay( 150 , false);
if ( PB0_PUSHED() )
{
BullsEye( 1 );
/* Generate an access violation in internal SRAM */
__set_CONTROL( 1 ); /* Enter User (unpriviledged) state */
*(volatile uint32_t *)(RAM_MEM_BASE + 0x2000) = 1;
BullsEye( 0 );
}
if ( PB1_PUSHED() )
{
BullsEye( 1 );
/* Generate an access violation in LCD peripheral */
__set_CONTROL( 1 ); /* Enter User (unpriviledged) state */
BullsEye( 0 );
}
}
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
/* Chip errata */
CHIP_Init();
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Initialize LCD controller without boost */
SegmentLCD_Init(false);
/* Disable all segments */
SegmentLCD_AllOff();
/* Copy contents of the userpage (flash) into the userData struct */
memcpy((void *) &userData, (void *) USERPAGE, sizeof(UserData_TypeDef));
/* Special case for uninitialized data */
if (userData.number > 10000)
userData.number = 0;
if (userData.numWrites == 0xFFFFFFFF)
userData.numWrites = 0;
/* Display the number */
SegmentLCD_Number(userData.number);
/* Setup GPIO interrupts. PB0 to increase number, PB1 to save to flash */
gpioSetup();
/* No save has occured yet */
recentlySaved = false;
/* Main loop - just scroll informative text describing the current state of
* the system */
while (1)
{
switch (currentError)
{
case mscReturnInvalidAddr:
ScrollText(" ERROR: INVALID ADDRESS ");
break;
case mscReturnLocked:
ScrollText(" ERROR: USER PAGE IS LOCKED ");
break;
case mscReturnTimeOut:
ScrollText(" ERROR: TIMEOUT OCCURED ");
break;
case mscReturnUnaligned:
ScrollText(" ERROR: UNALIGNED ACCESS ");
default:
if (recentlySaved)
{
recentlySaved = false;
SegmentLCD_Number(userData.numWrites);
ScrollText(" SAVE NUMBER ");
}
else
{
SegmentLCD_Number(userData.number);
ScrollText(" PRESS PB0 TO INCREASE NUMBER. PB1 TO SAVE TO INTERNAL FLASH ");
}
break;
}
}
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
SYSTEM_ChipRevision_TypeDef revision;
char string[8];
int i;
uint32_t temp;
/* Chip revision alignment and errata fixes */
CHIP_Init();
/* Initialize DVK board register access */
BSP_Init(BSP_INIT_DEFAULT);
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
CMU_ClockEnable(cmuClock_HFPER, true);
CMU_ClockEnable(cmuClock_ADC0, true);
CMU_ClockEnable(cmuClock_GPIO, true);
/* Initialize LCD controller without boost */
SegmentLCD_Init(false);
SegmentLCD_AllOff();
/* Check for revision after revision B. Chips with revision earlier than */
/* Revision C has known problems with the internal temperature sensor. */
/* Display a warning in this case */
SYSTEM_ChipRevisionGet(&revision);
if (revision.minor < 2)
{
SegmentLCD_Write("WARNING");
RTCDRV_Trigger(2000, NULL);
EMU_EnterEM2(true);
SegmentLCD_Write("REV C+");
RTCDRV_Trigger(2000, NULL);
EMU_EnterEM2(true);
SegmentLCD_Write("REQUIRD");
RTCDRV_Trigger(2000, NULL);
EMU_EnterEM2(true);
}
/* Enable board control interrupts */
BSP_InterruptDisable(0xffff);
BSP_InterruptFlagsClear(0xffff);
BSP_InterruptEnable(BC_INTEN_JOYSTICK);
temperatureIRQInit();
/* Setup ADC for sampling internal temperature sensor. */
setupSensor();
/* Main loop - just read temperature and update LCD */
while (1)
{
/* Start one ADC sample */
ADC_Start(ADC0, adcStartSingle);
/* Wait in EM1 for ADC to complete */
EMU_EnterEM1();
/* Read sensor value */
temp = ADC_DataSingleGet(ADC0);
/* Convert ADC sample to Fahrenheit / Celsius and print string to display */
if (showFahrenheit)
{
/* Show Fahrenheit on alphanumeric part of display */
i = (int)(convertToFahrenheit(temp) * 10);
snprintf(string, 8, "%2d,%1d%%F", (i/10), i%10);
/* Show Celsius on numeric part of display */
i = (int)(convertToCelsius(temp) * 10);
SegmentLCD_Number(i*10);
SegmentLCD_Symbol(LCD_SYMBOL_DP10, 1);
}
else
{
/* Show Celsius on alphanumeric part of display */
i = (int)(convertToCelsius(temp) * 10);
snprintf(string, 8, "%2d,%1d%%C", (i/10), i%10);
/* Show Fahrenheit on numeric part of display */
i = (int)(convertToFahrenheit(temp) * 10);
SegmentLCD_Number(i*10);
SegmentLCD_Symbol(LCD_SYMBOL_DP10, 1);
}
SegmentLCD_Write(string);
/* Sleep for 2 seconds in EM 2 */
RTCDRV_Trigger(2000, NULL);
EMU_EnterEM2(true);
}
}
/**************************************************************************//**
* @brief ACMP_setup
* Configures and starts the ACMP
*****************************************************************************/
void ACMP_setup(void)
{
/* Enable necessary clocks */
CMU_ClockEnable(cmuClock_ACMP0, true);
CMU_ClockEnable(cmuClock_GPIO, true);
/* Configure PC4 as input with pull down for ACMP channel 4 input */
GPIO_PinModeSet(gpioPortC, 4, gpioModeInputPullFilter, 0);
/* Analog comparator parameters */
const ACMP_Init_TypeDef acmpInit =
{
.fullBias = false, /* no full bias current*/
.halfBias = false, /* no half bias current */
.biasProg = 7, /* Biasprog current 1.4 uA */
.interruptOnFallingEdge = false, /* disable interrupt for falling edge */
.interruptOnRisingEdge = false, /* disable interrupt for rising edge */
.warmTime = acmpWarmTime256, /* Warm-up time in clock cycles, should be >140 cycles for >10us warm-up @ 14MHz */
.hysteresisLevel = acmpHysteresisLevel0, /* Hysteresis level 0 - no hysteresis */
.inactiveValue = 0, /* Inactive comparator output value */
.lowPowerReferenceEnabled = false, /* Low power reference mode disabled */
.vddLevel = 32, /* Vdd reference scaling of 32 */
};
/* Init ACMP and set ACMP channel 4 as positive input
and scaled Vdd as negative input */
ACMP_Init(ACMP0, &acmpInit);
ACMP_ChannelSet(ACMP0, acmpChannelVDD, acmpChannel4);
ACMP_Enable(ACMP0);
}
/**************************************************************************//**
* @brief PRS_ScanChannel
* Waits for activity on a selected PRS channel and writes on the LCD
when activity occurs
*
* @param[in] timer
* Pointer to TIMER peripheral register block.
*
* @param[in] prsCh
* PRS Channel to be monitored
*
* @param[in] edgeType
* Signal edge to be monitored/captured
*****************************************************************************/
void PRS_ScanChannel(TIMER_TypeDef *timer, TIMER_PRSSEL_TypeDef prsCh, TIMER_Edge_TypeDef edgeType)
{
/* enable the clock for the correct timer */
#define TIMER_Clock(T) (T==TIMER0 ? cmuClock_TIMER0 : \
T==TIMER1 ? cmuClock_TIMER1 : 0)
/* Enable necessary clocks */
CMU_ClockEnable((CMU_Clock_TypeDef)TIMER_Clock(timer), true);
/* Initialize LCD */
SegmentLCD_Init(false);
/* Select CC channel parameters */
const TIMER_InitCC_TypeDef timerCCInit =
{
.eventCtrl = timerEventFalling, /* input capture event control */
.edge = edgeType, /* input capture on falling edge */
.prsSel = prsCh, /* prs channel select channel 5*/
.cufoa = timerOutputActionNone, /* no action on counter underflow */
.cofoa = timerOutputActionNone, /* no action on counter overflow */
.cmoa = timerOutputActionNone, /* no action on counter match */
.mode = timerCCModeCapture, /* CC channel mode capture */
.filter = false, /* no filter */
.prsInput = true, /* CC channel PRS input */
.coist = false, /* comparator output initial state */
.outInvert = false, /* no output invert */
};
/* Initialize TIMER0 CC0 */
TIMER_InitCC(timer, 0, &timerCCInit);
/* Select timer parameters */
const TIMER_Init_TypeDef timerInit =
{
.enable = true, /* start counting when init complete */
.debugRun = false, /* counter not running on debug halt */
.prescale = timerPrescale1024, /* prescaler of 64 */
.clkSel = timerClkSelHFPerClk, /* TIMER0 clocked by the HFPERCLK */
.fallAction = timerInputActionNone, /* stop counter on falling edge */
.riseAction = timerInputActionNone, /* reload and start on rising edge */
.mode = timerModeUp, /* counting up */
.dmaClrAct = false, /* no DMA */
.quadModeX4 = false, /* no quad decoding */
.oneShot = false, /* counting up constinuously */
.sync = false, /* no start/stop/reload by other timers */
};
/* Initialize TIMER0 */
TIMER_Init(timer, &timerInit);
/* Poll the Input Capture Valid flag in the Status register
The program will hang at this point waiting for activity on this
channel */
while(!((TIMER0->STATUS & _TIMER_STATUS_ICV0_MASK )>>16));
}
/**************************************************************************//**
* @brief Main function
* Main is called from __iar_program_start, see assembly startup file
*****************************************************************************/
int main(void)
{
/* Align different chip revisions*/
CHIP_Init();
/* Initialise the ACMP */
ACMP_setup();
/* PRS setup */
/* Enable clock for PRS and select ACMP as source and ACMP0OUT (ACMP0 OUTPUT) as signal
for channel 5 */
CMU_ClockEnable(cmuClock_PRS, true);
PRS_SourceSignalSet(5, PRS_CH_CTRL_SOURCESEL_ACMP0, PRS_CH_CTRL_SIGSEL_ACMP0OUT, prsEdgeOff);
/* Start PRS scan
This function will halt the program while there is no PRS activity
This function assumes that the PRS has been setup previously */
PRS_ScanChannel(TIMER0, timerPRSSELCh5, timerEdgeFalling);
/* Write PRS and channel number on the LCD to acknowledge PRS activity */
SegmentLCD_Write("PRS");
SegmentLCD_Number((int)timerPRSSELCh5);
while(1)
{
/* Enter EM1 while waiting for capture. */
EMU_EnterEM1();
}
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
/* Initialize chip */
CHIP_Init();
/* Initialize the LCD */
SegmentLCD_Init(true);
/* Enable the DMA and TIMER0 clocks */
CMU_ClockEnable(cmuClock_DMA, true);
CMU_ClockEnable(cmuClock_TIMER0, true);
/* Enable overflow interrupt */
TIMER_IntEnable(TIMER0, TIMER_IF_OF);
/* Enable TIMER0 interrupt vector in NVIC */
NVIC_EnableIRQ(TIMER0_IRQn);
/* Initialize TIMER0 */
TIMER_Init_TypeDef timerInit =
{
.enable = true,
.debugRun = true,
.prescale = timerPrescale64,
.clkSel = timerClkSelHFPerClk,
.fallAction = timerInputActionNone,
.riseAction = timerInputActionNone,
.mode = timerModeUp,
.dmaClrAct = false,
.quadModeX4 = false,
.oneShot = false,
.sync = false,
};
TIMER_Init(TIMER0, &timerInit);
/* Initialize DMA */
DMA_Init_TypeDef dmaInit;
dmaInit.hprot = 0;
dmaInit.controlBlock = dmaControlBlock;
DMA_Init(&dmaInit);
/* Configure the DMA and perform the transfer */
performFlashTransfer();
while (1)
{
/* The transfer has finished. We wish to display the result on the LCD
* but use as little power as possible; go to EM2 (the LCD requires EM2). */
EMU_EnterEM2(true);
}
}