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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 电子技术分类讨论区 › 智能小车/机器人 › PS2遥控车资料分享-51单片机,stm32,arduino,树莓派源代 ...
返回列表 发新帖
查看: 10066|回复: 11
收起左侧

PS2遥控车资料分享-51单片机,stm32,arduino,树莓派源代码

  [复制链接]
ID:402431 发表于 2018-10-2 21:09 | 显示全部楼层 |阅读模式
Ps2遥控车资料分享（非本人所写，随ps2遥控器购买时赠送，供大家学习之用）--51，stm32,arduino,树莓派  代码，

代码自己看，自己调试，在此不做详解。

1、PS2手柄介绍
              PS2 手柄是游戏机的遥控手柄。psx 系列游戏主机在全球很是畅销。不知什么时候便有人打起 PS2 手柄的主意，破解了通讯协议，使得手柄可以接在其他器件上遥控使用，比如遥控我们熟悉的机器人。突出的特点是现在这款手柄性价比极高。按键丰富，方便扩展到其它应用中。
PS2 手柄介绍：
              PS2 由手柄与接收器两部分组成，手柄主要负责发送按键信息。都接通电源并打开手柄开关时，手柄与接收器自动配对连接，在未配对成功的状态下，接收器绿灯闪烁，手柄上的灯也会闪烁，配对成功后，接收器上绿灯常亮，手柄上灯也常亮，这时可以按“MODE”键，选择手柄发送模式，红灯模式：遥杆输出模拟值；绿灯模式：遥杆对应上面四个按键，只有四个极限方向对应。
接收器和主机（单片机）相连，实现主机与手柄之间的通讯。
接收器引脚输出：
1
2
3
4
5
6
7
8
9
DI/DAT
DO/CMD
NC
GND
VDD
CS/SEL
CLK
NC
ACK

接收器图片
图 1.1 接收器引脚序号
DI/DAT：信号流向，从手柄到主机，此信号是一个 8bit 的串行数据，同步传送于时钟
的下降沿。信号的读取在时钟由高到低的变化过程中完成。
DO/CMD：信号流向，从主机到手柄，此信号和 DI 相对，信号是一个 8bit 的串行数据，同步传送于时钟的下降沿。
NC：空端口；
GND：电源地；
VDD：接收器工作电源，电源范围 3~5V；
CS/SEL：用于提供手柄触发信号。在通讯期间，处于低电平；
CLK：时钟信号，由主机发出，用于保持数据同步；
NC：空端口；
ACK：从手柄到主机的应答信号。此信号在每个 8bits 数据发送的最后一个周期变低并且 CS 一直保持低电平，如果 CS 信号不变低，约 60 微秒PS 主机会试另一个外设。在编程时未使用ACK 端口。当主机想读手柄数据时，将会拉低 CS 线电平，并发出一个命令“0x01”；手柄会回复它的ID“0x41=模拟绿灯，0x73=模拟红灯”；在手柄发送 ID 的同时，主机将传送 0x42，请求数据；随后手柄发送出 0x5A，告诉主机“数据来了”。
表 1：数据意义对照表
顺序
DO
DI
Bit0、Bit1、Bit2、Bit3、Bit4、Bit5、Bit6、Bit7、
0
0X01
idle

1
0x42
ID

2
idle
0x5A

3
idle
data
SELECT、L3、R3、START、UP、RIGHT、DOWN、LEFT
4
idle
data
L2、R2、L1、R1、△、○、╳、□
5
idle
data
PSS_RX（0x00=left、0xFF=right）
6
idle
data
PSS_RY（0x00=up、0xFF=down）
7
idle
data
PSS_LX（0x00=left、0xFF=right）
8
idle
data
PSS_LY（0x00=up、0xFF=down）

当有按键按下，对应位为“0”，其他位为“1”，例如当键“SELECT”被按下时，
Data[3]=11111110B，
红灯模式时：左右摇杆发送模拟值，0x00~0xFF 之间，且摇杆按下的键值值 L3、R3 有
效；
绿灯模式时：左右摇杆模拟值为无效，推到极限时，对应发送 UP、RIGHT、DOWN、
LEFT、△、○、╳、□，按键 L3、R3 无效。
2、硬件连接方式
接收器与 stm32平衡车 连接方式
1
2
3
4
5
6
7
8
9
DI/DAT
DO/CMD
NC
GND
VDD
CS/SEL
CLK
NC
ACK
接收器引脚
功能脚
STM32
1
DI
PA8
2
DO
PA9
4
GND
GND
5
VDD
VCC
6
CS
PA10
7
CLK
PA11
3、按键对应说明

