void SensorCalibration()
{
char InitState = GetSensorInitState();
char calibration_sensor = GetChar();
#ifdef OPTION_RC
TIMER_Enable(false);
RC_Enable(false);
#endif
if((calibration_sensor=='a')&&(InitState&SENSOR_ACC)) { // Do 'a'cc calibration
AccCalibration();
}
else if((calibration_sensor=='g')&&(InitState&SENSOR_GYRO)) {// Do 'g'yro calibration
GyroCalibration();
}
else if((calibration_sensor=='m')&&(InitState&SENSOR_MAG)) { // Do 'g'yro calibration
MagCalibration();
if(CalQFactor<MAG_CAL_SUCESS_TH)
UpdateFlashCal(SENSOR_MAG, false);
SensorInitMAG();
}
else // Fail doing calibration
CalibrationFail();
#ifdef OPTION_RC
TIMER_Enable(true);
RC_Enable(true);
#endif
}
int timer_init(tim_t dev, unsigned long freq, timer_cb_t callback, void *arg)
{
TIMER_TypeDef *pre, *tim;
/* test if given timer device is valid */
if (dev >= TIMER_NUMOF) {
return -1;
}
/* save callback */
isr_ctx[dev].cb = callback;
/* get timers */
pre = timer_config[dev].prescaler.dev;
tim = timer_config[dev].timer.dev;
/* enable clocks */
CMU_ClockEnable(cmuClock_HFPER, true);
CMU_ClockEnable(timer_config[dev].prescaler.cmu, true);
CMU_ClockEnable(timer_config[dev].timer.cmu, true);
/* reset and initialize peripherals */
EFM32_CREATE_INIT(init_pre, TIMER_Init_TypeDef, TIMER_INIT_DEFAULT,
.conf.enable = false,
.conf.prescale = timerPrescale1
);
EFM32_CREATE_INIT(init_tim, TIMER_Init_TypeDef, TIMER_INIT_DEFAULT,
.conf.enable = false,
.conf.clkSel = timerClkSelCascade
);
TIMER_Reset(tim);
TIMER_Reset(pre);
TIMER_Init(tim, &init_tim.conf);
TIMER_Init(pre, &init_pre.conf);
/* configure the prescaler top value */
uint32_t freq_timer = CMU_ClockFreqGet(timer_config[dev].prescaler.cmu);
uint32_t top = (
freq_timer / TIMER_Prescaler2Div(init_pre.conf.prescale) / freq) - 1;
TIMER_TopSet(pre, top);
TIMER_TopSet(tim, 0xffff);
/* enable interrupts for the channels */
TIMER_IntClear(tim, TIMER_IFC_CC0 | TIMER_IFC_CC1 | TIMER_IFC_CC2);
TIMER_IntEnable(tim, TIMER_IEN_CC0 | TIMER_IEN_CC1 | TIMER_IEN_CC2);
NVIC_ClearPendingIRQ(timer_config[dev].irq);
NVIC_EnableIRQ(timer_config[dev].irq);
/* start the timers */
TIMER_Enable(tim, true);
TIMER_Enable(pre, true);
return 0;
}
/***************************************************************************//**
* @brief
* Configure Timer device
*
* @details
*
* @note
*
* @param[in] dev
* Pointer to device descriptor
*
* @param[in] cmd
* Timer control command
*
* @param[in] args
* Arguments
*
* @return
* Error code
******************************************************************************/
static rt_err_t rt_hs_timer_control (
rt_device_t dev,
rt_uint8_t cmd,
void *args)
{
RT_ASSERT(dev != RT_NULL);
struct efm32_timer_device_t *timer;
timer = (struct efm32_timer_device_t *)(dev->user_data);
switch (cmd)
{
case RT_DEVICE_CTRL_SUSPEND:
/* Suspend device */
dev->flag |= RT_DEVICE_FLAG_SUSPENDED;
TIMER_Enable(timer->timer_device, false);
break;
case RT_DEVICE_CTRL_RESUME:
/* Resume device */
dev->flag &= ~RT_DEVICE_FLAG_SUSPENDED;
TIMER_Enable(timer->timer_device, true);
break;
case RT_DEVICE_CTRL_TIMER_PERIOD:
{
/* change device setting */
struct efm32_timer_control_t *control;
rt_uint32_t running;
control = (struct efm32_timer_control_t *)args;
running = timer->timer_device->STATUS & 0x00000001;
TIMER_Enable(timer->timer_device, false);
timer->timer_device->CNT = _TIMER_CNT_RESETVALUE;
TIMER_TopSet(timer->timer_device, TIMER_TopCalculate(control->period));
timer->hook.cbFunc = control->hook.cbFunc;
timer->hook.userPtr = control->hook.userPtr;
if (running)
{
TIMER_Enable(timer->timer_device, true);
}
}
break;
}
return RT_EOK;
}
/**
* @brief Configure the TIMER peripheral.
* @param None
* @retval None
*/
void TIMER_Configuration(void)
{
/* ---------------------------------------------------------------------------
TIMER2 Configuration: Output Compare Toggle Mode:
TIMER2CLK = SystemCoreClock / 36000=2K,
CH2 update rate = TIMER2 counter clock / CHCC2 = 2000/4000 = 0.5 Hz
----------------------------------------------------------------------------*/
TIMER_BaseInitPara TIMER_TimeBaseStructure;
TIMER_OCInitPara TIMER_OCInitStructure;
/* TIMERS clock enable */
RCC_APB2PeriphClock_Enable(RCC_APB2PERIPH_TIMER1|RCC_APB2PERIPH_TIMER15|RCC_APB2PERIPH_TIMER16|RCC_APB2PERIPH_TIMER17,ENABLE);
RCC_APB1PeriphClock_Enable(RCC_APB1PERIPH_TIMER2|RCC_APB1PERIPH_TIMER3|RCC_APB1PERIPH_TIMER6|RCC_APB1PERIPH_TIMER14,ENABLE);
/* TIMER2 configuration */
TIMER_DeInit(TIMER2);
TIMER_TimeBaseStructure.TIMER_Prescaler = 35999;
TIMER_TimeBaseStructure.TIMER_CounterMode = TIMER_COUNTER_UP;
TIMER_TimeBaseStructure.TIMER_Period = 3999;
TIMER_TimeBaseStructure.TIMER_ClockDivision = TIMER_CDIV_DIV1;
TIMER_BaseInit(TIMER2,&TIMER_TimeBaseStructure);
/* CH2 Configuration in OC_TOGGLE mode */
TIMER_OCInitStructure.TIMER_OCMode = TIMER_OC_MODE_TOGGLE;
TIMER_OCInitStructure.TIMER_OCPolarity = TIMER_OC_POLARITY_HIGH;
TIMER_OCInitStructure.TIMER_OutputState = TIMER_OUTPUT_STATE_ENABLE;
TIMER_OCInitStructure.TIMER_Pulse = 3999;
TIMER_OC2_Init(TIMER2, &TIMER_OCInitStructure);
TIMER_OC2_Preload(TIMER2,TIMER_OC_PRELOAD_DISABLE);
/* Auto-reload preload enable */
TIMER_CARLPreloadConfig(TIMER2,ENABLE);
/* TIMER enable counter*/
TIMER_Enable( TIMER2, ENABLE );
}
/**
* @brief Timer2 configuration.
* @param None
* @retval None
*/
void TIMER_Configuration(void)
{
TIMER_BaseInitPara TIMER_TimeBaseStruct;
NVIC_InitPara NVIC_InitStruct;
TIMER_BaseStructInit(&TIMER_TimeBaseStruct);
TIMER_TimeBaseStruct.TIMER_Prescaler = 0;
TIMER_TimeBaseStruct.TIMER_CounterMode = TIMER_COUNTER_UP;
TIMER_TimeBaseStruct.TIMER_Period = 65535;
TIMER_TimeBaseStruct.TIMER_ClockDivision = TIMER_CDIV_DIV1 ;
TIMER_BaseInit(TIMER2, &TIMER_TimeBaseStruct);
TIMER_ClearBitState(TIMER2,TIMER_FLAG_UPDATE );
NVIC_InitStruct.NVIC_IRQ = TIMER2_IRQn;
NVIC_InitStruct.NVIC_IRQPreemptPriority = 1;
NVIC_InitStruct.NVIC_IRQSubPriority = 1;
NVIC_InitStruct.NVIC_IRQEnable = ENABLE;
NVIC_Init(&NVIC_InitStruct);
TIMER2->STR = 0;
TIMER_INTConfig(TIMER2, TIMER_INT_CH4, ENABLE);
TIMER_Enable(TIMER2, ENABLE);
}
void bsp_tick_timer_stop(void)
{
// Disable the interrupt and timer
TIMER_Enable(TIMER0, false);
TIMER_IntDisable(TIMER0, TIMER_IF_OF);
NVIC_DisableIRQ(TIMER0_IRQn);
}
void StoredFilter_Start(void)
{
Leds_SetLeds(0x4);
CMU_ClockEnable(cmuClock_USART2, true);
CMU_ClockEnable(cmuClock_GPIO, true);
SPI_setup(2, 0, true);
setupMEM();
setupFPGA();
setupSD();
done = false;
setupTimer();
FPGA_Enable();
while(1) {
if (done)
break;
}
FPGA_Disable();
TIMER_Enable( TIMER0, false );
TIMER_Reset( TIMER0 );
FPGADriver_Destroy();
SDDriver_Finalize();
MEM_Destroy();
}
void bsp_tick_timer_start(void)
{
// Enable the interrupt and start the timer
TIMER_IntEnable(TIMER0, TIMER_IF_OF);
NVIC_SetPriority(TIMER0_IRQn, 1);
NVIC_EnableIRQ(TIMER0_IRQn);
TIMER_Enable(TIMER0, true);
}
/*******************************************************************************
* Function Name: TIMER_Wakeup
********************************************************************************
*
* Summary:
* Restores and enables the user configuration
*
* Parameters:
* void
*
* Return:
* void
*
* Global variables:
* TIMER_backup.enableState: Is used to restore the enable state of
* block on wakeup from sleep mode.
*
*******************************************************************************/
void TIMER_Wakeup(void)
{
TIMER_RestoreConfig();
#if(!TIMER_UDB_CONTROL_REG_REMOVED)
if(TIMER_backup.TimerEnableState == 1u)
{ /* Enable Timer's operation */
TIMER_Enable();
} /* Do nothing if Timer was disabled before */
#endif /* Remove this code section if Control register is removed */
}
/***************************************************************************//**
* @brief
* Stop the TIMER1.
******************************************************************************/
void TD_TIMER_Stop(void)
{
// Disable timer
TIMER_Enable(TIMER1, false);
TD_TIMER_Enabled = false;
// Unroute CC0 to location 0 (PC13) and disable pin
TIMER1->ROUTE &= ~(TIMER_ROUTE_CC0PEN | TIMER_ROUTE_LOCATION_LOC0);
//TIMER_IntDisable(TIMER1, TIMER_IF_OF);
}
void motor_stop(void *ptr)
{
TIMER_CompareBufSet(TIMER2, 0, 0);
GPIO_PinOutClear(gpioPortA, 8);
light_state &= ~MOTOR_ON;
if(light_state == 0)
{
TIMER_Enable(TIMER2,false);
CMU_ClockEnable(cmuClock_TIMER2, false);
}
}
/**************************************************************************//**
* @brief Call-back called when transfer is complete
*****************************************************************************/
void transferComplete(unsigned int channel, bool primary, void *user)
{
(void) channel;
(void) primary;
(void) user;
/* Stopping ADC by stopping TIMER0 */
TIMER_Enable(TIMER0, false);
/* Clearing flag to indicate that transfer is complete */
transferActive = false;
}
void us_ticker_free(void)
{
if (us_ticker_inited) {
us_ticker_disable_interrupt();
NVIC_DisableIRQ(US_TICKER_TIMER_IRQ);
TIMER_Enable(US_TICKER_TIMER, false);
CMU_ClockEnable(US_TICKER_TIMER_CLOCK, false);
us_ticker_inited = false;
}
}
/**
* @brief Configure the TIMER peripheral.
* @param None
* @retval None
*/
void TIMER_Configuration(void)
{
/* TIMER1 DMA Transfer example -------------------------------------------------
TIMER1CLK = 72MHz, Prescaler = 72
TIMER1 counter clock = SystemCoreClock/72 = 1MHz.
The objective is to configure TIMER1 channel 1 to generate PWM
signal with a frequency equal to 1KHz and a variable duty cycle(25%,50%,75%) that is
changed by the DMA after a specific number of Update DMA request.
The number of this repetitive requests is defined by the TIMER1 Repetition counter,
each 2 Update Requests, the TIMER1 Channel 1 Duty Cycle changes to the next new
value defined by the buffer .
-----------------------------------------------------------------------------*/
TIMER_BaseInitPara TIMER_TimeBaseStructure;
TIMER_OCInitPara TIMER_OCInitStructure;
/* TIMERS clock enable */
RCC_APB2PeriphClock_Enable(RCC_APB2PERIPH_TIMER1|RCC_APB2PERIPH_TIMER15|RCC_APB2PERIPH_TIMER16|RCC_APB2PERIPH_TIMER17,ENABLE);
RCC_APB1PeriphClock_Enable(RCC_APB1PERIPH_TIMER2|RCC_APB1PERIPH_TIMER3|RCC_APB1PERIPH_TIMER6|RCC_APB1PERIPH_TIMER14,ENABLE);
/* TIMER1 configuration */
TIMER_DeInit(TIMER1);
TIMER_TimeBaseStructure.TIMER_Prescaler = 71;
TIMER_TimeBaseStructure.TIMER_CounterMode = TIMER_COUNTER_UP;
TIMER_TimeBaseStructure.TIMER_Period = 999;
TIMER_TimeBaseStructure.TIMER_ClockDivision = TIMER_CDIV_DIV1;
TIMER_TimeBaseStructure.TIMER_RepetitionCounter = 1;
TIMER_BaseInit(TIMER1,&TIMER_TimeBaseStructure);
/* CH1 Configuration in PWM mode */
TIMER_OCInitStructure.TIMER_OCMode = TIMER_OC_MODE_PWM1;
TIMER_OCInitStructure.TIMER_OCPolarity = TIMER_OC_POLARITY_HIGH;
TIMER_OCInitStructure.TIMER_OCNPolarity = TIMER_OCN_POLARITY_HIGH;
TIMER_OCInitStructure.TIMER_OutputState = TIMER_OUTPUT_STATE_ENABLE;
TIMER_OCInitStructure.TIMER_OutputNState = TIMER_OUTPUTN_STATE_ENABLE;
TIMER_OCInitStructure.TIMER_OCIdleState = TIMER_OC_IDLE_STATE_SET;
TIMER_OCInitStructure.TIMER_OCNIdleState = TIMER_OCN_IDLE_STATE_RESET;
TIMER_OCInitStructure.TIMER_Pulse = buffer[0];
TIMER_OC1_Init(TIMER1, &TIMER_OCInitStructure);
TIMER_OC1_Preload(TIMER1,TIMER_OC_PRELOAD_DISABLE);
/* TIMER1 output enable */
TIMER_CtrlPWMOutputs(TIMER1,ENABLE);
/* Auto-reload preload enable */
TIMER_CARLPreloadConfig(TIMER1,ENABLE);
/* TIMER1 Update DMA Request enable */
TIMER_DMACmd( TIMER1, TIMER_DMA_UPDATE, ENABLE);
/* TIMER enable counter*/
TIMER_Enable( TIMER1, ENABLE );
}
/**
* @brief Configures the DAC.
* @param None
* @retval None
*/
void TIM2_Configuration(void)
{
TIMER_BaseInitPara TIM_TimeBaseStructure;
RCC_APB1PeriphClock_Enable(RCC_APB1PERIPH_TIMER2, ENABLE);
TIM_TimeBaseStructure.TIMER_Period = 0xF;
TIM_TimeBaseStructure.TIMER_Prescaler = 0xF;
TIM_TimeBaseStructure.TIMER_ClockDivision = 0x0;
TIM_TimeBaseStructure.TIMER_CounterMode = TIMER_COUNTER_UP;
TIMER_BaseInit(TIMER2, &TIM_TimeBaseStructure);
/* TIM2 TRGO selection */
TIMER_SelectOutputTrigger(TIMER2, TIMER_TRI_OUT_SRC_UPDATE);
TIMER_Enable(TIMER2, ENABLE);
}
void SensorCalibration()
{
char InitState = GetSensorInitState();
char calibration_sensor = GetChar();
TIMER_Enable(false);
if((calibration_sensor=='a')&&(InitState&SENSOR_ACC)) // Do 'a'cc calibration
{
AccCalibration();
}
else if((calibration_sensor=='g')&&(InitState&SENSOR_GYRO)) // Do 'g'yro calibration
{
GyroCalibration();
}
else if((calibration_sensor=='m')&&(InitState&SENSOR_MAG)) // Do 'g'yro calibration
{
MagCalibration();
UpdateFlashCal(SENSOR_MAG, false);
}
else // Fail doing calibration
CalibrationFail();
TIMER_Enable(true);
}
/**
* @brief Configure the TIMER peripheral.
* @param None
* @retval None
*/
void TIMER_Configuration(void)
{
/* ---------------------------------------------------------------
TIMER2 Configuration:
TIMER2CLK = SystemCoreClock / 36000 = 2K,
And generate 3 signals with 3 different delays:
TIMER2_CH1 delay = 4000/2000 = 2s
TIMER2_CH2 delay = 8000/2000 = 4s
TIMER2_CH3 delay = 12000/2000 = 6s
--------------------------------------------------------------- */
TIMER_BaseInitPara TIMER_TimeBaseStructure;
TIMER_OCInitPara TIMER_OCInitStructure;
/* TIMERS clock enable */
RCC_APB2PeriphClock_Enable(RCC_APB2PERIPH_TIMER1|RCC_APB2PERIPH_TIMER15|RCC_APB2PERIPH_TIMER16|RCC_APB2PERIPH_TIMER17,ENABLE);
RCC_APB1PeriphClock_Enable(RCC_APB1PERIPH_TIMER2|RCC_APB1PERIPH_TIMER3|RCC_APB1PERIPH_TIMER6|RCC_APB1PERIPH_TIMER14,ENABLE);
/* TIMER2 configuration */
TIMER_DeInit(TIMER2);
TIMER_TimeBaseStructure.TIMER_Prescaler = 35999;
TIMER_TimeBaseStructure.TIMER_CounterMode = TIMER_COUNTER_UP;
TIMER_TimeBaseStructure.TIMER_Period = 19999;
TIMER_TimeBaseStructure.TIMER_ClockDivision = TIMER_CDIV_DIV1;
TIMER_BaseInit(TIMER2,&TIMER_TimeBaseStructure);
/* CH1,CH2 and CH3 Configuration in OC_ACTIVE mode */
TIMER_OCInitStructure.TIMER_OCMode = TIMER_OC_MODE_ACTIVE;
TIMER_OCInitStructure.TIMER_OCPolarity = TIMER_OC_POLARITY_HIGH;
TIMER_OCInitStructure.TIMER_OutputState = TIMER_OUTPUT_STATE_ENABLE;
TIMER_OCInitStructure.TIMER_Pulse = 3999;
TIMER_OC1_Init(TIMER2, &TIMER_OCInitStructure);
TIMER_OC1_Preload(TIMER2,TIMER_OC_PRELOAD_DISABLE);
TIMER_OCInitStructure.TIMER_Pulse = 7999;
TIMER_OC2_Init(TIMER2, &TIMER_OCInitStructure);
TIMER_OC2_Preload(TIMER2,TIMER_OC_PRELOAD_DISABLE);
TIMER_OCInitStructure.TIMER_Pulse = 11999;
TIMER_OC3_Init(TIMER2, &TIMER_OCInitStructure);
TIMER_OC3_Preload(TIMER2,TIMER_OC_PRELOAD_DISABLE);
/* Auto-reload preload enable */
TIMER_CARLPreloadConfig(TIMER2,ENABLE);
/* TIMER enable counter*/
TIMER_Enable( TIMER2, ENABLE );
}
/**
* @brief Configure the TIMER peripheral.
* @param None
* @retval None
*/
void TIMER_Configuration(void)
{
/* -----------------------------------------------------------------------
TIMER2 Configuration: generate 3 PWM signals with 3 different duty cycles:
TIMER2CLK = SystemCoreClock / 72 = 1MHz
TIMER2 Channel2 duty cycle = (4000/ 16000)* 100 = 25%
TIMER2 Channel3 duty cycle = (8000/ 16000)* 100 = 50%
TIMER2 Channel4 duty cycle = (12000/ 16000)* 100 = 75%
----------------------------------------------------------------------- */
TIMER_BaseInitPara TIMER_TimeBaseStructure;
TIMER_OCInitPara TIMER_OCInitStructure;
/* TIMERS clock enable */
RCC_APB2PeriphClock_Enable(RCC_APB2PERIPH_TIMER1|RCC_APB2PERIPH_TIMER15|RCC_APB2PERIPH_TIMER16|RCC_APB2PERIPH_TIMER17,ENABLE);
RCC_APB1PeriphClock_Enable(RCC_APB1PERIPH_TIMER2|RCC_APB1PERIPH_TIMER3|RCC_APB1PERIPH_TIMER6|RCC_APB1PERIPH_TIMER14,ENABLE);
/* TIMER2 configuration */
TIMER_DeInit(TIMER2);
TIMER_TimeBaseStructure.TIMER_Prescaler = 71;
TIMER_TimeBaseStructure.TIMER_CounterMode = TIMER_COUNTER_UP;
TIMER_TimeBaseStructure.TIMER_Period = 15999;
TIMER_TimeBaseStructure.TIMER_ClockDivision = TIMER_CDIV_DIV1;
TIMER_BaseInit(TIMER2,&TIMER_TimeBaseStructure);
/* CH2,CH3 and CH4 Configuration in PWM mode */
TIMER_OCInitStructure.TIMER_OCMode = TIMER_OC_MODE_PWM1;
TIMER_OCInitStructure.TIMER_OCPolarity = TIMER_OC_POLARITY_HIGH;
TIMER_OCInitStructure.TIMER_OutputState = TIMER_OUTPUT_STATE_ENABLE;
TIMER_OCInitStructure.TIMER_Pulse = 3999;
TIMER_OC2_Init(TIMER2, &TIMER_OCInitStructure);
TIMER_OC2_Preload(TIMER2,TIMER_OC_PRELOAD_DISABLE);
TIMER_OCInitStructure.TIMER_Pulse = 7999;
TIMER_OC3_Init(TIMER2, &TIMER_OCInitStructure);
TIMER_OC3_Preload(TIMER2,TIMER_OC_PRELOAD_DISABLE);
TIMER_OCInitStructure.TIMER_Pulse = 11999;
TIMER_OC4_Init(TIMER2, &TIMER_OCInitStructure);
TIMER_OC4_Preload(TIMER2,TIMER_OC_PRELOAD_DISABLE);
/* Auto-reload preload enable */
TIMER_CARLPreloadConfig(TIMER2,ENABLE);
/* TIMER enable counter*/
TIMER_Enable( TIMER2, ENABLE );
}
void enc_init(void)
{
static const TIMER_Init_TypeDef txTimerInit =
{ false, /* Don't enable timer when init complete. */
false, /* Stop counter during debug halt. */
HIJACK_TIMER_RESOLUTION,/* ... */
timerClkSelHFPerClk, /* Select HFPER clock. */
false, /* Not 2x count mode. */
false, /* No ATI. */
timerInputActionNone, /* No action on falling input edge. */
timerInputActionNone, /* No action on rising input edge. */
timerModeUp, /* Up-counting. */
false, /* Do not clear DMA requests when DMA channel is active. */
false, /* Select X2 quadrature decode mode (if used). */
false, /* Disable one shot. */
false /* Not started/stopped/reloaded by other timers. */
};
/* Ensure core frequency has been updated */
SystemCoreClockUpdate();
/* Enable peripheral clocks. */
CMU_ClockEnable(cmuClock_HFPER, true);
CMU_ClockEnable(HIJACK_TX_TIMERCLK, true);
/* Configure Rx timer. */
TIMER_Init(HIJACK_TX_TIMER, &txTimerInit);
/* Configure Tx timer output compare channel 0. */
HIJACK_CompareConfig(hijackOutputModeToggle);
TIMER_CompareSet(HIJACK_TX_TIMER, 0, HIJACK_NUM_TICKS_PER_HALF_CYCLE);
/* Route the capture channels to the correct pins, enable CC feature. */
HIJACK_TX_TIMER->ROUTE = HIJACK_TX_LOCATION | TIMER_ROUTE_CC0PEN;
/* Tx: Configure the corresponding GPIO pin as an input. */
GPIO_PinModeSet(HIJACK_TX_GPIO_PORT, HIJACK_TX_GPIO_PIN, gpioModePushPull, 0);
/* Enable Tx timer CC0 interrupt. */
NVIC_EnableIRQ(TIMER1_IRQn);
TIMER_IntEnable(HIJACK_TX_TIMER, TIMER_IF_CC0);
/* Enable the timer. */
TIMER_Enable(HIJACK_TX_TIMER, true);
}
void motor_on(uint8_t level, clock_time_t length)
{
CMU_ClockEnable(cmuClock_TIMER2, true);
TIMER_Enable(TIMER2,true);
if (level > 16) level = 16;
if (level == 0)
{
motor_stop(NULL);
}
else
{
TIMER_CompareBufSet(TIMER2, 0, level*200);
if (length > 0)
ctimer_set(&motor_timer, length, motor_stop, NULL);
}
}
/**
* \brief decode initial.
*/
void dec_init(void)
{
static const TIMER_Init_TypeDef rxTimerInit =
{ false, /* Don't enable timer when init complete. */
false, /* Stop counter during debug halt. */
HIJACK_TIMER_RESOLUTION,/* ... */
timerClkSelHFPerClk, /* Select HFPER clock. */
false, /* Not 2x count mode. */
false, /* No ATI. */
timerInputActionNone, /* No action on falling input edge. */
timerInputActionNone, /* No action on rising input edge. */
timerModeUp, /* Up-counting. */
false, /* Do not clear DMA requests when DMA channel is active. */
false, /* Select X2 quadrature decode mode (if used). */
false, /* Disable one shot. */
false /* Not started/stopped/reloaded by other timers. */
};
/* Ensure core frequency has been updated */
SystemCoreClockUpdate();
/* Enable RX_TIMER clock . */
CMU_ClockEnable(HIJACK_RX_TIMERCLK, true);
/* Configure Rx timer. */
TIMER_Init(HIJACK_RX_TIMER, &rxTimerInit);
/* Configure Rx timer input capture channel 0. */
HIJACK_CaptureConfig(hijackEdgeModeBoth);
/* Route the capture channels to the correct pins, enable CC1. */
HIJACK_RX_TIMER->ROUTE = TIMER_ROUTE_LOCATION_LOC3 | TIMER_ROUTE_CC1PEN;
/* Rx: Configure the corresponding GPIO pin (PortD, Ch2) as an input. */
GPIO_PinModeSet(HIJACK_RX_GPIO_PORT, HIJACK_RX_GPIO_PIN, gpioModeInput, 0);
/* Enable Rx timer CC1 interrupt. */
NVIC_EnableIRQ(TIMER0_IRQn);
TIMER_IntEnable(HIJACK_RX_TIMER, TIMER_IF_CC1);
/* Enable the timer. */
TIMER_Enable(HIJACK_RX_TIMER, true);
}
/**************************************************************************//**
* @brief Configure TIMER to trigger ADC through PRS at a set sample rate
*****************************************************************************/
void setupAdc(void)
{
ADC_Init_TypeDef adcInit = ADC_INIT_DEFAULT;
ADC_InitSingle_TypeDef adcInitSingle = ADC_INITSINGLE_DEFAULT;
/* Configure ADC single mode to sample Ref/2 */
adcInit.prescale = ADC_PrescaleCalc(7000000, 0); /* Set highest allowed prescaler */
ADC_Init(ADC0, &adcInit);
adcInitSingle.input = adcSingleInpVrefDiv2; /* Reference */
adcInitSingle.prsEnable = true;
adcInitSingle.prsSel = adcPRSSELCh0; /* Triggered by PRS CH0 */
ADC_InitSingle(ADC0, &adcInitSingle);
/* Connect PRS channel 0 to TIMER overflow */
PRS_SourceSignalSet(0, PRS_CH_CTRL_SOURCESEL_TIMER0, PRS_CH_CTRL_SIGSEL_TIMER0OF, prsEdgeOff);
/* Configure TIMER to trigger 100 kHz sampling rate */
TIMER_TopSet(TIMER0, CMU_ClockFreqGet(cmuClock_TIMER0)/ADCSAMPLESPERSEC);
TIMER_Enable(TIMER0, true);
}
/***************************************************************************//**
* @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;
}
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 Stop TIMER1
******************************************************************************/
void TX_Timer_Stop(void)
{
TIMER_Enable ( TIMER1, false ); /* Disable TIMER1 */
// CMU_ClockEnable ( cmuClock_TIMER1, false ); /* Disable clock for TIMER1 */
}
void pwm_init(void)
{
GPIO_InitPara GPIO_InitStructure;
// timer 3 pin PB1 config ( ch4 )
GPIO_InitStructure.GPIO_Pin = GPIO_PIN_1;
GPIO_InitStructure.GPIO_Mode = GPIO_MODE_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_SPEED_50MHZ;
GPIO_InitStructure.GPIO_OType = GPIO_OTYPE_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PUPD_PULLDOWN;
GPIO_Init(GPIOB,&GPIO_InitStructure);
GPIO_PinAFConfig(GPIOB,GPIO_PINSOURCE1,GPIO_AF_1);
// GPIO pins PA8 , 9 ,10 setup ( Timer1 ch 1 , 2 , 3)
GPIO_InitStructure.GPIO_Pin = GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10;
GPIO_Init(GPIOA,&GPIO_InitStructure);
GPIO_PinAFConfig(GPIOA,GPIO_PINSOURCE8,GPIO_AF_2);
GPIO_PinAFConfig(GPIOA,GPIO_PINSOURCE9,GPIO_AF_2);
GPIO_PinAFConfig(GPIOA,GPIO_PINSOURCE10,GPIO_AF_2);
TIMER_BaseInitPara TIM_TimeBaseStructure;
RCC_APB2PeriphClock_Enable(RCC_APB2PERIPH_TIMER1,ENABLE);
RCC_APB1PeriphClock_Enable(RCC_APB1PERIPH_TIMER3,ENABLE);
// TIMER3 for pins A8 A9 A10
TIM_TimeBaseStructure.TIMER_Prescaler = TIMER_PRESCALER - 1; //
TIM_TimeBaseStructure.TIMER_CounterMode = TIMER_COUNTER_UP;
TIM_TimeBaseStructure.TIMER_Period = PWMTOP;
TIM_TimeBaseStructure.TIMER_ClockDivision = TIMER_CDIV_DIV1;
TIMER_BaseInit(TIMER3,&TIM_TimeBaseStructure);
//Ch1 , 2 , 3
TIM_OCInitStructure.TIMER_OCMode = TIMER_OC_MODE_PWM1;
TIM_OCInitStructure.TIMER_OCPolarity = OUT_POLARITY;
TIM_OCInitStructure.TIMER_OutputState = TIMER_OUTPUT_STATE_ENABLE;
TIM_OCInitStructure.TIMER_OCIdleState = TIMER_OC_IDLE_STATE_RESET;
TIM_OCInitStructure.TIMER_Pulse = 0;
TIMER_OC4_Init(TIMER3, &TIM_OCInitStructure);
TIMER_CtrlPWMOutputs(TIMER3,ENABLE);
TIMER_CARLPreloadConfig(TIMER3,ENABLE);
TIMER_Enable( TIMER3, ENABLE );
TIMER_BaseInit(TIMER1,&TIM_TimeBaseStructure);
TIMER_OC1_Init(TIMER1, &TIM_OCInitStructure);
TIMER_OC2_Init(TIMER1, &TIM_OCInitStructure);
TIMER_OC3_Init(TIMER1, &TIM_OCInitStructure);
TIMER_CtrlPWMOutputs(TIMER1,ENABLE);
TIMER_CARLPreloadConfig(TIMER1,ENABLE);
TIMER_OC1_Preload(TIMER1,ESC_PRELOAD);
TIMER_OC2_Preload(TIMER1,ESC_PRELOAD);
TIMER_OC3_Preload(TIMER1,ESC_PRELOAD);
TIMER_OC4_Preload(TIMER3,ESC_PRELOAD);
TIMER_Enable( TIMER1, ENABLE );
}
void timer_start(tim_t dev)
{
TIMER_Enable(timer_config[dev].timer.dev, true);
}
void timer_stop(tim_t dev)
{
TIMER_Enable(timer_config[dev].timer.dev, false);
}
int main(void)
{
uint16_t vector_start = 0;
uint16_t vector_end = 0;
/* Initialize chip */
CHIP_Init();
// start HFXO
CMU_ClockSelectSet(cmuClock_HF, cmuSelect_HFXO);
/* Start LFXO, and use LFXO for low-energy modules */
CMU_ClockSelectSet(cmuClock_LFA, cmuSelect_LFXO);
CMU_ClockSelectSet(cmuClock_LFB, cmuSelect_LFXO);
CMU_ClockEnable(cmuClock_GPIO, true);
delay_init();
initLeuart();
initSpi();
#if 0
printf("cmuClock_HF: %" PRIu32 "\r\n", CMU_ClockFreqGet(cmuClock_HF));
printf("cmuClock_CORE: %" PRIu32 "\r\n", CMU_ClockFreqGet(cmuClock_CORE));
printf("cmuClock_HFPER: %" PRIu32 "\r\n", CMU_ClockFreqGet(cmuClock_HFPER));
printf("cmuClock_TIMER1: %" PRIu32 "\r\n", CMU_ClockFreqGet(cmuClock_TIMER1));
#endif
init_analog_switches();
printf("\r\n* vector test *\r\n");
while (1)
{
char c;
c = leuart_blocking_read_char();
switch(c)
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
vector_start = vector_end;
vector_end = 4095 * (c - '0') / 9;
break;
case 'v':
printf("vector from %d to %d\r\n", vector_start, vector_end);
setDAC(0, true, vector_start);
set_analog_switch(T1, false);
setDAC(0, true, vector_end);
TIMER_CounterSet(T2_TIMER, 0);
TIMER_Enable(T2_TIMER, true);
while(T2_TIMER->STATUS & TIMER_STATUS_RUNNING)
;
set_analog_switch(T1, true);
break;
default:
break;
}
}
}
void pwm_init(void)
{
GPIO_InitPara GPIO_InitStructure;
//pin A0 TM2_ch1
GPIO_InitStructure.GPIO_Pin = GPIO_PIN_1;
GPIO_InitStructure.GPIO_Mode = GPIO_MODE_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_SPEED_50MHZ;
GPIO_InitStructure.GPIO_OType = GPIO_OTYPE_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PUPD_PULLDOWN;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_PinAFConfig(GPIOA, GPIO_PINSOURCE1, GPIO_AF_2);
TIMER_BaseInitPara TIM_TimeBaseStructure;
RCC_APB1PeriphClock_Enable(RCC_APB1PERIPH_TIMER2 |
RCC_APB1PERIPH_TIMER14 |
RCC_APB1PERIPH_TIMER3, ENABLE);
RCC_APB2PeriphClock_Enable(RCC_APB2PERIPH_TIMER1, ENABLE);
// timer 2
TIM_TimeBaseStructure.TIMER_Prescaler = TIMER_PRESCALER - 1; //
TIM_TimeBaseStructure.TIMER_CounterMode = TIMER_COUNTER_CENTER_ALIGNED2;
TIM_TimeBaseStructure.TIMER_Period = PWMTOP;
TIM_TimeBaseStructure.TIMER_ClockDivision = TIMER_CDIV_DIV1;
// init timer 2
TIMER_BaseInit(TIMER2, &TIM_TimeBaseStructure);
TIM_OCInitStructure.TIMER_OCMode = TIMER_OC_MODE_PWM1;
TIM_OCInitStructure.TIMER_OCPolarity = TIMER_OC_POLARITY_HIGH;
TIM_OCInitStructure.TIMER_OutputState = TIMER_OUTPUT_STATE_ENABLE;
TIM_OCInitStructure.TIMER_OCIdleState = TIMER_OC_IDLE_STATE_RESET;
TIM_OCInitStructure.TIMER_Pulse = 0;
TIMER_OC2_Init(TIMER2, &TIM_OCInitStructure);
TIMER_CtrlPWMOutputs(TIMER2, ENABLE);
TIMER_CARLPreloadConfig(TIMER2, ENABLE);
TIMER_OC2_Preload(TIMER2, TIMER_OC_PRELOAD_DISABLE);
// pin A3
GPIO_InitStructure.GPIO_Pin = GPIO_PIN_3;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_PinAFConfig(GPIOA, GPIO_PINSOURCE3, GPIO_AF_2);
TIMER_OC4_Init(TIMER2, &TIM_OCInitStructure);
TIMER_OC4_Preload(TIMER2, TIMER_OC_PRELOAD_DISABLE);
// TIMER_Enable( TIMER2, ENABLE );
// timer 1 ch3 , ch1
// pins A10 , A8
GPIO_InitStructure.GPIO_Pin = GPIO_PIN_10 | GPIO_PIN_8;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_PinAFConfig(GPIOA, GPIO_PINSOURCE10, GPIO_AF_2);
GPIO_PinAFConfig(GPIOA, GPIO_PINSOURCE8, GPIO_AF_2);
// timer 1
// init timer 1
TIMER_BaseInit(TIMER1, &TIM_TimeBaseStructure);
TIM_OCInitStructure.TIMER_Pulse = 0;
TIMER_OC3_Init(TIMER1, &TIM_OCInitStructure);
TIMER_OC1_Init(TIMER1, &TIM_OCInitStructure);
TIMER_CtrlPWMOutputs(TIMER1, ENABLE);
TIMER_CARLPreloadConfig(TIMER1, ENABLE);
TIMER_OC3_Preload(TIMER1, TIMER_OC_PRELOAD_DISABLE);
TIMER_OC1_Preload(TIMER1, TIMER_OC_PRELOAD_DISABLE);
// bridge dir 2
///////////////
//pin A9 TM1_ch2
GPIO_InitStructure.GPIO_Pin = GPIO_PIN_9;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_PinAFConfig(GPIOA, GPIO_PINSOURCE9, GPIO_AF_2);
// timer 1
// init timer 1
TIMER_BaseInit(TIMER1, &TIM_TimeBaseStructure);
TIM_OCInitStructure.TIMER_Pulse = 0;
TIMER_OC2_Init(TIMER2, &TIM_OCInitStructure);
TIMER_CtrlPWMOutputs(TIMER1, ENABLE);
TIMER_CARLPreloadConfig(TIMER1, ENABLE);
TIMER_OC2_Preload(TIMER1, TIMER_OC_PRELOAD_DISABLE);
// timer 3 PB1 af1 ch4
GPIO_InitStructure.GPIO_Pin = GPIO_PIN_1;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_PinAFConfig(GPIOB, GPIO_PINSOURCE1, GPIO_AF_1);
// timer 3
// init timer 3
TIMER_BaseInit(TIMER3, &TIM_TimeBaseStructure);
TIM_OCInitStructure.TIMER_Pulse = 0;
TIMER_OC4_Init(TIMER3, &TIM_OCInitStructure);
TIMER_CtrlPWMOutputs(TIMER3, ENABLE);
TIMER_CARLPreloadConfig(TIMER3, ENABLE);
TIMER_OC4_Preload(TIMER3, TIMER_OC_PRELOAD_DISABLE);
// A0
// Timer2 ch1
GPIO_InitStructure.GPIO_Pin = GPIO_PIN_0;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_PinAFConfig(GPIOA, GPIO_PINSOURCE0, GPIO_AF_2);
// timer 2
// init timer 2
TIMER_BaseInit(TIMER2, &TIM_TimeBaseStructure);
TIM_OCInitStructure.TIMER_Pulse = 0;
TIMER_OC1_Init(TIMER2, &TIM_OCInitStructure);
TIMER_CtrlPWMOutputs(TIMER2, ENABLE);
TIMER_CARLPreloadConfig(TIMER2, ENABLE);
TIMER_OC1_Preload(TIMER2, TIMER_OC_PRELOAD_DISABLE);
// PA2 tm2 ch3
GPIO_InitStructure.GPIO_Pin = GPIO_PIN_2;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_PinAFConfig(GPIOA, GPIO_PINSOURCE2, GPIO_AF_2);
TIMER_OC3_Init(TIMER2, &TIM_OCInitStructure);
TIMER_OC3_Preload(TIMER2, TIMER_OC_PRELOAD_DISABLE);
TIMER_Enable(TIMER3, ENABLE);
TIMER_Enable(TIMER1, ENABLE);
TIMER_Enable(TIMER2, ENABLE);
}
