static void setupBSP()
{
BSP_Init( BSP_INIT_DEFAULT );
BSP_TraceProfilerSetup();
BSP_PeripheralAccess( BSP_AUDIO_IN, true );
BSP_PeripheralAccess( BSP_AUDIO_OUT, true );
}
int main(void)
{
CHIP_Init();
if (SysTick_Config(CMU_ClockFreqGet(cmuClock_CORE) / 1000)) while (1) ;
BSP_Init(BSP_INIT_DEFAULT);
BSP_LedsSet(0);
BSP_PeripheralAccess(BSP_AUDIO_IN, true);
BSP_PeripheralAccess(BSP_AUDIO_OUT, true);
RTCDRV_Trigger(1000, NULL);
EMU_EnterEM2(true);
initSource();
setupCMU();
setupDMA();
//setupADC();
//setupDAC();
//setupDMAInput();
//setupDMAOutput();
//setupDMASplit();
//setupDMAMerge();
ADCConfig();
DACConfig();
TIMER_Init_TypeDef timerInit = TIMER_INIT_DEFAULT;
TIMER_TopSet(TIMER0, CMU_ClockFreqGet(cmuClock_HFPER) / SAMPLE_RATE);
TIMER_Init(TIMER0, &timerInit);
Delay(100);
BSP_LedsSet(3);
Delay(500);
BSP_LedsSet(0);
Delay(100);
while(1) {
volatile bool result = test();
if (result) {
BSP_LedsSet(0x00FF);
} else {
BSP_LedsSet(0xFF00);
}
Delay(1000);
BSP_LedsSet(0x0);
Delay(1000);
}
}
/***************************************************************************//**
* @brief
* Initalize basic I2C master mode driver for use on the DK.
*
* @details
* This driver only supports master mode, single bus-master. In addition
* to configuring the EFM32 I2C peripheral module, it also configures DK
* specific setup in order to use the I2C bus.
*
* @param[in] init
* Pointer to I2C initialization structure.
******************************************************************************/
void I2CDRV_Init(const I2C_Init_TypeDef *init)
{
int i;
BSP_PeripheralAccess(BSP_I2C, true);
CMU_ClockEnable(cmuClock_HFPER, true);
CMU_ClockEnable(cmuClock_I2C0, true);
/* Use location 3: SDA - Pin D14, SCL - Pin D15 */
/* Output value must be set to 1 to not drive lines low... We set */
/* SCL first, to ensure it is high before changing SDA. */
GPIO_PinModeSet(gpioPortD, 15, gpioModeWiredAnd, 1);
GPIO_PinModeSet(gpioPortD, 14, gpioModeWiredAnd, 1);
/* In some situations (after a reset during an I2C transfer), the slave */
/* device may be left in an unknown state. Send 9 clock pulses just in case. */
for (i = 0; i < 9; i++)
{
/*
* TBD: Seems to be clocking at appr 80kHz-120kHz depending on compiler
* optimization when running at 14MHz. A bit high for standard mode devices,
* but DK only has fast mode devices. Need however to add some time
* measurement in order to not be dependable on frequency and code executed.
*/
GPIO_PinModeSet(gpioPortD, 15, gpioModeWiredAnd, 0);
GPIO_PinModeSet(gpioPortD, 15, gpioModeWiredAnd, 1);
}
/* Enable pins at location 3 (which is used on the DK) */
I2C0->ROUTE = I2C_ROUTE_SDAPEN |
I2C_ROUTE_SCLPEN |
(3 << _I2C_ROUTE_LOCATION_SHIFT);
I2C_Init(I2C0, init);
}
/** function loads calibration table from EEPROM, validate it and if OK uses it */
static void touch_LoadCalibration(void)
{
I2CSPM_Init_TypeDef i2cInit = I2CSPM_INIT_DEFAULT;
uint32_t temp, checksum;
int count;
MATRIX new_matrix;
#if !defined( BSP_STK )
BSP_PeripheralAccess(BSP_I2C, true);
#endif
/* Initialize I2C driver, using standard rate. Devices on DK itself */
/* supports fast mode, but in case some slower devices are added on */
/* prototype board, we use standard mode. */
I2CSPM_Init(&i2cInit);
count = EEPROM_Read(I2C0, EEPROM_DVK_ADDR, CALIBRATION_EEPROM_OFFSET, (uint8_t*) &temp, sizeof(temp));
count += EEPROM_Read(I2C0, EEPROM_DVK_ADDR, CALIBRATION_EEPROM_OFFSET + 4, (uint8_t*) &new_matrix, sizeof(new_matrix));
if (count == sizeof(new_matrix) + 4)
{
if (temp == CALIBRATION_MAGIC_NUMBER)
{
checksum = touch_CountChecksum(temp, (uint32_t*) &new_matrix, sizeof(new_matrix) / 4);
count = EEPROM_Read(I2C0, EEPROM_DVK_ADDR, CALIBRATION_EEPROM_OFFSET + 4 + sizeof(new_matrix), (uint8_t*) &temp, sizeof(temp));
if (temp == checksum)
{ /* looks like calibration table is valid */
ADC_IntDisable(ADC0, ADC_IF_SINGLE); /* we need to disable ADC interrupt to avoid current_pos structure update for a while */
memcpy(&calibrationMatrix, &new_matrix, sizeof(calibrationMatrix));
ADC_IntEnable(ADC0, ADC_IF_SINGLE);
}
}
}
}
/******************************************************************************
* @brief Main function
*
*****************************************************************************/
int main(void)
{
/* Initialize chip - handle erratas */
CHIP_Init( );
/* Initialize clocks and oscillators */
cmuSetup( );
/* Initialize UART peripheral */
uartSetup( );
/* Initialize Development Kit in EBI mode */
BSP_Init(BSP_INIT_DEFAULT);
/* Enable RS-232 transceiver on Development Kit */
BSP_PeripheralAccess(BSP_RS232_UART, true);
/* When DVK is configured, and no more DVK access is needed, the interface can safely be disabled to save current */
BSP_Disable();
/* Write welcome message to UART */
uartPutData((uint8_t*) welcomeString, welLen);
/* Eternal while loop
* CPU will sleep during Rx and Tx. When a byte is transmitted, an interrupt
* wakes the CPU which copies the next byte in the txBuf queue to the
* UART TXDATA register.
*
* When the predefined termiation character is received, the all pending
* data in rxBuf is copied to txBuf and echoed back on the UART */
while (1)
{
/* Wait in EM1 while UART transmits */
EMU_EnterEM1();
/* Check if RX buffer has overflowed */
if (rxBuf.overflow)
{
rxBuf.overflow = false;
uartPutData((uint8_t*) overflowString, ofsLen);
}
/* Check if termination character is received */
if (rxBuf.data[(rxBuf.wrI - 1) % BUFFERSIZE] == TERMINATION_CHAR)
{
/* Copy received data to UART transmit queue */
uint8_t tmpBuf[BUFFERSIZE];
int len = uartGetData(tmpBuf, 0);
uartPutData(tmpBuf, len);
}
}
}
/**************************************************************************//**
* @brief TFT initialize or reinitialize
* Assumes EBI has been configured correctly in BSP_Init(BSP_INIT_DK_EBI)
*
* @param[in] tftInit Pointer to EBI TFT initialization structure
*
* @return true if we should redraw into buffer, false if BC has control
* over display
*****************************************************************************/
bool TFT_DirectInit(const EBI_TFTInit_TypeDef *tftInit)
{
bool ret;
uint32_t i, freq;
EMSTATUS stat;
/* If we are in BC_UIF_AEM_EFM state, we can redraw graphics */
if (BSP_RegisterRead(&BC_REGISTER->UIF_AEM) == BC_UIF_AEM_EFM)
{
/* If we're not BC_ARB_CTRL_EBI state, we need to reconfigure display controller */
if ((BSP_RegisterRead(&BC_REGISTER->ARB_CTRL) != BC_ARB_CTRL_EBI) || runOnce)
{
/* Enable SSD2119 Serial Port Interface */
BSP_PeripheralAccess(BSP_TFT, true);
/* Enable EBI mode of operation on SSD2119 controller */
BSP_DisplayControl(BSP_Display_EBI);
BSP_DisplayControl(BSP_Display_ResetAssert);
BSP_DisplayControl(BSP_Display_PowerDisable);
freq = SystemCoreClockGet();
for (i = 0; i < (freq / 100); i++)
{
__NOP();
}
/* Configure display for Direct Drive "Mode Generic" + 3-wire SPI mode */
BSP_DisplayControl(BSP_Display_ModeGeneric);
BSP_DisplayControl(BSP_Display_PowerEnable);
BSP_DisplayControl(BSP_Display_ResetRelease);
/* Configure GPIO for EBI and TFT */
TFT_DirectGPIOConfig();
/* Initialize display */
stat = DMD_init(0);
if (DMD_OK == stat) stat = DMD_selectFramebuffer((void*)EBI_BankAddress(EBI_BANK2));
if (DMD_OK != stat) while (1) ;
/* Configure EBI TFT direct drive */
EBI_TFTInit(tftInit);
runOnce = false;
}
ret = true;
}
else
{
ret = false;
}
return ret;
}
/**************************************************************************//**
* @brief
* Initialize the storage media interface.
*****************************************************************************/
bool MSDDMEDIA_Init( void )
{
#if ( MSD_MEDIA != MSD_SDCARD_MEDIA ) && ( MSD_MEDIA != MSD_NORFLASH_MEDIA )
numSectors = MEDIA_SIZE / 512;
#endif
#if ( MSD_MEDIA == MSD_PSRAM_MEDIA )
storage = (uint8_t*)EBI_BankAddress( EBI_BANK2 );
storage[0] = 0; /* To force new "format disk" when host detects disk. */
#endif
#if ( MSD_MEDIA == MSD_SDCARD_MEDIA )
/* Enable SPI access to MicroSD card */
BSP_PeripheralAccess( BSP_MICROSD, true );
MICROSD_Init();
if ( disk_initialize( 0 ) != 0 )
return false;
/* Get numSectors from media. */
if ( disk_ioctl( 0, GET_SECTOR_COUNT, &numSectors ) != RES_OK )
return false;
#endif
#if ( MSD_MEDIA == MSD_FLASH_MEDIA )
flashStatus.pendingWrite = false;
MSC_Init(); /* Unlock and calibrate flash timing */
MSC_Deinit(); /* Lock flash */
#endif
#if ( MSD_MEDIA == MSD_NORFLASH_MEDIA )
flashStatus.pendingWrite = false;
NORFLASH_Init(); /* Initialize NORFLASH interface */
storage = (uint8_t*)NORFLASH_DeviceInfo()->baseAddress;
flashPageSize = NORFLASH_DeviceInfo()->sectorSize;
/* Use external PSRAM as page (flash sector) buffer */
flashPageBuf = (uint8_t*)EBI_BankAddress( EBI_BANK2 );
numSectors = NORFLASH_DeviceInfo()->deviceSize / 512;
#endif
return true;
}
/**************************************************************************//**
* @brief Intializes UART/LEUART
*****************************************************************************/
void UART1_SerialInit(void)
{
/* Configure GPIO pins */
CMU_ClockEnable(cmuClock_GPIO, true);
/* To avoid false start, configure output as high */
GPIO_PinModeSet(gpioPortB, 9, gpioModePushPull, 1);
GPIO_PinModeSet(gpioPortB, 10, gpioModeInput, 0);
USART_TypeDef *usart = UART1;
USART_InitAsync_TypeDef init = USART_INITASYNC_DEFAULT;
/* Enable EFM32GG_DK3750 RS232/UART switch */
BSP_PeripheralAccess(BSP_RS232_UART, true);
/* Enable peripheral clocks */
CMU_ClockEnable(cmuClock_HFPER, true);
CMU_ClockEnable(cmuClock_UART1, true);
/* Configure USART for basic async operation */
init.enable = usartDisable;
USART_InitAsync(usart, &init);
/* Enable pins at UART1 location #2 */
usart->ROUTE = USART_ROUTE_RXPEN | USART_ROUTE_TXPEN | USART_ROUTE_LOCATION_LOC2;
/* Clear previous RX interrupts */
USART_IntClear(UART1, USART_IF_RXDATAV);
NVIC_ClearPendingIRQ(UART1_RX_IRQn);
/* Enable RX interrupts */
USART_IntEnable(UART1, USART_IF_RXDATAV);
NVIC_EnableIRQ(UART1_RX_IRQn);
/* Finally enable it */
USART_Enable(usart, usartEnable);
#if !defined(__CROSSWORKS_ARM) && defined(__GNUC__)
setvbuf(stdout, NULL, _IONBF, 0); /*Set unbuffered mode for stdout (newlib)*/
#endif
initialized = true;
}
int main(void)
{
CHIP_Init();
/* Enable access to the I2C bus on the DK */
BSP_Init(BSP_INIT_DEFAULT);
BSP_PeripheralAccess(BSP_I2C, true);
/* Set up DMA and I2C */
dmaInit();
i2cInit();
/* Clear error flag. Will be set on any error during transmission. */
i2cError = false;
i2cDmaWrite(EEPROM_I2C_ADDR, 0, (uint8_t *)txData, sizeof(txData));
/* Wait until the I2C transfer is complete */
sleepUntilTransferDone();
/* The EEPROM will be busy for a while after writing to it.
* Do an 'ACK poll' until it is ready */
ackPoll(EEPROM_I2C_ADDR);
/* Read the sequence back from the EEPROM */
i2cDmaRead(EEPROM_I2C_ADDR, 0, (uint8_t *)rxData, sizeof(txData));
/* Wait until the I2C transfer is complete */
sleepUntilTransferDone();
if ( i2cError )
{
/* An error occured during the transfer */
}
/* Done */
while (1);
}
/***************************************************************************//**
* @brief
* Initialize touch panel driver
*
* @param config
* Driver configuration data.
******************************************************************************/
void TOUCH_Init(TOUCH_Config_TypeDef *config)
{
ADC_Init_TypeDef init = ADC_INIT_DEFAULT;
#ifndef TOUCH_WITHOUT_STORE
touch_LoadCalibration();
#endif
CMU_ClockEnable(cmuClock_ADC0, true);
ADC_IntDisable(ADC0, _ADC_IF_MASK);
init.prescale = ADC_PrescaleCalc(config->frequency, 0);
touch_ignore_move = config->ignore;
init.ovsRateSel = config->oversampling;
ADC_Init(ADC0, &init);
BSP_PeripheralAccess(BSP_TOUCH, true);
sInit.input = ADC_Y;
sInit.reference = adcRefVDD;
sInit.resolution = adcResOVS;
ADC_InitSingle(ADC0, &sInit);
ADC_IntClear(ADC0, _ADC_IF_MASK);
touch_state = TOUCH_INIT;
NVIC_ClearPendingIRQ(ADC0_IRQn);
NVIC_EnableIRQ(ADC0_IRQn);
ADC_IntEnable(ADC0, ADC_IF_SINGLE);
ADC_Start(ADC0, adcStartSingle);
}
/*
*********************************************************************************************************
* 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 Main function
*****************************************************************************/
int main(void)
{
bool redraw, firstRun;
FRESULT res;
int mountStatus;
/* Used when iterating through directory */
FILINFO Finfo;
DIR dir;
FRESULT listDirStatus = FR_OK;
/* Used for manifest operation */
bool useManifest = false;
char buffer[20];
/* Use 32MHZ HFXO as core clock frequency */
CMU_ClockSelectSet(cmuClock_HF, cmuSelect_HFXO);
/* Initialize DK board register access */
BSP_Init(BSP_INIT_DEFAULT);
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Setup SysTick Timer for 10 msec interrupts */
if (SysTick_Config(CMU_ClockFreqGet(cmuClock_CORE) / 100))
{
while (1) ;
}
/* Enable SPI access to MicroSD card */
BSP_PeripheralAccess(BSP_MICROSD, true);
/* Initialize filesystem */
mountStatus = initFatFS();
/* Open Manifest file. If a manifest file is not present, iterate through the
* File system in filesystem order. */
if (f_open(&manifest, "files.txt", FA_READ) == FR_OK)
useManifest = true;
firstRun = true;
/* Update TFT display forever */
while (1)
{
if (!useManifest)
{
/* Open root directory */
strcpy(path, "");
listDirStatus = f_opendir(&dir, path);
}
/* Iterate through files */
while (1)
{
/* Check if we should control TFT display instead of
* AEM/board control application. Read state of AEM pushbutton */
redraw = TFT_AddressMappedInit();
if (redraw)
{
if ( firstRun )
{
firstRun = false;
SLIDES_init();
}
/* Check disk status */
if (disk_status(0) != 0)
{
/* Filesystem not mounted, show fatal error. */
SLIDES_showError(true, "Fatal:\n Filesystem is not ready.\n (%d)", disk_status(0));
}
/* Check if filesystem was successfully mounted. */
if (mountStatus != 0)
{
/* Filesystem not mounted, show fatal error. */
SLIDES_showError(true, "Fatal:\n Filesystem could not be mounted.\n (%d)", mountStatus);
}
/* Is there a manifest file present? */
if (useManifest)
{
/* If we are at the end of the file, reset filepointer */
if (f_eof(&manifest))
f_lseek(&manifest, 0);
/* Read next file from manifest file */
f_gets(buffer, 20, &manifest);
/* Display Bitmap */
SLIDES_showBMP(buffer);
}
else
{
/* Check to see if the root directory was correctly opened. */
if (listDirStatus != FR_OK)
{
SLIDES_showError(true, "Fatal:\n Could not read root directory.\n (%d)", listDirStatus);
}
/* Open the next entry in directory */
res = f_readdir(&dir, &Finfo);
if ((res != FR_OK) || !Finfo.fname[0])
{
/* End of directory listing. Break out of inner loop and reopen
* directory entry */
break;
}
/* Update display */
SLIDES_showBMP(Finfo.fname);
}
/* Delay to allow the user to see the BMP file. */
Delay(200);
}
}
}
}
/***************************************************************************//**
* @brief
* Main function. Setup ADC, FFT, clocks, PRS, DMA, Timer,
* and process FFT forever.
*******************************************************************************/
int main(void)
{
arm_status status;
char buf[20];
bool redraw = false;
int glibStatus;
DMA_Init_TypeDef dmaInit;
TIMER_Init_TypeDef timerInit = TIMER_INIT_DEFAULT;
/* 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_TraceEtmSetup();
/* Connect audio in to ADC */
BSP_PeripheralAccess(BSP_AUDIO_IN, true);
/* Wait a while in order to let signal from audio-in stabilize after */
/* enabling audio-in peripheral. */
RTCDRV_Trigger(1000, NULL);
EMU_EnterEM2(true);
/* Initialize the CFFT/CIFFT module */
status = arm_rfft_init_f32(&rfft_instance,
&cfft_instance,
GUITAR_AUDIO_BUFFER_SAMPLES,
0, /* forward transform */
1); /* normal, not bitreversed, order */
if (status != ARM_MATH_SUCCESS) {
/* Error initializing RFFT module. */
while (1) ;
}
dataReadyForFFT = false;
processingFFT = false;
/* Use the HFXO. We still only manage to process about
* a third the buffers through FFT
*/
CMU_ClockSelectSet(cmuClock_HF, cmuSelect_HFXO);
/* Setup SysTick Timer for 1 msec interrupts */
if (SysTick_Config(CMU_ClockFreqGet(cmuClock_CORE) / 1000))
{
while (1) ;
}
/* Enable clocks required */
CMU_ClockEnable(cmuClock_HFPER, true);
CMU_ClockEnable(cmuClock_ADC0, true);
CMU_ClockEnable(cmuClock_PRS, true);
CMU_ClockEnable(cmuClock_DMA, true);
CMU_ClockEnable(cmuClock_TIMER0, true);
NVIC_SetPriority(DMA_IRQn, 0); /* Highest priority */
/* Configure peripheral reflex system used by TIMER to trigger ADC/DAC */
guitarPRSConfig(GUITAR_PRS_CHANNEL);
/* Configure general DMA issues */
dmaInit.hprot = 0;
dmaInit.controlBlock = dmaControlBlock;
DMA_Init(&dmaInit);
/* Configure ADC used for audio-in */
guitarADCConfig();
/* Trigger sampling according to configured sample rate */
TIMER_TopSet(TIMER0, CMU_ClockFreqGet(cmuClock_HFPER) / GUITAR_AUDIO_SAMPLE_RATE);
TIMER_Init(TIMER0, &timerInit);
/* Wait until we have control over display */
while(!redraw)
{
redraw = TFT_AddressMappedInit();
}
/* Init graphics context - abort on failure */
glibStatus = GLIB_contextInit(&gc);
if (glibStatus != GLIB_OK) while (1) ;
/* Clear the screen */
gc.backgroundColor = GLIB_rgbColor(0, 0, 0);
GLIB_clear(&gc);
while (1)
{
while (dataReadyForFFT)
{
float32_t freq;
processingFFT = true;
processFFT();
dataReadyForFFT = false;
processingFFT = false;
/* Get frequency and make string with one decimal accuracy */
freq = getFreq();
sprintf(buf, "%6.1f", freq);
/* Check if we should control TFT display instead of AEM/board controller */
redraw = TFT_AddressMappedInit();
if (redraw)
{
gc.foregroundColor = GLIB_rgbColor(220, 220, 220);
gc.backgroundColor = GLIB_rgbColor(0, 0, 0);
/* Print the frequency somewhere in the middle of the screen */
GLIB_drawString(&gc,
buf,
strlen(buf),
100,
120,
1);
}
}
EMU_EnterEM1();
}
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
uint32_t buttons;
POINT touchSample, P[ 3 ];
ADC_Init_TypeDef init = ADC_INIT_DEFAULT;
/* Configure for 48MHz HFXO operation of core clock */
CMU_ClockSelectSet(cmuClock_HF, cmuSelect_HFXO);
/* Initialize DK 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_GPIO, true);
CMU_ClockEnable( cmuClock_ADC0, true);
/* Max ADC clock is 13MHz, use 14MHz/(1+1) or 48MHz/(5+1) */
init.prescale = 5;
ADC_Init(ADC0, &init);
sInit.reference = adcRefVDD;
/* Set frame buffer start address */
frameBuffer = (uint16_t *) EBI_BankAddress(EBI_BANK2);
/* Make sure CYCCNT is running, needed by delay functions. */
DWT_CTRL |= 1;
/* Indicate we are waiting for AEM button state enabling EFM */
BSP_LedsSet(0x8001);
while (BSP_RegisterRead(&BC_REGISTER->UIF_AEM) != BC_UIF_AEM_EFM)
{
/* Show a short "strobe light" on DK LEDs, indicating wait */
BSP_LedsSet(0x8001);
delayMs(200);
BSP_LedsSet(0x4002);
delayMs(50);
}
/* Initialize touch screen calibration factor matrix with approx. values */
setCalibrationMatrix( (POINT*)&lcdCalibPoints, /* Display coordinates */
(POINT*)&touchCalibPoints, /* Touch coordinates */
&calibFactors ); /* Calibration factor matrix */
while (1)
{
if ( TFT_DirectInit(&tftInit) )
{
displayHelpScreen();
BSP_LedsSet(0x0000);
BSP_PeripheralAccess(BSP_TOUCH, true);
GPIO_PinModeSet(LCD_TOUCH_X1, gpioModeInput, 0);
GPIO_PinModeSet(LCD_TOUCH_X2, gpioModeInput, 0);
GPIO_PinModeSet(LCD_TOUCH_Y1, gpioModeInput, 0);
GPIO_PinModeSet(LCD_TOUCH_Y2, gpioModeInput, 0);
do
{
buttons = readButtons();
/* Draw on screen */
if ( buttons & BC_UIF_PB1 )
{
memset( frameBuffer, BLACK, 2 * WIDTH * HEIGHT ); /* Clear screen */
do
{
if ( touched() )
{
touchSample = getTouchSample();
drawPixel( touchSample.x, touchSample.y, COLOR );
}
delayMs( 2 );
buttons = readButtons() & ~BC_UIF_PB1;
} while ( buttons == 0 );
}
/* Calibrate touch screen */
else if ( buttons & BC_UIF_PB2 )
{
memset( frameBuffer, BLACK, 2 * WIDTH * HEIGHT ); /* Clear screen */
drawCross( lcdCalibPoints[ 0 ].x, lcdCalibPoints[ 0 ].y, COLOR );
TFT_DrawString(30, 35, "Tap green marker" );
P[ 0 ] = getTouchTapSample10bit();
memset( frameBuffer, BLACK, 2 * WIDTH * HEIGHT ); /* Clear screen */
drawCross( lcdCalibPoints[ 1 ].x, lcdCalibPoints[ 1 ].y, COLOR );
TFT_DrawString(40, 130, "Tap green marker" );
P[ 1 ] = getTouchTapSample10bit();
memset( frameBuffer, BLACK, 2 * WIDTH * HEIGHT ); /* Clear screen */
drawCross( lcdCalibPoints[ 2 ].x, lcdCalibPoints[ 2 ].y, COLOR );
TFT_DrawString(20, 180, "Tap green marker" );
P[ 2 ] = getTouchTapSample10bit();
setCalibrationMatrix( (POINT*)&lcdCalibPoints,/* Display coordinates*/
&P[0], /* Touch coordinates */
&calibFactors ); /* Calibration factor matrix*/
memset( frameBuffer, BLACK, 2 * WIDTH * HEIGHT ); /* Clear screen */
TFT_DrawString(10, 100, "The touch screen is" );
TFT_DrawString(30, 130, "now calibrated !" );
}
/* Display help screen */
else if ( buttons & BC_UIF_PB3 )
{
displayHelpScreen();
while ( readButtons() & BC_UIF_PB3 ) {}
}
} while ( ( buttons & EXIT_LOOP ) == 0 );
}
else
{
BSP_LedsSet(0x8001);
delayMs(200);
}
}
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
uint32_t buttons;
POINT P[ 3 ];
TOUCH_Config_TypeDef touch_config = TOUCH_INIT_DEFAULT;
const char readmeText[] = \
"USB Bitmap transfer using USB drive functionality.\r\n\r\n"\
"This example demonstrate use several functionalities:\r\n"\
"1. Creation of virtual drive in system with FAT FS,\r\n"\
"2. Mounting the drive on PC and file transfer,\r\n"\
"3. Bitmap file creation based on TFT frame buffer content,\r\n"\
"4. Resistive touch panel interaction.\r\n\r\n"\
"On system startup initial drive is created and\r\n"\
"formatted using FAT FS then simple readme.txt file\r\n"\
"is put on file system. Every time user press PB4 key\r\n"\
"new file, containing TFT frame buffer in bitmap format\r\n"\
"is added. All files could be retrieved after connecting\r\n"\
"board to PC by means of USB. For this connection use\r\n"\
"small USB socket located on Leopard Gecko CPU board, not\r\n"\
"the big one on development kit.\r\n\r\n"\
"If new files doesn't appear on drive after pressing PB4,\r\n"\
"try to reconnect the board to PC.\r\n\r\n"\
"Board: Energy Micro EFM32LG-DK3650 Development Kit\r\n"\
"Device: EFM32LG990F256\r\n";
/* Configure for 48MHz HFXO operation of core clock */
CMU_ClockSelectSet(cmuClock_HF, cmuSelect_HFXO);
/* Initialize DK 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_GPIO, true);
CMU_ClockEnable( cmuClock_ADC0, true);
/* Set frame buffer start address */
frameBuffer = (uint16_t *) EBI_BankAddress(EBI_BANK2);
/* Make sure CYCCNT is running, needed by delay functions. */
DWT_CTRL |= 1;
/* Initialize USB subsystem and prepare for taking pictures */
BITMAP_Init();
/* Create our first file on disk - simple readme */
BITMAP_CreateFileAndSaveData("README.TXT", readmeText, sizeof(readmeText));
/* Indicate we are waiting for AEM button state enabling EFM */
while (BSP_RegisterRead(&BC_REGISTER->UIF_AEM) != BC_UIF_AEM_EFM)
{
/* Show a short "strobe light" on DK LEDs, indicating wait */
BSP_LedsSet(0x8001);
delayMs(100);
BSP_LedsSet(0x4002);
delayMs(100);
}
touch_config.frequency = 13000000; /* use max ADC frequency */
touch_config.ignore = 0; /* notice every move, even 1 pixel */
TOUCH_Init(&touch_config);
/* Initialize touch screen calibration factor matrix with approx. values */
setCalibrationMatrix( (POINT*)&lcdCalibPoints, /* Display coordinates */
(POINT*)&touchCalibPoints, /* Touch coordinates */
&calibFactors ); /* Calibration factor matrix */
while (1)
{
delayMs(100);
if ( TFT_DirectInit(&tftInit) )
{
delayMs(100);
displayHelpScreen();
BSP_LedsSet(0x0000);
BSP_PeripheralAccess(BSP_TOUCH, true);
GPIO_PinModeSet(LCD_TOUCH_X1, gpioModeInput, 0);
GPIO_PinModeSet(LCD_TOUCH_X2, gpioModeInput, 0);
GPIO_PinModeSet(LCD_TOUCH_Y1, gpioModeInput, 0);
GPIO_PinModeSet(LCD_TOUCH_Y2, gpioModeInput, 0);
do
{
delayMs(25);
buttons = readButtons();
/* Draw on screen */
if ( buttons & BC_UIF_PB1 )
{
memset( frameBuffer, BLACK, 2 * WIDTH * HEIGHT ); /* Clear screen */
do
{ TOUCH_Pos_TypeDef *pos = TOUCH_GetPos();
if ( pos->pen )
drawPixel( pos->x, pos->y, COLOR );
delayMs(1);
buttons = readButtons() & ~BC_UIF_PB1;
if(buttons == BC_UIF_PB4)
{
getNicePicture();
buttons &= ~BC_UIF_PB4;
}
} while ( buttons == 0 );
}
/* Calibrate touch screen */
else if ( buttons & BC_UIF_PB2 )
{
memset( frameBuffer, BLACK, 2 * WIDTH * HEIGHT ); /* Clear screen */
drawCross( lcdCalibPoints[ 0 ].x, lcdCalibPoints[ 0 ].y, COLOR );
TFT_DrawString(30, 35, "Tap green marker" );
P[ 0 ] = getTouchTapSample10bit();
memset( frameBuffer, BLACK, 2 * WIDTH * HEIGHT ); /* Clear screen */
drawCross( lcdCalibPoints[ 1 ].x, lcdCalibPoints[ 1 ].y, COLOR );
TFT_DrawString(40, 130, "Tap green marker" );
P[ 1 ] = getTouchTapSample10bit();
memset( frameBuffer, BLACK, 2 * WIDTH * HEIGHT ); /* Clear screen */
drawCross( lcdCalibPoints[ 2 ].x, lcdCalibPoints[ 2 ].y, COLOR );
TFT_DrawString(20, 180, "Tap green marker" );
P[ 2 ] = getTouchTapSample10bit();
TOUCH_CalibrationTable((POINT*)&lcdCalibPoints,/* Display coordinates*/
&P[0]); /* Touch coordinates */
memset( frameBuffer, BLACK, 2 * WIDTH * HEIGHT ); /* Clear screen */
TFT_DrawString(10, 100, "The touch screen is" );
TFT_DrawString(30, 130, "now calibrated !" );
}
/* Display help screen */
else if ( buttons & BC_UIF_PB3 )
{
displayHelpScreen();
while ( readButtons() & BC_UIF_PB3 )
delayMs(50);
} else if( buttons & BC_UIF_PB4 )
{
getNicePicture();
}
} while ( ( buttons & EXIT_LOOP ) == 0 );
}
else
{
BSP_LedsSet(0x8001);
delayMs(100);
BSP_LedsSet(0x4002);
}
}
}
int main(void)
{
/** Number of samples/channels taken from accelerometer. */
#define ACCEL_SAMPLES 3
/** X axis sample index. */
#define ACCEL_X 0
/** Y axis sample index. */
#define ACCEL_Y 1
/** Z axis sample index. */
#define ACCEL_Z 2
/*
* Tilt levels: Midpoint is theoretically half value of max sampling value
* (ie 0x800 for 12 bit sampling). In real world, some sort of calibration
* is required if more accurate sensing is required. We just use set some
* fixed limit, that should be sufficient for this basic example.
*/
/** Tilt left limit */
#define TILT_LEFT 0x750
/** Tilt right limit */
#define TILT_RIGHT 0x8b0
SYSTEM_ChipRevision_TypeDef chipRev;
uint32_t leds;
uint32_t samples[ACCEL_SAMPLES];
int errataShift = 0;
int i;
/* Chip revision alignment and errata fixes */
CHIP_Init();
/* ADC errata for rev B when using VDD as reference, need to multiply */
/* result by 2 */
SYSTEM_ChipRevisionGet(&chipRev);
if ((chipRev.major == 1) && (chipRev.minor == 1))
{
errataShift = 1;
}
/* Initialize DK board register access */
BSP_Init(BSP_INIT_DEFAULT);
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Connect accelerometer to EFM32. */
BSP_PeripheralAccess(BSP_ACCEL, true);
/* Enable clocks required */
CMU_ClockEnable(cmuClock_HFPER, true);
CMU_ClockEnable(cmuClock_ADC0, true);
CMU_ClockEnable(cmuClock_DMA, true);
/* Configure ADC and DMA used for scanning accelerometer */
accelADCConfig();
accelDMAConfig();
/* Main loop, keep polling accelerometer */
leds = 0x0180;
while (1)
{
DMA_ActivateBasic(ACCEL_DMA_CHANNEL,
true,
false,
samples,
(void *)((uint32_t)&(ADC0->SCANDATA)),
ACCEL_SAMPLES - 1);
/* Scan all axis', even though this app only use the X axis */
ADC_IntClear(ADC0, ADC_IF_SCAN);
ADC_Start(ADC0, adcStartScan);
/* Poll for completion, entering EM2 when waiting for next poll */
while (!(ADC_IntGet(ADC0) & ADC_IF_SCAN))
{
RTCDRV_Trigger(5, NULL);
EMU_EnterEM2(true);
}
if (errataShift)
{
for (i = 0; i < ACCEL_SAMPLES; i++)
{
samples[i] <<= errataShift;
}
}
if (samples[ACCEL_X] < TILT_LEFT)
{
if (leds < 0xc000)
{
leds <<= 1;
}
}
else if (samples[ACCEL_X] > TILT_RIGHT)
{
if (leds > 0x0003)
{
leds >>= 1;
}
}
else
{
if (leds > 0x0180)
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
/* Initialize DK board register access */
BSP_Init(BSP_INIT_DEFAULT);
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Setup SysTick Timer for 1 msec interrupts */
if (SysTick_Config(CMU_ClockFreqGet(cmuClock_CORE) / 1000))
{
while (1) ;
}
/* "Silly" loop that just enables peripheral access to the EFM32, and then
* disables them again. Verify that DK LEDs light up when access is enabled */
while (1)
{
/* Enable peripheral */
BSP_PeripheralAccess(BSP_MICROSD, true); Delay(500);
BSP_PeripheralAccess(BSP_I2C, true); Delay(500);
BSP_PeripheralAccess(BSP_TOUCH, true); Delay(500);
BSP_PeripheralAccess(BSP_I2S, true); Delay(500);
BSP_PeripheralAccess(BSP_AUDIO_OUT, true); Delay(500);
BSP_PeripheralAccess(BSP_AUDIO_IN, true); Delay(500);
BSP_PeripheralAccess(BSP_ANALOG_DIFF, true); Delay(500);
BSP_PeripheralAccess(BSP_ANALOG_SE, true); Delay(500);
BSP_PeripheralAccess(BSP_ETH, true); Delay(500);
BSP_PeripheralAccess(BSP_RS232_UART, true); Delay(500);
BSP_PeripheralAccess(BSP_RS232_LEUART, true); Delay(500);
BSP_PeripheralAccess(BSP_TRACE, true); Delay(500);
/* Disable peripheral */
BSP_PeripheralAccess(BSP_MICROSD, false); Delay(500);
BSP_PeripheralAccess(BSP_I2C, false); Delay(500);
BSP_PeripheralAccess(BSP_TOUCH, false); Delay(500);
BSP_PeripheralAccess(BSP_I2S, false); Delay(500);
BSP_PeripheralAccess(BSP_AUDIO_OUT, false); Delay(500);
BSP_PeripheralAccess(BSP_AUDIO_IN, false); Delay(500);
BSP_PeripheralAccess(BSP_ANALOG_DIFF, false); Delay(500);
BSP_PeripheralAccess(BSP_ANALOG_SE, false); Delay(500);
BSP_PeripheralAccess(BSP_ETH, false); Delay(500);
BSP_PeripheralAccess(BSP_RS232_UART, false); Delay(500);
BSP_PeripheralAccess(BSP_RS232_LEUART, false); Delay(500);
BSP_PeripheralAccess(BSP_TRACE, false); Delay(500);
}
}
/*
*********************************************************************************************************
* 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 */
;
}
}
int main(void)
{
DMA_Init_TypeDef dmaInit;
TIMER_Init_TypeDef timerInit = TIMER_INIT_DEFAULT;
SYSTEM_ChipRevision_TypeDef chipRev;
uint32_t volSample;
uint32_t vpot;
uint32_t rpot;
uint32_t leds;
/* Chip revision alignment and errata fixes */
CHIP_Init();
/* ADC errata for rev B when using VDD as reference, need to multiply */
/* result by 2 */
SYSTEM_ChipRevisionGet(&chipRev);
if ((chipRev.major == 1) && (chipRev.minor == 1))
{
preampErrataShift = 1;
}
/* 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();
/* Connect potentiometer to EFM32 (and ensure ambient light sensor */
/* sharing same ADC channel is not enabled). */
BSP_PeripheralAccess(BSP_AMBIENT, false);
BSP_PeripheralAccess(BSP_POTMETER, true);
/* Connect audio in/out to ADC/DAC */
BSP_PeripheralAccess(BSP_AUDIO_IN, true);
BSP_PeripheralAccess(BSP_AUDIO_OUT, true);
/* Wait a while in order to let signal from audio-in stabilize after */
/* enabling audio-in peripheral. */
RTCDRV_Trigger(1000, NULL);
EMU_EnterEM2(true);
/* Current example gets by at 14MHz core clock (also with low level of compiler */
/* optimization). That may however change if modified, consider changing to */
/* higher HFRCO band or HFXO. */
/*
Use for instance one of below statements to increase core clock.
CMU_ClockSelectSet(cmuClock_HF, cmuSelect_HFXO);
CMU_HFRCOBandSet(cmuHFRCOBand_28MHz);
*/
/* Enable clocks required */
CMU_ClockEnable(cmuClock_HFPER, true);
CMU_ClockEnable(cmuClock_ADC0, true);
CMU_ClockEnable(cmuClock_DAC0, true);
CMU_ClockEnable(cmuClock_PRS, true);
CMU_ClockEnable(cmuClock_DMA, true);
CMU_ClockEnable(cmuClock_TIMER0, true);
/* Ensure DMA interrupt at higher priority than PendSV. */
/* (PendSV used to process sampled audio). */
NVIC_SetPriority(DMA_IRQn, 0); /* Highest priority */
NVIC_SetPriority(PendSV_IRQn, (1 << __NVIC_PRIO_BITS) - 1); /* Lowest priority */
/* Configure peripheral reflex system used by TIMER to trigger ADC/DAC */
preampPRSConfig(PREAMP_PRS_CHANNEL);
/* Configure general DMA issues */
dmaInit.hprot = 0;
dmaInit.controlBlock = dmaControlBlock;
DMA_Init(&dmaInit);
/* Configure DAC used for audio-out */
preampDACConfig();
/* Configure ADC used for audio-in */
preampADCConfig();
/* Trigger sampling according to configured sample rate */
TIMER_TopSet(TIMER0, CMU_ClockFreqGet(cmuClock_HFPER) / PREAMP_AUDIO_SAMPLE_RATE);
TIMER_Init(TIMER0, &timerInit);
/* Main loop, only responsible for checking volume */
while (1)
{
/* Triggered to check volume setting? */
if (preampCheckVolume)
{
preampCheckVolume = false;
/* Trigger single conversion, and wait for it to complete */
ADC_IntClear(ADC0, ADC_IF_SINGLE);
ADC_Start(ADC0, adcStartSingle);
while (!(ADC_IntGet(ADC0), ADC_IF_SINGLE))
{
/* Just wait for an interrupt to wake us up (DMA interrupts occur */
/* regularly). Thus, we don't need to enable ADC interrupt. */
EMU_EnterEM1();
}
volSample = ADC_DataSingleGet(ADC0) << preampErrataShift;
/*
DVK potentiometer design:
| Vdd = 3.3V
+-+
| | Rpullup = 10kOhm
+-+
|
+------> Vpot (to ADC)
|
+-+
| | Rpot = 0-100kOhm
+-+
| Gnd
Vpot = Rpot * Vdd / (Rpullup + Rpot)
This gives a non-linear voltage level measured by ADC with respect to
pot meter position. In order to determine the actual Rpot setting, which
is linear with respect to position, rewrite the above formula to:
Rpot = Rpullup * Vpot / (Vdd - Vpot)
*/
/* Vpot sampled with 8 bit, divide by max value */
vpot = (POTENTIOMETER_VDD_mV * volSample) / 0xff;
/* Calculate Rpot determining volume */
rpot = (POTENTIOMETER_PULLUP_OHM * vpot) / (POTENTIOMETER_VDD_mV - vpot);
/* The potentiometer may not be exact in upper range, make sure we don't use a higher */
/* value than assumed by defines. */
if (rpot > POTENTIOMETER_MAX_OHM)
{
rpot = POTENTIOMETER_MAX_OHM;
}
/* Precalculate adjustment factor to avoid repeated calculation when used. */
/* Scale down Rpot a bit to use in integer calculation without overflowing 32 bit reg. */
preampAdjustFactor = rpot / PREAMP_ADJUST_DIVISOR;
/* Use 14 right leds for volume control indicating. Leftmost led is used to indicate */
/* clipping of audio out signal (in order to limit volume out). Add half interval */
/* for improving integer rounding effects. */
leds = rpot + (POTENTIOMETER_MAX_OHM / (14 * 2));
leds = (1 << ((14 * leds) / POTENTIOMETER_MAX_OHM)) - 1;
/* Audio out clipped? */
if (preampAudioOutClipped)
{
preampAudioOutClipped = false;
leds |= 0x8000;
}
BSP_LedsSet((uint16_t)leds);
}
EMU_EnterEM1();
}
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
ADC_Init_TypeDef init = ADC_INIT_DEFAULT;
ADC_InitSingle_TypeDef singleInit = ADC_INITSINGLE_DEFAULT;
uint32_t sample;
uint32_t vpot;
uint32_t rpot;
SYSTEM_ChipRevision_TypeDef chipRev;
int errataShift = 0;
/* Chip revision alignment and errata fixes */
CHIP_Init();
/* ADC errata for rev B when using VDD as reference, need to multiply */
/* result by 2 */
SYSTEM_ChipRevisionGet(&chipRev);
if ((chipRev.major == 1) && (chipRev.minor == 1))
{
errataShift = 1;
}
/* 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();
/* Connect potentiometer to EFM32 (and ensure ambient light sensor */
/* sharing same ADC channel is not enabled). */
BSP_PeripheralAccess(BSP_AMBIENT, false);
BSP_PeripheralAccess(BSP_POTMETER, true);
/* Enable clocks required */
CMU_ClockEnable(cmuClock_HFPER, true);
CMU_ClockEnable(cmuClock_ADC0, true);
/* Init common issues for both single conversion and scan mode */
init.timebase = ADC_TimebaseCalc(0);
/* Might as well finish conversion as quickly as possibly since polling */
/* for completion. */
init.prescale = ADC_PrescaleCalc(7000000, 0);
/* WARMUPMODE must be set to Normal according to ref manual before */
/* entering EM2. In this example, the warmup time is not a big problem */
/* due to relatively infrequent polling. Leave at default NORMAL, */
ADC_Init(ADC0, &init);
/* Init for single conversion use. */
singleInit.reference = adcRefVDD;
singleInit.input = adcSingleInpCh5; /* According to DVK HW design */
singleInit.resolution = adcRes8Bit; /* Use at least 8 bit since unlinear voltage */
ADC_InitSingle(ADC0, &singleInit);
/* Ensure internal reference settled */
RTCDRV_Trigger(1, NULL);
EMU_EnterEM2(true);
/* Main loop - just check potentiometer and update LEDs */
while (1)
{
ADC_IntClear(ADC0, ADC_IF_SINGLE);
ADC_Start(ADC0, adcStartSingle);
/* Wait for completion */
while (!(ADC_IntGet(ADC0) & ADC_IF_SINGLE));
sample = ADC_DataSingleGet(ADC0) << errataShift;
/*
DVK potentiometer design:
| Vdd = 3.3V
+-+
| | Rpullup = 10kOhm
+-+
|
+------> Vpot (to ADC)
|
+-+
| | Rpot = 0-100kOhm
+-+
| Gnd
Vpot = Rpot * Vdd / (Rpullup + Rpot)
This gives a non-linear voltage level measured by ADC with respect to
pot meter position. In order to determine the actual Rpot setting, which
is linear with respect to position, rewrite the above formula to:
Rpot = Rpullup * Vpot / (Vdd - Vpot)
*/
/* Vpot sampled with 8 bit, divide by max value */
vpot = (POTENTIOMETER_VDD_mV * sample) / 0xff;
/* Calculate Rpot determining volume */
rpot = (POTENTIOMETER_PULLUP_OHM * vpot) / (POTENTIOMETER_VDD_mV - vpot);
/* The potentiometer may not be exact in upper range, make sure we don't use a higher */
/* value than assumed by defines. */
if (rpot > POTENTIOMETER_MAX_OHM)
{
rpot = POTENTIOMETER_MAX_OHM;
}
/* We have 16 LEDs, add half interval for improving rounding effects. */
rpot += (POTENTIOMETER_MAX_OHM / (16 * 2));
BSP_LedsSet((uint16_t)((1 << ((16 * rpot) / POTENTIOMETER_MAX_OHM)) - 1));
/* Wait some time before polling again */
RTCDRV_Trigger(100, NULL);
EMU_EnterEM2(true);
}
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
/* 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();
/* Setup SysTick Timer for 1 msec interrupts */
if (SysTick_Config(CMU_ClockFreqGet(cmuClock_CORE) / 1000))
{
while (1) ;
}
/* "Silly" loop that just enables peripheral access to the EFM32, and then
* disables them again. Verify that DVK LEDs light up when access is enabled */
while (1)
{
BSP_PeripheralAccess(BSP_POTMETER, true); Delay(500);
BSP_PeripheralAccess(BSP_AMBIENT, true); Delay(500);
BSP_PeripheralAccess(BSP_IRDA, true); Delay(500);
BSP_PeripheralAccess(BSP_AUDIO_OUT, true); Delay(500);
BSP_PeripheralAccess(BSP_AUDIO_IN, true); Delay(500);
BSP_PeripheralAccess(BSP_ANALOG_SE, true); Delay(500);
BSP_PeripheralAccess(BSP_ANALOG_DIFF, true); Delay(500);
BSP_PeripheralAccess(BSP_RS232B, true); Delay(500);
BSP_PeripheralAccess(BSP_RS232A, true); Delay(500);
BSP_PeripheralAccess(BSP_ACCEL, true); Delay(500);
BSP_PeripheralAccess(BSP_SPI, true); Delay(500);
BSP_PeripheralAccess(BSP_I2C, true); Delay(500);
BSP_PeripheralAccess(BSP_POTMETER, false); Delay(500);
BSP_PeripheralAccess(BSP_AMBIENT, false); Delay(500);
BSP_PeripheralAccess(BSP_IRDA, false); Delay(500);
BSP_PeripheralAccess(BSP_AUDIO_OUT, false); Delay(500);
BSP_PeripheralAccess(BSP_AUDIO_IN, false); Delay(500);
BSP_PeripheralAccess(BSP_ANALOG_SE, false); Delay(500);
BSP_PeripheralAccess(BSP_ANALOG_DIFF, false); Delay(500);
BSP_PeripheralAccess(BSP_RS232B, false); Delay(500);
BSP_PeripheralAccess(BSP_RS232A, false); Delay(500);
BSP_PeripheralAccess(BSP_ACCEL, false); Delay(500);
BSP_PeripheralAccess(BSP_SPI, false); Delay(500);
BSP_PeripheralAccess(BSP_I2C, false); Delay(500);
}
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
#ifdef GG_STK
uint32_t mode = 0;
#else
/* Initialize DK board register access, necessary if run on DK */
BSP_Init(BSP_INIT_DEFAULT);
BSP_PeripheralAccess(BSP_AUDIO_OUT, true);
#endif
/* Initialize peripherals */
initClock();
initDma();
initDac();
initDacDma();
initTimer();
#ifdef GG_STK
initGpio();
#endif
while(1)
{
/*** Operation for EFM32GG-DK3750 ***/
#ifndef GG_STK
/* Wait key press */
while(!BSP_PushButtonsGet())
;
if (BSP_PushButtonsGet() == BC_UIF_PB1)
{
BSP_LedsSet(0x0001);
/* Wait key release */
while(BSP_PushButtonsGet()!=0);
/* Start play files */
playList[0].frameStart = (char *)voice8k;
playList[1].frameStart = NULL;
playList[0].frameNum = sizeof(voice8k)/FRAME_SIZE_8K;
speexPlayBack(0, NARROWBAND, FRAME_SIZE_8K, &playList[0]);
BSP_LedsSet(0x0000);
}
if (BSP_PushButtonsGet() == BC_UIF_PB2)
{
BSP_LedsSet(0x0002);
/* Wait key release */
while(BSP_PushButtonsGet()!=0);
/* Start play files */
playList[0].frameStart = (char *)voice11k;
playList[1].frameStart = NULL;
playList[0].frameNum = sizeof(voice11k)/FRAME_SIZE_11K;
speexPlayBack(0, NARROWBAND, FRAME_SIZE_11K, &playList[0]);
BSP_LedsSet(0x0000);
}
if (BSP_PushButtonsGet() == BC_UIF_PB3)
{
BSP_LedsSet(0x0004);
/* Wait key release */
while(BSP_PushButtonsGet()!=0);
/* Start play files */
playList[0].frameStart = (char *)voice15k;
playList[1].frameStart = NULL;
playList[0].frameNum = sizeof(voice15k)/FRAME_SIZE_15K;
speexPlayBack(0, NARROWBAND, FRAME_SIZE_15K, &playList[0]);
BSP_LedsSet(0x0000);
}
if (BSP_PushButtonsGet() == BC_UIF_PB4)
{
BSP_LedsSet(0x0008);
/* Wait key release */
while(BSP_PushButtonsGet()!=0);
/* Start play files */
playList[0].frameStart = (char *)voice18k2;
playList[1].frameStart = NULL;
playList[0].frameNum = sizeof(voice18k2)/FRAME_SIZE_18K2;
speexPlayBack(0, NARROWBAND, FRAME_SIZE_18K2, &playList[0]);
BSP_LedsSet(0x0000);
}
/*** Operation for EFM32GG-STK3750 ***/
#else
/* Wait key press */
EMU_EnterEM1();
switch (keyCheck())
{
case 1:
mode++;
if (mode == 4)
{
mode = 0;
}
GPIO_PortOutSetVal(gpioPortE, (mode << 2), 0x000c);
break;
case 2:
if (mode == 0x00)
{
/* Start play files */
playList[0].frameStart = (char *)voice8k;
playList[1].frameStart = NULL;
playList[0].frameNum = sizeof(voice8k)/FRAME_SIZE_8K;
speexPlayBack(0, NARROWBAND, FRAME_SIZE_8K, &playList[0]);
}
else if (mode == 0x01)
{
/* Start play files */
playList[0].frameStart = (char *)voice11k;
playList[1].frameStart = NULL;
playList[0].frameNum = sizeof(voice11k)/FRAME_SIZE_11K;
speexPlayBack(0, NARROWBAND, FRAME_SIZE_11K, &playList[0]);
}
else if (mode == 0x02)
{
/* Start play files */
playList[0].frameStart = (char *)voice15k;
playList[1].frameStart = NULL;
playList[0].frameNum = sizeof(voice15k)/FRAME_SIZE_15K;
speexPlayBack(0, NARROWBAND, FRAME_SIZE_15K, &playList[0]);
}
else
{
/* Start play files */
playList[0].frameStart = (char *)voice18k2;
playList[1].frameStart = NULL;
playList[0].frameNum = sizeof(voice18k2)/FRAME_SIZE_18K2;
speexPlayBack(0, NARROWBAND, FRAME_SIZE_18K2, &playList[0]);
}
break;
default:
break;
}
#endif
}
}
int main(void)
{
DMA_Init_TypeDef dmaInit;
TIMER_Init_TypeDef timerInit = TIMER_INIT_DEFAULT;
uint32_t leds;
static uint16_t last_buttons = 0;
uint16_t buttons;
/* Initialize DK board register access */
BSP_Init(BSP_INIT_DEFAULT);
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
volume = 7;
preampAdjustFactor = preampVolume[ volume ];
BSP_LedsSet((uint16_t)(0x00003FFF << (15 - volume)));
/* Connect audio in/out to ADC/DAC */
BSP_PeripheralAccess(BSP_AUDIO_IN, true);
BSP_PeripheralAccess(BSP_AUDIO_OUT, true);
/* Wait a while in order to let signal from audio-in stabilize after */
/* enabling audio-in peripheral. */
RTCDRV_Trigger(1000, NULL);
EMU_EnterEM2(true);
/* Current example gets by at 14MHz core clock (also with low level of compiler */
/* optimization). That may however change if modified, consider changing to */
/* higher HFRCO band or HFXO. */
/*
* Use for instance one of below statements to increase core clock.
* CMU_ClockSelectSet(cmuClock_HF, cmuSelect_HFXO);
* CMU_HFRCOBandSet(cmuHFRCOBand_28MHz);
*/
/* Enable clocks required */
CMU_ClockEnable(cmuClock_HFPER, true);
CMU_ClockEnable(cmuClock_ADC0, true);
CMU_ClockEnable(cmuClock_DAC0, true);
CMU_ClockEnable(cmuClock_PRS, true);
CMU_ClockEnable(cmuClock_DMA, true);
CMU_ClockEnable(cmuClock_TIMER0, true);
/* Ensure DMA interrupt at higher priority than PendSV. */
/* (PendSV used to process sampled audio). */
NVIC_SetPriority(DMA_IRQn, 0); /* Highest priority */
NVIC_SetPriority(PendSV_IRQn, (1 << __NVIC_PRIO_BITS) - 1); /* Lowest priority */
/* Configure peripheral reflex system used by TIMER to trigger ADC/DAC */
preampPRSConfig(PREAMP_PRS_CHANNEL);
/* Configure general DMA issues */
dmaInit.hprot = 0;
dmaInit.controlBlock = dmaControlBlock;
DMA_Init(&dmaInit);
/* Configure DAC used for audio-out */
preampDACConfig();
/* Configure ADC used for audio-in */
preampADCConfig();
/* Trigger sampling according to configured sample rate */
TIMER_TopSet(TIMER0, CMU_ClockFreqGet(cmuClock_HFPER) / PREAMP_AUDIO_SAMPLE_RATE);
TIMER_Init(TIMER0, &timerInit);
/* Main loop, only responsible for checking volume */
while (1)
{
/* Triggered to check volume setting? */
if (preampCheckVolume)
{
preampCheckVolume = false;
/* Calculate new output volume. */
buttons = BSP_PushButtonsGet() & PB_MASK; /* Check pushbuttons */
if (buttons != last_buttons)
{
if (buttons & BC_UIF_PB2) /* Increase volume */
{
if (volume < VOLUME_MAX)
volume++;
}
else if (buttons & BC_UIF_PB1) /* Decrease volume */
{
if (volume)
volume--;
}
preampAdjustFactor = preampVolume[ volume ];
last_buttons = buttons;
}
/* Use 14 leftmost leds for volume control indication. Rightmost led is */
/* used to indicate clipping of audio out signal. */
leds = 0x00003FFF << (15 - volume);
/* Audio out clipped? */
if (preampAudioOutClipped)
{
preampAudioOutClipped = false;
leds |= 0x0001;
}
BSP_LedsSet((uint16_t) leds);
}
EMU_EnterEM1();
}
}
/*
*********************************************************************************************************
* 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;
/* Use 48MHZ HFXO as core clock frequency */
CMU_ClockSelectSet(cmuClock_HF, cmuSelect_HFXO);
/* Initialize DK board register access */
/* This demo currently only works in EBI mode */
BSP_Init(BSP_INIT_DEFAULT);
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Setup SysTick Timer for 10 msec interrupts */
if (SysTick_Config(CMU_ClockFreqGet(cmuClock_CORE) / 1000))
{
while (1) ;
}
/* 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();
/* Enable EFM32LG_DK3650 RS232/UART switch */
BSP_PeripheralAccess(BSP_RS232_UART, true);
UART1_SerialInit();
UART1_SerialCrLf(1);
/* Initialize the TFT stdio retarget module. */
RETARGET_TftInit();
RETARGET_TftCrLf(0);
osVersion3 = OSVersion();
osVersion1 = osVersion3 / 10000;
osVersion3 -= osVersion1 * 10000;
osVersion2 = osVersion3 / 100;
osVersion3 -= osVersion2 * 100;
osVersion3 %= 100;
printf("\n*************************************");
printf("\n uC/OS-II v%d.%02d.%02d on EFM32 DK ",
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 is running on ");
printf("\n Silicon Labs EFM32 ");
printf("\n www.silabs.com \n");
printf("\nDescription:");
printf("\n\nTask1: LED blink task");
printf("\n\nTask2: Receives characters from serial and posts message to Task3");
printf("\n\nTask3: Receives message from Task2 and writes it on screen");
printf("\n\n**************************************\n");
printf("\nStart typing...\n");
/* 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 */
;
}
}
