设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › STM32/8 › 用ps2手柄控制 stm32F4驱动麦克纳姆轮3D图纸源码资料
返回列表 发新帖
查看: 5896|回复: 3
打印 上一主题 下一主题
收起左侧

用ps2手柄控制 stm32F4驱动麦克纳姆轮3D图纸源码资料

[复制链接]
跳转到指定楼层
楼主
ID:384234 发表于 2018-10-10 11:23 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
ps2手柄控制 stm32f4zgt6芯片驱动麦克纳姆轮资料
这里使用的是PWM调速来完成的，简单的程序，资料和源码在下面。


麦克纳姆轮3D图纸:


单片机源程序如下:
  1. #include <sys.h>
  2. #include <pwm.h>
  3. #include <delay.h>
  4. #include <usart.h>
  5. #include <pstwo.h>

  7. int main(void)
  8. {
  9.         u16 L11=0;   
  10.   u16 L12=0;
  11.         u16 L21=0;   
  12.   u16 L22=0;
  13.         u16 R11=0;   
  14.   u16 R12=0;
  15.         u16 R21=0;   
  16.   u16 R22=0;
  17.         u8 key;       
  18.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
  19.         delay_init(168);      //初始化延时函数
  20.         uart_init(115200);    //初始化串口波特率为115200
  21.         PWM_init(500-1,84-1);        //84M/84=1Mhz的计数频率,重装载值500，所以PWM频率为 1M/500=2Khz.     
  22.         PS2_Init();
  23.         PS2_SetInit();
  24.        
  25.         while(1)
  26.         {
  27.                 key=PS2_DataKey();
  28.                 if(key!=0)
  29.                 {      
  30.                         switch(key)
  31.                         {
  32.                                 case 5:        //前进
  33.                                 {
  34.                             L11=300;   
  35.           L12=0;
  36.                 L21=300;   
  37.           L22=0;
  38.                 R11=300;   
  39.           R12=0;
  40.           R21=300;   
  41.           R22=0;
  42.           TIM_SetCompare1(TIM14,L11);
  43.           TIM_SetCompare1(TIM13,L12);
  44.           TIM_SetCompare1(TIM11,L21);
  45.           TIM_SetCompare1(TIM10,L22);
  46.           TIM_SetCompare1(TIM3,R11);
  47.           TIM_SetCompare2(TIM3,R12);
  48.           TIM_SetCompare3(TIM3,R21);
  49.           TIM_SetCompare4(TIM3,R22);                                       
  50.                                 }
  51.                                 break;
  52.                                 case 6:        //右平移
  53.                                 {
  54.                 L11=0;   
  55.           L12=300;
  56.                 L21=300;   
  57.           L22=0;
  58.                 R11=300;   
  59.           R12=0;
  60.           R21=0;   
  61.           R22=300;
  62.           TIM_SetCompare1(TIM14,L11);
  63.           TIM_SetCompare1(TIM13,L12);
  64.           TIM_SetCompare1(TIM11,L21);
  65.           TIM_SetCompare1(TIM10,L22);
  66.           TIM_SetCompare1(TIM3,R11);
  67.           TIM_SetCompare2(TIM3,R12);
  68.           TIM_SetCompare3(TIM3,R21);
  69.           TIM_SetCompare4(TIM3,R22);                                       
  70.                                 }
  71.                                 break;
  72.                                 case 8:         //左平移
  73.                                 {
  74.                 L11=300;   
  75.           L12=0;
  76.                 L21=0;   
  77.           L22=300;
  78.                 R11=0;   
  79.           R12=300;
  80.           R21=300;   
  81.           R22=0;
  82.           TIM_SetCompare1(TIM14,L11);
  83.           TIM_SetCompare1(TIM13,L12);
  84.           TIM_SetCompare1(TIM11,L21);
  85.           TIM_SetCompare1(TIM10,L22);
  86.           TIM_SetCompare1(TIM3,R11);
  87.           TIM_SetCompare2(TIM3,R12);
  88.           TIM_SetCompare3(TIM3,R21);
  89.           TIM_SetCompare4(TIM3,R22);                                       
  90.                                 }
  91.                                 break;
  92.                                 case 7:        //后退
  93.                                 {
  94.                 L11=0;   
  95.           L12=300;
  96.                 L21=0;   
  97.           L22=300;
  98.                 R11=0;   
  99.           R12=300;
  100.           R21=0;   
  101.           R22=300;
  102.           TIM_SetCompare1(TIM14,L11);
  103.           TIM_SetCompare1(TIM13,L12);
  104.           TIM_SetCompare1(TIM11,L21);
  105.           TIM_SetCompare1(TIM10,L22);
  106.           TIM_SetCompare1(TIM3,R11);
  107.           TIM_SetCompare2(TIM3,R12);
  108.           TIM_SetCompare3(TIM3,R21);
  109.           TIM_SetCompare4(TIM3,R22);                                       
  110.                                 }
  111.                                 break;
  112.                                 case 9:         //逆时针旋转
  113.                                 {
  114.                 L11=0;   
  115.           L12=300;
  116.                 L21=0;   
  117.           L22=300;
  118.                 R11=300;   
  119.           R12=0;
  120.           R21=300;   
  121.           R22=0;
  122.           TIM_SetCompare1(TIM14,L11);
  123.           TIM_SetCompare1(TIM13,L12);
  124.           TIM_SetCompare1(TIM11,L21);
  125.           TIM_SetCompare1(TIM10,L22);
  126.           TIM_SetCompare1(TIM3,R11);
  127.           TIM_SetCompare2(TIM3,R12);
  128.           TIM_SetCompare3(TIM3,R21);
  129.           TIM_SetCompare4(TIM3,R22);                                       
  130.                                 }
  131.                                 break;
  132.                                 case 10:         //顺时针旋转
  133.                                 {
  134.                 L11=300;   
  135.           L12=0;
  136.                 L21=300;   
  137.           L22=0;
  138.                 R11=0;   
  139.           R12=300;
  140.           R21=0;   
  141.           R22=300;
  142.           TIM_SetCompare1(TIM14,L11);
  143.           TIM_SetCompare1(TIM13,L12);
  144.           TIM_SetCompare1(TIM11,L21);
  145.           TIM_SetCompare1(TIM10,L22);
  146.           TIM_SetCompare1(TIM3,R11);
  147.           TIM_SetCompare2(TIM3,R12);
  148.           TIM_SetCompare3(TIM3,R21);
  149.           TIM_SetCompare4(TIM3,R22);                                       
  150.                                 }
  151.                                 break;
  152.                                 case 13:         //左前
  153.                                 {
  154.                 L11=0;   
  155.           L12=0;
  156.                 L21=300;   
  157.           L22=0;
  158.                 R11=300;   
  159.           R12=0;
  160.           R21=0;   
  161.           R22=0;
  162.           TIM_SetCompare1(TIM14,L11);
  163.           TIM_SetCompare1(TIM13,L12);
  164.           TIM_SetCompare1(TIM11,L21);
  165.           TIM_SetCompare1(TIM10,L22);
  166.           TIM_SetCompare1(TIM3,R11);
  167.           TIM_SetCompare2(TIM3,R12);
  168.           TIM_SetCompare3(TIM3,R21);
  169.           TIM_SetCompare4(TIM3,R22);                                       
  170.                                 }
  171.                                 break;
  172.                                 case 14:         //右前
  173.                                 {
  174.                 L11=300;   
  175.           L12=0;
  176.                 L21=0;   
  177.           L22=0;
  178.                 R11=0;   
  179.           R12=0;
  180.           R21=300;   
  181.           R22=0;
  182.           TIM_SetCompare1(TIM14,L11);
  183.           TIM_SetCompare1(TIM13,L12);
  184.           TIM_SetCompare1(TIM11,L21);
  185.           TIM_SetCompare1(TIM10,L22);
  186.           TIM_SetCompare1(TIM3,R11);
  187.           TIM_SetCompare2(TIM3,R12);
  188.           TIM_SetCompare3(TIM3,R21);
  189.           TIM_SetCompare4(TIM3,R22);                                       
  190.                                 }
  191.                                 break;
  192.                                 case 16:         //左后
  193.                                 {
  194.                 L11=0;   
  195.           L12=0;
  196.                 L21=0;   
  197.           L22=300;
  198.                 R11=0;   
  199.           R12=300;
  200.           R21=0;   
  201.           R22=0;
  202.           TIM_SetCompare1(TIM14,L11);
  203.           TIM_SetCompare1(TIM13,L12);
  204.           TIM_SetCompare1(TIM11,L21);
  205.           TIM_SetCompare1(TIM10,L22);
  206.           TIM_SetCompare1(TIM3,R11);
  207.           TIM_SetCompare2(TIM3,R12);
  208.           TIM_SetCompare3(TIM3,R21);
  209.           TIM_SetCompare4(TIM3,R22);                                       
  210.                                 }
  211.                                 break;
  212.                                 case 15:         //右后
  213.                                 {
  214.                 L11=0;   
  215.           L12=300;
  216.                 L21=0;   
  217.           L22=0;
  218.                 R11=0;   
  219.           R12=0;
  220.           R21=0;   
  221.           R22=300;
  222.           TIM_SetCompare1(TIM14,L11);
  223.           TIM_SetCompare1(TIM13,L12);
  224.           TIM_SetCompare1(TIM11,L21);
  225.           TIM_SetCompare1(TIM10,L22);
  226.           TIM_SetCompare1(TIM3,R11);
  227.           TIM_SetCompare2(TIM3,R12);
  228.           TIM_SetCompare3(TIM3,R21);
  229.           TIM_SetCompare4(TIM3,R22);                                       
  230.                                 }
  231.                                 break;
  232.                         }                               

  234.            }
  235.                         else//停止
  236.                         {
  237.                                   L11=0;   
  238.           L12=0;
  239.                 L21=0;   
  240.           L22=0;
  241.                 R11=0;   
  242.           R12=0;
  243.           R21=0;   
  244.           R22=0;
  245.                                   TIM_SetCompare1(TIM14,L11);
  246.           TIM_SetCompare1(TIM13,L12);
  247.           TIM_SetCompare1(TIM11,L21);
  248.           TIM_SetCompare1(TIM10,L22);
  249.           TIM_SetCompare1(TIM3,R11);
  250.           TIM_SetCompare2(TIM3,R12);
  251.           TIM_SetCompare3(TIM3,R21);
  252.           TIM_SetCompare4(TIM3,R22);
  253.                         }
  254.                         delay_ms(50);
  255.          }
  256.         }
