一次暑假课程的智能车设计

于 2021-07-20 16:54:58 发布
阅读量225 收藏 2
点赞数 1
分类专栏： 大学 文章标签： 嵌入式 stm32 pid
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sduerchenbo/article/details/118939436
版权

智能车设计报告

  1. 设计目标：

  小车能够检测20khz的信号源 并以较快的速度沿着信号线移动。

  1. 总体方案设计：

总体分为硬件软件两部分

硬件部分：(1):驱动系统 (2):转向系统 (3):电源 (4):信号检测模块 (5):信号放大模块

软件部分：分段pid控制，分段速度控制，丢线判断，信号边缘采集，信号归一化，信号滤波，优化算法。

  1. 硬件电路：
  1. :驱动系统：采用购买的电机驱动模块，模块能提供足够的功率让电机更好的工作。
  2. :转向系统：SD-5舵机 根据调节pwm占空比实现车的转向。
  3. :电源：7.2v电池+电源模块，分别给电机驱动，mcu，舵机等等模块供电。
  4. :信号检测模块：四组6.8nf电容和10mh的电感 与20khz信号源谐振，再通过整流滤波得到一个稳定的电压值，然后使用运算放大电路将小信号放大，使用mcu的adc模块采集信号。
  1. 软件设计：

主控板stm32f103c8t6。

配置TIM2作为两通道pwm发生器（50hz），一路作为舵机的信号输出，一路作为电机的pwm调速输出。可调节TIM2->CCRX(x对应为通道)寄存器的值来调节占空比。从而实现舵机的多角度输出和电机的速度可调。

配置ADC1作为赛道信号检测，4通道循环扫描模式，1.5采样周期，优先级递减。并开启dma，可以使adc将赛道信号以不通过cpu的方式直接采集到内存中，从而增加了小车对赛道的响应速度。左右两个通道的值各采集三组然后分别加权平均进行滤波，减小脉冲等噪声影响。

HAL_ADC_Start_DMA(&hadc1,(uint32_t *)adc_value,12);

HAL_Delay(70);//开机延时一段时间 等待第一次转换。

Adc处理代码 adc_value为采集到的电压值

Ad_xxxx_noc表示未归一化处理的数据

//均值滤波

AD_Left_noc = (adc_value[2] + adc_value[3] + adc_value[6] + adc_value[7]+ adc_value[10] + adc_value[11])/6;

AD_Right_noc = (adc_value[0] + adc_value[4] + adc_value[8] + adc_value[1]+ adc_value[5] + adc_value[9])/6;

/*这是范围提取 开机时先将车处于赛道信号最强和最弱处检测并存储边缘值*/

if((AD_Right_noc > adc_max)||(AD_Left_noc > adc_max ))

{

adc_max = AD_Right_noc > AD_Left_noc ? AD_Right_noc : AD_Left_noc;

}

if((AD_Right_noc < adc_min)||(AD_Left_noc < adc_min ))

{

adc_min = AD_Right_noc < AD_Left_noc ? AD_Right_noc : AD_Left_noc;

}

/*归一化算法*/

AD_Right = 800*((float)AD_Right_noc-adc_min)/(adc_max - adc_min) + 200 ;

AD_Left  = 800*((float)AD_Left_noc-adc_min)/(adc_max - adc_min) + 200 ;

}

位置式PID算法。以左右电感采集电压差值作为Pid输入量,用jlink在线调试得出较好的一组KP,KI,KD。

{

PID_dec.setpoint = AD_Left;

PIDW(&PID_dec,AD_Right);

这是调用到的pidw的函数：

void PIDW(Pidwei *vPID, float processValue)//输出PID变量地址和当前采样值

{

   float thisError;

  thisError=vPID->setpoint-processValue;//当前误差等于设定值减去当前值

  vPID->integral+=thisError;//误差积分，把所有误差累加起来

  vPID->result=vPID->Kp*thisError  +  vPID->Ki*vPID->integral  +  vPID->Kd*(thisError-vPID->lasterror);

  vPID->lasterror=thisError;

}

}

丢线处理

