devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

电赛校赛总结----一维板球系统【代码开源】_一维板球控制系统

作者：繁依Fanyi0 | 2024-06-08 09:12:55

赞

踩

一维板球控制系统

 2022/4/21

搭建了整体的机械结构，最后因为经费问题，选择了用去年风力摆的架子去搭摄像头【openmv】，看当年的国赛题，选择的是ov7670，但我们讨论后觉得还是openmv的识别比较好,,下面的小球选用的是外径为3.2cm的水管，然后将水管一分为二，然后去放置小球，舵机采用是的是MG996R舵机，原本想着用的是MG995R【因为以前学长他们做过一个就用的是这个】，但是发现996R响应的更快。通过舵机占空比的调整将占空比传入PID算法去完成让管子进行倾斜且保持平衡。板子用的就是stm32mini开发板，这次这个不用考虑这个板子大小，就选IO口多的。

2022/4/22

凌晨开始较为正式写代码，才开始还是比较头疼这个PID该怎么调以及怎么调用，因为确实平时用的很少，后来想到了一个简单的方法，先调试舵机的占空比，知道这个转轴什么时候是水平，最高和最低，把三个的占空比分别记录出来，为后面的PID调用的做准备，调好之后我们把舵机那个转轴放置水平去安装机械结构【这样为我们后面省了不少事】，相当于我们起始装置就是水平的，这样直接将算出来的PID的占空比直接加减到上面就行了，调试简单了很多。

Xplot运行代码：

  1. 运行函数
  2. //send_wave();
  3. //getdatas();
  4. //get_cmd();
  5.  
  6.  
  7. 函数定义
  8. //void send_wave(void)
  9. //{
  10. //	//定义通道名帧头帧尾
  11. //	u8 frameNameHead[] = "AABBCC";
  12. //	u8 frameNameEnd[] = "CCBBAA";
  13. //	
  14. //	//定义数据帧头帧尾
  15. //	u8 frameDataHead[] = "DDEEFF";
  16. //	u8 frameDataEnd[] = "FFEEDD";
  17. //	
  18. //	//定义通道名
  19. //	u8 name[] = {"x_now,I,D,PWM_X,flag,aim,MOtor_X_PWM"};
  20. //	
  21. //	//赋值数据
  22. //	float channels[7];
  23. //	channels[0] = x_now;
  24. //	channels[1] = kp;
  25. //	channels[2] = kd;
  26. //	channels[3] = data[0];
  27. //	channels[4] = flag;
  28. //	channels[5] = X_aim;
  29. //	channels[6] = Motor_X_PWM;
  30. //	//通过串口1，向上位机发送数据
  31. //	usart_senddatas(USART1,frameNameHead,sizeof(frameNameHead)-1);
  32. //	usart_senddatas(USART1,name,sizeof(name)-1);
  33. //	usart_senddatas(USART1,frameNameEnd,sizeof(frameNameEnd)-1);
  34. //	
  35. //	usart_senddatas(USART1,frameDataHead,sizeof(frameDataHead)-1);
  36. //	usart_senddatas(USART1,(u8*)channels,sizeof(channels));
  37. //	usart_senddatas(USART1,frameDataEnd,sizeof(frameDataEnd)-1);
  38. //	
  39. //}
  40.  
  41. //void getdatas(void)
  42. //{
  43. //	data[0] = kp*X.err[0]+flag*ki*X.e_I+kd*(X.err[0]-X.err[1]);
  44. //}
  45.  
  46. //void get_cmd(void)
  47. //{
  48. //	char u_buff[10];
  49. //	float u_d1,u_d2,u_d3;
  50. //	if(usart_get_data(u_buff,&u_d1,&u_d2,&u_d3))
  51. //	{
  52. //		if(strcmp(u_buff,"PID") == 0) //比较命令控制字符是否为PID
  53. //		{
  54. //			kp = u_d1;
  55. //		  ki = u_d2;
  56. //			kd = u_d3;
  57. //		}
  58. //	}
  59. //	memset(u_buff,0,sizeof(u_buff));
  60. //}
  61.  
  62.  
  63.  
  64.  
  65. usart.c
  66.  
  67. //char usart_readbuff[30] = {0}; //串口接受缓存数组
  68. //u8 usart_readok = 0; //一帧数据处理标志
  69. //void USART1_IRQHandler(void)                	//串口1中断服务程序
  70. //{
  71. //	u8 temp;
  72. //	static u8 count = 0;  // 接收数组控制变量
  73. //	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //判断是否为接收中断
  74. //	{
  75. //		temp = USART_ReceiveData(USART1);	//读取接收到的数据,并清除中断标志
  76. //		if(temp == '#' && usart_readok == 0) 
  77. //		{
  78. //			usart_readbuff[count] = '#';
  79. //			usart_readok = 1;
  80. //			count = 0;
  81. //		}
  82. //		else if(usart_readok==0)
  83. //		{
  84. //			usart_readbuff[count] = temp; //保存接收到的数据到接收缓存数组
  85. //			count++; //数组下标切换
  86. //			if(count >= 30) // 防止数据越界
  87. //				count = 0;
  88. //		}
  89. //	}
  90. //}
  91.  
  92.  
  93. // 
  94.  
  95. //u8 usart_get_data(char *cmd,float *d1,float *d2,float *d3)
  96. //{
  97. //	u8 flag = 0;
  98. //	if(usart_readok == 1)
  99. //	{
  100. //		if(sscanf(usart_readbuff,"%3s=%f,%f,%f#",
  101. //											cmd,d1,d2,d3)==4)
  102. //		{
  103. //			flag = 1;
  104. //		}
  105. //		//清除接收完成标志
  106. //		memset(usart_readbuff,0,sizeof(usart_readbuff));
  107. //		usart_readok = 0;
  108. //	}
  109. //	return flag;
  110. //}
  111.  
  112.  
  113. //void usart_senddatas(USART_TypeDef* USARTx,u8* addr,int size)
  114. //{
  115. //	while(size--) //判断数据发送完没有
  116. //	{
  117. //		while(USART_GetFlagStatus(USARTx,USART_FLAG_TC) == RESET);//等待上一个byte的数据发送结束。
  118. //		USART_SendData(USARTx,*addr);//调用STM32标准库函数发送数据
  119. //		addr++; //地址偏移
  120. //	}
  121. //}