模式我们选择红灯模式，这样可以使用遥杆流畅的控制小车。其他所有按键接口都有留出来，方便后续自己DIY按键功能。

模拟值对应XY坐标图：



PS2_4WD智能小车（51版）程序源码（部分）：

  1. #include "STC12C5A60S2.h"
  2. #include "stdio.h"
  3. #include "ps2.h"

  5. #define ON 1     //使能LED
  6. #define OFF 0    //禁止LED
  7.                                                                                                       
  8. //定义电机引脚
  9. sbit Left_motor_go=P2^1;           //左电机前进AIN2
  10. sbit Left_motor_back=P2^2;           //左电机后退AIN1
  11. sbit Right_motor_go=P2^4;           //右电机前进BIN2
  12. sbit Right_motor_back=P2^3;           //右电机后退BIN1
  13. sbit Left_motor_pwm=P2^0;           //左电机控速PWMA
  14. sbit Right_motor_pwm=P2^5;           //右电机控速PWMB

  16. unsigned char pwm_val_left  =0; //变量定义
  17. unsigned char pwm_val_right =0;

  19. //速度调节变量 0-200,0最小,200最大
  20. unsigned char push_val_left =150;  // 左电机占空比push_val_left/200
  21. unsigned char push_val_right=150;  // 右电机占空比push_val_right/200

  23. //蜂鸣器引脚定义
  24. sbit FM=P2^7;

  26. //定义舵机引脚
  27. sbit ServoPin=P0^5;


  30. //舵机定时计数
  31. int servocount=0;

  33. //定义舵机角度值
  34. int myangle = 0;

  36. //定义RGB七彩灯引脚
  37. sbit LED_R = P4^6;        //LED_R接在STC12C5A60S2的EA（P4^6）管脚
  38. sbit LED_G = P4^5;  //LED_G接在STC12C5A60S2的ALE（P4^5）管脚
  39. sbit LED_B = P4^4;        //LED_B接在STC12C5A60S2的PSEN（P4^4）管脚

  41. //电机控速开关                          
  42. bit Left_PWM_ON=1;
  43. bit Right_PWM_ON=1;

  45. //时间变量和小车速度，小车状态变量定义
  46. unsigned char  time;                  
  47. int g_carstate = 0;
  48. int g_ServoState = 0;     //1左摇 2 右摇
  49. //小车速度档位
  50. int g_volume = 0;

  52. //小车运行状态枚举
  53. enum{
  54.   enSTOP = 0,
  55.   enRUN,
  56.   enBACK,
  57.   enLEFT,
  58.   enRIGHT,
  59.   enUPLEFT,
  60.   enUPRIGHT,
  61.   enDOWNLEFT,
  62.   enDOWNRIGHT,
  63.   enSPINLEFT,
  64.   enSPINRIGHT
  65. }enCarState;

  67. //宏定义电机速度档位
  68. #define         enMinMin() do{\
  69.                        push_val_left =50; \
  70.                                            push_val_right =50;\
  71.                                            }while(0)

  73. #define         enMin() do{\
  74.                        push_val_left =100; \
  75.                                            push_val_right =100;\
  76.                                            }while(0)

  78. #define         enMidle() do{\
  79.                        push_val_left =150; \
  80.                                            push_val_right =150;\
  81.                                            }while(0)

  83. #define         enMax() do{\
  84.                        push_val_left =200; \
  85.                                            push_val_right =200;\
  86.                                            }while(0)
  87.                                                                                     
  88. /**
  89. * Function       delay
  90. * @author        Danny
  91. * @date          2017.08.16
  92. * @brief         延时函数
  93. * @param         xms：延时时间（ms）
  94. * @retval        void
  95. * @par History   无
  96. */      
  97. void delay(unsigned int xms)                              
  98. {
  99.     unsigned int i,j;
  100.         for(i=xms;i>0;i--)                     
  101.     for(j=850;j>0;j--);
  102. }

  104. /**
  105. * Function       pwm_out_left_motor
  106. * @author        Danny
  107. * @date          2017.08.16
  108. * @brief         左电机调速        ,调节push_val_left的值改变电机转速,占空比
  109. * @param         void
  110. * @retval        void
  111. * @par History   无
  112. */                        
  113. void pwm_out_left_motor(void)               
  114. {  
  115.      if(Left_PWM_ON)
  116.      {
  117.           if(pwm_val_left<=push_val_left)
  118.               {
  119.                   Left_motor_pwm =1;
  120.               }
  121.               else
  122.               {
  123.                    Left_motor_pwm=0;
  124.           }
  125.           if(pwm_val_left>=200) //这里的200代表的是pwm为20ms即50hz
  126.               pwm_val_left=0;
  127.      }
  128.      else   
  129.      {
  130.           Left_motor_pwm=0;   //若未开启PWM则PWMA=0 左电机停止
  131.      }
  132. }


  135. /**
  136. * Function       pwm_out_right_motor
  137. * @author        Danny
  138. * @date          2017.08.16
  139. * @brief         右电机调速        ,调节pwm_val_right的值改变电机转速,占空比
  140. * @param         void
  141. * @retval        void
  142. * @par History   无
  143. */
  144. void pwm_out_right_motor(void)                  
  145. {
  146.     if(Right_PWM_ON)
  147.     {
  148.         if(pwm_val_right<=push_val_right)      
  149.             {
  150.                 Right_motor_pwm=1;                                                        
  151.         }
  152.             else
  153.             {
  154.                 Right_motor_pwm=0;
  155.         }
  156.             if(pwm_val_right>=200) //这里的200代表的是pwm为20ms即50hz
  157.             pwm_val_right=0;
  158.     }
  159.     else   
  160.     {
  161.         Right_motor_pwm=0;          //若未开启PWM则PWMB=0右电机停止
  162.     }
  163. }

  165.   /**
  166. * Function       servo_appointed_detection
  167. * @author        Danny
  168. * @date          2017.08.16
  169. * @brief         舵机旋转到指定角度
  170. * @param[in]     pos：指定的角度
  171. * @param[out]    void
  172. * @retval        void
  173. * @par History   无
  174. */
  175. void servo_appointed_detection(int pos)
  176. {
  177.   int i = 0;
  178.   for (i = 0; i <= 15; i++) //产生PWM个数，等效延时以保证能转到响应角度
  179.   {
  180.     myangle = pos;          //模拟产生PWM
  181.         delay(20);
  182. }
  183. }

  185. /**
  186. * Function       run
  187. * @author        Danny
  188. * @date          2017.08.16
  189. * @brief         小车前进
  190. * @param[in1]    time :延时时间
  191. * @param[out]    void
  192. * @retval        void
  193. * @par History   无
  194. */
  195. void run(unsigned int time)
  196. {
  197.   //左电机前进
  198.   Left_motor_go = 1;   //左电机前进使能
  199.   Left_motor_back = 0; //左电机后退禁止
  200.   //更新指定管脚的PWM值，更改可实现控速（0-200）
  201. // push_val_left=CarSpeed;
  202.          
  203.   //右电机前进
  204.   Right_motor_go=1;   //右电机前进使能
  205.   Right_motor_back=0; //右电机后退禁止
  206.   //更新指定管脚的PWM值，更改可实现控速（0-200）
  207.   //push_val_right=CarSpeed;

  209.   //延时
  210.   delay(time * 100);
  211.   return;
  212. }

  214. /**
  215. * Function       brake
  216. * @author        Danny
  217. * @date          2017.08.16
  218. * @brief         小车刹车
  219. * @param[in]     time
  220. * @param[out]    void
  221. * @retval        void
  222. * @par History   无
  223. */
  224. void brake(unsigned int time)
  225. {
  226.   //左电机停止
  227.   Left_motor_go = 0;   //左电机前进禁止
  228.   Left_motor_back = 0; //左电机后退禁止
  229.          
  230.   //右电机停止
  231.   Right_motor_go=0;   //右电机前进禁止
  232.   Right_motor_back=0;  //右电机后退禁止

  234.   //延时
  235.   delay(time * 100);
  236.   return;
  237. }

  239. /**
  240. * Function       left
  241. * @author        Danny
  242. * @date          2017.08.16
  243. * @brief         小车左转 左转(左轮不动,右轮前进)
  244. * @param[in]     time :延时时间
  245. * @param[out]    void
  246. * @retval        void
  247. * @par History   无
  248. */
  249. void left(unsigned int time)
  250. {
  251.   //左电机停止
  252.   Left_motor_go = 0;   //左电机前进禁止
  253.   Left_motor_back = 0;   //左电机后退禁止
  254.   //更新指定管脚的PWM值，更改可实现控速（0-200）
  255. // push_val_left=0;
  256.            
  257.   //右电机前进
  258.   Right_motor_go=1;   //右电机前进使能
  259.   Right_motor_back=0;  //右电机后退禁止
  260.   //更新指定管脚的PWM值，更改可实现控速（0-200）
  261.   //push_val_right=CarSpeed;

  263.   //延时
  264.   delay(time * 100);
  265.   return;
  266. }

  268. /**
  269. * Function       right
  270. * @author        Danny
  271. * @date          2017.08.16
  272. * @brief         小车右转 右转(左轮前进,右轮不动)
  273. * @param[in]     time:延时时间
  274. * @param[out]    void
  275. * @retval        void
  276. * @par History   无
  277. */
  278. void right(unsigned int time)
  279. {
  280.   //左电机前进
  281.   Left_motor_go = 1;   //左电机前进使能
  282.   Left_motor_back = 0;   //左电机后退禁止
  283.   //更新指定管脚的PWM值，更改可实现控速（0-20）
  284.   //push_val_left=CarSpeed;
  285.          
  286.   //右电机停止
  287.   Right_motor_go=0;   //右电机前进禁止
  288.   Right_motor_back=0;  //右电机后退禁止
  289.   //更新指定管脚的PWM值，更改可实现控速（0-20）
  290.   push_val_right=0;

  292.   //延时
  293.   delay(time * 100);  
  294.   return;
  295. }

  297. /**
  298. * Function       spin_left
  299. * @author        Danny
  300. * @date          2017.08.16
  301. * @brief         小车原地左转 原地左转(左轮后退，右轮前进)
  302. * @param[in]     time:延时时间
  303. * @param[out]    void
  304. * @retval        void
  305. * @par History   无
  306. */
  307. void spin_left(unsigned int time)
  308. {
  309.   //左电机后退
  310.   Left_motor_go = 0;   //左电机前进禁止
  311.   Left_motor_back = 1;   //左电机后退使能
  312.   //更新指定管脚的PWM值，更改可实现控速（0-20）
  313. // push_val_left=CarSpeed;
  314.          
  315.   //右电机前进
  316.   Right_motor_go=1;   //右电机前进使能
  317.   Right_motor_back=0;  //右电机后退禁止
  318.   //更新指定管脚的PWM值，更改可实现控速（0-20）
  319. // push_val_right=CarSpeed;

  321.   //延时
  322.   delay(time * 100);  
  323.   return;
  324. }

  326. /**
  327. * Function       spin_right
  328. * @author        Danny
  329. * @date          2017.08.16
  330. * @brief         小车原地右转 原地右转(右轮后退，左轮前进)
  331. * @param[in]     time:延时时间
  332. * @param[out]    void
  333. * @retval        void
  334. * @par History   无
  335. */
  336. void spin_right(unsigned int time)
  337. {
  338.   //左电机前进
  339.   Left_motor_go = 1;   //左电机前进使能
  340.   Left_motor_back = 0;  //左电机后退禁止
  341.   //更新指定管脚的PWM值，更改可实现控速（0-20）
  342.   //push_val_left=CarSpeed;
  343.          
  344.   //右电机后退
  345.   Right_motor_go=0;   //右电机前进禁止
  346.   Right_motor_back=1;  //右电机后退使能
  347.   //更新指定管脚的PWM值，更改可实现控速（0-20）
  348.   //push_val_right=CarSpeed;

  350.   //延时
  351.   delay(time * 100);  
  352.   return;
  353. }

  355. /**
  356. * Function       up_right
  357. * @author        Danny
  358. * @date          2017.08.16
  359. * @brief         小车往右上方转
  360. * @param[in]     time:延时时间
  361. * @param[out]    void
  362. * @retval        void
  363. * @par History   无
  364. */
  365. void up_right(unsigned int time)        //右上
  366. {
  367.         Left_motor_go=1;
  368.         Left_motor_back=0;
  369. //        push_val_left=CarSpeed+50;
  370.         push_val_left=18;

  372.         Right_motor_go=1;
  373.         Right_motor_back=0;
  374.         //push_val_right=CarSpeed;
  375.         push_val_right=10;
  376.     //延时
  377.     delay(time * 100);
  378.     return;
  379. }

  381. /**
  382. * Function       down_right
  383. * @author        Danny
  384. * @date          2017.08.16
  385. * @brief         小车往右下方转
  386. * @param[in]     time:延时时间
  387. * @param[out]    void
  388. * @retval        void
  389. * @par History   无
  390. */
  391. void down_right(unsigned int time)  //右下
  392. {      
  393.         Left_motor_go=0;
  394.         Left_motor_back=1;
  395.         //push_val_left=CarSpeed+50;
  396.     push_val_left=18;
  397.         Right_motor_go=0;
  398.         Right_motor_back=1;
  399.         //push_val_right=CarSpeed;
  400.         push_val_right=10;
  401.         delay(time * 100);
  402.         return;
  403. }

  405. /**
  406. * Function       up_left
  407. * @author        Danny
  408. * @date          2017.08.16
  409. * @brief         小车往左上方转
  410. * @param[in]     time:延时时间
  411. * @param[out]    void
  412. * @retval        void
  413. * @par History   无
  414. */
  415. void up_left(unsigned int time)         
  416. {
  417.            Left_motor_go=1;
  418.         Left_motor_back=0;
  419.         //push_val_left=CarSpeed;
  420.         push_val_left=10;
  421.         Right_motor_go=1;
  422.         Right_motor_back=0;
  423. //        push_val_right=CarSpeed+50;
  424.         push_val_right=18;
  425.         delay(time * 100);
  426.     return;
  427. }

  429. /**
  430. * Function       down_left
  431. * @author        Danny
  432. * @date          2017.08.16
  433. * @brief         小车往左下方转
  434. * @param[in]     time :延时时间
  435. * @param[out]    void
  436. * @retval        void
  437. * @par History   无
  438. */
  439. void down_left(unsigned int time)      
  440. {
  441.            Left_motor_go=0;
  442.         Left_motor_back=1;
  443.         //push_val_left=CarSpeed;
  444.         push_val_left=10;
  445.         Right_motor_go=0;
  446.         Right_motor_back=1;
  447.         //push_val_right=CarSpeed+50;
  448.         push_val_right=18;
  449.         delay(time * 100);
  450.     return;
  451. }

  453. /**
  454. * Function       back
  455. * @author        Danny
  456. * @date          2017.08.16
  457. * @brief         小车后退
  458. * @param[in]     time ：延时时间
  459. * @param[out]    void
  460. * @retval        void
  461. * @par History   无
  462. */
  463. void back(unsigned int time)
  464. {
  465.   //左电机后退
  466.   Left_motor_go = 0;   //左电机前进禁止
  467.   Left_motor_back = 1; //左电机后退使能
  468.          
  469.   //右电机后退
  470.   Right_motor_go=0;    //右电机前进禁止
  471.   Right_motor_back=1;  //右电机后退使能

  473.   //延时
  474.   delay(time * 100);
  475.   return;
  476. }

  478. /**
  479. * Function       timer0
  480. * @author        Danny
  481. * @date          2017.08.16
  482. * @brief         TIMER0中断服务子函数产生PWM信号，用于控制电机速度和控制舵机的转动
  483. * @param[in]     void
  484. * @param[out]    void
  485. * @retval        void
  486. * @par History   无
  487. */
  488. void timer0()interrupt 1
  489. {
  490.      int PulseWidth;
  491.      TH0=0Xff;              //100us定时
  492.          TL0=0Xa4;
  493.          servocount++;
  494.                                                      //定义脉宽变量
  495.      PulseWidth = ((myangle*11)+500)/100 ;  //为了将0-180度转换为相应的脉宽值
  496.      if(servocount == PulseWidth)
  497.      {
  498.             ServoPin=0;                //将舵机接口电平置高
  499.      }                  
  500.      if(servocount == 190)                   //190为最终调试获得的一个最佳值
  501.      {
  502.             servocount = 0;
  503.         ServoPin=1;                //将舵机接口电平置低
  504.      }
  505.          pwm_val_left++;
  506.          pwm_val_right++;
  507.          pwm_out_left_motor();
  508.          pwm_out_right_motor();
  509. }

  511. /**
  512. * Function       TIME0_Init
  513. * @author        Danny
  514. * @date          2017.08.16
  515. * @brief         定时器0初始化
  516. * @param[in]     void
  517. * @param[out]    void
  518. * @retval        void
  519. * @par History   无
  520. */
  521. void TIME0_Init(void)
  522. {
  523.         TMOD |=0X01;        //定时器工作方式1
  524.         TH0= 0Xff;      //100Us定时
  525.     TL0= 0Xa4;
  526.         TR0= 1;                    //启动T0工作
  527.         ET0= 1;                    //允许T0中断
  528.         EA = 1;                //开总中断
  529. }

  531. /**
  532. * Function       color_led
  533. * @author        Danny
  534. * @date          2017.08.16
  535. * @brief         由R,G,B三色的不同组合形成7种不同的色彩
  536. * @param[in1]    Red开关
  537. * @param[in2]    Green开关
  538. * @param[in3]    Blue开关
  539. * @retval        void
  540. * @par History   无
  541. */
  542. void color_led(int v_iRed, int v_iGreen, int v_iBlue)
  543. {
  544.   //红色LED
  545.   v_iRed == ON ? (LED_R = 1): (LED_R = 0);

  547.   //绿色LED
  548.   v_iGreen == ON ? (LED_G = 1): (LED_G = 0);

  550.   //蓝色LED
  551.   v_iBlue == ON ? (LED_B = 1): (LED_B = 0);
  552. }


  555. /**
  556. * Function       UartInit
  557. * @author        Danny
  558. * @date          2017.08.16
  559. * @brief         串口初始化
  560. *                定时器工作方式2：
  561. *                实现的是自动重载：波特率的计算为：
  562. *                (2的SMOD次方/32)*(sysclk(单片机内部时钟频率)/12)/(256-TH1)
  563.                  (系统默认下的SMOD是0，T1X12也是为0的)
  564.                                  1/32*((11059200/12)/(256-FD))=9600
  565. * @param[in]     void
  566. * @retval        void
  567. * @par History   无
  568. */

  570. void UartInit(void)   
  571. {
  572.     SCON|=0x50;           //串行口工作在方式1，允许串行接收
  573.     TMOD|=0x20;                 //定时器1工作方式2，自动重载初值，TL1：初始值，TH1：重载值
  574.     TH1=0xfd;                 //初始化波特率为9600
  575.         TL1=0xfd;
  576.     TI=1;                         //发送标志位置1，表示发送完一个字节
  577.     TR1=1;                         //定时器1开始工作
  578. }

  580. /**
  581. * Function       PS2_control
  582. * @author        Danny
  583. * @date          2017.07.25
  584. * @brief         PS2控制小车
  585. * @param[in]     void
  586. * @param[out]    void
  587. * @retval        void
  588. * @par History   无
  589. */
  590. void PS2_control()
  591. {
  592.         //PS2按键变量定义
  593.         stPS2KeyValue * PS2;
  594.            
  595.                 PS2 = ReadPS2KeyValue();            //检测手柄按键之后获得的值
  596.                 //由data[3]和data[4]返回来的组合成16位的数组
  597.                 //如data[4]data[3]:当select按下时
  598.                 //FunBtn：0x1111 1111 1111 1110
  599.                 if((PS2->FunBtn & PSB_SELECT) == 0)
  600.                 {
  601.                   printf("PSB_SELECT!\n");
  602.                 }
  603.                
  604.                 if((PS2->FunBtn & PSB_START) == 0)
  605.                 {
  606.                   printf("PSB_START!\n");
  607.                 }
  608.                  
  609.                 if((PS2->FunBtn & PSB_L3) == 0)
  610.                 {
  611.                          printf("PSB_L3!\n");
  612.                          g_carstate = enSTOP;      //将小车定义为停止状态
  613.                 }

  615.                 if((PS2->FunBtn & PSB_R3) == 0)
  616.                 {
  617.                         printf("PSB_R3!\n");
  618.                          g_carstate = enSTOP;      //将小车定义为停止状态
  619.                 }

  621.                 if((PS2->FunBtn & PSB_PAD_UP) == 0)
  622.                 {
  623.                          printf("PSB_PAD_UP!\n");
  624.                          g_carstate = enRUN;       //将小车定义为前进状态
  625.                 }

  627.                 else if((PS2->FunBtn & PSB_PAD_RIGHT) == 0)
  628.                 {
  629.                          printf("PSB_PAD_RIGHT!\n");
  630.                          g_carstate = enRIGHT;     //将小车定义为状态右转
  631.                 }
  632.                 else if((PS2->FunBtn & PSB_PAD_DOWN) == 0)
  633.                 {
  634.                         printf("PSB_PAD_DOWN!\n");
  635.                         g_carstate = enBACK;       //将小车定义为后退状态
  636.                 }
  637.                 else if((PS2->FunBtn & PSB_PAD_LEFT) == 0)
  638.                 {
  639.                          printf("PSB_PAD_LEFT!\n");
  640.                          g_carstate = enLEFT;       //将小车定义为左转状态
  641.                 }
  642.          
  643.                 else                           //去掉则按下一直执行，加此段则放开停止
  644.                 {
  645.                    g_carstate = enSTOP;        //将小车定义为停止状态
  646.                 }
  647.                   
  648.                 if((PS2->FunBtn & PSB_L2) == 0)                         //加速
  649.                 {
  650.                         printf("PSB_L2!\n");
  651. //                        CarSpeed=CarSpeed+40;
  652. //                        if(CarSpeed>=200)                       
  653. //                        {
  654. //                                CarSpeed = 200;
  655. //                        }
  656.             g_volume++;
  657.                         if(g_volume>=4)                          //将速度设置了四个等级
  658.                         {
  659.                                 g_volume = 4;
  660.                         }
  661.                 }
  662.                  
  663.                 if((PS2->FunBtn & PSB_R2) == 0)                         //减速
  664.                 {
  665.                         printf("PSB_R2!\n");
  666. //                        CarSpeed=CarSpeed-40;
  667. //                        if(CarSpeed<0)                       
  668. //                        {
  669. //                                CarSpeed = 50;
  670. //                        }
  671.                         g_volume--;
  672.                         if(g_volume <= 0)
  673.                         {
  674.                                 g_volume = 1;
  675.                         }
  676.                 }
  677.                 //当手柄的L1键被按下后，且有左侧有摇杆数据（X1，Y1）之后处理
  678.                 //左侧摇杆控制小车的运行状态                        
  679.                 if((PS2->FunBtn & PSB_L1) == 0)
  680.                 {
  681.                          printf("PSB_L1!\n");
  682.                         
  683.                     if (PS2->Y1 < 5 && PS2->X1 > 80 && PS2->X1 < 180) //上
  684.                     {
  685.                               g_carstate = enRUN;
  686.                                   printf("enRUN\n");
  687.                     }
  688.                     else if (PS2->Y1 > 230 && PS2->X1 > 80 && PS2->X1 < 180) //下
  689.                     {
  690.                               g_carstate = enBACK;
  691.                                   printf("enBACK\n");
  692.                     }
  693.                     else if (PS2->X1 < 5 && PS2->Y1 > 80 && PS2->Y1 < 180) //左
  694.                     {
  695.                               g_carstate = enLEFT;
  696.                                   printf("enLEFT\n");
  697.                     }
  698.                     else if (PS2->Y1 > 80 && PS2->Y1 < 180 && PS2->X1 > 230)//右
  699.                     {
  700.                               g_carstate = enRIGHT;
  701.                            printf("enRIGHT\n");
  702.                     }
  703.                     else if (PS2->Y1 <= 80 && PS2->X1 <= 80) //左上
  704.                     {
  705.                               g_carstate = enUPLEFT;
  706.                                   printf("enUPLEFT\n");
  707.                     }
  708.                     else if (PS2->Y1 <= 80 && PS2->X1 >= 180) //右上
  709.                     {
  710.                               g_carstate = enUPRIGHT;
  711.                                   printf("enUPRIGHT\n");
  712.                     }
  713.                     else if (PS2->X1 <= 80 && PS2->Y1 >= 180) // 左下
  714.                     {
  715.                               g_carstate = enDOWNLEFT;
  716.                                   printf("enDOWNLEFT\n");
  717.                     }
  718.                     else if (PS2->Y1 >= 180 && PS2->X1 >= 180) //右下
  719.                     {
  720.                               g_carstate = enDOWNRIGHT;
  721.                                   printf("enDOWNRIGHT\n");
  722.                     }
  723.                     else//停
  724.                     {
  725.                               g_carstate = enSTOP;
  726.                     }
  727.                 }
  728.                 //当R1被按下之后，且有右侧摇杆数据来临时。
  729.                 //右侧摇杆控制小车的舵机的运行状态
  730.                 if((PS2->FunBtn & PSB_R1) == 0)
  731.                 {
  732.                      printf("PSB_R1!\n");
  733.                          //右摇杆
  734.                      if (PS2->X2 < 5 && PS2->Y2 > 80 && PS2->Y2 < 180)    //左
  735.              {
  736.                 g_ServoState = 1;
  737.              }
  738.              else if (PS2->Y2 > 80 && PS2->Y2 < 180 &&PS2->X2 > 230)//右
  739.              {
  740.                 g_ServoState = 2;
  741.              }
  742.              else                                      //归位
  743.              {
  744.                 g_ServoState = 0;
  745.              }
  746.                 }        
  747.                        
  748.                 if((PS2->FunBtn & PSB_TRIANGLE) == 0) // 控制灯
  749.                 {
  750.                          printf("PSB_TRIANGLE!\n");

  752.                            color_led(ON, OFF, ON);

  754.                         // ReadPS2KeyValue();
  755.                 }
  756.                  
  757.                 if((PS2->FunBtn & PSB_CIRCLE) == 0)        // 控制左旋
  758.                 {
  759.                          printf("PSB_CIRCLE!\n");
  760.                          g_carstate = enLEFT;  
  761.                         // ReadPS2KeyValue();
  762.                 }  
  763.       
  764.                 if((PS2->FunBtn & PSB_CROSS) == 0) // 鸣笛
  765.                 {
  766.                         printf("PSB_CROSS!\n");
  767.                         FM = 0;
  768.                         delay(500);
  769.                         FM = 1;
  770.                 //        ReadPS2KeyValue();
  771.                 }
  772.                  
  773.                 if((PS2->FunBtn & PSB_SQUARE) == 0)          //控制右旋
  774.                 {
  775.                          printf("PSB_SQUARE!\n");
  776.                          g_carstate = enRIGHT;
  777.                         // ReadPS2KeyValue();
  778.                 }
  779. }