if(AD_Right < start && AD_Left < start)

{

   MOTOR_PWM  = 0;

//在两边采集值都小于启动阈值时关闭电机。

}

分段式pid控制

#if divide

if(angle >15)//angle为pid输出值开根号

{

KP = 2.8;

KD = 2.7;//弯道应该适当增大kp kd

}

else

{

KP = 1.66;

KD = 1.96;

}

#endif

Divide为一个宏定义 可以更改其值决定是否使用分段pid

电机调速

I f(angle < 30)

MOTOR_PWM = 305-1.2*angle;

else

 MOTOR_PWM = 260;

Pid输出量给到电机占空比，在过弯，非直道适当降低速度。

转向控制

  angle = sqrt(PID_dec.result);

anglelast = 1.92*angle + 125 ; //左转控制，右转对应为125-2*angle

pwm_changevalue(anglelast);

125值对应舵机0偏 小车直行

  1. 调试与检测过程

在第一周先组装好了小车，并调整了机械结构，让小车能更稳定的行驶。

第二周第一天小组一起讨论了方案，并着手各个模块的调试。

第二天到4310进行实地调试，先是调节了运算放大器的放大倍数使检测更准确，pid输出更明显。然后采用swd的在线调试 查看各个寄存器值，在弯道，直道，转向种种时刻小车和pid输出以及模块响应的变化与联系，最终确定采用分段式pid，并将速度控制在一定范围内，防止小车冲出赛道。在下午便完成了调试，小车已经可以以较快的速度跑完两个赛道。

  1. 关键问题讨论及结论
  1. 小车在速度太快时容易冲出赛道

     结论：适当增大kd的值，并将pid输出同时反馈给电机占空比，在弯道即将到来时减速。 再通过机械结构的调整差不多解决了该问题

  1. 十字线的识别处理 出现十字线走错方向的情况

结论：调整四个电感的权重，加权平均，在十字线适当增大速度便能正确判断并沿着指定道路行驶。

  1. 电机转不动，电机驱动模块发烫严重

结论：电机与车轮齿轮的啮合太紧，导致电机负载过大转不起来从而堵转产生很大的内能使得模块发烫严重。适当调松齿轮解决。

  1. 设计总结与体会

在学校两年来少有的多模块多功能的综合设计，从中学到了pid算法的调试，机械结构对运动的影响等等。。。如果以后还有这样的机会一定积极参与，提升自己。

最后附上代码


/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "pid.h"
#include<math.h>
/* USER CODE BEGIN PTD */
float  KP = 1.66;
float  KI = 0;
float  KD = 1.96;
#define start  400
#define divide 1
ADC_HandleTypeDef hadc1;
DMA_HandleTypeDef hdma_adc1;

TIM_HandleTypeDef htim2;

/* USER CODE BEGIN PV */
uint16_t pwm_compare=125;//原点
//82右转限幅 175左转限幅
uint16_t pwm_max=0;
uint16_t pwm_time=2000;
uint16_t adc_value[12]={0};
uint16_t adc_max = 0;
uint16_t adc_min = 4095;
uint16_t AD_Right_noc = 0;
uint16_t AD_Left_noc = 0;
float AD_Left=0,AD_Right=0;
uint16_t MOTOR_CONTROL = 0;
uint16_t MOTOR_TIME = 1000-5;
uint16_t MOTOR_PWM = 0;
uint16_t anglelast = 0;
uint16_t angle=0;
Pidwei PID_dec;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_TIM2_Init(void);
static void MX_ADC1_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
void pwm_changevalue(uint16_t value)
{
	if(value>87&&value<175)
		pwm_compare = value;
	else if(value<88&&value>0)
		pwm_compare = 88;
	else if(value>175)
		pwm_compare = 175;

}
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  
  SystemClock_Config();

  MX_GPIO_Init();
  MX_DMA_Init();
  MX_TIM2_Init();
  MX_ADC1_Init();
  /* USER CODE BEGIN 2 */