凌晨两点：我和我们组的一个女生还在对着电脑用一个第一次用的软甲yplot去调试PID参数，现在想想，还是觉得痛苦，最后调到大概中午12点，感觉还算满意，就先放着了，当时调的差不多的时候，我们就觉得没啥事情了，就有点懈怠，因为看了看这几个题，觉得只要PID调出来了，就没啥难的了【为后来埋下了后患！！！！】

因为有八道题，原本用的是触摸屏进行串口发送信息读取去选择功能的，但是我不小心把供电的电源短接了，结果瞬间就烧了，哎，后来就换了OLED【多级菜单，板载按键控制】，设定了两级菜单，因为就八个功能，当时发现还有个按键，就想着用给调平【让系统保持水平】吧，所以就有了2的功能。

  1. //按键控制发送信息
  2. void Menu_key_set(void)
  3. {
  4.     key_state = KEY_Scan(0);
  5.     if (key_state == 1)
  6.     {
  7. 			  OLED_Clear();
  8.         func_index = table[func_index].next;
  9.     }
  10. 		if(key_state == 2)
  11. 		{
  12. 		    TIM_SetCompare1(TIM3,14.5);
  13. 		}
  14.     if(key_state == 3)
  15. 		{
  16. 			  OLED_Clear();
  17. 				func_index = table[func_index].enter;
  18. 		}
  19.     current_operation_index = table[func_index].current_operation;
  20.     (*current_operation_index)();
  21. }
  22.  
  23. //多级菜单
  24. void meun1_func(void)
  25. {
  26.     OLED_ShowString(0, 0, "   1.I    ", 16);
  27.     OLED_ShowString(0, 2, "   2.II", 16);
  28. }
  29.  
  30. void meun3_func(void)
  31. {
  32.     OLED_ShowString(0, 0, "   1.1    ", 16);
  33.     OLED_ShowString(0, 2, "   2.2", 16);
  34.     OLED_ShowString(0, 4, "   3.3", 16);
  35.     OLED_ShowString(0, 6, "   4.4", 16);
  36. }
  37.  
  38. void meun2_func(void)
  39. {
  40.     OLED_ShowString(0, 0, "   1.21    ", 16);
  41.     OLED_ShowString(0, 2, "   2.22", 16);
  42.     OLED_ShowString(0, 4, "   3.23", 16);
  43.     OLED_ShowString(0, 6, "   4.24", 16);
  44. }