复制代码
全部资料51hei下载地址：

PS2_51智能小车.zip

2.89 MB, 下载次数: 139, 下载积分: 黑币 -5

PS2_Arduino智能小车.zip

778.8 KB, 下载次数: 73, 下载积分: 黑币 -5

PS2_STM32平衡车.rar

1.99 MB, 下载次数: 52, 下载积分: 黑币 -5

PS2_蝙蝠车.zip

1.56 MB, 下载次数: 33, 下载积分: 黑币 -5

PS2_4WD智能小车（51版）程序源码.rar

1.11 MB, 下载次数: 91, 下载积分: 黑币 -5

PS2_4WD智能小车（Arduino版）程序源码.rar

662.6 KB, 下载次数: 52, 下载积分: 黑币 -5

PS2_4WD智能小车（STM32版）程序.rar

1.34 MB, 下载次数: 89, 下载积分: 黑币 -5

PS2_4WD智能小车（树莓派版）程序源码.rar

636.92 KB, 下载次数: 91, 下载积分: 黑币 -5

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

回复

使用道具 举报

ID:439952 发表于 2019-1-19 15:18 | 显示全部楼层

PS2_4WD智能小车（STM32版）程序.rar哪来的源文件？？？？？？？？
回复

使用道具 举报

ID:598292 发表于 2019-8-9 11:50 | 显示全部楼层
厉害了，感谢楼主分享
回复

使用道具 举报

ID:208192 发表于 2019-9-2 10:15 | 显示全部楼层
感谢楼主分享
回复

使用道具 举报

ID:608128 发表于 2019-9-7 10:13 | 显示全部楼层
很厉害，感谢分享
回复

使用道具 举报

ID:626121 发表于 2019-10-18 13:15 | 显示全部楼层
谢谢楼主分享
回复

使用道具 举报

ID:376710 发表于 2020-2-6 12:47 | 显示全部楼层
感谢楼主
回复

使用道具 举报

ID:365823 发表于 2020-2-14 14:02 | 显示全部楼层
感谢楼主分享
回复

使用道具 举报

ID:742063 发表于 2021-5-1 16:56 | 显示全部楼层
有链接吗？哪个是三轮的程序STC89C52的
回复

使用道具 举报

ID:920352 发表于 2021-5-13 21:46 | 显示全部楼层
好资料，51黑有你更精彩!!!
回复

使用道具 举报

ID:920352 发表于 2021-5-13 21:47 | 显示全部楼层
好资料，51黑有你更精彩!!!
回复

使用道具 举报

ID:949550 发表于 2024-1-17 16:11 | 显示全部楼层
好像是亚博智能的资料，感谢分享
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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