// ===============================================================================================
void Pump_now(FunctionalState pump)
{
if(pump==ENABLE && !Power.Pump_deny)
{
Power.Pump_active=ENABLE;
dac_on(); // Включаем ЦАП
TIM9->EGR |= 0x0001; // Устанавливаем бит UG для принудительного сброса счетчика
TIM_ClearITPendingBit(TIM9, TIM_IT_Update);
TIM_CCxCmd(TIM9, TIM_Channel_1, TIM_CCx_Enable); // разрешить накачку
TIM_ITConfig(TIM9, TIM_IT_Update, ENABLE);
comp_on(); // Включаем компаратор
} else {
TIM_CCxCmd(TIM9, TIM_Channel_1, TIM_CCx_Disable); // запретить накачку
TIM_ITConfig(TIM9, TIM_IT_Update, DISABLE);
pump_counter_avg_impulse_by_1sec[0]++;
comp_off(); // Выключаем компаратор
dac_off(); // Выключаем ЦАП
TIM_ClearITPendingBit(TIM9, TIM_IT_Update);
Power.Pump_active=DISABLE;
}
}
void pwm_motorStop()
{
motor_running=0;
TIM1->CCR1 = 0;
TIM1->CCR2 = 0;
TIM1->CCR3 = 0;
TIM_CCxCmd(TIM1, TIM_Channel_1, TIM_CCx_Disable);
TIM_CCxCmd(TIM1, TIM_Channel_2, TIM_CCx_Disable);
TIM_CCxCmd(TIM1, TIM_Channel_3, TIM_CCx_Disable);
TIM_CCxNCmd(TIM1, TIM_Channel_1, TIM_CCxN_Disable);
TIM_CCxNCmd(TIM1, TIM_Channel_2, TIM_CCxN_Disable);
TIM_CCxNCmd(TIM1, TIM_Channel_3, TIM_CCxN_Disable);
}
void TIMER2_CH2_PWM_Init(int prescaler,int autoreload){
//USER LED / PB3 / TIM2_CH2 / AF1
RCC_AHBPeriphClockCmd(RCC_AHBENR_GPIOBEN ,ENABLE);
GPIO_InitTypeDef myGPIO;
GPIO_StructInit(&myGPIO);
myGPIO.GPIO_Pin=GPIO_Pin_3;
myGPIO.GPIO_Mode=GPIO_Mode_AF;
myGPIO.GPIO_Speed=GPIO_Speed_10MHz;
GPIO_Init(GPIOB,&myGPIO);
GPIO_PinAFConfig(GPIOB,GPIO_PinSource3,GPIO_AF_1);
//select the output mode by writing the CCS bits in the CCMRx register
//Timer time base configuration
RCC_APB1PeriphClockCmd(RCC_APB1ENR_TIM2EN,ENABLE);
TIM_TimeBaseInitTypeDef myTimeBase;
TIM_TimeBaseStructInit(&myTimeBase);
myTimeBase.TIM_CounterMode=TIM_CounterMode_Up;
myTimeBase.TIM_Period=autoreload;
myTimeBase.TIM_Prescaler=prescaler;
myTimeBase.TIM_ClockDivision= TIM_CKD_DIV1;
TIM_TimeBaseInit(TIM2,&myTimeBase);
//Timer capture compare configuration
TIM_OCInitTypeDef myTimerOC;
TIM_OCStructInit(&myTimerOC);
myTimerOC.TIM_OCMode=TIM_OCMode_PWM1;
myTimerOC.TIM_OCPolarity=TIM_OCPolarity_High;
myTimerOC.TIM_OutputState=TIM_OutputState_Enable;
myTimerOC.TIM_Pulse=autoreload;//0 Duty cycle at start
TIM_OC2Init(TIM2,&myTimerOC);
TIM_CCxCmd(TIM2,TIM_Channel_2,TIM_CCx_Enable);//enable CCP2
//start Timer
TIM_Cmd(TIM2,ENABLE);//Counter enabled
}
static void _ws_Timer_Init(void)
{
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
TIM_OCInitTypeDef TIM_OCInitStructure;
TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
TIM_TimeBaseStructure.TIM_Period = WS_PERIOD;
TIM_TimeBaseStructure.TIM_Prescaler = WS_PRESCALE;
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(WS_OUTPUT_TIM, &TIM_TimeBaseStructure);
/* PWM1 Mode configuration */
TIM_OCStructInit(&TIM_OCInitStructure);
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = WS_PERIOD+1;
WS_OUTPUT_TIM_OC_INIT_CMD(WS_OUTPUT_TIM, &TIM_OCInitStructure);
WS_OUTPUT_TIM_OC_PLOAD_CMD(WS_OUTPUT_TIM, TIM_OCPreload_Enable);
TIM_ARRPreloadConfig(WS_OUTPUT_TIM, ENABLE);
TIM_CCxCmd(WS_OUTPUT_TIM, WS_OUTPUT_TIM_CH, TIM_CCx_Enable);
/* WS_OUTPUT_TIM enable/disable counter */
TIM_Cmd(WS_OUTPUT_TIM, ENABLE);
}
static void serialInputPortActivate(softSerial_t *softSerial)
{
if (softSerial->port.options & SERIAL_INVERTED) {
#ifdef STM32F1
IOConfigGPIO(softSerial->rxIO, IOCFG_IPD);
#else
IOConfigGPIO(softSerial->rxIO, IOCFG_AF_PP_PD);
#endif
} else {
#ifdef STM32F1
IOConfigGPIO(softSerial->rxIO, IOCFG_IPU);
#else
IOConfigGPIO(softSerial->rxIO, IOCFG_AF_PP_UP);
#endif
}
softSerial->rxActive = true;
softSerial->isSearchingForStartBit = true;
softSerial->rxBitIndex = 0;
// Enable input capture
#ifdef USE_HAL_DRIVER
TIM_CCxChannelCmd(softSerial->timerHardware->tim, softSerial->timerHardware->channel, TIM_CCx_ENABLE);
#else
TIM_CCxCmd(softSerial->timerHardware->tim, softSerial->timerHardware->channel, TIM_CCx_Enable);
#endif
}
/*********************************************************************************
*Function : void noTone(uint8_t pin)
*Description : none pwm
*Input : pin: pin number
*Output : none
*Return : none
*author : lz
*date : 6-December-2013
*Others :
**********************************************************************************/
void noTone(uint8_t pin)
{
if (pin >= TOTAL_PINS || PIN_MAP[pin].timer_peripheral == NULL)
{
return;
}
if(PIN_MAP[pin].timer_ch == TIM_Channel_1)
{
TIM_ITConfig(PIN_MAP[pin].timer_peripheral, TIM_IT_CC1, DISABLE);
}
else if(PIN_MAP[pin].timer_ch == TIM_Channel_2)
{
TIM_ITConfig(PIN_MAP[pin].timer_peripheral, TIM_IT_CC2, DISABLE);
}
else if(PIN_MAP[pin].timer_ch == TIM_Channel_3)
{
TIM_ITConfig(PIN_MAP[pin].timer_peripheral, TIM_IT_CC3, DISABLE);
}
else if(PIN_MAP[pin].timer_ch == TIM_Channel_4)
{
TIM_ITConfig(PIN_MAP[pin].timer_peripheral, TIM_IT_CC4, DISABLE);
}
TIM_CCxCmd(PIN_MAP[pin].timer_peripheral, PIN_MAP[pin].timer_ch, TIM_CCx_Disable);
PIN_MAP[pin].timer_ccr = 0;
PIN_MAP[pin].user_property = 0;
}
static void serialEnableCC(softSerial_t *softSerial)
{
#ifdef USE_HAL_DRIVER
TIM_CCxChannelCmd(softSerial->timerHardware->tim, softSerial->timerHardware->channel, TIM_CCx_ENABLE);
#else
TIM_CCxCmd(softSerial->timerHardware->tim, softSerial->timerHardware->channel, TIM_CCx_Enable);
#endif
}
static void stop_pwm_hw(void) {
m_is_running = false;
m_sample_buffer.write = 0;
m_sample_buffer.read = 0;
#ifdef HW_HAS_DRV8313
DISABLE_BR();
#endif
TIM_SelectOCxM(TIM1, TIM_Channel_1, TIM_ForcedAction_InActive);
TIM_CCxCmd(TIM1, TIM_Channel_1, TIM_CCx_Enable);
TIM_CCxNCmd(TIM1, TIM_Channel_1, TIM_CCxN_Disable);
TIM_SelectOCxM(TIM1, TIM_Channel_3, TIM_ForcedAction_InActive);
TIM_CCxCmd(TIM1, TIM_Channel_3, TIM_CCx_Enable);
TIM_CCxNCmd(TIM1, TIM_Channel_3, TIM_CCxN_Disable);
TIM_GenerateEvent(TIM1, TIM_EventSource_COM);
}
static void init_PWM(void) {
TIM_OCInitTypeDef pwm = {
TIM_OCMode_PWM1,
TIM_OutputState_Enable,
0,
30,
TIM_OCPolarity_High,
0, 0, 0
};
TIM_CtrlPWMOutputs(TIM14, ENABLE);
TIM_OC1Init(TIM14, &pwm);
TIM_CCxCmd(TIM14, TIM_Channel_1, TIM_CCx_Enable);
}
static void serialInputPortDeActivate(softSerial_t *softSerial)
{
// Disable input capture
#ifdef USE_HAL_DRIVER
TIM_CCxChannelCmd(softSerial->timerHardware->tim, softSerial->timerHardware->channel, TIM_CCx_DISABLE);
#else
TIM_CCxCmd(softSerial->timerHardware->tim, softSerial->timerHardware->channel, TIM_CCx_Disable);
#endif
IOConfigGPIO(softSerial->rxIO, IOCFG_IN_FLOATING);
softSerial->rxActive = false;
}
bool Servo::detach() {
if (!this->attached()) {
return false;
}
TIM_TypeDef *tdev = g_APinDescription[this->pin].ulTimerPeripheral;
uint8_t tchan = g_APinDescription[this->pin].ulTimerChannel;
TIM_CCxCmd(tdev, tchan, TIM_CCx_Disable);
this->resetFields();
return true;
}
static void set_modulation(float mod) {
utils_truncate_number_abs(&mod, m_conf->l_max_duty);
m_mod_now = mod;
if (m_output_mode == GPD_OUTPUT_MODE_NONE || mc_interface_get_fault() != FAULT_CODE_NONE) {
return;
}
if (m_conf->pwm_mode == PWM_MODE_BIPOLAR) {
uint32_t duty = (uint32_t) (((float)TIM1->ARR / 2.0) * mod + ((float)TIM1->ARR / 2.0));
TIM1->CCR1 = duty;
TIM1->CCR3 = duty;
// +
TIM_SelectOCxM(TIM1, TIM_Channel_1, TIM_OCMode_PWM1);
TIM_CCxCmd(TIM1, TIM_Channel_1, TIM_CCx_Enable);
TIM_CCxNCmd(TIM1, TIM_Channel_1, TIM_CCxN_Enable);
// -
TIM_SelectOCxM(TIM1, TIM_Channel_3, TIM_OCMode_PWM2);
TIM_CCxCmd(TIM1, TIM_Channel_3, TIM_CCx_Enable);
TIM_CCxNCmd(TIM1, TIM_Channel_3, TIM_CCxN_Enable);
} else {
uint32_t duty = (uint32_t)((float)TIM1->ARR * fabsf(mod));
TIM1->CCR1 = duty;
TIM1->CCR3 = duty;
if (mod >= 0) {
// +
TIM_SelectOCxM(TIM1, TIM_Channel_1, TIM_OCMode_PWM1);
TIM_CCxCmd(TIM1, TIM_Channel_1, TIM_CCx_Enable);
TIM_CCxNCmd(TIM1, TIM_Channel_1, TIM_CCxN_Enable);
// -
TIM_SelectOCxM(TIM1, TIM_Channel_3, TIM_OCMode_Inactive);
TIM_CCxCmd(TIM1, TIM_Channel_3, TIM_CCx_Enable);
TIM_CCxNCmd(TIM1, TIM_Channel_3, TIM_CCxN_Enable);
} else {
// +
TIM_SelectOCxM(TIM1, TIM_Channel_3, TIM_OCMode_PWM1);
TIM_CCxCmd(TIM1, TIM_Channel_3, TIM_CCx_Enable);
TIM_CCxNCmd(TIM1, TIM_Channel_3, TIM_CCxN_Enable);
// -
TIM_SelectOCxM(TIM1, TIM_Channel_1, TIM_OCMode_Inactive);
TIM_CCxCmd(TIM1, TIM_Channel_1, TIM_CCx_Enable);
TIM_CCxNCmd(TIM1, TIM_Channel_1, TIM_CCxN_Enable);
}
}
TIM_GenerateEvent(TIM1, TIM_EventSource_COM);
m_is_running = true;
}
void pwm_out2_init(uint16_t frequency)
{
int period = 0;
int psc = 0;
config_pwm_freq((int)frequency, &period, &psc);
TIM_TimeBaseInitTypeDef i;
TIM_OCInitTypeDef j;
GPIO_InitTypeDef g;
i.TIM_CounterMode = TIM_CounterMode_Up;
i.TIM_ClockDivision = 0;//clk_div;
i.TIM_RepetitionCounter = 0;
i.TIM_Prescaler = ((uint16_t)psc)-1;
i.TIM_Period = ((uint16_t)period)-1;
j.TIM_OCMode = TIM_OCMode_PWM1;
j.TIM_OutputState = TIM_OutputState_Enable;
j.TIM_Pulse = 8191;
j.TIM_OCPolarity = TIM_OCPolarity_High;
g.GPIO_Mode = GPIO_Mode_AF;
g.GPIO_OType = GPIO_OType_PP;
g.GPIO_Pin = GPIO_Pin_5;
g.GPIO_PuPd = GPIO_PuPd_UP;
g.GPIO_Speed = GPIO_Speed_50MHz;
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource5, GPIO_AF_2); // AF 2, 10:
GPIO_Init(GPIOB, &g);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
TIM_InternalClockConfig(TIM3);
TIM_TimeBaseInit(TIM3, &i);
TIM_OC2Init(TIM3, &j);
TIM_OC2PreloadConfig(TIM3, TIM_OCPreload_Enable);
TIM_ARRPreloadConfig(TIM3, ENABLE);
TIM_CCxCmd(TIM3, TIM_Channel_2, TIM_CCx_Enable);
TIM_Cmd(TIM3, ENABLE);
TIM_GenerateEvent(TIM3, TIM_EventSource_Update);
}
/**------------------------------------------------------------------
*
* @brief Activation du signal PWM
*
*/
uint8_t
Pwm_Activer(
Mapping_GPIO_e IdPinPwm /** <[in] ID de la PIN où générer le signal PWM */
) {
Liste_Etat_PWM_e PWM_State;
//--------- Verif que periph conf
if( __GetConfState(Mapping_GPIO[IdPinPwm].Periph, Mapping_GPIO[IdPinPwm].Parametre) == PWM_Unconfigured)
return PWM_Unconfigured;
PWM_State = __GetRunningState( Mapping_GPIO[IdPinPwm].Periph,
Mapping_GPIO[IdPinPwm].Parametre );
if(PWM_State == PWM_Running) return PWM_Running;
__SetRunningState( PWM_Running,
Mapping_GPIO[IdPinPwm].Periph,
Mapping_GPIO[IdPinPwm].Parametre );
TIM_CCxCmd ( (TIM_TypeDef*) Mapping_GPIO[IdPinPwm].Periph,
Mapping_GPIO[IdPinPwm].Parametre,
TIM_CCx_Enable );
TIM_CtrlPWMOutputs( (TIM_TypeDef*) Mapping_GPIO[IdPinPwm].Periph,
ENABLE );
if(Mapping_GPIO[IdPinPwm].Etat_Interruption == Interrupt_ON)
TIM_ITConfig((TIM_TypeDef* )Mapping_GPIO[IdPinPwm].Periph, __GetITChannel(Mapping_GPIO[IdPinPwm].Parametre), ENABLE);
return PWM_Running;
}
/**------------------------------------------------------------------
*
* @brief Desactivation du signal PWM
*
*/
uint8_t
Pwm_Desactiver(
Mapping_GPIO_e IdPinPwm /** <[in] ID de la PIN où le signal PWM était généré */
) {
Liste_Etat_PWM_e PWM_State;
//--------- Verif que periph conf
if( __GetConfState(Mapping_GPIO[IdPinPwm].Periph, Mapping_GPIO[IdPinPwm].Parametre) == PWM_Unconfigured)
return PWM_Unconfigured;
PWM_State = __GetRunningState( Mapping_GPIO[IdPinPwm].Periph,
Mapping_GPIO[IdPinPwm].Parametre );
if(PWM_State == PWM_Stopped) return PWM_Stopped;
__SetRunningState( FALSE,
Mapping_GPIO[IdPinPwm].Periph,
Mapping_GPIO[IdPinPwm].Parametre );
TIM_CCxCmd ( (TIM_TypeDef*) Mapping_GPIO[IdPinPwm].Periph,
Mapping_GPIO[IdPinPwm].Parametre,
TIM_CCx_Disable );
TIM_CtrlPWMOutputs( (TIM_TypeDef*) Mapping_GPIO[IdPinPwm].Periph,
DISABLE );
/*if(Mapping_GPIO[IdPinPwm].Etat_Interruption == Interrupt_ON)
TIM_ITConfig((TIM_TypeDef* )Mapping_GPIO[IdPinPwm].Periph, __GetITChannel(Mapping_GPIO[IdPinPwm].Parametre), DISABLE);*/
return PWM_Stopped;
}
void vMotorsInit(unsigned portBASE_TYPE motors_daemon_priority,
unsigned portBASE_TYPE beeping_daemon_priority)
{
// Enable GPIOA & GPIOC clock
gpio_clock_init(GPIOA);
gpio_clock_init(GPIOC);
timer_clock_init(TIM5);
// Motors PWM: MOTOR1=left, MOTOR2=right ; A and B have opposed polarity
GPIO_InitTypeDef GPIO_InitStructure1 =
{
.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | // MOTOR2_B, MOTOR2_A
GPIO_Pin_2 | GPIO_Pin_3 , // MOTOR1_B, MOTOR1_A
.GPIO_Mode = GPIO_Mode_AF_PP, // alternate function push pull
.GPIO_Speed = GPIO_Speed_2MHz
};
GPIO_Init(GPIOA, &GPIO_InitStructure1);
// Motors enable pin
GPIO_InitTypeDef GPIO_InitStructure2 =
{
.GPIO_Pin = GPIO_Pin_3, // MOTORS_ENABLE
.GPIO_Mode = GPIO_Mode_Out_PP, // push pull
.GPIO_Speed = GPIO_Speed_2MHz
};
GPIO_Init(GPIOC, &GPIO_InitStructure2);
// Set output compare interrupt flags of channels configured in output
// (CCxS=00 in TIMx_CCMRx register) when counting up or down
TIM_CounterModeConfig(TIM5, TIM_CounterMode_CenterAligned3);
// robots.freehostia.com/SpeedControl/SpeedControllersBody.html#2.2
// f = 72MHz / 960 / 4 =~ 18kHz (P=5%, R=0.6ohms, L=100uH)
TIM_TimeBaseInitTypeDef Timer_InitStructure =
{
.TIM_ClockDivision = TIM_CKD_DIV1,
.TIM_Prescaler = DEFAULT_PSC,
.TIM_Period = PERIOD,
.TIM_CounterMode = TIM_CounterMode_Up
};
TIM_TimeBaseInit(TIM5, &Timer_InitStructure);
// Output Compare Init :
TIM_OCInitTypeDef OC_InitStructure;
TIM_OCStructInit(&OC_InitStructure);
OC_InitStructure.TIM_OCMode = TIM_OCMode_PWM2;
// Channel 1 & 2, left motor
TIM_OC1Init(TIM5, &OC_InitStructure);
TIM_OC1PreloadConfig(TIM5, TIM_OCPreload_Enable);
TIM_OC1PolarityConfig(TIM5, TIM_OCPolarity_High); // pos pwm
TIM_OC2Init(TIM5, &OC_InitStructure);
TIM_OC2PreloadConfig(TIM5, TIM_OCPreload_Enable);
TIM_OC2PolarityConfig(TIM5, TIM_OCPolarity_Low); // neg pwm
// Channel 3 & 4, right motor
TIM_OC3Init(TIM5, &OC_InitStructure);
TIM_OC3PreloadConfig(TIM5, TIM_OCPreload_Enable);
TIM_OC3PolarityConfig(TIM5, TIM_OCPolarity_High); // pos pwm
TIM_OC4Init(TIM5, &OC_InitStructure);
TIM_OC4PreloadConfig(TIM5, TIM_OCPreload_Enable);
TIM_OC4PolarityConfig(TIM5, TIM_OCPolarity_Low); // neg pwm
// Enables the TIM Capture Compare Channels
TIM_CCxCmd(TIM5, TIM_Channel_1, TIM_CCx_Enable);
TIM_CCxCmd(TIM5, TIM_Channel_2, TIM_CCx_Enable);
TIM_CCxCmd(TIM5, TIM_Channel_3, TIM_CCx_Enable);
TIM_CCxCmd(TIM5, TIM_Channel_4, TIM_CCx_Enable);
// Set default value: motor stopped
vMotorsDisable();
// Enables TIM5 peripheral Preload register on ARR
TIM_ARRPreloadConfig(TIM5, ENABLE);
TIM_Cmd(TIM5, ENABLE); // enable timer 5
// Create the beep mutex
xBeepMutex = xSemaphoreCreateMutex();
// Create the daemon
xTaskCreate(vMotorsTask, (const signed char * const)"motorsd",
configMINIMAL_STACK_SIZE, NULL, motors_daemon_priority, NULL);
xTaskCreate(beeping_daemon, (const signed char * const)"motorsd",
configMINIMAL_STACK_SIZE, NULL, beeping_daemon_priority, NULL);
}
static void vMotorsReset()
{
motors_command_t command;
command.motors = 0;
vMotorsApplyCommands(command);
previous_command.motors = 0;
}
/**
* @brief This function handles TIM1 Break, Update, Trigger and Commutation interrupt request.
* @param None
* @retval None
*/
void TIM1_BRK_UP_TRG_COM_IRQHandler(void)
{
/* Clear TIM1 COM pending bit */
TIM_ClearITPendingBit(TIM1, TIM_IT_COM);
if (step == 1)
{
/* Next step: Step 2 Configuration -------------------------------------- */
/* Channel3 configuration */
TIM_CCxCmd(TIM1, TIM_Channel_3, TIM_CCx_Disable);
TIM_CCxNCmd(TIM1, TIM_Channel_3, TIM_CCxN_Disable);
/* Channel1 configuration */
TIM_SelectOCxM(TIM1, TIM_Channel_1, TIM_OCMode_PWM1);
TIM_CCxCmd(TIM1, TIM_Channel_1, TIM_CCx_Enable);
TIM_CCxNCmd(TIM1, TIM_Channel_1, TIM_CCxN_Disable);
/* Channel2 configuration */
TIM_SelectOCxM(TIM1, TIM_Channel_2, TIM_OCMode_PWM1 );
TIM_CCxCmd(TIM1, TIM_Channel_2, TIM_CCx_Disable);
TIM_CCxNCmd(TIM1, TIM_Channel_2, TIM_CCxN_Enable);
step++;
}
else if (step == 2)
{
/* Next step: Step 3 Configuration -------------------------------------- */
/* Channel2 configuration */
TIM_SelectOCxM(TIM1, TIM_Channel_2, TIM_OCMode_PWM1);
TIM_CCxCmd(TIM1, TIM_Channel_2, TIM_CCx_Disable);
TIM_CCxNCmd(TIM1, TIM_Channel_2, TIM_CCxN_Enable);
/* Channel3 configuration */
TIM_SelectOCxM(TIM1, TIM_Channel_3, TIM_OCMode_PWM1);
TIM_CCxCmd(TIM1, TIM_Channel_3, TIM_CCx_Enable);
TIM_CCxNCmd(TIM1, TIM_Channel_3, TIM_CCxN_Disable);
/* Channel1 configuration */
TIM_CCxCmd(TIM1, TIM_Channel_1, TIM_CCx_Disable);
TIM_CCxNCmd(TIM1, TIM_Channel_1, TIM_CCxN_Disable);
step++;
}
else if (step == 3)
{
/* Next step: Step 4 Configuration -------------------------------------- */
/* Channel3 configuration */
TIM_SelectOCxM(TIM1, TIM_Channel_3, TIM_OCMode_PWM1);
TIM_CCxCmd(TIM1, TIM_Channel_3, TIM_CCx_Enable);
TIM_CCxNCmd(TIM1, TIM_Channel_3, TIM_CCxN_Disable);
/* Channel2 configuration */
TIM_CCxCmd(TIM1, TIM_Channel_2, TIM_CCx_Disable);
TIM_CCxNCmd(TIM1, TIM_Channel_2, TIM_CCxN_Disable);
/* Channel1 configuration */
TIM_SelectOCxM(TIM1, TIM_Channel_1, TIM_OCMode_PWM1);
TIM_CCxCmd(TIM1, TIM_Channel_1, TIM_CCx_Disable);
TIM_CCxNCmd(TIM1, TIM_Channel_1, TIM_CCxN_Enable);
step++;
}
else if (step == 4)
{
/* Next step: Step 5 Configuration -------------------------------------- */
/* Channel3 configuration */
TIM_CCxCmd(TIM1, TIM_Channel_3, TIM_CCx_Disable);
TIM_CCxNCmd(TIM1, TIM_Channel_3, TIM_CCxN_Disable);
/* Channel1 configuration */
TIM_SelectOCxM(TIM1, TIM_Channel_1, TIM_OCMode_PWM1);
TIM_CCxCmd(TIM1, TIM_Channel_1, TIM_CCx_Disable);
TIM_CCxNCmd(TIM1, TIM_Channel_1, TIM_CCxN_Enable);
/* Channel2 configuration */
TIM_SelectOCxM(TIM1, TIM_Channel_2, TIM_OCMode_PWM1);
TIM_CCxCmd(TIM1, TIM_Channel_2, TIM_CCx_Enable);
TIM_CCxNCmd(TIM1, TIM_Channel_2, TIM_CCxN_Disable);
step++;
}
else if (step == 5)
{
/* Next step: Step 6 Configuration -------------------------------------- */
/* Channel3 configuration */
TIM_SelectOCxM(TIM1, TIM_Channel_3, TIM_OCMode_PWM1);
TIM_CCxCmd(TIM1, TIM_Channel_3, TIM_CCx_Disable);
TIM_CCxNCmd(TIM1, TIM_Channel_3, TIM_CCxN_Enable);
/* Channel1 configuration */
TIM_CCxCmd(TIM1, TIM_Channel_1, TIM_CCx_Disable);
TIM_CCxNCmd(TIM1, TIM_Channel_1, TIM_CCxN_Disable);
/* Channel2 configuration */
TIM_SelectOCxM(TIM1, TIM_Channel_2, TIM_OCMode_PWM1);
TIM_CCxCmd(TIM1, TIM_Channel_2, TIM_CCx_Enable);
TIM_CCxNCmd(TIM1, TIM_Channel_2, TIM_CCxN_Disable);
step++;
}
else
{
/* Next step: Step 1 Configuration -------------------------------------- */
/* Channel1 configuration */
TIM_SelectOCxM(TIM1, TIM_Channel_1, TIM_OCMode_PWM1);
TIM_CCxCmd(TIM1, TIM_Channel_1, TIM_CCx_Enable);
TIM_CCxNCmd(TIM1, TIM_Channel_2, TIM_CCxN_Disable);
/* Channel3 configuration */
TIM_SelectOCxM(TIM1, TIM_Channel_3, TIM_OCMode_PWM1);
TIM_CCxCmd(TIM1, TIM_Channel_3, TIM_CCx_Disable);
TIM_CCxNCmd(TIM1, TIM_Channel_3, TIM_CCxN_Enable);
/* Channel2 configuration */
TIM_CCxCmd(TIM1, TIM_Channel_2, TIM_CCx_Disable);
TIM_CCxNCmd(TIM1, TIM_Channel_2, TIM_CCxN_Disable);
step = 1;
}
}
/**
* @brief This function handles SysTick Handler.
* @param None
* @retval None
*/
void SysTick_Handler(void)
{
uint8_t *buf;
uint8_t temp1, temp2 = 0x00;
if (DemoEnterCondition == 0x00)
{
TimingDelay_Decrement();
}
else
{
buf = USBD_HID_GetPos();
if((buf[1] != 0) ||(buf[2] != 0))
{
USBD_HID_SendReport (&USB_OTG_dev,
buf,
4);
}
Counter ++;
if (Counter == 10)
{
Buffer[0] = 0;
Buffer[2] = 0;
/* Disable All TIM4 Capture Compare Channels */
TIM_CCxCmd(TIM4, TIM_Channel_1, DISABLE);
TIM_CCxCmd(TIM4, TIM_Channel_2, DISABLE);
TIM_CCxCmd(TIM4, TIM_Channel_3, DISABLE);
TIM_CCxCmd(TIM4, TIM_Channel_4, DISABLE);
LIS302DL_Read(Buffer, LIS302DL_OUT_X_ADDR, 6);
/* Remove the offsets values from data */
Buffer[0] -= X_Offset;
Buffer[2] -= Y_Offset;
/* Update autoreload and capture compare registers value*/
temp1 = ABS((int8_t)(Buffer[0]));
temp2 = ABS((int8_t)(Buffer[2]));
TempAcceleration = MAX(temp1, temp2);
if(TempAcceleration != 0)
{
if ((int8_t)Buffer[0] < -2)
{
/* Enable TIM4 Capture Compare Channel 4 */
TIM_CCxCmd(TIM4, TIM_Channel_4, ENABLE);
/* Sets the TIM4 Capture Compare4 Register value */
TIM_SetCompare4(TIM4, TIM_CCR/TempAcceleration);
}
if ((int8_t)Buffer[0] > 2)
{
/* Enable TIM4 Capture Compare Channel 2 */
TIM_CCxCmd(TIM4, TIM_Channel_2, ENABLE);
/* Sets the TIM4 Capture Compare2 Register value */
TIM_SetCompare2(TIM4, TIM_CCR/TempAcceleration);
}
if ((int8_t)Buffer[2] > 2)
{
/* Enable TIM4 Capture Compare Channel 1 */
TIM_CCxCmd(TIM4, TIM_Channel_1, ENABLE);
/* Sets the TIM4 Capture Compare1 Register value */
TIM_SetCompare1(TIM4, TIM_CCR/TempAcceleration);
}
if ((int8_t)Buffer[2] < -2)
{
/* Enable TIM4 Capture Compare Channel 3 */
TIM_CCxCmd(TIM4, TIM_Channel_3, ENABLE);
/* Sets the TIM4 Capture Compare3 Register value */
TIM_SetCompare3(TIM4, TIM_CCR/TempAcceleration);
}
/* Time base configuration */
TIM_SetAutoreload(TIM4, TIM_ARR/TempAcceleration);
}
Counter = 0x00;
}
}
}
// PE0, TIM16:
void pwm_out3_init(uint16_t frequency)
{
/*
int period = 0;
int psc = 0;
config_pwm_freq((int)frequency, &period, &psc);
TIM_TimeBaseInitTypeDef i;
TIM_OCInitTypeDef j;
GPIO_InitTypeDef g;
i.TIM_CounterMode = TIM_CounterMode_Up;
i.TIM_ClockDivision = 0;
i.TIM_RepetitionCounter = 0;
i.TIM_Prescaler = ((uint16_t)psc)-1;
i.TIM_Period = ((uint16_t)period)-1;
j.TIM_OCMode = TIM_OCMode_PWM1;
j.TIM_OutputState = TIM_OutputState_Enable;
j.TIM_Pulse = 8191;
j.TIM_OCPolarity = TIM_OCPolarity_High;
// PE0
g.GPIO_Mode = GPIO_Mode_AF;
g.GPIO_OType = GPIO_OType_PP;
g.GPIO_Pin = GPIO_Pin_12;
g.GPIO_PuPd = GPIO_PuPd_NOPULL;
g.GPIO_Speed = GPIO_Speed_50MHz;
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource12, GPIO_AF_4); // AF 1, 2, 3, or 9 (TIM15); 1, 4 (TIM16); 1, 2, 10 (TIM2); 2, 4, 6, 9, 11 (TIM1)
GPIO_Init(GPIOA, &g);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM16, ENABLE);
TIM_InternalClockConfig(TIM16);
TIM_TimeBaseInit(TIM16, &i);
TIM_OC1Init(TIM16, &j);
TIM_OC1PreloadConfig(TIM16, TIM_OCPreload_Enable);
TIM_ARRPreloadConfig(TIM16, ENABLE);
TIM_CtrlPWMOutputs(TIM16, ENABLE);
TIM_CCPreloadControl(TIM16, ENABLE);
TIM_CCxCmd(TIM16, TIM_Channel_1, TIM_CCx_Enable);
TIM_Cmd(TIM16, ENABLE);
TIM_GenerateEvent(TIM16, TIM_EventSource_Update);
*/
///////////////////////////////////////////////////
int period = 0;
int psc = 0;
config_pwm_freq((int)frequency, &period, &psc);
TIM_TimeBaseInitTypeDef i;
TIM_OCInitTypeDef j;
GPIO_InitTypeDef g;
i.TIM_CounterMode = TIM_CounterMode_Up;
i.TIM_ClockDivision = 0;
i.TIM_RepetitionCounter = 0;
i.TIM_Prescaler = ((uint16_t)psc)-1;
i.TIM_Period = ((uint16_t)period)-1;
j.TIM_OCMode = TIM_OCMode_PWM1;
j.TIM_OutputState = TIM_OutputState_Enable;
j.TIM_Pulse = 8191;
j.TIM_OCPolarity = TIM_OCPolarity_High;
// PE0
g.GPIO_Mode = GPIO_Mode_AF;
g.GPIO_OType = GPIO_OType_PP;
g.GPIO_Pin = GPIO_Pin_14;
g.GPIO_PuPd = GPIO_PuPd_NOPULL;
g.GPIO_Speed = GPIO_Speed_Level_1;//GPIO_Speed_50MHz;
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOE, ENABLE);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource14, GPIO_AF_2); // AF 1, 2, 3, or 9 (TIM15); 1, 4 (TIM16); 1, 2, 10 (TIM2); 2, 4, 6, 9, 11, 12 (TIM1)
GPIO_Init(GPIOE, &g);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);
TIM_InternalClockConfig(TIM1);
TIM_TimeBaseInit(TIM1, &i);
TIM_OC4Init(TIM1, &j);
TIM_OC4PreloadConfig(TIM1, TIM_OCPreload_Enable);
TIM_ARRPreloadConfig(TIM1, ENABLE);
TIM_CtrlPWMOutputs(TIM1, ENABLE);
// TIM_CCPreloadControl(TIM1, ENABLE);
TIM_CCxCmd(TIM1, TIM_Channel_4, TIM_CCx_Enable);
TIM_Cmd(TIM1, ENABLE);
TIM_GenerateEvent(TIM1, TIM_EventSource_Update);
}
void ConfigKernel()
{
//настраиваем ADC порт Current
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOA, &GPIO_InitStructure);
//Voltage
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
GPIO_Init(GPIOB, &GPIO_InitStructure);
DMA_InitTypeDef DMA_InitStructure;
/* DMA1 Channel1 Config */
DMA_DeInit(DMA1_Channel1);
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)ADC1_DR_Address;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)RegularConvData_Tab;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = 2;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel1, &DMA_InitStructure);
/* DMA1 Channel1 enable */
DMA_Cmd(DMA1_Channel1, ENABLE);
/* ADC DMA request in circular mode */
ADC_DMARequestModeConfig(ADC1, ADC_DMAMode_Circular);
/* Enable ADC_DMA */
ADC_DMACmd(ADC1, ENABLE);
/* ADC1 configuration ---------------*/
ADC_InitTypeDef ADC_InitStructure;
ADC_DeInit(ADC1);
ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;// DISABLE; // вкл/выкл непрерывное преобразование
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;// выравнивание
ADC_InitStructure.ADC_Resolution=ADC_Resolution_12b;
ADC_InitStructure.ADC_ExternalTrigConv=ADC_ExternalTrigConv_T15_TRGO;//чтобы ошибка не срабатывала
ADC_InitStructure.ADC_ExternalTrigConvEdge=ADC_ExternalTrigConvEdge_None;
ADC_InitStructure.ADC_ScanDirection=ADC_ScanDirection_Upward;
ADC_Init(ADC1, &ADC_InitStructure);
/* ADC1 regular channel configuration */
ADC_ChannelConfig(ADC1, ADC_Channel_6, ADC_SampleTime_55_5Cycles);//current
ADC_ChannelConfig(ADC1, ADC_Channel_9, ADC_SampleTime_55_5Cycles);//voltage
/* Check the end of ADC1 reset calibration register */
ADC_GetCalibrationFactor(ADC1);
/* Enable ADC1 */
ADC_Cmd(ADC1, ENABLE);
/* DMA1 Channel1 enable */
DMA_Cmd(DMA1_Channel1, ENABLE);
/* ADC DMA request in circular mode */
ADC_DMARequestModeConfig(ADC1, ADC_DMAMode_Circular);
/* Enable ADC_DMA */
ADC_DMACmd(ADC1, ENABLE);
/* Wait the ADCEN falg */
while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_ADEN));
//настраиваем TIM2_CH2
/* GPIOA Configuration: Channel 2 PA1*/
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_DOWN ;
GPIO_Init(GPIOA, &GPIO_InitStructure);
//прикрепляем АФ к таймеру 2
GPIO_PinAFConfig(GPIOA, GPIO_PinSource1, GPIO_AF_2);
TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
/* Time Base configuration */
TIM_TimeBaseStructure.TIM_Period = TimerPeriod;
//TIM_TimeBaseStructure.TIM_Prescaler =3;
TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);
TIM_OCStructInit(&TIM_OCInitStructure);
/* Channel 2 Configuration in PWM mode */
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
TIM_OCInitStructure.TIM_Pulse = Channel2CCR;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
//TIM_OCInitStructure.TIM_OutputNState = TIM_OutputNState_Enable; //Not use N port
#ifdef INVERSEN
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_Low;
//TIM_OCInitStructure.TIM_OCNPolarity = TIM_OCNPolarity_High; //Not use N port
TIM_OCInitStructure.TIM_OCIdleState = TIM_OCIdleState_Set;
//TIM_OCInitStructure.TIM_OCNIdleState = TIM_OCIdleState_Reset; //Not use N port
#else
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
//TIM_OCInitStructure.TIM_OCNPolarity = TIM_OCNPolarity_Low; //Not use N port
TIM_OCInitStructure.TIM_OCIdleState = TIM_OCIdleState_Reset;
//TIM_OCInitStructure.TIM_OCNIdleState = TIM_OCIdleState_Set; //Not use N port
#endif
TIM_OC2Init(TIM2, &TIM_OCInitStructure);
// Как я понял - автоматическая перезарядка таймера.
TIM_OC2PreloadConfig(TIM2, TIM_OCPreload_Enable);
TIM_ARRPreloadConfig(TIM2, ENABLE);
TIM_CCxCmd(TIM2, TIM_Channel_2, TIM_CCx_Enable);
/* TIM2 counter enable */
TIM_Cmd(TIM2, ENABLE);
ADC_StartOfConversion(ADC1);
State=StateStart;
}
void initPWMInput()
{
GPIO_InitTypeDef GPIO_InitStructure;
//TIM3 as PWM input
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
GPIO_Init(GPIOA, &GPIO_InitStructure);
//PA7 as DIR pin
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
GPIO_Init(GPIOA, &GPIO_InitStructure);
//PA5 as ENA pin
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
GPIO_Init(GPIOA, &GPIO_InitStructure);
EXTI_InitTypeDef EXTI_initStructure;
EXTI_initStructure.EXTI_Line = EXTI_Line5;
EXTI_initStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_initStructure.EXTI_Trigger = EXTI_Trigger_Rising_Falling;
EXTI_initStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_initStructure);
NVIC_InitTypeDef nvicStructure;
nvicStructure.NVIC_IRQChannel = EXTI9_5_IRQn;
nvicStructure.NVIC_IRQChannelPreemptionPriority = 0;
nvicStructure.NVIC_IRQChannelSubPriority = 2;
nvicStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&nvicStructure);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
TIM_TimeBaseStructure.TIM_Prescaler = 1;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseStructure.TIM_Period = 65535;
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;
TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);
TIM_ICInitTypeDef TIM_ICInit;
#if STEP_POLARITY == 1
TIM_ICInit.TIM_ICPolarity = TIM_ICPolarity_Rising;
#else
TIM_ICInit.TIM_ICPolarity = TIM_ICPolarity_Falling;
#endif
TIM_ICInit.TIM_ICFilter = 5;
TIM_ICInit.TIM_Channel = TIM_Channel_1;
TIM_ICInit.TIM_ICPrescaler = TIM_ICPSC_DIV1;
TIM_ICInit.TIM_ICSelection = TIM_ICSelection_DirectTI;
TIM_PWMIConfig(TIM3, &TIM_ICInit);
TIM_CCxCmd(TIM3, TIM_Channel_1, ENABLE);
TIM_CCxCmd(TIM3, TIM_Channel_2, ENABLE);
TIM_SelectInputTrigger(TIM3,TIM_TS_TI1FP1);
TIM_SelectSlaveMode(TIM3, TIM_SlaveMode_Reset);
TIM_ITConfig(TIM3, TIM_IT_CC1 | TIM_IT_Update, ENABLE);
TIM_Cmd(TIM3,ENABLE);
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
/**
* Initialize the LEDs and other GPIO on the actual PCB.
*/
void gpioInit() {
GPIO_InitTypeDef gpio;
TIM_ICInitTypeDef ic;
TIM_OCInitTypeDef oc;
TIM_TimeBaseInitTypeDef tim;
// Reset RSSI structure
rssiData.rssi = 0U;
rssiData.lastValue = 0U;
rssiData.flags = 0x00;
// Set up clocks
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
// Power on TIM5
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM5, ENABLE);
// Set up LED pin
gpio.GPIO_Pin = GPIO_Pin_13;
gpio.GPIO_Mode = GPIO_Mode_OUT;
gpio.GPIO_OType = GPIO_OType_PP;
gpio.GPIO_PuPd = GPIO_PuPd_NOPULL;
gpio.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOC, &gpio);
// Set up the RSSI pin as alternate function input pull-up
gpio.GPIO_Pin = GPIO_Pin_1;
gpio.GPIO_Mode = GPIO_Mode_AF;
GPIO_Init(GPIOA, &gpio);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource1, GPIO_AF_TIM5);
// Set up TIM1 to tick at 1us, auto reload at maximum (200 us expected max PWM width)
// APB1 = SYSCLK/4 = 168/4 = 42 MHz
tim.TIM_ClockDivision = TIM_CKD_DIV1;
tim.TIM_CounterMode = TIM_CounterMode_Up;
tim.TIM_Prescaler = 83U;
tim.TIM_Period = 0xFFFFFFFFU;
tim.TIM_RepetitionCounter = 0U;
TIM_TimeBaseInit(TIM5, &tim);
// Set up TIM5 for input capture on channel 2
ic.TIM_Channel = TIM_Channel_2;
ic.TIM_ICPolarity = TIM_ICPolarity_Rising;
ic.TIM_ICSelection = TIM_ICSelection_DirectTI;
ic.TIM_ICPrescaler = TIM_ICPSC_DIV1;
ic.TIM_ICFilter = 0U;
TIM_ICInit(TIM5, &ic);
// Set up TIM5 compare interrupt OC1 for the "timed out" indicator
oc.TIM_OCMode = TIM_OCMode_Timing;
oc.TIM_OCIdleState = TIM_OCIdleState_Reset;
oc.TIM_OCNIdleState = TIM_OCNIdleState_Reset;
oc.TIM_OCPolarity = TIM_OCPolarity_High;
oc.TIM_OCNPolarity = TIM_OCNPolarity_High;
oc.TIM_OutputState = TIM_OutputState_Disable;
oc.TIM_OutputNState = TIM_OutputState_Disable;
TIM_OC1Init(TIM5, &oc);
// Turn on the capture/compare lines
TIM_SetCounter(TIM5, 0U);
TIM5->CCR1 = 200U;
TIM_CCxCmd(TIM5, TIM_Channel_2, TIM_CCx_Enable);
// Enable the TIM5 interrupts
TIM_ITConfig(TIM5, TIM_IT_CC1, ENABLE);
TIM_ITConfig(TIM5, TIM_IT_CC2, ENABLE);
// Enable TIM5
TIM_Cmd(TIM5, ENABLE);
NVIC_SetPriority(TIM5_IRQn, 4);
NVIC_EnableIRQ(TIM5_IRQn);
}
/**
* @brief This function handles SysTick Handler.
* @param None
* @retval None
*/
void SysTick_Handler(void)
{
uint8_t temp1, temp2 = 0;
if (TimingDelay != 0x00)
{
TimingDelay_Decrement();
}
else
{
Counter ++;
if (Counter == 10)
{
Buffer[0] = 0;
Buffer[2] = 0;
/* Disable All TIM4 Capture Compare Channels */
TIM_CCxCmd(TIM4, TIM_Channel_1, DISABLE);
TIM_CCxCmd(TIM4, TIM_Channel_2, DISABLE);
TIM_CCxCmd(TIM4, TIM_Channel_3, DISABLE);
TIM_CCxCmd(TIM4, TIM_Channel_4, DISABLE);
LIS302DL_Read(Buffer, LIS302DL_OUT_X_ADDR, 6);
/* Remove the offsets values from data */
Buffer[0] -= XOffset;
Buffer[2] -= YOffset;
/* Update autoreload and capture compare registers value*/
temp1 = ABS((int8_t)(Buffer[0]));
temp2 = ABS((int8_t)(Buffer[2]));
TempAcceleration = MAX(temp1, temp2);
if(TempAcceleration != 0)
{
if ((int8_t)Buffer[0] < -2)
{
/* Enable TIM4 Capture Compare Channel 4 */
TIM_CCxCmd(TIM4, TIM_Channel_4, ENABLE);
/* Sets the TIM4 Capture Compare4 Register value */
TIM_SetCompare4(TIM4, TIM_CCR/TempAcceleration);
}
if ((int8_t)Buffer[0] > 2)
{
/* Enable TIM4 Capture Compare Channel 2 */
TIM_CCxCmd(TIM4, TIM_Channel_2, ENABLE);
/* Sets the TIM4 Capture Compare2 Register value */
TIM_SetCompare2(TIM4, TIM_CCR/TempAcceleration);
}
if ((int8_t)Buffer[2] > 2)
{
/* Enable TIM4 Capture Compare Channel 1 */
TIM_CCxCmd(TIM4, TIM_Channel_1, ENABLE);
/* Sets the TIM4 Capture Compare1 Register value */
TIM_SetCompare1(TIM4, TIM_CCR/TempAcceleration);
}
if ((int8_t)Buffer[2] < -2)
{
/* Enable TIM4 Capture Compare Channel 3 */
TIM_CCxCmd(TIM4, TIM_Channel_3, ENABLE);
/* Sets the TIM4 Capture Compare3 Register value */
TIM_SetCompare3(TIM4, TIM_CCR/TempAcceleration);
}
/* Time base configuration */
TIM_SetAutoreload(TIM4, TIM_ARR/TempAcceleration);
/* Read click status register */
LIS302DL_Read(&ClickReg, LIS302DL_CLICK_SRC_REG_ADDR, 1);
if(ClickReg == SINGLECLICK_Z)
{
SingleClickDetect = 0x01;
}
}
Counter = 0x00;
}
}
}
/**
* @brief Execute the demo application.
* @param None
* @retval None
*/
static void Demo_Exec(void)
{
RCC_ClocksTypeDef RCC_Clocks;
uint8_t togglecounter = 0x00;
while(1)
{
DemoEnterCondition = 0x00;
/* Reset UserButton_Pressed variable */
UserButtonPressed = 0x00;
/* Initialize LEDs to be managed by GPIO */
STM_EVAL_LEDInit(LED4);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED5);
STM_EVAL_LEDInit(LED6);
/* SysTick end of count event each 10ms */
RCC_GetClocksFreq(&RCC_Clocks);
SysTick_Config(RCC_Clocks.HCLK_Frequency / 100);
/* Turn OFF all LEDs */
STM_EVAL_LEDOff(LED4);
STM_EVAL_LEDOff(LED3);
STM_EVAL_LEDOff(LED5);
STM_EVAL_LEDOff(LED6);
/* Waiting User Button is pressed */
while (UserButtonPressed == 0x00)
{
/* Toggle LED4 */
STM_EVAL_LEDToggle(LED4);
Delay(10);
/* Toggle LED4 */
STM_EVAL_LEDToggle(LED3);
Delay(10);
/* Toggle LED4 */
STM_EVAL_LEDToggle(LED5);
Delay(10);
/* Toggle LED4 */
STM_EVAL_LEDToggle(LED6);
Delay(10);
togglecounter ++;
if (togglecounter == 0x10)
{
togglecounter = 0x00;
while (togglecounter < 0x10)
{
STM_EVAL_LEDToggle(LED4);
STM_EVAL_LEDToggle(LED3);
STM_EVAL_LEDToggle(LED5);
STM_EVAL_LEDToggle(LED6);
Delay(10);
togglecounter ++;
}
togglecounter = 0x00;
}
}
/* Waiting User Button is Released */
while (STM_EVAL_PBGetState(BUTTON_USER) == Bit_SET)
{}
UserButtonPressed = 0x00;
/* TIM4 channels configuration */
TIM4_Config();
/* Disable all Timer4 channels */
TIM_CCxCmd(TIM4, TIM_Channel_1, DISABLE);
TIM_CCxCmd(TIM4, TIM_Channel_2, DISABLE);
TIM_CCxCmd(TIM4, TIM_Channel_3, DISABLE);
TIM_CCxCmd(TIM4, TIM_Channel_4, DISABLE);
/* MEMS configuration */
LIS302DL_InitStruct.Power_Mode = LIS302DL_LOWPOWERMODE_ACTIVE;
LIS302DL_InitStruct.Output_DataRate = LIS302DL_DATARATE_100;
LIS302DL_InitStruct.Axes_Enable = LIS302DL_XYZ_ENABLE;
LIS302DL_InitStruct.Full_Scale = LIS302DL_FULLSCALE_2_3;
LIS302DL_InitStruct.Self_Test = LIS302DL_SELFTEST_NORMAL;
LIS302DL_Init(&LIS302DL_InitStruct);
/* Required delay for the MEMS Accelerometre: Turn-on time = 3/Output data Rate
= 3/100 = 30ms */
Delay(30);
DemoEnterCondition = 0x01;
/* MEMS High Pass Filter configuration */
LIS302DL_FilterStruct.HighPassFilter_Data_Selection = LIS302DL_FILTEREDDATASELECTION_OUTPUTREGISTER;
LIS302DL_FilterStruct.HighPassFilter_CutOff_Frequency = LIS302DL_HIGHPASSFILTER_LEVEL_1;
LIS302DL_FilterStruct.HighPassFilter_Interrupt = LIS302DL_HIGHPASSFILTERINTERRUPT_1_2;
LIS302DL_FilterConfig(&LIS302DL_FilterStruct);
LIS302DL_Read(Buffer, LIS302DL_OUT_X_ADDR, 6);
X_Offset = Buffer[0];
Y_Offset = Buffer[2];
Z_Offset = Buffer[4];
/* USB configuration */
Demo_USBConfig();
/* Waiting User Button is pressed */
while (UserButtonPressed == 0x00)
{}
/* Waiting User Button is Released */
while (STM_EVAL_PBGetState(BUTTON_USER) == Bit_SET)
{}
/* Disable SPI1 used to drive the MEMS accelerometre */
SPI_Cmd(LIS302DL_SPI, DISABLE);
/* Disconnect the USB device */
DCD_DevDisconnect(&USB_OTG_dev);
USB_OTG_StopDevice(&USB_OTG_dev);
}
}
/**
* @brief This function handles SysTick Handler.
* @param None
* @retval None
*/
void SysTick_Handler(void)
{
uint8_t temp1, temp2 = 0x00;
if (DemoEnterCondition == 0x00)
{
TimingDelay_Decrement();
}
else
{
// Wysy³anie danych USB
for(int i = 0; i <= 3; i++){
APP_Rx_Buffer[APP_Rx_ptr_in] = Buffer[i];
APP_Rx_ptr_in++;
/* To avoid buffer overflow */
if(APP_Rx_ptr_in == APP_RX_DATA_SIZE)
{
APP_Rx_ptr_in = 0;
}
}
// Koniec
// buf = USBD_HID_GetPos();
// if((buf[1] != 0) ||(buf[2] != 0))
// {
// USBD_HID_SendReport (&USB_OTG_dev,
// buf,
// 4);
// }
Counter ++;
if (Counter == 10)
{
Buffer[0] = 0;
Buffer[2] = 0;
/* Disable All TIM4 Capture Compare Channels */
TIM_CCxCmd(TIM4, TIM_Channel_1, DISABLE);
TIM_CCxCmd(TIM4, TIM_Channel_2, DISABLE);
TIM_CCxCmd(TIM4, TIM_Channel_3, DISABLE);
TIM_CCxCmd(TIM4, TIM_Channel_4, DISABLE);
LIS302DL_Read(Buffer, LIS302DL_OUT_X_ADDR, 6);
/* Remove the offsets values from data */
Buffer[0] -= X_Offset;
Buffer[2] -= Y_Offset;
/* Update autoreload and capture compare registers value*/
temp1 = ABS((int8_t)(Buffer[0]));
temp2 = ABS((int8_t)(Buffer[2]));
TempAcceleration = MAX(temp1, temp2);
if(TempAcceleration != 0)
{
if ((int8_t)Buffer[0] < -2)
{
/* Enable TIM4 Capture Compare Channel 4 */
TIM_CCxCmd(TIM4, TIM_Channel_4, ENABLE);
/* Sets the TIM4 Capture Compare4 Register value */
TIM_SetCompare4(TIM4, TIM_CCR/TempAcceleration);
}
if ((int8_t)Buffer[0] > 2)
{
/* Enable TIM4 Capture Compare Channel 2 */
TIM_CCxCmd(TIM4, TIM_Channel_2, ENABLE);
/* Sets the TIM4 Capture Compare2 Register value */
TIM_SetCompare2(TIM4, TIM_CCR/TempAcceleration);
}
if ((int8_t)Buffer[2] > 2)
{
/* Enable TIM4 Capture Compare Channel 1 */
TIM_CCxCmd(TIM4, TIM_Channel_1, ENABLE);
/* Sets the TIM4 Capture Compare1 Register value */
TIM_SetCompare1(TIM4, TIM_CCR/TempAcceleration);
}
if ((int8_t)Buffer[2] < -2)
{
/* Enable TIM4 Capture Compare Channel 3 */
TIM_CCxCmd(TIM4, TIM_Channel_3, ENABLE);
/* Sets the TIM4 Capture Compare3 Register value */
TIM_SetCompare3(TIM4, TIM_CCR/TempAcceleration);
}
/* Time base configuration */
TIM_SetAutoreload(TIM4, TIM_ARR/TempAcceleration);
}
Counter = 0x00;
}
}
}
//互补输出使能
void pwm_set_on(TIM_TypeDef* TIMx, uint16_t TIM_Channel)
{
TIM_SelectOCxM(TIMx, TIM_Channel, TIM_OCMode_PWM1);
TIM_CCxCmd(TIMx, TIM_Channel, TIM_CCx_Enable);
TIM_CCxNCmd(TIMx, TIM_Channel, TIM_CCxN_Enable);
}
/**
* @brief Configures the TIM Peripheral.
* @param None
* @retval None
*/
static void TIM4_Config(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
TIM_OCInitTypeDef TIM_OCInitStructure;
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
/* --------------------------- System Clocks Configuration -----------------*/
/* TIM4 clock enable */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
/* GPIOD clock enable */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
/*-------------------------- GPIO Configuration ----------------------------*/
/* GPIOD Configuration: Pins 12, 13, 14 and 15 in output push-pull */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOD, &GPIO_InitStructure);
/* Connect TIM4 pins to AF2 */
GPIO_PinAFConfig(GPIOD, GPIO_PinSource12, GPIO_AF_TIM4);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource13, GPIO_AF_TIM4);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource14, GPIO_AF_TIM4);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource15, GPIO_AF_TIM4);
/* -----------------------------------------------------------------------
TIM4 Configuration: Output Compare Timing Mode:
In this example TIM4 input clock (TIM4CLK) is set to 2 * APB1 clock (PCLK1),
since APB1 prescaler is different from 1 (APB1 Prescaler = 4, see system_stm32f4xx.c file).
TIM4CLK = 2 * PCLK1
PCLK1 = HCLK / 4
=> TIM4CLK = 2*(HCLK / 4) = HCLK/2 = SystemCoreClock/2
To get TIM4 counter clock at 2 KHz, the prescaler is computed as follows:
Prescaler = (TIM4CLK / TIM1 counter clock) - 1
Prescaler = (168 MHz/(2 * 2 KHz)) - 1 = 41999
To get TIM4 output clock at 1 Hz, the period (ARR)) is computed as follows:
ARR = (TIM4 counter clock / TIM4 output clock) - 1
= 1999
TIM4 Channel1 duty cycle = (TIM4_CCR1/ TIM4_ARR)* 100 = 50%
TIM4 Channel2 duty cycle = (TIM4_CCR2/ TIM4_ARR)* 100 = 50%
TIM4 Channel3 duty cycle = (TIM4_CCR3/ TIM4_ARR)* 100 = 50%
TIM4 Channel4 duty cycle = (TIM4_CCR4/ TIM4_ARR)* 100 = 50%
==> TIM4_CCRx = TIM4_ARR/2 = 1000 (where x = 1, 2, 3 and 4).
Note:
SystemCoreClock variable holds HCLK frequency and is defined in system_stm32f4xx.c file.
Each time the core clock (HCLK) changes, user had to call SystemCoreClockUpdate()
function to update SystemCoreClock variable value. Otherwise, any configuration
based on this variable will be incorrect.
----------------------------------------------------------------------- */
/* Compute the prescaler value */
PrescalerValue = (uint16_t) ((SystemCoreClock /2) / 2000) - 1;
/* Time base configuration */
TIM_TimeBaseStructure.TIM_Period = TIM_ARR;
TIM_TimeBaseStructure.TIM_Prescaler = PrescalerValue;
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);
/* Enable TIM4 Preload register on ARR */
TIM_ARRPreloadConfig(TIM4, ENABLE);
/* TIM PWM1 Mode configuration: Channel */
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = TIM_CCR;
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
/* Output Compare PWM1 Mode configuration: Channel1 */
TIM_OC1Init(TIM4, &TIM_OCInitStructure);
TIM_CCxCmd(TIM4, TIM_Channel_1, DISABLE);
TIM_OC1PreloadConfig(TIM4, TIM_OCPreload_Enable);
/* Output Compare PWM1 Mode configuration: Channel2 */
TIM_OC2Init(TIM4, &TIM_OCInitStructure);
TIM_CCxCmd(TIM4, TIM_Channel_2, DISABLE);
TIM_OC2PreloadConfig(TIM4, TIM_OCPreload_Enable);
/* Output Compare PWM1 Mode configuration: Channel3 */
TIM_OC3Init(TIM4, &TIM_OCInitStructure);
TIM_CCxCmd(TIM4, TIM_Channel_3, DISABLE);
TIM_OC3PreloadConfig(TIM4, TIM_OCPreload_Enable);
/* Output Compare PWM1 Mode configuration: Channel4 */
TIM_OC4Init(TIM4, &TIM_OCInitStructure);
TIM_CCxCmd(TIM4, TIM_Channel_4, DISABLE);
TIM_OC4PreloadConfig(TIM4, TIM_OCPreload_Enable);
/* TIM4 enable counter */
TIM_Cmd(TIM4, ENABLE);
}
//输出比较关断
void pwm_set_off(TIM_TypeDef* TIMx, uint16_t TIM_Channel)
{
TIM_CCxCmd(TIMx, TIM_Channel, TIM_CCx_Disable);
TIM_CCxNCmd(TIMx, TIM_Channel, TIM_CCxN_Disable);
}
void vMotorsInit(unsigned portBASE_TYPE motorsDaemonPriority_)
{
// Enable GPIOA & GPIOC clock
vGpioClockInit(GPIOA);
vGpioClockInit(GPIOC);
// Enable TIM2 clock
vTimerClockInit(TIM2);
// Motors PWM: MOTOR1=left, MOTOR2=right ; A and B have opposed polarity
GPIO_InitTypeDef GPIO_InitStructure1 =
{
.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | // MOTOR2_B, MOTOR2_A
GPIO_Pin_2 | GPIO_Pin_3 , // MOTOR1_B, MOTOR1_A
.GPIO_Mode = GPIO_Mode_AF_PP, // alternate function push pull
.GPIO_Speed = GPIO_Speed_2MHz
};
GPIO_Init(GPIOA, &GPIO_InitStructure1);
// Motors enable pin
GPIO_InitTypeDef GPIO_InitStructure2 =
{
.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1, // MOTOR1_EN, MOTOR2_EN
.GPIO_Mode = GPIO_Mode_Out_PP, // push pull
.GPIO_Speed = GPIO_Speed_2MHz
};
GPIO_Init(GPIOC, &GPIO_InitStructure2);
// Set output compare interrupt flags of channels configured in output
// (CCxS=00 in TIMx_CCMRx register) when counting up and down
TIM_CounterModeConfig(TIM2, TIM_CounterMode_CenterAligned3);
TIM_TimeBaseInitTypeDef Timer_InitStructure =
{
.TIM_ClockDivision = TIM_CKD_DIV1,
.TIM_Prescaler = DEFAULT_PSC,
.TIM_Period = PERIOD,
.TIM_CounterMode = TIM_CounterMode_Up
};
TIM_TimeBaseInit(TIM2, &Timer_InitStructure);
// Output Compare Init :
TIM_OCInitTypeDef OC_InitStructure;
TIM_OCStructInit(&OC_InitStructure);
OC_InitStructure.TIM_OCMode = TIM_OCMode_PWM1;
// Channel 1 & 2, left motor
TIM_OC1Init(TIM2, &OC_InitStructure);
TIM_OC1PreloadConfig(TIM2, TIM_OCPreload_Enable);
TIM_OC1PolarityConfig(TIM2, TIM_OCPolarity_High); // pos pwm
TIM_OC2Init(TIM2, &OC_InitStructure);
TIM_OC2PreloadConfig(TIM2, TIM_OCPreload_Enable);
TIM_OC2PolarityConfig(TIM2, TIM_OCPolarity_Low); // neg pwm
// Channel 3 & 4, right motor
TIM_OC3Init(TIM2, &OC_InitStructure);
TIM_OC3PreloadConfig(TIM2, TIM_OCPreload_Enable);
TIM_OC3PolarityConfig(TIM2, TIM_OCPolarity_High); // pos pwm
TIM_OC4Init(TIM2, &OC_InitStructure);
TIM_OC4PreloadConfig(TIM2, TIM_OCPreload_Enable);
TIM_OC4PolarityConfig(TIM2, TIM_OCPolarity_Low); // neg pwm
// Enables the TIM Capture Compare Channels
TIM_CCxCmd(TIM2, TIM_Channel_1, TIM_CCx_Enable);
TIM_CCxCmd(TIM2, TIM_Channel_2, TIM_CCx_Enable);
TIM_CCxCmd(TIM2, TIM_Channel_3, TIM_CCx_Enable);
TIM_CCxCmd(TIM2, TIM_Channel_4, TIM_CCx_Enable);
// Set default value: motors stopped
vMotorsDisable();
// Enables TIM peripheral Preload register on ARR
TIM_ARRPreloadConfig(TIM2, ENABLE);
TIM_Cmd(TIM2, ENABLE); // enable timer
// Create the daemon
xTaskCreate(vMotorsTask, (const signed char * const)"motorsd",
configMINIMAL_STACK_SIZE, NULL, motorsDaemonPriority_, NULL);
}
static void vMotorsReset()
{
previousCommand.motors = 0;
vMotorsApplyCommands(previousCommand);
}
void vMotorsEnable()
{
// We first stop the motors
vMotorsReset();
GPIO_SetBits(GPIOC, GPIO_Pin_0);
GPIO_SetBits(GPIOC, GPIO_Pin_1);
}
/* set phase to "negative without PWM */
void pwm_set_low(TIM_TypeDef* TIMx, uint16_t TIM_Channel)
{
TIM_SelectOCxM(TIMx, TIM_Channel, TIM_ForcedAction_InActive);
TIM_CCxCmd(TIMx, TIM_Channel, TIM_CCx_Disable);
TIM_CCxNCmd(TIMx, TIM_Channel, TIM_CCxN_Enable);
}