功能1，2，3都是从1运动到某个点，因为我们在开始的时候，用openmv详细的记录了每个点的像素位置，这样相当于我们把目标位置的X_aim传入到pid算法就可以了，然后openmv会实时的读取当前的小球坐标然后借助串口3传回给单片机，将这个X_now也回传到PID,进行计算出来的占空比。

后面的4，5相较于之前的是变为三个点，且需要稳定2s,这样就需要加入定时器的功能，才开始用的TIM1,但是发现无法进行定时，我到现在不知道为啥，后来该到了TIM2,一下子就好了，真够玄学的，定时器时间就设为0.5s，在定时器的中断里面加入一个static静态变量，这样你需要传一次flag标志位由你定，当时间到了，对应的flag的数值一变，定时就结束了

  1. //定时器2中断服务程序
  2. void TIM2_IRQHandler(void)
  3. {
  4.     //判断TIM2更新中断是否发生
  5.     if(TIM_GetITStatus(TIM2,TIM_IT_Update)!=RESET)
  6. {
  7.         //代码应用区
  8. 		i++;
  9. 		t++;
  10. 		if(i%20 == 0)
  11. 		{
  12. 			timeflag = 1;
  13. 		}
  14. 		if(t%20 == 0)
  15. 		{
  16. 			lanyaflag= 1;  
  17.     }
  18. 		
  19. }

 当时就是如何开始定时器的计时，还是想了一些时间的，后来设置一个jinruflag标志位，这样达到要求初始化一次了，然后根据timeflag的数值，若为1，则时间到了，然后就去走到下一个点。

为啥我这个时间这么长，哎，主要pid调的不是很好，所以想给小球更多的时间去稳定下来，因为我们测试发现，当时间太短，确实可以到达目标点，但是却没有稳定下来，结果就是，去往下一个点的时候有初速度，这样下一个点就更不稳定了，恶性循环，所以就想着时间拉长一点，给它多一点的时间，让他在一个点稳定下来。

  1. else if(a==5)
  2. 	{
  3. 		if(timeflag == 0)
  4. 		{
  5. 			X_aim = 83;
  6. 			task();
  7. 			if(jinruflag==0)
  8. 			{
  9. 				TIM2_Init(5000-1,7200-1);         //0.5s中断一次   
  10. 				delay_ms(20);
  11. 				jinruflag = 1;
  12. 			}
  13. 		}	
  14. 		if(timeflag == 1)
  15. 		{
  16. 			 X_aim = 145;
  17. 			 task();
  18. 		}
  19. 	}

第6题用的自主选择四个点，让小球进行平衡，看看也就是将之前的三个固定点变为随机的四个点，用蓝牙输入就行，我们选择的是蓝牙app上位机软件，发送的就是四个字符，到时候接收过来之后直接放在接收的数组里面，直接调用就行，确实，思路没啥问题，可是偏偏蓝牙接收就出问题了，我们可以在手机app端发送字符串，但是单片机的串口并不接受字符，换了几个串口都无济于事，花费了几个小时的时间，最后突然用了一个之前调好项目的蓝牙代码就好了，最后也找到了问题的根源---->

这是串口的中断的代码，你会发现有0X0D和0X0A的判断，对了，这是我们输入在app软件也要有这个多一行的换行符的存在，因为这个中断是通过判断0X0D和0X0A判断接收完成的，如果你的中断不加这个，就可以不用换行。

  1. void USART2_IRQHandler(void)                    //串口1中断服务程序
  2.     {
  3.     u8 Res;
  4.     if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
  5.         {
  6.         Res =USART_ReceiveData(USART2);    //读取接收到的数据
  7.         if((USART2_RX_STA&0x8000)==0)//接收未完成
  8.             {
  9.             if(USART2_RX_STA&0x4000)//接收到了0x0d
  10.                 {
  11.                 if(Res!=0x0a)USART2_RX_STA=0;//接收错误,重新开始
  12.                 else USART2_RX_STA|=0x8000;    //接收完成了 
  13.                 }
  14.             else //还没收到0X0D
  15.                 {    
  16.                 if(Res==0x0d)USART2_RX_STA|=0x4000;
  17.                 else
  18.                     {
  19.                     USART2_RX_BUF[USART2_RX_STA&0X3FFF]=Res;
  20.                     USART2_RX_STA++;
  21.                     if(USART2_RX_STA>(USART_REC_LEN-1))USART2_RX_STA=0;//接收数据错误,重新开始接收      
  22.                     }         
  23.                 }
  24.             }   
  25.         						
  26.      } 
  27.  
  28. }

功能7：在2，4两点运行四次往复，最后去往5，因为当时就剩几个小时了，我们的硬件电路还没接好，所以我就有点着急，也没休息好，脑子很乱，当时想了一个方案计时，用static的静态变量去算，到2，4的次数有没有8次，来确定是否往复四次，想想也简单，就是传个已经有的现成坐标和openmv的实时坐标相减，得到位置差,传入PID,可是PID的参数调的不是很好，小球从2出发，到4还没稳定就又往2，所以误差越来越大，以至于到最后5的时候就飞出去了，当时去调PID已经不太可能了，但是我们发现选择的2，4两个点，它却在1，5之间徘徊，所以我们干脆把判断的范围直接往小了缩，类似于给小球一个预判，原本小球的目标是4，到4或者快到4它才开始大幅度调节，我们现在让他变成3.5，从2开始的距离差变小了，它就会判断提前，改了之后还真效果不错，只有一次没达到标【比之前就一次达标好太多了】，这道题后来也这样了。

  1. else if(a == 7)
  2. 	{
  3. 		if(x_now<57&&x_now>46)
  4.   {
  5.    while(1)
  6.    {
  7.     X_aim = 93;                      //原来 4的X_aim是 113
  8.     task();
  9.     if(x_now<114&&x_now>106)
  10.      break;
  11.    }
  12.    count++;
  13.   }
  14.   if(x_now<114&&x_now>106)
  15.   {
  16.    while(1)
  17.    {
  18.     X_aim = 70;                         //原来的2的X_aim = 53
  19.      task();
  20.     if(x_now<57&&x_now>50)
  21.      break;
  22.    } 
  23.    count++;
  24.   }
  25.   if(count >= 8)
  26.   {
  27.    while(1)
  28.    {
  29.     X_aim = 145;
  30.      task();
  31.    }
  32.   }
  33. 	}

最后一个是鲁棒性的测试，这个和之前的1，2，3很像，还是如果PID调的好的话，就很快，我们那个就是有点慢，这个题就在那个秒数限定的极限范围。

后来时间不允许就做了8问。

总结回顾：

1.PID调参很重要，如果有友友有啥好的推荐的软件可以给我推荐一下吗？？

2.硬件电路的降压以及电压稳压问题需要格外重视

3.32的部分模块具体详细的作用还是不太清晰。

4.我们的团队配合还是不太好，团队的力量很重要

代码开源：MMMMMs426/-: 电赛一维板球代码 (github.com)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/689233
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号