复制代码


  1. #include "main.h"
  2. #include "PID.h"
  3. #include<stdio.h>
  4. #include<math.h>
  5. #include<systick.h>
  6. #include<main.h>


  9. #define Kp 10                                                 //比例系数
  10. #define Ki 10                                         //积分系数
  11. #define Kd 0                                                 //微分系数

  13. #define PID_MAX 12800

  15. uint8_t last_error;                          //上次误差
  16. uint8_t last_error1;                  //上次误差
  17. uint8_t last_error2;                  //上次误差

  19. float I_term;                                                  //前面温差和
  20. float I_term1;                                          //前面温差和
  21. float I_term2;                                          //前面温差和

  23. u16 PWMA_Num =0;
  24. u16        PWMB_Num =0;
  25. u16 PWMC_Num =0;

  27. //unsigned int out;//,PWMT;
  28. //unsigned int out1//,PWMT;

  30. int PID(int Set_value,int Real_value) //标准PID温度控制算法
  31. {
  32.         int error;
  33.         float P_term, D_term;
  34.         int pid_out;
  35.         error=Set_value - Real_value;                                                                                                //误差量
  36.   //if(error<1000)
  37.   //{
  38.                 P_term =Kp*error;                                                                                                                                 //比例量
  39.                 I_term+=Ki*error;                                                                                                                                 //积分量
  40.                 if(I_term>PID_MAX) I_term=PID_MAX;                                                                 //限定积分量上限
  41.                 else if(I_term<0) I_term=0;                                                                                   //限定积分量下限
  42.                 D_term =Kd*(error - last_error);                                                                  //微分量
  43.                 last_error=error;                                                                                                                                 //缓存当前误差量
  44.                 if(error<20)I_term=130;
  45.                 else I_term=0;
  46.                 pid_out=(signed int)(P_term+I_term+D_term);                         //PID控制量计算
  47.   
  48.                 if(pid_out>PID_MAX) pid_out=PID_MAX;                                                  //控制量上限=PID_MAX
  49.                 else if(pid_out<0) pid_out=0;                                                                            //控制量下限=0
  50.                 //return(pid_out);
  51.   //}
  52.   //else if(error>=1000) pid_out=12800;
  53.    
  54.   return(pid_out);
  55. }

  57. int PID1(int Set_value,int Real_value) //标准PID温度控制算法
  58. {
  59.         int error;
  60.         float P_term, D_term;
  61.         int pid_out;
  62.         error=Set_value - Real_value;                                                                                                //误差量
  63.   //if(error<1000)
  64.   //{
  65.                 P_term =Kp*error;                                                                                                                                 //比例量
  66.                 I_term1+=Ki*error;                                                                                                                                 //积分量
  67.                 if(I_term1>PID_MAX) I_term1=PID_MAX;                                                                 //限定积分量上限
  68.                 else if(I_term1<0) I_term1=0;                                                                                   //限定积分量下限
  69.                 D_term =Kd*(error - last_error1);                                                                  //微分量
  70.                 last_error1=error;                                                                                                                                 //缓存当前误差量
  71.                 if(error<20)I_term1=130;
  72.                 else I_term1=0;
  73.                 pid_out=(signed int)(P_term+I_term1+D_term);                         //PID控制量计算
  74.   
  75.                 if(pid_out>PID_MAX) pid_out=PID_MAX;                                                  //控制量上限=PID_MAX
  76.                 else if(pid_out<0) pid_out=0;                                                                            //控制量下限=0
  77.                 //return(pid_out);
  78.   //}
  79.   //else if(error>=1000) pid_out=12800;
  80.    
  81.   return(pid_out);
  82. }

  84. int PID2(int Set_value,int Real_value) //标准PID温度控制算法
  85. {
  86.         int error;
  87.         float P_term, D_term;
  88.         int pid_out;
  89.         error=Set_value - Real_value;                                                                                                //误差量
  90.   //if(error<1000)
  91.   //{
  92.                 P_term =Kp*error;                                                                                                                                 //比例量
  93.                 I_term2+=Ki*error;                                                                                                                                 //积分量
  94.                 if(I_term2>PID_MAX) I_term2=PID_MAX;                                                                 //限定积分量上限
  95.                 else if(I_term2<0) I_term2=0;                                                                                   //限定积分量下限
  96.                 D_term =Kd*(error - last_error2);                                                                  //微分量
  97.                 last_error2=error;                                                                                                                                 //缓存当前误差量
  98.                 if(error<20)I_term2=130;
  99.                 else I_term2=0;
  100.                 pid_out=(signed int)(P_term+I_term2+D_term);                         //PID控制量计算
  101.   
  102.                 if(pid_out>PID_MAX) pid_out=PID_MAX;                                                  //控制量上限=PID_MAX
  103.                 else if(pid_out<0) pid_out=0;                                                                            //控制量下限=0
  104.                 //return(pid_out);
  105.   //}
  106.   //else if(error>=1000) pid_out=12800;
  107.    
  108.   return(pid_out);
  109. }

  111. void jiare_pid_kongzhi(void)
  112. {
  113.         uint16_t goal_temp=0;//目标温度
  114.         //PWMT=12800;                                                                                                                                                           //128级步进PWM控制  
  115.         //PID_MAX=PWMT;

  117.         uint16_t out=0;
  118.         I_term=0;
  119.         last_error=0;
  120.         if (WorkFaceDisBuff[10]==0)//现场测试华氏不加热 增加温度单位转换 目标温度是摄氏和华氏分开存放的 2017年12月6日 09:16:22
  121.         {
  122.                 goal_temp = (WorkFaceDisBuff[3]+0)*100;//之前的是+3 会导致PWM值超过目标温度值3度的时候才停止 可能需要PID数值才是正确方法 2017年11月30日 15:04:01
  123.         }
  124.         else
  125.         {
  126.                 goal_temp = (WorkFaceDisBuff[11]+0)*100;//之前的是+3 会导致PWM值超过目标温度值3度的时候才停止 可能需要PID数值才是正确方法 2017年11月30日 15:04:01
  127.         }
  128.         out=PID(goal_temp,WorkFaceDisBuff[4]);                                                                                                                          //PID程序
  129.         PWMA_Num= (out/100);                                                                                                                 //PWM值
  130. }  

  132. void jiare_pid_kongzhi1(void)
  133. {
  134.         uint16_t goal_temp=0;//目标温度
  135.         //PWMT=12800;                                                                                                                                                           //128级步进PWM控制  
  136.         //PID_MAX=PWMT;

  138.         uint16_t out=0;
  139.         I_term1=0;
  140.         last_error1=0;
  141.        
  142.         if (WorkFaceDisBuff[10]==0)//现场测试华氏不加热 增加温度单位转换 目标温度是摄氏和华氏分开存放的 2017年12月6日 09:16:22
  143.         {
  144.                 goal_temp = (WorkFaceDisBuff[5]+0)*100;//之前的是+3 会导致PWM值超过目标温度值3度的时候才停止 可能需要PID数值才是正确方法 2017年11月30日 15:04:01
  145.         }
  146.         else
  147.         {
  148.                 goal_temp = (WorkFaceDisBuff[12]+0)*100;//之前的是+3 会导致PWM值超过目标温度值3度的时候才停止 可能需要PID数值才是正确方法 2017年11月30日 15:04:01
  149.         }
  150.         out=PID1(goal_temp,WorkFaceDisBuff[6]);                                                                                                                          //PID程序
  151.         PWMB_Num= (out/100);                                                                                                                 //PWM值
  152. }  

  154. void jiare_pid_kongzhi2(void)
  155. {
  156.         uint16_t goal_temp=0;//目标温度
  157. //        //PWMT=12800;                                                                                                                                                           //128级步进PWM控制  
  158. //        //PID_MAX=PWMT;

  160. //        uint16_t out=0;
  161. //        I_term2=0;
  162. //        last_error2=0;
  163.        
  164.         if (WorkFaceDisBuff[10]==0)//现场测试华氏不加热 增加温度单位转换 目标温度是摄氏和华氏分开存放的 2017年12月6日 09:16:22
  165.         {
  166.                 goal_temp = (WorkFaceDisBuff[7]+0)*100;//之前的是+3 会导致PWM值超过目标温度值3度的时候才停止 可能需要PID数值才是正确方法 2017年11月30日 15:04:01
  167.         }
  168.         else
  169.         {
  170.                 goal_temp = (WorkFaceDisBuff[13]+0)*100;//之前的是+3 会导致PWM值超过目标温度值3度的时候才停止 可能需要PID数值才是正确方法 2017年11月30日 15:04:01
  171.         }
  172. //        out=PID1(goal_temp,WorkFaceDisBuff[8]);                                                                                                                          //PID程序
  173. //        PWMC_Num= (out/100);                                                                                                                 //PWM值
  174.         if (goal_temp>WorkFaceDisBuff[8])//将PWM转化为开关量了 因为C路是继电器控制的
  175.         {
  176.                 PWMC_Num=129;//永远大于128
  177.         }
  178.         else
  179.         {
  180.                 PWMC_Num=0;
  181.         }
  182. }  
复制代码

所有资料51hei提供下载:
2018.9.28 TIM3backup.rar (459.3 KB, 下载次数: 76)
纳姆车资料 STM32源码+3D图纸.7z (4.45 MB, 下载次数: 99)


分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏1 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:305426 发表于 2018-11-30 17:26 | 只看该作者
正好要用呐。想问下这个经过测试了咩，PID控制可靠么~
回复

使用道具 举报

板凳
ID:305426 发表于 2018-11-30 17:47 | 只看该作者
下载来看了一下，原来是开环控制…失望…
回复

使用道具 举报

地板
ID:243337 发表于 2019-4-9 08:51
下载的程序打不开。
5#
ID:537157 发表于 2019-5-21 16:12 | 只看该作者
不知道你这个东西能干嘛？还以为是PS2的东西，
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表