//	HAL_TIM_Base_Start(&htim2 );
	HAL_TIM_Base_Start_IT(&htim2);
	HAL_ADC_Start_DMA(&hadc1,(uint32_t *)adc_value,12);
	HAL_Delay(70);
	PID_dec.setpoint= AD_Left;
	PID_dec.Kp = KP;
	PID_dec.Kd = KD;
	PID_dec.Ki = KI;
	PID_dec.integral = 0;
	PID_dec.result = 0;
	PID_dec.lasterror = 0;
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
//	while(1);
  while (1)
  {
		//均值滤波
		AD_Left_noc = (adc_value[2] + adc_value[3] + adc_value[6] + adc_value[7]+ adc_value[10] + adc_value[11])/6;
		AD_Right_noc = (adc_value[0] + adc_value[4] + adc_value[8] + adc_value[1]+ adc_value[5] + adc_value[9])/6;
		
		/*这是范围提取*/
		if((AD_Right_noc > adc_max)||(AD_Left_noc > adc_max ))
		{
			adc_max = AD_Right_noc > AD_Left_noc ? AD_Right_noc : AD_Left_noc;
		
		}
		if((AD_Right_noc < adc_min)||(AD_Left_noc < adc_min ))
		{
			adc_min = AD_Right_noc < AD_Left_noc ? AD_Right_noc : AD_Left_noc;
		
		}
		
//		AD_Right = 400*((float)(adc_value[2]-adc_min )/(adc_max-adc_min) )+200+400*((float)(adc_value[3]-adc_min)/(adc_max-adc_min));
//		AD_Left  = 400*((float)(adc_value[0]-adc_min )/(adc_max-adc_min) )+200+400*((float)(adc_value[1]-adc_min)/(adc_max-adc_min));
		AD_Right = 800*((float)AD_Right_noc-adc_min)/(adc_max - adc_min) + 200 ;
		AD_Left  = 800*((float)AD_Left_noc-adc_min)/(adc_max - adc_min) + 200 ;
		if(AD_Right < start && AD_Left < start)
		{
	   MOTOR_PWM  = 0;
		
		}
		else
		{
		
			PID_dec.setpoint = AD_Left;
			PIDW(&PID_dec,AD_Right);
			if(PID_dec.result>0)
			{
			   angle = sqrt(PID_dec.result);
				#if divide
				if(angle >15)
				{
					KP = 2.8;
					KD = 2.7;
				}
				else 
				{
					KP = 1.66;
					KD = 1.96;
				}
				#endif
				anglelast = 1.92*angle + 125 ; 
			   pwm_changevalue(anglelast);
				if(angle < 30)
				MOTOR_PWM = 305-1.2*angle;
				else
					 MOTOR_PWM = 260;
		  }
		  else if(PID_dec.result <0)
		   {
			   PID_dec.result *= -1;
				 
			   angle = sqrt(PID_dec.result);
				 #if divide
				if(angle >15)
				{
					KP = 2.8;
					KD = 2.7;
				}
				else 
				{
					KP = 1.66;
					KD = 1.86;
				}
				#endif
				 anglelast = 125 - 1.98*angle ;
				 if(angle < 30)
				MOTOR_PWM = 315- 1.4*angle;
				else
					 MOTOR_PWM = 260;
			   pwm_changevalue(anglelast);
		   }
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
}
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC;
  PeriphClkInit.AdcClockSelection = RCC_ADCPCLK2_DIV6;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief ADC1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_ADC1_Init(void)
{

  /* USER CODE BEGIN ADC1_Init 0 */

  /* USER CODE END ADC1_Init 0 */

  ADC_ChannelConfTypeDef sConfig = {0};

  /* USER CODE BEGIN ADC1_Init 1 */

  /* USER CODE END ADC1_Init 1 */
  /** Common config
  */
  hadc1.Instance = ADC1;
  hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE;
  hadc1.Init.ContinuousConvMode = ENABLE;
  hadc1.Init.DiscontinuousConvMode = DISABLE;
  hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc1.Init.NbrOfConversion = 4;
  if (HAL_ADC_Init(&hadc1) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure Regular Channel
  */
  sConfig.Channel = ADC_CHANNEL_0;
  sConfig.Rank = ADC_REGULAR_RANK_1;
  sConfig.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure Regular Channel
  */
  sConfig.Channel = ADC_CHANNEL_1;
  sConfig.Rank = ADC_REGULAR_RANK_2;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure Regular Channel
  */
  sConfig.Channel = ADC_CHANNEL_2;
  sConfig.Rank = ADC_REGULAR_RANK_3;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure Regular Channel
  */
  sConfig.Channel = ADC_CHANNEL_4;
  sConfig.Rank = ADC_REGULAR_RANK_4;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN ADC1_Init 2 */

  /* USER CODE END ADC1_Init 2 */

}

/**
  * @brief TIM2 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM2_Init(void)
{

  /* USER CODE BEGIN TIM2_Init 0 */

  /* USER CODE END TIM2_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  /* USER CODE BEGIN TIM2_Init 1 */

  /* USER CODE END TIM2_Init 1 */
  htim2.Instance = TIM2;
  htim2.Init.Prescaler = 71;
  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim2.Init.Period = 9;
  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM2_Init 2 */

  /* USER CODE END TIM2_Init 2 */

}

/**
  * Enable DMA controller clock
  */
static void MX_DMA_Init(void)
{

  /* DMA controller clock enable */
  __HAL_RCC_DMA1_CLK_ENABLE();

  /* DMA interrupt init */
  /* DMA1_Channel1_IRQn interrupt configuration */
//  HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0);
//  HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOD_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_3, GPIO_PIN_RESET);
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_RESET);
  /*Configure GPIO pin : PA3 */
  GPIO_InitStruct.Pin = GPIO_PIN_3;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
	
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  GPIO_InitStruct.Pin = GPIO_PIN_10;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
	HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
	

}

