/**************************************************************************//**
* @brief Configure SPI for correct peripheral
*
* @param[in] device
* Device to enable SPI bus for
*****************************************************************************/
void DVK_spiControl(DVK_SpiControl_TypeDef device)
{
switch (device)
{
case DVK_SPI_Audio:
DVK_writeRegister(&BC_REGISTER->SPI_DEMUX, BC_SPI_DEMUX_SLAVE_AUDIO);
break;
case DVK_SPI_Ethernet:
DVK_writeRegister(&BC_REGISTER->SPI_DEMUX, BC_SPI_DEMUX_SLAVE_ETHERNET);
break;
case DVK_SPI_Display:
DVK_writeRegister(&BC_REGISTER->SPI_DEMUX, BC_SPI_DEMUX_SLAVE_DISPLAY);
break;
case DVK_SPI_OFF:
USART_Reset(USART1);
CMU_ClockEnable(cmuClock_USART1, false);
break;
}
}
/***************************************************************************//**
* @brief
* Start the TIMER1 to generate a 50% duty cycle output.
*
* @param[in] frequency
* The output frequency in Hz.
******************************************************************************/
void TD_TIMER_Start(uint32_t frequency)
{
uint32_t top;
top = CMU_ClockFreqGet(cmuClock_TIMER1);
top = top / frequency;
// Enable clock for TIMER1 module
CMU_ClockEnable(cmuClock_TIMER1, true);
// Configure CC channel 0
TIMER_InitCC(TIMER1, 0, &timerCCInit);
// Route CC0 to location 0 (PC13) and enable pin
//TIMER1->ROUTE |= (TIMER_ROUTE_CC0PEN | TIMER_ROUTE_LOCATION_LOC0);
// Set Top Value
TIMER_TopSet(TIMER1, top);
// Set compare value starting at 0 - it will be incremented in the interrupt handler
TIMER_CompareBufSet(TIMER1, 0, top >> 1);
// Configure timer
TIMER_Init(TIMER1, &timerInit);
// Enable overflow interrupt
TIMER_IntEnable(TIMER1, TIMER_IF_OF);
// Disable interrupts
//TIMER_IntDisable(TIMER1, TIMER_IF_OF);
// Enable TIMER1 interrupt vector in NVIC
NVIC_EnableIRQ(TIMER1_IRQn);
// Enable timer
TIMER_Enable(TIMER1, true);
TD_TIMER_Enabled = true;
}
/******************************************************************************
* @brief uartSetup function
*
******************************************************************************/
void uartSetup(void)
{
/* Enable clock for GPIO module (required for pin configuration) */
CMU_ClockEnable(cmuClock_GPIO, true);
/* Configure GPIO pins */
GPIO_PinModeSet(gpioPortB, 9, gpioModePushPull, 1);
GPIO_PinModeSet(gpioPortB, 10, gpioModeInput, 0);
/* Prepare struct for initializing UART in asynchronous mode*/
uartInit.enable = usartDisable; /* Don't enable UART upon intialization */
uartInit.refFreq = 0; /* Provide information on reference frequency. When set to 0, the reference frequency is */
uartInit.baudrate = 115200; /* Baud rate */
uartInit.oversampling = usartOVS16; /* Oversampling. Range is 4x, 6x, 8x or 16x */
uartInit.databits = usartDatabits8; /* Number of data bits. Range is 4 to 10 */
uartInit.parity = usartNoParity; /* Parity mode */
uartInit.stopbits = usartStopbits1; /* Number of stop bits. Range is 0 to 2 */
uartInit.mvdis = false; /* Disable majority voting */
uartInit.prsRxEnable = false; /* Enable USART Rx via Peripheral Reflex System */
uartInit.prsRxCh = usartPrsRxCh0; /* Select PRS channel if enabled */
/* Initialize USART with uartInit struct */
USART_InitAsync(uart, &uartInit);
/* Prepare UART Rx and Tx interrupts */
USART_IntClear(uart, _UART_IF_MASK);
USART_IntEnable(uart, UART_IF_RXDATAV);
NVIC_ClearPendingIRQ(UART1_RX_IRQn);
NVIC_ClearPendingIRQ(UART1_TX_IRQn);
NVIC_EnableIRQ(UART1_RX_IRQn);
NVIC_EnableIRQ(UART1_TX_IRQn);
/* Enable I/O pins at UART1 location #2 */
uart->ROUTE = UART_ROUTE_RXPEN | UART_ROUTE_TXPEN | UART_ROUTE_LOCATION_LOC2;
/* Enable UART */
USART_Enable(uart, usartEnable);
}
void gpioSetup(){
/* Enable GPIO in CMU */
CMU_ClockEnable(cmuClock_GPIO, true);
/* Configure PC0 as Output */
GPIO_PinModeSet(gpioPortC, 0, gpioModePushPull, 0);
/* Configure PD0 as input */
GPIO_PinModeSet(gpioPortB, 9, gpioModeInput, 0);
/* Set rising edge interrupt for both ports */
GPIO_IntConfig(gpioPortB, 9, true, false, true);
motor_gpioSetup(); //set up the output pins for the step motor
/* Enable interrupt in core for even and odd gpio interrupts */
NVIC_ClearPendingIRQ(GPIO_EVEN_IRQn);
NVIC_EnableIRQ(GPIO_EVEN_IRQn);
/* Set PC0 to 0 */
GPIO_PinOutSet(gpioPortC, 0);
}
/**************************************************************************//**
* @brief Initialize TIMER0 in Up Count mode and to give interrupt on overflow
*****************************************************************************/
void initTimer()
{
TIMER_Init_TypeDef initValues = TIMER_INIT_DEFAULT;
/* Enable clock for TIMER0 */
CMU_ClockEnable(cmuClock_TIMER0, true);
/* Enable overflow interrupt for TIMER0*/
TIMER_IntEnable(TIMER0, TIMER_IF_OF);
/* Enable TIMER0 interrupt vector in NVIC */
NVIC_EnableIRQ(TIMER0_IRQn);
/* Set TIMER0 Top value */
TIMER_TopSet(TIMER0, TOP);
/* Initialize TIMER0 in with 1024x prescaling */
initValues.prescale = timerPrescale1024;
TIMER_Init(TIMER0, &initValues);
/* Start TIMER0 */
TIMER0->CMD = TIMER_CMD_START;
}
void i2c_setup()
{
CMU_ClockEnable(cmuClock_I2C0, true);
I2C_Init_TypeDef init = I2C_INIT_DEFAULT;
init.enable = 1;
init.master = 1;
init.freq = I2C_FREQ_STANDARD_MAX;
init.clhr = i2cClockHLRStandard;
I2C_Init(I2C0, &init);
// The rest of this is cut-and-pasted from chapter 10's InitDevice.c file
/* Module I2C0 is configured to location 1 */
I2C0->ROUTE = (I2C0->ROUTE & ~_I2C_ROUTE_LOCATION_MASK) | I2C_ROUTE_LOCATION_LOC1;
/* Enable signals SCL, SDA */
I2C0->ROUTE |= I2C_ROUTE_SCLPEN | I2C_ROUTE_SDAPEN;
/* Module PCNT0 is configured to location 1 */
PCNT0->ROUTE = (PCNT0->ROUTE & ~_PCNT_ROUTE_LOCATION_MASK) | PCNT_ROUTE_LOCATION_LOC1;
/* Module USART1 is configured to location 1 */
USART1->ROUTE = (USART1->ROUTE & ~_USART_ROUTE_LOCATION_MASK) | USART_ROUTE_LOCATION_LOC1;
/* Enable signals RX, TX */
USART1->ROUTE |= USART_ROUTE_RXPEN | USART_ROUTE_TXPEN;
// [Route Configuration]$
/* Pin PD6 is configured to Open-drain with pull-up and filter */
GPIO->P[3].MODEL = (GPIO->P[3].MODEL & ~_GPIO_P_MODEL_MODE6_MASK) | GPIO_P_MODEL_MODE6_WIREDANDPULLUPFILTER;
/* Pin PD7 is configured to Open-drain with pull-up and filter */
GPIO->P[3].MODEL = (GPIO->P[3].MODEL & ~_GPIO_P_MODEL_MODE7_MASK) | GPIO_P_MODEL_MODE7_WIREDANDPULLUPFILTER;
// [Port D Configuration]$
}
/**************************************************************************//**
* @brief Setup GPIO interrupt to set the time
*****************************************************************************/
void gpioSetup(void)
{
/* Configure PD8 as input */
//GPIO_PinModeSet(gpioPortD, 8, gpioModeInput, 0);
/* Set falling edge interrupt */
//GPIO_IntConfig(gpioPortD, 8, false, true, true);
//NVIC_ClearPendingIRQ(GPIO_EVEN_IRQn);
//NVIC_EnableIRQ(GPIO_EVEN_IRQn);
/* Configure PB11 as input */
//GPIO_PinModeSet(gpioPortB, 11, gpioModeInput, 0);
/* Set falling edge interrupt */
//GPIO_IntConfig(gpioPortB, 11, false, true, true);
//NVIC_ClearPendingIRQ(GPIO_ODD_IRQn);
//NVIC_EnableIRQ(GPIO_ODD_IRQn);
/* Enable GPIO in CMU */
CMU_ClockEnable(cmuClock_GPIO, true);
/* Configure PD8 and PB11 as input */
GPIO_PinModeSet(gpioPortD, 8, gpioModeInput, 0);
GPIO_PinModeSet(gpioPortB, 11, gpioModeInput, 0);
/* Set falling edge interrupt for both ports */
GPIO_IntConfig(gpioPortD, 8, false, true, true);
GPIO_IntConfig(gpioPortB, 11, false, true, true);
/* Enable interrupt in core for even and odd gpio interrupts */
NVIC_ClearPendingIRQ(GPIO_EVEN_IRQn);
NVIC_EnableIRQ(GPIO_EVEN_IRQn);
NVIC_ClearPendingIRQ(GPIO_ODD_IRQn);
NVIC_EnableIRQ(GPIO_ODD_IRQn);
}
/***************************************************************************//**
* @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);
}
int main(void)
{
CHIP_Init();
/*Turn on the DAC clock.*/
CMU_ClockEnable(cmuClock_DAC0, true);
/*configure and enable the DAC.*/
DAC_setup();
DAC_Enable(DAC0, 0, true);
/*Write data to registers. V1 = 1.0*/
DAC0->CH0DATA = (uint32_t)((1.0 * 4096) / 3.3);
/*configure OPA0, OPA1 and OPA2.*/
OPAMP_Init_TypeDef configuration0 = OPA_INIT_DIFF_RECEIVER_OPA0 ;
OPAMP_Init_TypeDef configuration2 = OPA_INIT_DIFF_RECEIVER_OPA2 ;
/*Redefine the resistances. Want to divide the difference by 3.*/
configuration2.resSel = opaResSelDefault;
configuration0.resSel = opaResSelR2eq3R1;
/*OPA2 positive input = VSS*/
configuration2.resInMux = opaResInMuxVss;
/*Enable OPA0 and OPA2. All the configurations are set.*/
OPAMP_Enable(DAC0, OPA0, &configuration0);
OPAMP_Enable(DAC0, OPA2, &configuration2);
/*Disable OPA0. This is done because we want to use OPA0 as a part of the DAC.
The configurations set above are still there.*/
DAC0->OPACTRL &= ~DAC_OPACTRL_OPA0EN;
/*Never end.*/
while(1);
}
void us_ticker_init(void)
{
if (us_ticker_inited) {
/* calling init again should cancel current interrupt */
us_ticker_disable_interrupt();
return;
}
us_ticker_inited = true;
/* Enable clock for TIMERs */
CMU_ClockEnable(US_TICKER_TIMER_CLOCK, true);
if (REFERENCE_FREQUENCY > 24000000) {
US_TICKER_TIMER->CTRL = (US_TICKER_TIMER->CTRL & ~_TIMER_CTRL_PRESC_MASK) | (4 << _TIMER_CTRL_PRESC_SHIFT);
} else {
US_TICKER_TIMER->CTRL = (US_TICKER_TIMER->CTRL & ~_TIMER_CTRL_PRESC_MASK) | (3 << _TIMER_CTRL_PRESC_SHIFT);
}
/* Clear TIMER counter value */
TIMER_CounterSet(US_TICKER_TIMER, 0);
/* Start TIMER */
TIMER_Enable(US_TICKER_TIMER, true);
/* Select Compare Channel parameters */
TIMER_InitCC_TypeDef timerCCInit = TIMER_INITCC_DEFAULT;
timerCCInit.mode = timerCCModeCompare;
/* Configure Compare Channel 0 */
TIMER_InitCC(US_TICKER_TIMER, 0, &timerCCInit);
/* Enable interrupt vector in NVIC */
TIMER_IntClear(US_TICKER_TIMER, TIMER_IEN_CC0);
NVIC_SetVector(US_TICKER_TIMER_IRQ, (uint32_t) us_ticker_irq_handler);
NVIC_EnableIRQ(US_TICKER_TIMER_IRQ);
}
/**************************************************************************//**
* @brief vPortSetupTimerInterrupt
* Override the default definition of vPortSetupTimerInterrupt() that is weakly
* defined in the FreeRTOS Cortex-M3, which set source of system tick interrupt
*****************************************************************************/
void vPortSetupTimerInterrupt(void)
{
/* Set our timer's data used as system ticks*/
ulTimerReloadValueForOneTick = SYSTICK_LOAD_VALUE;
#if (configUSE_TICKLESS_IDLE == 1)
xMaximumPossibleSuppressedTicks = TIMER_CAPACITY / (SYSTICK_LOAD_VALUE);
ulStoppedTimerCompensation = TIMER_COMPENSATION / (configCPU_CLOCK_HZ / configSYSTICK_CLOCK_HZ);
#endif /* (configUSE_TICKLESS_IDLE == 1) */
/* Ensure LE modules are accessible */
CMU_ClockEnable(cmuClock_CORELE, true);
/* Enable access to BURTC registers */
RMU_ResetControl(rmuResetBU, false);
/* Configure BURTC as system tick source */
BURTC_Init_TypeDef burtcInit = BURTC_INIT_DEFAULT;
burtcInit.mode = burtcModeEM3; /* BURTC is enabled to EM3 */
burtcInit.clkSel = burtcClkSelULFRCO; /* Select ULFRCO as clock source */
burtcInit.clkDiv = burtcClkDiv_1; /* Choose 2kHz ULFRCO clock frequency */
/* Initialization of BURTC */
BURTC_Init(&burtcInit);
/* Disable interrupt generation from BURTC */
BURTC_IntDisable(BURTC_IF_COMP0);
/* Tick interrupt MUST execute at the lowest interrupt priority. */
NVIC_SetPriority(BURTC_IRQn, 255);
/* Enable interrupts */
NVIC_ClearPendingIRQ(BURTC_IRQn);
NVIC_EnableIRQ(BURTC_IRQn);
BURTC_CompareSet(0, SYSTICK_LOAD_VALUE);
BURTC_IntClear(BURTC_IF_COMP0);
BURTC_IntEnable(BURTC_IF_COMP0);
BURTC_CounterReset();
}
/**************************************************************************//**
* @brief Enabling clocks
*****************************************************************************/
void setupCmu(void)
{
/* Enabling clocks */
CMU_ClockEnable(cmuClock_DMA, true);
}
/**************************************************************************//**
* @brief Main function
* The example data is first encrypted and encrypted data is checked.
* The encrypted data is then decrypted and checked against original data.
* Program ends at last while loop if all is OK.
*****************************************************************************/
int main(void)
{
uint32_t i;
/* Chip errata */
CHIP_Init();
/* Initialize error indicator */
bool error = false;
/* Enable AES clock */
CMU_ClockEnable(cmuClock_AES, true);
/* Copy plaintext to dataBuffer */
for (i=0; i<(sizeof(exampleData) / sizeof(exampleData[0])); i++)
{
dataBuffer[i] = exampleData[i];
}
/* Encrypt data in AES-128 OFB */
AesOfb128(exampleKey,
dataBuffer,
dataBuffer,
sizeof(dataBuffer) / (sizeof(dataBuffer[0]) * 16),
initVector);
/* Wait for AES to finish */
while (!AesFinished());
/* Check whether encrypted results are correct */
for (i = 0; i < (sizeof(dataBuffer) / sizeof(dataBuffer[0])); i++)
{
if (dataBuffer[i] != expectedEncryptedData[i])
{
error = true;
}
}
/* Decrypt data in AES-128 OFB. Note that this is the same operation as encrypt */
AesOfb128(exampleKey,
dataBuffer,
dataBuffer,
sizeof(dataBuffer) / (sizeof(dataBuffer[0]) * 16),
initVector);
/* Wait for AES to finish */
while (!AesFinished());
/* Check whether decrypted result is identical to the plaintext */
for (i = 0; i < (sizeof(dataBuffer) / sizeof(dataBuffer[0])); i++)
{
if (dataBuffer[i] != exampleData[i])
{
error = true;
}
}
/* Check for success */
if (error)
{
while (1) ; /* Ends here if there has been an error */
}
else
{
while (1) ; /* Ends here if all OK */
}
}
/**************************************************************************//**
* @brief TIMER0_setup
* Configures the TIMER
*****************************************************************************/
void TIMER_setup(void)
{
/* Enable necessary clocks */
CMU_ClockEnable(cmuClock_TIMER0, true);
CMU_ClockEnable(cmuClock_PRS, true);
/* Select CC channel parameters */
TIMER_InitCC_TypeDef timerCCInit =
{
.eventCtrl = timerEventEveryEdge, /* Input capture event control */
.edge = timerEdgeBoth, /* Input capture on falling edge */
.prsSel = timerPRSSELCh5, /* 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 channel */
TIMER_InitCC(HIJACK_RX_TIMER, 0, &timerCCInit);
/* Select timer parameters */
const TIMER_Init_TypeDef timerInit =
{
.enable = false, /* Do not start counting when init complete */
.debugRun = false, /* Counter not running on debug halt */
.prescale = HIJACK_TIMER_RESOLUTION, /* Prescaler of 1 */
.clkSel = timerClkSelHFPerClk, /* TIMER0 clocked by the HFPERCLK */
.fallAction = timerInputActionReloadStart, /* Stop counter on falling edge */
.riseAction = timerInputActionReloadStart, /* 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(HIJACK_RX_TIMER, &timerInit);
/* PRS setup */
/* Select ACMP as source and ACMP0OUT (ACMP0 OUTPUT) as signal */
PRS_SourceSignalSet(5, PRS_CH_CTRL_SOURCESEL_ACMP0, PRS_CH_CTRL_SIGSEL_ACMP0OUT, prsEdgeOff);
/* Enable CC0 interrupt */
TIMER_IntEnable(HIJACK_RX_TIMER, TIMER_IF_CC0);
/* Enable TIMER0 interrupt vector in NVIC */
NVIC_EnableIRQ(TIMER0_IRQn);
}
/**************************************************************************//**
* @brief ACMP_setup
* Configures and starts the ACMP
*****************************************************************************/
static void ACMP_setup(void)
{
/* Enable necessary clocks */
CMU_ClockEnable(HIJACK_RX_ACMPCLK, true);
CMU_ClockEnable(cmuClock_GPIO, true);
/* Configure ACMP input pin. */
GPIO_PinModeSet(HIJACK_RX_GPIO_PORT, HIJACK_RX_GPIO_PIN, gpioModeInput, 0);
/* Analog comparator parameters */
const ACMP_Init_TypeDef acmpInit =
{
.fullBias = false, /* No full bias current*/
.halfBias = true, /* No half bias current */
.biasProg = 2, /* 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 = acmpHysteresisLevel7, /* Hysteresis level 0 - no hysteresis */
.inactiveValue = 1, /* Inactive comparator output value */
.lowPowerReferenceEnabled = false, /* Low power reference mode disabled */
.vddLevel = HIJACK_RX_ACMP_LEVEL, /* Vdd reference scaling of 32 */
};
/* Use ACMP0 output, PD6 . */
//GPIO_PinModeSet(gpioPortD, 6, gpioModePushPull, 0);
//ACMP_GPIOSetup(ACMP0, 2, true, false);
/* Init ACMP and set ACMP channel 4 as positive input
and scaled Vdd as negative input */
ACMP_Init(HIJACK_RX_ACMP, &acmpInit);
ACMP_ChannelSet(HIJACK_RX_ACMP, HIJACK_RX_ACMP_NEG, HIJACK_RX_ACMP_CH);
ACMP_Enable(HIJACK_RX_ACMP);
}
/**
* @brief calculate whether cnt is in 500us region
* ticker = 64Mhz/128 = 2us
* 475us < cnt < 510us
*
*/
static chk_result_t IsTime2Detect(uint32_t inv)
{
chk_result_t ret;
if( inv < HIJACK_DEC_NUM_TICKS_MIN){
offset = inv;
ret = pass;
}
else if ( ( inv <= HIJACK_DEC_NUM_TICKS_MAX ) && ( inv >= HIJACK_DEC_NUM_TICKS_MIN ) ) {
offset = 0;
inv = 0;
ret = suit;
}
else{
offset = 0;
inv = 0;
ret = error;
}
return ret;
}
/*
* Find phase remain or phase reversal.
*/
static void dec_parser(uint8_t bit_msk, state_t state)
{
if ( ( suit == IsTime2Detect(inv) ) ){ //it's time to determine
if( falling == cur_edge ){
dec.data &= ~(1 << bit_msk);
#if DEC_DEBUG == 1
uartPutChar( '+' ) ;
uartPutChar( '_' ) ;
#endif//DEC_DEBUG == 1
}
else{
dec.data |= (1 << bit_msk);
#if DEC_DEBUG == 1
uartPutChar( '_' ) ;
uartPutChar( '+' ) ;
#endif//DEC_DEBUG == 1
dec.odd++;
}
dec.state = state; //state switch
}
else if ( error == IsTime2Detect(inv) ){ //wait for edge detection time
dec.state = Waiting; //state switch
}
}
/**************************************************************************//**
* @brief decode state machine
* Invoke in TIMER_ISR for decoding.
*****************************************************************************/
void decode_machine(void)
{
inv = offset + cur_stamp; //update offset
#if 0
if( dec.state > Waiting ){
USART_printHexBy16u(inv);
if(cur_edge == rising){
uartPutChar( '\\' ) ;
}
else{
uartPutChar( '/' ) ;
}
}
#endif
switch (dec.state){
case Waiting:
/* go to start bit if rising edge exist. */
if (rising == cur_edge) {
dec.state = Sta0;
offset = 0;
inv = 0;
}
break;
//
case Sta0:
if( ( suit == IsTime2Detect(inv) ) && ( falling == cur_edge ) ){
dec.data = 0; //clear data field for store new potential data
dec.odd = 0; //clear odd field parity counter
dec.state = Bit0;
#if DEC_DEBUG == 1
uartPutChar( 'S' ) ;
uartPutChar( '+' ) ;
uartPutChar( '_' ) ;
#endif
}
else{
dec.state = Waiting;
}
break;
//
case Bit0:
#if DEC_DEBUG == 1
uartPutChar( '0' ) ;
#endif
dec_parser(BIT0, Bit1);
break;
//
case Bit1:
#if DEC_DEBUG == 1
uartPutChar( '1' ) ;
#endif
dec_parser(BIT1, Bit2);
break;
//
case Bit2:
#if DEC_DEBUG == 1
uartPutChar( '2' ) ;
#endif
dec_parser(BIT2, Bit3);
break;
//
case Bit3:
#if DEC_DEBUG == 1
uartPutChar( '3' ) ;
#endif
dec_parser(BIT3, Bit4);
break;
//
case Bit4:
#if DEC_DEBUG == 1
uartPutChar( '4' ) ;
#endif
dec_parser(BIT4, Bit5);
break;
//
case Bit5:
#if DEC_DEBUG == 1
uartPutChar( '5' ) ;
#endif
dec_parser(BIT5, Bit6);
break;
//
case Bit6:
#if DEC_DEBUG == 1
uartPutChar( '6' ) ;
#endif
dec_parser(BIT6, Bit7);
break;
//
case Bit7:
#if DEC_DEBUG == 1
uartPutChar( '7' ) ;
#endif
dec_parser(BIT7, Parity);
break;
//
case Parity:
if ( ( suit == IsTime2Detect(inv) ) ){ //it's time to determine
if( rising == cur_edge ){
dec.odd++;
#if DEC_DEBUG == 1
uartPutChar( '_' ) ;
uartPutChar( '+' ) ;
#endif
}
else{
#if DEC_DEBUG == 1
uartPutChar( '+' ) ;
uartPutChar( '_' ) ;
#endif
}
#if DEC_DEBUG == 1
uartPutChar( dec.odd + 0x30) ;
#endif
if( 1 == (dec.odd%2)){ //parity pass
dec.state = Sto0;
}
else{ //parity failed
dec.state = Waiting;
}
}
else if ( error == IsTime2Detect(inv) ){ //wait for edge detection time
dec.state = Waiting;
}
break;
//
case Sto0:
if ( ( suit == IsTime2Detect(inv) ) ){ //it's time to determine
if( rising == cur_edge ){ //stop bit is rising edge
USART_txByte(dec.data);
#if DEC_DEBUG == 1
uartPutChar( '_' ) ;
uartPutChar( '+' ) ;
#endif
HIJACKPutData(&dec.data, &decBuf, sizeof(uint8_t));
}
else{
#if DEC_DEBUG == 1
uartPutChar( '+' ) ;
uartPutChar( '_' ) ;
#endif
}
dec.state = Waiting;
#if DEC_DEBUG == 1
uartPutChar( '\r' ) ;
uartPutChar( '\n' ) ;
#endif
}
else if ( error == IsTime2Detect(inv) ){ //wait for edge detection time
dec.state = Waiting;
}
break;
//
default:
break;
//
}
}
int main(void)
{
CHIP_Init();
CMU_ClockEnable(cmuClock_GPIO, true);
CMU_ClockEnable(cmuClock_TIMER1, true);
CMU_ClockEnable(cmuClock_TIMER3, true);
// Set up TIMER1 for timekeeping
TIMER_Init_TypeDef timerInit = TIMER_INIT_DEFAULT;
timerInit.prescale = timerPrescale1024;
TIMER_IntEnable(TIMER1, TIMER_IF_OF);
// Enable TIMER1 interrupt vector in NVIC
NVIC_EnableIRQ(TIMER1_IRQn);
// Set TIMER Top value
TIMER_TopSet(TIMER1, ONE_SECOND_TIMER_COUNT);
TIMER_Init(TIMER1, &timerInit);
// Wait for the timer to get going
while (TIMER1->CNT == 0) ;
// Enable LED output
GPIO_PinModeSet(LED_PORT, LED_PIN, gpioModePushPull, 0);
// Create the object initializer for LED PWM
TIMER_InitCC_TypeDef timerCCInit = TIMER_INITCC_DEFAULT;
timerCCInit.mode = timerCCModePWM;
timerCCInit.cmoa = timerOutputActionToggle;
// Configure TIMER3 CC channel 2
TIMER_InitCC(TIMER3, TIMER_CHANNEL, &timerCCInit);
// Route CC2 to location 1 (PE3) and enable pin for cc2
TIMER3->ROUTE |= (TIMER_ROUTE_CC2PEN | TIMER_ROUTE_LOCATION_LOC1);
// Set Top Value
TIMER_TopSet(TIMER3, TIMER_TOP);
// Set the PWM duty cycle here!
TIMER_CompareBufSet(TIMER3, TIMER_CHANNEL, 0);
// Create a timerInit object, based on the API default
TIMER_Init_TypeDef timerInit2 = TIMER_INIT_DEFAULT;
timerInit2.prescale = timerPrescale256;
TIMER_Init(TIMER3, &timerInit2);
enum mode_values { RAMPING_UP, HIGH, RAMPING_DOWN, LOW};
// Check for properly sized constants
uint16_t delta = MAX_BRIGHTNESS - MIN_BRIGHTNESS;
if ( delta == 0 || RAMP_UP_TIME_MS % delta || RAMP_DOWN_TIME_MS % delta)
{
DEBUG_BREAK
}
// Set the initial condition
uint16_t mode = RAMPING_UP;
uint32_t time_step = RAMP_UP_TIME_MS / delta;
uint16_t brightness = MIN_BRIGHTNESS;
TIMER_CompareBufSet(TIMER3, TIMER_CHANNEL, brightness);
uint64_t mode_timeout = set_ms_timeout(RAMP_UP_TIME_MS);
while (1)
{
switch (mode)
{
case RAMPING_UP:
delay_ms(time_step);
brightness++;
TIMER_CompareBufSet(TIMER3, TIMER_CHANNEL, brightness);
if (expired_ms(mode_timeout))
{
mode = HIGH;
mode_timeout = set_ms_timeout(HIGH_DURATION_MS);
}
break;
case HIGH:
if (expired_ms(mode_timeout))
{
mode = RAMPING_DOWN;
time_step = RAMP_DOWN_TIME_MS / delta;
mode_timeout = set_ms_timeout(RAMP_DOWN_TIME_MS);
}
break;
case RAMPING_DOWN:
delay_ms(time_step);
brightness--;
TIMER_CompareBufSet(TIMER3, TIMER_CHANNEL, brightness);
if (expired_ms(mode_timeout))
{
mode = LOW;
mode_timeout = set_ms_timeout(LOW_DURATION_MS);
}
break;
case LOW:
if (expired_ms(mode_timeout))
{
mode = RAMPING_UP;
time_step = RAMP_UP_TIME_MS / delta;
mode_timeout = set_ms_timeout(RAMP_UP_TIME_MS);
}
break;
}
}
}
void i2c_poweron(i2c_t dev)
{
CMU_ClockEnable(i2c_config[dev].cmu, true);
}
void i2c_poweroff(i2c_t dev)
{
CMU_ClockEnable(i2c_config[dev].cmu, false);
}
void initPWM() // Brightness should be less than TIMER_TOP (1024)
{
/* Enable clocks */
CMU->HFPERCLKEN0 |= CMU_HFPERCLKEN0_GPIO;
CMU_ClockEnable(cmuClock_TIMER1, true);
/* Set pins */
GPIO_PinModeSet(gpioPortE,10,gpioModePushPull,1);
GPIO_PinModeSet(gpioPortE,11,gpioModePushPull,1);
/* Select CC channel parameters */
TIMER_InitCC_TypeDef timerCCInit =
{
.eventCtrl = timerEventEveryEdge,
.edge = timerEdgeBoth,
.prsSel = timerPRSSELCh0,
.cufoa = timerOutputActionNone,
.cofoa = timerOutputActionNone,
.cmoa = timerOutputActionToggle,
.mode = timerCCModePWM,
.filter = false,
.prsInput = false,
.coist = false,
.outInvert = false,
};
/* Configure CC channels */
TIMER_InitCC(TIMER1, 0, &timerCCInit);
TIMER_InitCC(TIMER1, 1, &timerCCInit);
/* Set which pins will be set by the timer */
TIMER1->ROUTE = TIMER_ROUTE_CC0PEN | TIMER_ROUTE_CC1PEN | TIMER_ROUTE_LOCATION_LOC1;
/* Set Top Value */
TIMER_TopSet(TIMER1, TIMER_TOP);
/* Set compare value starting at top - it will be incremented in the interrupt handler */
TIMER_CompareBufSet(TIMER1, 0, TIMER_TOP + 1);
TIMER_CompareBufSet(TIMER1, 1, TIMER_TOP + 1);
/* Select timer parameters */
TIMER_Init_TypeDef timerInit =
{
.enable = true,
.debugRun = false,
.prescale = timerPrescale16,
.clkSel = timerClkSelHFPerClk,
.fallAction = timerInputActionNone,
.riseAction = timerInputActionNone,
.mode = timerModeUp,
.dmaClrAct = false,
.quadModeX4 = false,
.oneShot = false,
.sync = false,
};
/* Enable overflow interrupt */
TIMER_IntEnable(TIMER1, TIMER_IF_OF);
TIMER_IntClear(TIMER1, TIMER_IF_OF);
/* Enable TIMER1 interrupt vector in NVIC */
NVIC_EnableIRQ(TIMER1_IRQn);
/* Configure timer */
TIMER_Init(TIMER1, &timerInit);
}
void InitAudioPWM(void)
{
CMU_ClockEnable(cmuClock_TIMER1, true);
/* Select CC channel parameters */
TIMER_InitCC_TypeDef timerCCInit =
{
.eventCtrl = timerEventEveryEdge,
.edge = timerEdgeBoth,
.prsSel = timerPRSSELCh0,
.cufoa = timerOutputActionNone,
.cofoa = timerOutputActionNone,
.cmoa = timerOutputActionToggle,
.mode = timerCCModePWM,
.filter = false,
.prsInput = false,
.coist = false,
.outInvert = false,
};
/* Configure CC channel 0 */
TIMER_InitCC(TIMER1, 0, &timerCCInit);
TIMER_InitCC(TIMER1, 1, &timerCCInit);
//TIMER_InitCC(TIMER0, 2, &timerCCInit);
// TIMER3->ROUTE |= (TIMER_ROUTE_CC0PEN | TIMER_ROUTE_CC1PEN | TIMER_ROUTE_CC2PEN | TIMER_ROUTE_LOCATION_LOC0);
TIMER1->ROUTE = TIMER_ROUTE_CC0PEN | TIMER_ROUTE_CC1PEN | TIMER_ROUTE_LOCATION_LOC1;
/* Set Top Value */
TIMER_TopSet(TIMER1, 255);//384
/* Set compare value starting at top - it will be incremented in the interrupt handler */
TIMER_CompareBufSet(TIMER1, 0, 256);//385
TIMER_CompareBufSet(TIMER1, 1, 256);//385
//TIMER_CompareBufSet(TIMER3, 2, RGB_PWM_TIMER_TOP + 1);
/* Select timer parameters */
TIMER_Init_TypeDef timerInit =
{
.enable = true,
.debugRun = false,
.prescale = timerPrescale8,
.clkSel = timerClkSelHFPerClk,
.fallAction = timerInputActionNone,
.riseAction = timerInputActionNone,
.mode = timerModeUp,
.dmaClrAct = false,
.quadModeX4 = false,
.oneShot = false,
.sync = false,
};
///* Enable overflow interrupt */
TIMER_IntEnable(TIMER1, TIMER_IF_OF);
TIMER_IntClear(TIMER1, TIMER_IF_OF);
/* Enable TIMER0 interrupt vector in NVIC */
NVIC_EnableIRQ(TIMER1_IRQn);
/* Configure timer */
TIMER_Init(TIMER1, &timerInit);
}
void TIMER1_IRQHandler(void)
{
int audio_Sample = 0;
if(toPlay > 0)
{
audio_Sample = buff[(iterator = next(iterator))];
toPlay--;
}
else
{
audio_Sample = 0;
}
TIMER_CompareBufSet(TIMER1, 0, (audio_Sample));
TIMER_IntClear(TIMER1, TIMER_IF_OF);
}
/**************************************************************************//**
* @brief main - the entrypoint after reset.
*****************************************************************************/
int main(void)
{
/* Initialize LEUSB state variables */
leusbTogglePushed = false;
leusbEnabled = false;
refreshDisplay = false;
HIDKBD_Init_t hidInitStruct;
/* Chip errata */
CHIP_Init();
/* Go slow to reduce current consumption. */
CMU_HFRCOBandSet( cmuHFRCOBand_7MHz );
CMU_ClockEnable( cmuClock_GPIO, true );
GPIO_PinModeSet( BUTTON0_PORT, BUTTON0_PIN, gpioModeInputPull, 1 );
GPIO_PinModeSet( BUTTON1_PORT, BUTTON1_PIN, gpioModeInputPull, 1 );
/* Initialize the display module. */
DISPLAY_Init();
/* Retrieve the properties of the display. */
if ( DISPLAY_DeviceGet( 0, &displayDevice ) != DISPLAY_EMSTATUS_OK )
{
/* Unable to get display handle. */
while( 1 );
}
memset( (void*)blank_image, 0xFF, 128*16 );
displayDevice.pPixelMatrixDraw( &displayDevice, (void*)blank_image,
/* start column, width */
0, displayDevice.geometry.width,
/* start row, height */
0, displayDevice.geometry.height);
scrollLcd( &displayDevice, scrollLeft, blank_image, gecko_image );
/* Initialize HID keyboard driver. */
hidInitStruct.hidDescriptor = (void*)USBDESC_HidDescriptor;
hidInitStruct.setReportFunc = NULL;
HIDKBD_Init( &hidInitStruct );
/* Initialize and start USB device stack. */
USBD_Init( &usbInitStruct );
/* Turn off the Low Energy Mode (LEM) features that were enabled in USBD_Init() */
USB->CTRL &= ~USB_CTRL_LEMIDLEEN; // LEUSB off to begin demo
/*
* When using a debugger it is practical to uncomment the following three
* lines to force host to re-enumerate the device.
*/
/* USBD_Disconnect(); */
/* USBTIMER_DelayMs(1000); */
/* USBD_Connect(); */
for (;;)
{
if (refreshDisplay)
{
refreshDisplay = false; /* Clear the "refresh display" flag */
if (leusbEnabled)
{
/* Update the LCD image to reflect USB Low Energy Mode enabled */
displayDevice.pPixelMatrixDraw( &displayDevice, (void*)leusb_image,
/* start column, width */
0, displayDevice.geometry.width,
/* start row, height */
0, displayDevice.geometry.height);
}
else
{
/* Update the LCD image to reflect normal USB HID keyboard demo status */
displayDevice.pPixelMatrixDraw( &displayDevice, (void*)usb_image,
/* start column, width */
0, displayDevice.geometry.width,
/* start row, height */
0, displayDevice.geometry.height);
}
}
/* Conserve energy ! */
EMU_EnterEM1();
}
}
/**************************************************************************//**
* @brief Turn on micro SD card power.
* DK doesn't support socket power control, only enable the SPI clock.
*****************************************************************************/
void MICROSD_PowerOn(void)
{
/* Enable SPI clock */
CMU_ClockEnable(MICROSD_CMUCLOCK, true);
}
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 short basic initialization to enable generic controller functions
* @note user initialization can vary here
*/
void initController(void)
{
/* Enable required clock domains */
CMU_ClockEnable(cmuClock_HFPER, true);
/* TODO : user initialization here */
}
//================================================================================
// CMU_enter_DefaultMode_from_RESET
//================================================================================
extern void CMU_enter_DefaultMode_from_RESET(void) {
// $[LFXO enable]
CMU_OscillatorEnable(cmuOsc_LFXO, true, true);
// [LFXO enable]$
// $[HFXO enable]
CMU_OscillatorEnable(cmuOsc_HFXO, true, true);
// [HFXO enable]$
// $[LFACLK Setup]
/* Select LFXO as clock source for LFACLK */
CMU_ClockSelectSet(cmuClock_LFA, cmuSelect_LFXO); //LFA采用外部低频晶振
// [LFACLK Setup]$
// $[High Frequency Clock select]
/* Using HFXO as high frequency clock, HFCLK */
CMU_ClockSelectSet(cmuClock_HF, cmuSelect_HFXO);//HF采用外部高频晶振
/* Enable peripheral clock */
CMU_ClockEnable(cmuClock_HFPER, true);
// [High Frequency Clock select]$
// $[LF clock tree setup]
/* Enable LF clocks */
CMU_ClockEnable(cmuClock_CORELE, true);
CMU_ClockSelectSet(cmuClock_LFA, cmuSelect_LFXO);
CMU_ClockSelectSet(cmuClock_LFB, cmuSelect_LFXO);
// [LF clock tree setup]$
// $[Peripheral Clock enables]
/* Enable clock for ADC0 */
CMU_ClockEnable(cmuClock_ADC0, true);
/* Enable clock for DMA */
CMU_ClockEnable(cmuClock_DMA, true);
/* Enable clock for I2C0 */
CMU_ClockEnable(cmuClock_I2C0, true);
/* Enable clock for LETIMER0 */
CMU_ClockEnable(cmuClock_LETIMER0, true);
/* Enable clock for LEUART0 */
CMU_ClockEnable(cmuClock_LEUART0, true);
/* Enable clock for RTC */
CMU_ClockEnable(cmuClock_RTC, true);
/* Enable clock for TIMER0 */
CMU_ClockEnable(cmuClock_TIMER0, true);
/* Enable clock for TIMER1 */
CMU_ClockEnable(cmuClock_TIMER1, true);
/* Enable clock for TIMER2 */
CMU_ClockEnable(cmuClock_TIMER2, true);
/* Enable clock for UART0 */
CMU_ClockEnable(cmuClock_UART0, true);
/* Enable clock for USART0 */
CMU_ClockEnable(cmuClock_USART0, true);
/* Enable clock for USART2 */
CMU_ClockEnable(cmuClock_USART2, true);
/* Enable clock for GPIO by default */
CMU_ClockEnable(cmuClock_GPIO, true);
// [Peripheral Clock enables]$
}
/**************************************************************************//**
* @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)
{
/* Chip errata */
CHIP_Init();
/* Use 32MHZ HFXO as core clock frequency*/
CMU_ClockSelectSet(cmuClock_HF, cmuSelect_HFXO);
/* Enable clock for HF peripherals */
CMU_ClockEnable(cmuClock_HFPER, true);
/* Enabling clock to USART0*/
CMU_ClockEnable(cmuClock_USART0, true);
/* Enable clock for GPIO module (required for pin configuration) */
CMU_ClockEnable(cmuClock_GPIO, true);
/* 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) ;
/* Enable LCD without voltage boost */
SegmentLCD_Init(false);
/* Enable all segments */
SegmentLCD_AllOff();
SegmentLCD_Write("GPS!");
Delay(2000);
SegmentLCD_AllOff();
/* Initialization of GPS */
GPS_Initialization();
SegmentLCD_Write("SD!");
Delay(2000);
SegmentLCD_AllOff();
/* Initialization of SDCARD */
SDCARD_Initialization();
SegmentLCD_AllOff();
SegmentLCD_Write("DONE!");
Delay(2000);
SegmentLCD_AllOff();
/* Infinite loop with test pattern. */
while (1)
{
/* Wait for data in sleep mode */
GPS_WaitForData(&gpsData);
/* Save it on SDCARD */
SDCARD_Save(&gpsData);
/* Indicate on LCD */
LCD_Show();
}
}
/**************************************************************************//**
* @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 Main function
*****************************************************************************/
int main(void)
{
uint8_t prod_rev;
uint32_t temp;
uint32_t temp_offset;
float temperature;
/* 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();
/* Initialize the TFT stdio retarget module. */
RETARGET_TftInit();
printf("\nEFM32 onchip temperature sensor example\n\n");
CMU_ClockEnable(cmuClock_HFPER, true);
CMU_ClockEnable(cmuClock_ADC0, true);
CMU_ClockEnable(cmuClock_GPIO, true);
/* Enable board control interrupts */
BSP_InterruptDisable(0xffff);
BSP_InterruptFlagsClear(0xffff);
BSP_InterruptEnable(BC_INTEN_JOYSTICK);
temperatureIRQInit();
/* This is a work around for Chip Rev.D Errata, Revision 0.6. */
/* Check for product revision 16 and 17 and set the offset */
/* for ADC0_TEMP_0_READ_1V25. */
prod_rev = (DEVINFO->PART & _DEVINFO_PART_PROD_REV_MASK) >> _DEVINFO_PART_PROD_REV_SHIFT;
if( (prod_rev == 16) || (prod_rev == 17) )
{
temp_offset = 112;
}
else
{
temp_offset = 0;
}
/* Setup ADC for sampling internal temperature sensor. */
setupSensor();
/* Main loop - just read temperature and update LCD */
while (1)
{
/* Start one ADC sample */
ADC_Start(ADC0, adcStartSingle);
/* Wait in EM1 for ADC to complete */
EMU_EnterEM1();
/* Read sensor value */
/* According to rev. D errata ADC0_TEMP_0_READ_1V25 should be decreased */
/* by the offset but it is the same if ADC reading is increased - */
/* reference manual 28.3.4.2. */
temp = ADC_DataSingleGet(ADC0) + temp_offset;
/* Convert ADC sample to Fahrenheit / Celsius and print string to display */
if (showFahrenheit)
{
temperature = convertToFahrenheit(temp);
}
else
{
temperature = convertToCelsius(temp);
}
printf("%d.%d %c\n",
(int) temperature, (int)(10*(temperature-(int)temperature)),
showFahrenheit? 'F' : 'C');
/* Sleep for 2 seconds in EM 2 */
RTCDRV_Trigger(2000, NULL);
EMU_EnterEM2(true);
}
}
/***************************************************************************//**
* @brief
* Initalize I2C peripheral
*
* @details
* This driver supports master mode only, single bus-master. In addition
* to configuring the I2C peripheral module, it also configures DK/STK
* specific setup in order to use the I2C bus.
*
* @param[in] init
* Pointer to I2C initialization structure
******************************************************************************/
void I2CSPM_Init(I2CSPM_Init_TypeDef *init)
{
int i;
CMU_Clock_TypeDef i2cClock;
I2C_Init_TypeDef i2cInit;
EFM_ASSERT(init != NULL);
CMU_ClockEnable(cmuClock_HFPER, true);
/* Select I2C peripheral clock */
if (false)
{
#if defined( I2C0 )
}
else if (init->port == I2C0)
{
i2cClock = cmuClock_I2C0;
#endif
#if defined( I2C1 )
}
else if (init->port == I2C1)
{
i2cClock = cmuClock_I2C1;
#endif
}
else
{
/* I2C clock is not defined */
EFM_ASSERT(false);
return;
}
CMU_ClockEnable(i2cClock, true);
/* Output value must be set to 1 to not drive lines low. Set
SCL first, to ensure it is high before changing SDA. */
GPIO_PinModeSet(init->sclPort, init->sclPin, gpioModeWiredAndPullUp, 1);
GPIO_PinModeSet(init->sdaPort, init->sdaPin, gpioModeWiredAndPullUp, 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 to
set slave in a defined state. */
for (i = 0; i < 9; i++)
{
GPIO_PinOutSet(init->sclPort, init->sclPin);
GPIO_PinOutClear(init->sclPort, init->sclPin);
}
/* Enable pins and set location */
#if defined (_I2C_ROUTEPEN_MASK)
init->port->ROUTEPEN = I2C_ROUTEPEN_SDAPEN | I2C_ROUTEPEN_SCLPEN;
init->port->ROUTELOC0 = (init->portLocationSda << _I2C_ROUTELOC0_SDALOC_SHIFT)
| (init->portLocationScl << _I2C_ROUTELOC0_SCLLOC_SHIFT);
#else
init->port->ROUTE = I2C_ROUTE_SDAPEN |
I2C_ROUTE_SCLPEN |
(init->portLocation << _I2C_ROUTE_LOCATION_SHIFT);
#endif
/* Set emlib init parameters */
i2cInit.enable = true;
i2cInit.master = true; /* master mode only */
i2cInit.freq = init->i2cMaxFreq;
i2cInit.refFreq = init->i2cRefFreq;
i2cInit.clhr = init->i2cClhr;
I2C_Init(init->port, &i2cInit);
}
/**************************************************************************//**
* @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);
}
}
}