void TIM3_IRQHandler(void) {
GPIO_SetBits(GPIOD, GPIO_Pin_13);
static uint16_t total_len = 0;
static uint16_t pulse = 0;
static uint16_t capture = 0;
static uint8_t updown = 0;
static uint8_t channel = 0;
static uint8_t mchannel = 0;
if (TIM_GetITStatus(TIM3, TIM_IT_CC3) != RESET) {
TIM_ClearITPendingBit(TIM3, TIM_IT_CC3);
capture = TIM_GetCapture3(TIM3);
if (GPIO_ReadInputDataBit(PPM1_OUTPUT_PORT, PPM1_OUTPUT_PIN) != 0) {
updown = 1;
} else {
updown = 0;
}
if (updown == 0) {
pulse = 300;
TIM_SetCompare3(TIM3, capture + pulse * PPM_SCALE);
total_len += pulse;
} else {
if (channel < 8) {
pulse = (1000 - 300 + ppm_channel_values[channel]);
TIM_SetCompare3(TIM3, capture + pulse * PPM_SCALE);
total_len += pulse;
channel++;
} else {
TIM_SetCompare3(TIM3, capture + (7000) * PPM_SCALE);
channel = 0;
total_len = 0;
}
}
}
}
void loop(void) {
int32_t data[3];
LIS302DL_ReadACC(data);
int32_t x = cround(data[0], 300)/5;
int32_t y = cround(data[1], 300)/5;
TIM_SetCompare1(TIM4, 0);
TIM_SetCompare2(TIM4, 0);
TIM_SetCompare3(TIM4, 0);
TIM_SetCompare4(TIM4, 0);
if ( x > 0 ) {
TIM_SetCompare2(TIM4, x);
}
else {
TIM_SetCompare4(TIM4, -x);
}
if ( y > 0 ) {
TIM_SetCompare1(TIM4, y);
}
else {
TIM_SetCompare3(TIM4, -y);
}
delay(10);
}
void setRightMotor(int32_t m_speed){
if(m_speed >= 0){
TIM_SetCompare3(TIM4, m_speed);
TIM_SetCompare4(TIM4, 0);
}else{
TIM_SetCompare3(TIM4, 0);
TIM_SetCompare4(TIM4, -m_speed);
}
}
/*
last 500
*/
void dc_moter_setspeed(int flag,int speed)
{
switch(flag)
{
case 1: TIM_SetCompare3(TIM3,speed); break;
case 2: TIM_SetCompare4(TIM3,speed); break;
case 3: TIM_SetCompare3(TIM4,speed); break;
case 4: TIM_SetCompare4(TIM4,speed); break;
}
}
/********************************************************************************************************
Function Name: SetMotor2PWM
Description :
Inputs : xpwm
Outputs : None
Notes :
Revision :
********************************************************************************************************/
void SetMotor2PWM(s16 xpwm)
{
if(xpwm < 0)
{
MOTOR2_DIR_L;
TIM_SetCompare3(MOTOR_TIM,0-xpwm);
}
else
{
MOTOR2_DIR_H;
TIM_SetCompare3(MOTOR_TIM,MOTOR_Period-xpwm);
}
}
/************************************************************************************************
* 函数名：turn_to_left
* 函数作用：控制小车右转
* 参数：yscs (预设次数) 预设光电传感器输出方波的次数 pwm_x 时分别给左右两个电机输出不同占空比的pwm波
* 库版本 ：ST3.5.0
*************************************************************************************************/
void turn_to_left( u16 pwm_1 , u16 pwm_2,u16 yanshi )
{
//yushe_cishu=yscs;
TIM_SetCompare1(TIM4,pwm_1);//设置电机的初始pwn波 1、2是控制右侧的电机，3、4控制左侧的电机。1、3是前进,2、4是后退。
TIM_SetCompare2(TIM4,0);
TIM_SetCompare3(TIM4,0);
TIM_SetCompare4(TIM4,pwm_2);
delay_ms(yanshi);//根据实际情况更改
TIM_SetCompare1(TIM4,0);//设置电机的初始pwn波 1、2是控制右侧的电机，3、4控制左侧的电机。1、3是前进,2、4是后退。
TIM_SetCompare2(TIM4,0);
TIM_SetCompare3(TIM4,0);
TIM_SetCompare4(TIM4,0);
}
void Move (uint8_t chan, float angle, servo type)
{
switch(chan)
{
case 1:
TIM_SetCompare1(TIM12, AngleToDuty(angle, type));
break;
case 2:
TIM_SetCompare2(TIM12, AngleToDuty(angle, type));
break;
case 3:
TIM_SetCompare1(TIM3, AngleToDuty(angle, type));
break;
case 4:
TIM_SetCompare2(TIM3, AngleToDuty(angle, type));
break;
case 5:
TIM_SetCompare3(TIM3, AngleToDuty(angle, type));
break;
case 6:
TIM_SetCompare1(TIM4, AngleToDuty(angle, type));
break;
case 7:
TIM_SetCompare2(TIM4, AngleToDuty(angle, type));
break;
case 8:
TIM_SetCompare3(TIM4, AngleToDuty(angle, type));
break;
case 9:
TIM_SetCompare4(TIM4, AngleToDuty(angle, type));
break;
case 10:
TIM_SetCompare1(TIM4, AngleToDuty(angle, type));
break;
default:
break;
}
}
/**
* @brief This function handles TIM4 global interrupt request.
* @param None
* @retval None
*/
void TIM4_IRQHandler(void)
{
uint16_t capture = 0;
/* TIM4_CH1 toggling */
if (TIM_GetITStatus(TIM4, TIM_IT_CC1) != RESET)
{
TIM_ClearITPendingBit(TIM4, TIM_IT_CC1 );
capture = TIM_GetCapture1(TIM4);
TIM_SetCompare1(TIM4, capture + Channel1Pulse );
}
/* TIM4_CH2 toggling */
if (TIM_GetITStatus(TIM4, TIM_IT_CC2) != RESET)
{
TIM_ClearITPendingBit(TIM4, TIM_IT_CC2);
capture = TIM_GetCapture2(TIM4);
TIM_SetCompare2(TIM4, capture + Channel2Pulse);
}
/* TIM4_CH3 toggling */
if (TIM_GetITStatus(TIM4, TIM_IT_CC3) != RESET)
{
TIM_ClearITPendingBit(TIM4, TIM_IT_CC3);
capture = TIM_GetCapture3(TIM4);
TIM_SetCompare3(TIM4, capture + Channel3Pulse);
}
/* TIM4_CH4 toggling */
if (TIM_GetITStatus(TIM4, TIM_IT_CC4) != RESET)
{
TIM_ClearITPendingBit(TIM4, TIM_IT_CC4);
capture = TIM_GetCapture4(TIM4);
TIM_SetCompare4(TIM4, capture + Channel4Pulse);
}
/* TIM_Update reset all */
if (TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)
{
TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
TIM_SetCompare1(TIM4, Channel1Pulse);
TIM_SetCompare2(TIM4, Channel2Pulse);
TIM_SetCompare3(TIM4, Channel3Pulse);
TIM_SetCompare4(TIM4, Channel4Pulse);
}
}
Status StartCompareTimer(int channel, int ticks)
{
Status status = OK;
switch (channel)
{
case TIMER_CHANNEL_1:
TIM_SetCompare1(COMPARE_TIMER, (uint16_t) (TIM_GetCounter(COMPARE_TIMER) + ticks));
break;
case TIMER_CHANNEL_2:
TIM_SetCompare2(COMPARE_TIMER, (uint16_t) (TIM_GetCounter(COMPARE_TIMER) + ticks));
break;
case TIMER_CHANNEL_3:
TIM_SetCompare3(COMPARE_TIMER, (uint16_t) (TIM_GetCounter(COMPARE_TIMER) + ticks));
break;
case TIMER_CHANNEL_4:
TIM_SetCompare4(COMPARE_TIMER, (uint16_t) (TIM_GetCounter(COMPARE_TIMER) + ticks));
break;
default:
status = "InvalidComparatorId";
break;
}
if (status == OK)
{
TIM_ClearITPendingBit(COMPARE_TIMER, channel);
TIM_ITConfig(COMPARE_TIMER, channel, ENABLE);
}
return status;
}
//电机控制函数，控制输出PWM的占空比。
void motor_control(void) //初始化电机控制
{
TIM_SetCompare1(TIM2, 0);
TIM_SetCompare2(TIM2, 0);
TIM_SetCompare3(TIM2, 0);
TIM_SetCompare4(TIM2, 0);
}
/**
* @brief This function handles TIM4 global interrupt request.
* @param None
* @retval None
*/
void TIM4_IRQHandler(void)
{
static __IO uint8_t servo1TurningRight = 1;
static __IO uint8_t servo2TurningRight = 1;
int16_t incrementX = 0;
int16_t incrementY = 0;
/* TIM_Update */
if (TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)
{
TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
/* Read MEMS values */
Buffer[0] = 0;
Buffer[2] = 0;
LIS302DL_Read(Buffer, LIS302DL_OUT_X_ADDR, 4);
/* Remove the offsets values from data */
Buffer[0] -= XOffset;
Buffer[2] -= YOffset;
incrementX = Buffer[0] * LIS302DL_SENSITIVITY_2_3G;
servo1Pulse = incrementX + 1500;
incrementY = Buffer[2] * LIS302DL_SENSITIVITY_2_3G;
servo2Pulse = incrementY + 1500;
TIM_SetCompare1(TIM4, servo1Pulse);
TIM_SetCompare2(TIM4, servo1Pulse);
TIM_SetCompare3(TIM4, servo2Pulse);
TIM_SetCompare4(TIM4, servo2Pulse);
}
}
int timer_set(tim_t dev, int channel, unsigned int timeout)
{
int now = timer_read(dev);
TIM_TypeDef *timer = NULL;
switch (dev) {
case TIMER_0:
timer = TIMER_0_DEV;
break;
case TIMER_1:
timer = TIMER_1_DEV;
break;
default:
return -1;
}
DEBUG("set timer %i to %i + %i\n", channel-1, now, timeout);
switch (channel) {
case 1:
TIM_SetCompare1(timer, now + timeout - 1);
TIM_ITConfig(timer, TIM_IT_CC1, ENABLE);
break;
case 2:
TIM_SetCompare2(timer, now + timeout - 1);
TIM_ITConfig(timer, TIM_IT_CC2, ENABLE);
break;
case 3:
TIM_SetCompare3(timer, now + timeout - 1);
TIM_ITConfig(timer, TIM_IT_CC3, ENABLE);
break;
case 4:
TIM_SetCompare4(timer, now + timeout - 1);
TIM_ITConfig(timer, TIM_IT_CC4, ENABLE);
break;
}
return 0;
}
//后右电机控制
void motorHY_control(TIM_TypeDef* TMM , uint16_t PWMPulse, u8 Channel, u8 Cmd)
{
//PWM控制
if(Channel==1)
TIM_SetCompare1(TMM, PWMPulse);
else if(Channel==2)
TIM_SetCompare2(TMM, PWMPulse);
else if(Channel==3)
TIM_SetCompare3(TMM, PWMPulse);
else if(Channel==4)
TIM_SetCompare4(TMM, PWMPulse);
//模式控制
if(Cmd==1) //模式0，停止
{
MotorHY_IN1_Reset;
MotorHY_IN2_Reset;
}
if(Cmd==2) //模式1，正转
{
MotorHY_IN1_Set;
MotorHY_IN2_Reset;
}
if(Cmd==3) //模式2，反转
{
MotorHY_IN1_Reset;
MotorHY_IN2_Set;
}
if(Cmd==4) //模式3，刹车
{
MotorHY_IN1_Set;
MotorHY_IN2_Set;
}
}
void Timer::set_duty(float duty, uint8_t CH_No) {
uint16_t C_Val = (uint16_t) (TIMER_CLOCK / (this->freq_) * duty);
if (CH_No==1) TIM_SetCompare1(this->TIM,C_Val); //设置占空比
if (CH_No==2) TIM_SetCompare2(this->TIM,C_Val);
if (CH_No==3) TIM_SetCompare3(this->TIM,C_Val);
if (CH_No==4) TIM_SetCompare4(this->TIM,C_Val);
}
void Servo::writeMicroseconds(uint16_t pulseWidth) {
if (!this->attached()) {
return;
}
pulseWidth = constrain(pulseWidth, this->minPW, this->maxPW);
//SERVO_TIM_CCR = pulseWidth * (SERVO_TIM_ARR + 1) * SERVO_TIM_PWM_FREQ / 1000000;
uint16_t SERVO_TIM_CCR = pulseWidth;
if(PIN_MAP[this->pin].timer_ch == TIM_Channel_1)
{
TIM_SetCompare1(PIN_MAP[this->pin].timer_peripheral, SERVO_TIM_CCR);
}
else if(PIN_MAP[this->pin].timer_ch == TIM_Channel_2)
{
TIM_SetCompare2(PIN_MAP[this->pin].timer_peripheral, SERVO_TIM_CCR);
}
else if(PIN_MAP[this->pin].timer_ch == TIM_Channel_3)
{
TIM_SetCompare3(PIN_MAP[this->pin].timer_peripheral, SERVO_TIM_CCR);
}
else if(PIN_MAP[this->pin].timer_ch == TIM_Channel_4)
{
TIM_SetCompare4(PIN_MAP[this->pin].timer_peripheral, SERVO_TIM_CCR);
}
}
void spindle_stop()
{
// // On the Uno, spindle enable and PWM are shared. Other CPUs have seperate enable pin.
// #ifdef VARIABLE_SPINDLE
// TCCRA_REGISTER &= ~(1<<COMB_BIT); // Disable PWM. Output voltage is zero.
// #if defined(CPU_MAP_ATMEGA2560) || defined(USE_SPINDLE_DIR_AS_ENABLE_PIN)
// #ifdef INVERT_SPINDLE_ENABLE_PIN
// SPINDLE_ENABLE_PORT |= (1<<SPINDLE_ENABLE_BIT); // Set pin to high
// #else
// SPINDLE_ENABLE_PORT &= ~(1<<SPINDLE_ENABLE_BIT); // Set pin to low
// #endif
// #endif
// #else
// #ifdef INVERT_SPINDLE_ENABLE_PIN
// SPINDLE_ENABLE_PORT |= (1<<SPINDLE_ENABLE_BIT); // Set pin to high
// #else
// SPINDLE_ENABLE_PORT &= ~(1<<SPINDLE_ENABLE_BIT); // Set pin to low
// #endif
// #endif
#ifdef VARIABLE_SPINDLE
#ifdef STANDARD_GRBL
TIM_SetCompare1(TIM3,1000); // 1ms pulsewidth
#else
TIM_SetCompare3(TIM3,1000); // 1ms pulsewidth
#endif
#else
GPIO_ResetBits(SPINDLE_EN);
#endif
}
/**
* @brief This function handles timer 8 capture/compare interrupt request.
* @retval None
*/
void TIM8_CC_IRQHandler(void) {
if (TIM_GetITStatus(TIM8, TIM_IT_CC1) != RESET) {
TIM_ClearITPendingBit(TIM8, TIM_IT_CC1);
if(TIM_Handler[TIM8CH1] != NULL) {
TIM_Handler[TIM8CH1]();
}
TIM_SetCompare1(TIM8, TIM_GetCapture1(TIM8) + TIM_IRQ_period[TIM8CH1]);
}
else if (TIM_GetITStatus(TIM8, TIM_IT_CC2) != RESET) {
TIM_ClearITPendingBit(TIM8, TIM_IT_CC2);
if(TIM_Handler[TIM8CH2] != NULL) {
TIM_Handler[TIM8CH2]();
}
TIM_SetCompare2(TIM8, TIM_GetCapture2(TIM8) + TIM_IRQ_period[TIM8CH2]);
}
else if (TIM_GetITStatus(TIM8, TIM_IT_CC3) != RESET) {
TIM_ClearITPendingBit(TIM8, TIM_IT_CC3);
if(TIM_Handler[TIM8CH3] != NULL) {
TIM_Handler[TIM8CH3]();
}
TIM_SetCompare3(TIM8, TIM_GetCapture3(TIM8) + TIM_IRQ_period[TIM8CH3]);
}
else if (TIM_GetITStatus(TIM8, TIM_IT_CC4) != RESET) {
TIM_ClearITPendingBit(TIM8, TIM_IT_CC4);
if(TIM_Handler[TIM8CH4] != NULL) {
TIM_Handler[TIM8CH4]();
}
TIM_SetCompare4(TIM8, TIM_GetCapture4(TIM8) + TIM_IRQ_period[TIM8CH4]);
}
}
void pwm_out_set_value()
{
TIM_SetCompare1(TIM4, pwm_out[0]);
TIM_SetCompare2(TIM4, pwm_out[1]);
TIM_SetCompare3(TIM4, pwm_out[2]);
TIM_SetCompare4(TIM4, pwm_out[3]);
}
/**
* @brief This function handles TIM3 global interrupt request.
* @param None
* @retval None
*/
void TIM3_IRQHandler(void)
{
/* TIM3_CH1 toggling with frequency = 183.1 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC1) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC1 );
capture = TIM_GetCapture1(TIM3);
TIM_SetCompare1(TIM3, capture + CCR1_Val );
}
/* TIM3_CH2 toggling with frequency = 366.2 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC2) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC2);
capture = TIM_GetCapture2(TIM3);
TIM_SetCompare2(TIM3, capture + CCR2_Val);
}
/* TIM3_CH3 toggling with frequency = 732.4 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC3) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC3);
capture = TIM_GetCapture3(TIM3);
TIM_SetCompare3(TIM3, capture + CCR3_Val);
}
/* TIM3_CH4 toggling with frequency = 1464.8 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC4) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC4);
capture = TIM_GetCapture4(TIM3);
TIM_SetCompare4(TIM3, capture + CCR4_Val);
}
}
/**
* \brief Changes the engine speed by update the duty cycle of the PWM output.
* \param[in] speed New speed of the engine. Equivalent to the duty cycle of the
* PWM. It must be smaller than the period register, which is configured
* in BSP_ENGINE_PWM_PERIOD.
*/
void bsp_EngineSpeedSet(uint32_t speed) {
switch (BSP_ENGINE_TIMER_PORT_CHANEL) {
case CHANNEL1:
/* Set the Capture Compare Register: Channel 1 */
TIM_SetCompare1(BSP_ENGINE_TIMER_PORT_BASE, speed % BSP_ENGINE_PWM_PERIOD);
break;
case CHANNEL2:
/* Set the Capture Compare Register: Channel 2 */
TIM_SetCompare2(BSP_ENGINE_TIMER_PORT_BASE, speed % BSP_ENGINE_PWM_PERIOD);
break;
case CHANNEL3:
/* Set the Capture Compare Register: Channel 3 */
TIM_SetCompare3(BSP_ENGINE_TIMER_PORT_BASE, speed % BSP_ENGINE_PWM_PERIOD);
break;
case CHANNEL4:
/* Set the Capture Compare Register: Channel 4 */
TIM_SetCompare4(BSP_ENGINE_TIMER_PORT_BASE, speed % BSP_ENGINE_PWM_PERIOD);
break;
default:
assert(BSP_ENGINE_TIMER_PORT_CHANEL);
break;
}
}
void TIM5_PWM_OUTPUT(u16 DR1,u16 DR2,u16 DR3,u16 DR4)
{
TIM_SetCompare1(TIM5,DR1);
TIM_SetCompare2(TIM5,DR2);
TIM_SetCompare3(TIM5,DR3);
TIM_SetCompare4(TIM5,DR4);
}
/*******************************************************************************
** Function name: PWM_SetDutyCycle( PWM_typedef * PWM)
** Description : The function settings dutycycle on PWM channel
** Parameter : None
** Return value : None
** Remarks : PWM_FAIL - Init unsuccessful
** PWM_OK - Init successful
*******************************************************************************/
int PWM_SetDutyCycle( PWM_typedef * PWM )
{
int Retval = PWM_FAIL;
if(PWM != NULL)
{
switch(PWM->chid)
{
case PWM_CH1:
TIM_SetCompare1(TIM3,PWM->duty_cycle);
break;
case PWM_CH2:
TIM_SetCompare2(TIM3,PWM->duty_cycle);
break;
case PWM_CH3:
TIM_SetCompare3(TIM3,PWM->duty_cycle);
break;
case PWM_CH4:
TIM_SetCompare4(TIM3,PWM->duty_cycle);
break;
default: break;
}
Retval = PWM_OK;
}
else
{
/* do nothing */
}
return Retval;
}
/**
* @brief This function handles TIM3 global interrupt request.
* @param None
* @retval None
*/
void TIM3_IRQHandler(void)
{
/* TIM3_CH1 toggling with frequency = 256.35 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC1) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC1 );
uhCapture = TIM_GetCapture1(TIM3);
TIM_SetCompare1(TIM3, uhCapture + uhCCR1_Val );
}
/* TIM3_CH2 toggling with frequency = 512.7 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC2) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC2);
uhCapture = TIM_GetCapture2(TIM3);
TIM_SetCompare2(TIM3, uhCapture + uhCCR2_Val);
}
/* TIM3_CH3 toggling with frequency = 1025.4 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC3) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC3);
uhCapture = TIM_GetCapture3(TIM3);
TIM_SetCompare3(TIM3, uhCapture + uhCCR3_Val);
}
/* TIM3_CH4 toggling with frequency = 2050.78 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC4) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC4);
uhCapture = TIM_GetCapture4(TIM3);
TIM_SetCompare4(TIM3, uhCapture + uhCCR4_Val);
}
}
/**
* @brief This function handles TIM3 global interrupt request.
* @param None
* @retval None
*/
void TIM3_IRQHandler(void)
{
/* TIM3_CH1 toggling with frequency = 585.9 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC1) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC1 );
capture = TIM_GetCapture1(TIM3);
TIM_SetCompare1(TIM3, capture + CCR1_Val );
}
/* TIM3_CH2 toggling with frequency = 1171.8 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC2) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC2);
capture = TIM_GetCapture2(TIM3);
TIM_SetCompare2(TIM3, capture + CCR2_Val);
}
/* TIM3_CH3 toggling with frequency = 2343.75 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC3) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC3);
capture = TIM_GetCapture3(TIM3);
TIM_SetCompare3(TIM3, capture + CCR3_Val);
}
/* TIM3_CH4 toggling with frequency = 4687.5 Hz */
if (TIM_GetITStatus(TIM3, TIM_IT_CC4) != RESET)
{
TIM_ClearITPendingBit(TIM3, TIM_IT_CC4);
capture = TIM_GetCapture4(TIM3);
TIM_SetCompare4(TIM3, capture + CCR4_Val);
}
}
void batholithResetPwm(){
TIM_SetCompare2(TIM8,0);
TIM_SetCompare3(TIM8,0);
TIM_SetCompare2(TIM1,0);
TIM_SetCompare1(TIM1,0);
me.isPWMallowed=0;
}
void setAllSteeringEngine(void)
{
int i;
for(i=0;i<12;i++)
{
switch(i)
{
case 0:
TIM_SetCompare1(TIM5,sValue[i]);
break;
case 1:
TIM_SetCompare2(TIM5,sValue[i]);
break;
case 2:
TIM_SetCompare3(TIM5,sValue[i]);
break;
case 3:
TIM_SetCompare4(TIM5,sValue[i]);
break;
case 4:
TIM_SetCompare1(TIM8,sValue[i]);
break;
case 5:
TIM_SetCompare1(TIM4,sValue[i]);
break;
case 6:
TIM_SetCompare2(TIM4,sValue[i]);
break;
case 7:
TIM_SetCompare3(TIM4,sValue[i]);
break;
case 8:
TIM_SetCompare4(TIM4,sValue[i]);
break;
case 9:
TIM_SetCompare2(TIM8,sValue[i]);
break;
case 10:
TIM_SetCompare3(TIM8,sValue[i]);
break;
case 11:
TIM_SetCompare4(TIM8,sValue[i]);
break;
default:break;
}
}
}
/*******************************************************************************
* Function Name : TIM3_IRQHandler
* Description : This function handles TIM3 global interrupt request.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void TIM3_IRQHandler(void)
{
vu16 capture = 0; /* 当前捕获计数值局部变量 */
printf("SR = %x\r\n", TIM3->SR);
/*
* TIM2 时钟 = 72 MHz, 分频数 = 7299 + 1, TIM2 counter clock = 10KHz
* CC1 更新率 = TIM2 counter clock / CCRx_Val
*/
if(TIM_GetITStatus(TIM3, TIM_IT_CC1) != RESET)
{
//GPIO_WriteBit(GPIOA, GPIO_Pin_4, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOA, GPIO_Pin_4)));
PA_PIN_NOT(4);
/* 读出当前计数值 */
capture = TIM_GetCapture1(TIM3);
//printf("capture1 = %d\r\n", capture);
/* 根据当前计数值更新输出捕获寄存器 */
TIM_SetCompare1(TIM3, capture + 40000);
TIM_ClearITPendingBit(TIM3, TIM_IT_CC1);
}
else if(TIM_GetITStatus(TIM3, TIM_IT_CC2) != RESET)
{
//GPIO_WriteBit(GPIOA, GPIO_Pin_5, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOA, GPIO_Pin_5)));
PA_PIN_NOT(5);
capture = TIM_GetCapture2(TIM3);
//printf("capture2 = %d\r\n", capture);
TIM_SetCompare2(TIM3, capture + 20000);
TIM_ClearITPendingBit(TIM3, TIM_IT_CC2);
}
else if(TIM_GetITStatus(TIM3, TIM_IT_CC3) != RESET)
{
//GPIO_WriteBit(GPIOA, GPIO_Pin_6, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOA, GPIO_Pin_6)));
PA_PIN_NOT(6);
capture = TIM_GetCapture3(TIM3);
//printf("capture3 = %d\r\n", capture);
TIM_SetCompare3(TIM3, capture + 10000);
TIM_ClearITPendingBit(TIM3, TIM_IT_CC3);
}
else if(TIM_GetITStatus(TIM3, TIM_IT_CC4) != RESET)
{
//GPIO_WriteBit(GPIOA, GPIO_Pin_7, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOA, GPIO_Pin_7)));
PA_PIN_NOT(7);
capture = TIM_GetCapture4(TIM3);
//printf("capture4 = %d\r\n", capture);
TIM_SetCompare4(TIM3, capture + 5000);
TIM_ClearITPendingBit(TIM3, TIM_IT_CC4);
}
else if(TIM3->SR & 0x0001)
{
//capture = TIM_GetCapture4(TIM3);
//printf("capture5 = %d\r\n", capture);
//printf("SR = %x\r\n", TIM3->SR);
TIM3->SR &= ~(1 << 0); // 清除中断标志位
}
}
void motorStop(){
GPIO_WriteBit(MOTOR_PWM_PORT,MOTOR_LEFT_IN1_PIN,Bit_RESET); /* 0 */
GPIO_WriteBit(MOTOR_PWM_PORT,MOTOR_LEFT_IN2_PIN,Bit_RESET); /* 0 */
GPIO_WriteBit(MOTOR_PWM_PORT,MOTOR_RIGHT_IN3_PIN,Bit_RESET); /* 0 */
GPIO_WriteBit(MOTOR_PWM_PORT,MOTOR_RIGHT_IN4_PIN,Bit_RESET); /* 0 */
TIM_SetCompare3(TIM4, MinPWM);
TIM_SetCompare4(TIM4, MinPWM);
}
void motorBackward(){
GPIO_WriteBit(MOTOR_PWM_PORT ,MOTOR_LEFT_IN1_PIN,Bit_SET); /* 0 */
GPIO_WriteBit(MOTOR_PWM_PORT,MOTOR_LEFT_IN2_PIN,Bit_RESET); /* 1 */
GPIO_WriteBit(MOTOR_PWM_PORT,MOTOR_RIGHT_IN3_PIN,Bit_SET); /* 0 */
GPIO_WriteBit(MOTOR_PWM_PORT,MOTOR_RIGHT_IN4_PIN,Bit_RESET); /* 1 */
TIM_SetCompare3(TIM4, MaxPWM);
TIM_SetCompare4(TIM4, MaxPWM);
}
/************************************************************************************************
* 函数名：go_straight
* 函数作用：控制小车直行
* 参数：yscs (预设次数) 预设光电传感器输出方波的次数 pwm_x 时分别给左右两个电机输出不同占空比的pwm波
* 库版本 ：ST3.5.0
*************************************************************************************************/
void go_straight( u16 pwm_1 , u16 pwm_2 )//直行函数
{
TIM_SetCompare1(TIM4,pwm_1);//设置电机的初始pwn波 1、2是控制右侧的电机，3、4控制左侧的电机。1、3是前进,2、4是后退。
TIM_SetCompare2(TIM4,0);
TIM_SetCompare3(TIM4,pwm_2);
TIM_SetCompare4(TIM4,0);
}