/* USER CODE BEGIN 4 */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	pwm_max++;
	MOTOR_CONTROL++;
	if(pwm_compare>pwm_max)
	{
	HAL_GPIO_WritePin(GPIOA,GPIO_PIN_3,GPIO_PIN_SET);
	}
	else
	{
	HAL_GPIO_WritePin(GPIOA,GPIO_PIN_3,GPIO_PIN_RESET);
		if(pwm_max>=pwm_time)
			pwm_max=0;
	}
	if(MOTOR_CONTROL<MOTOR_PWM)
	{
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_10,GPIO_PIN_SET);
	}
	else 
	{
		HAL_GPIO_WritePin(GPIOB,GPIO_PIN_10,GPIO_PIN_RESET);
		if(MOTOR_CONTROL >= MOTOR_TIME)
			MOTOR_CONTROL = 0;
	}
}
/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */

  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

//分割线-------------------------------------------------
Pid.c
#include "pid.h"

void PIDW(Pidwei *vPID, float processValue)//输出PID变量地址和当前采样值
{
	
  float thisError;
  thisError=vPID->setpoint-processValue;//当前误差等于设定值减去当前值
  vPID->integral+=thisError;//误差积分，把所有误差累加起来
  vPID->result=vPID->Kp*thisError  +  vPID->Ki*vPID->integral  +  vPID->Kd*(thisError-vPID->lasterror);
  vPID->lasterror=thisError;
	}
 =================================================================

Pid.h
#ifndef __PID_H_
#define __PID_H_
typedef struct
{
      float  setpoint;       //设定值
      float Kp;     //比例系数
      float Kd;      //积分系数
      float Ki;    //微分系数
      float integral;//积分值
      float lasterror;     //前一拍偏差
      float result; //输出值
}Pidwei;
typedef struct
{
      float  setpoint;       //设定值
      float Kp;     //比例系数
      float Kd;      //积分系数
      float Ki;    //微分系数
      
      float lasterror;     //前一拍偏差   
      float preerror;     //前两拍偏差
      float result; //输出值
}Pidzeng;
void PIDW(Pidwei *vPID, float processValue);
void PIDZ(Pidzeng *vPID, float processValue);

#endif
/*    */

SDU-cb
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

SDU-cb

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值