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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › Arduino › arduino驱动PS2无线手柄库文件与资料下载
返回列表 发新帖
查看: 9907|回复: 6
打印 上一主题 下一主题
收起左侧

arduino驱动PS2无线手柄库文件与资料下载

[复制链接]
跳转到指定楼层
楼主
ID:408859 发表于 2018-10-13 06:44 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
PS2无线手柄快速上手教程
使用前准备
程序分析
使用前准备
将接收器连接到arduino上（共用到6个引脚，程序中使用的是8、
9、10、11号引脚，接收器跟arduino的连线可根据实际情况修改引脚。
如果没有接收器转接板，请查看接收器引脚说明）。
下载例程（使用的是arduino uno r3），打开串口监视器，按下遥控
按键查看效果（具体使用见下面程序分析）。

程序源码与资料链接:
校内机器人比赛.rar (6.1 MB, 下载次数: 65)

游客，本帖隐藏的内容需要积分高于 10 才可浏览，您当前积分为 0

引脚需要与程序相对应
接收器转接板
接收器引脚说明
程序分析
1. 首先将文件PS2X_lib.cpp，PS2X_lib.h拷贝到项目文件夹下。
2. 添加头文件。
3. 遥控接收器引脚声明（需要跟实际连线相对应）。
4. 实例化一个PS2对象
5. arduino初始化
ps2x.config_gamepad(PS2_CLK, PS2_CMD, PS2_CS, PS2_DAT, pressures, rumble);
PS2引脚初始化，返回值为0说明遥控连接成功。
6. 在循环中读取遥控数据
ps2x.read_gamepad(false, 0);
You must Read Gamepad to get new values and set vibration values
ps2x.read_gamepad(small motor on/off, larger motor strenght from 0-255)，if
you don't enable the rumble, use ps2x.read_gamepad(); with no values。You
should call this at least once a second。
PS2遥控内部是有两个震动马达的，这里我们不使用。
调用此函数读取遥控器状态，每个循环调用一次，但不要太频繁。
按键状态读取有三个函数
ps2x.Button( x ) ,只要按键按下会一直触发，按下时串口一直打印数据。
ps2x.ButtonPressed(x)，按键按下时触发一次，按下时串口只打印一次数据。
ps2x.ButtonReleased(x)，按键释放时触发一次，松开时串口只打印一次数据。
x表示按键的宏定义，
具体效果请自行测试。
摇杆数据读取
ps2x.Analog( x ) ，x表示摇杆的宏定义，具体如下图：
遥控读取数据的教程就到这里了，按键的具体功能就需要结合自己的机器人使用
了。

单片机源程序如下:
  1. #include "PS2X_lib.h"
  2. #include <math.h>
  3. #include <stdio.h>
  4. #include <stdint.h>
  5. #include <avr/io.h>
  6. #if ARDUINO > 22
  7. #include "Arduino.h"
  8. #else
  9. #include "WProgram.h"
  10. #include "pins_arduino.h"
  11. #endif



  15. static byte enter_config[]={0x01,0x43,0x00,0x01,0x00};
  16. static byte set_mode[]={0x01,0x44,0x00,0x01,0x03,0x00,0x00,0x00,0x00};
  17. static byte set_bytes_large[]={0x01,0x4F,0x00,0xFF,0xFF,0x03,0x00,0x00,0x00};
  18. static byte exit_config[]={0x01,0x43,0x00,0x00,0x5A,0x5A,0x5A,0x5A,0x5A};
  19. static byte enable_rumble[]={0x01,0x4D,0x00,0x00,0x01};
  20. static byte type_read[]={0x01,0x45,0x00,0x5A,0x5A,0x5A,0x5A,0x5A,0x5A};

  22. boolean PS2X::NewButtonState() {
  23.    return ((last_buttons ^ buttons) > 0);

  25. }

  27. boolean PS2X::NewButtonState(unsigned int button) {
  28.   return (((last_buttons ^ buttons) & button) > 0);
  29. }

  31. boolean PS2X::ButtonPressed(unsigned int button) {
  32.   return(NewButtonState(button) & Button(button));
  33. }

  35. boolean PS2X::ButtonReleased(unsigned int button) {
  36.   return((NewButtonState(button)) & ((~last_buttons & button) > 0));
  37. }
  38.   
  39. boolean PS2X::Button(uint16_t button) {
  40.    return ((~buttons & button) > 0);
  41. }

  43. unsigned int PS2X::ButtonDataByte() {
  44.    return (~buttons);
  45. }

  47. byte PS2X::Analog(byte button) {
  48.   return PS2data[button];
  49. }
  50. unsigned char PS2X::_gamepad_shiftinout (char byte) {
  51.   

  53.    unsigned char tmp = 0;
  54.    for(i=0;i<8;i++) {

  56.           if(CHK(byte,i)) CMD_SET();
  57.           else  CMD_CLR();
  58.           CLK_CLR();

  60.           delayMicroseconds(CTRL_CLK);

  62.           if(DAT_CHK()) SET(tmp,i);
  63.           CLK_SET();
  64. #if CTRL_CLK_HIGH
  65.           delayMicroseconds(CTRL_CLK_HIGH);
  66. #endif          
  67.    }
  68.    CMD_SET();
  69.    delayMicroseconds(CTRL_BYTE_DELAY);
  70.    return tmp;
  71. }

  73. void PS2X::read_gamepad() {
  74.     read_gamepad(false, 0x00);
  75. }


  78. boolean PS2X::read_gamepad(boolean motor1, byte motor2) {
  79.   double temp = millis() - last_read;
  80.   
  81.   if (temp > 1500) //waited to long
  82.     reconfig_gamepad();
  83.    
  84.   if(temp < read_delay)  //waited too short
  85.     delay(read_delay - temp);
  86.    
  87.    

  89.   if(motor2 != 0x00)
  90.     motor2 = map(motor2,0,255,0x40,0xFF); //noting below 40 will make it spin
  91.   
  92.   char dword[9] = {0x01,0x42,0,motor1,motor2,0,0,0,0};
  93.   byte dword2[12] = {0,0,0,0,0,0,0,0,0,0,0,0};

  95.   // Try a few times to get valid data...
  96.   for (byte RetryCnt = 0; RetryCnt < 5; RetryCnt++) {
  97.             CMD_SET();
  98.       CLK_SET();
  99.       ATT_CLR(); // low enable joystick
  100.           
  101.           delayMicroseconds(CTRL_BYTE_DELAY);
  102.           //Send the command to send button and joystick data;

  104.           for (int i = 0; i<9; i++) {
  105.                   PS2data[i] = _gamepad_shiftinout(dword[i]);
  106.           }


  109.           if((PS2data[1] == 0x79) || (PS2data[1] == 0x41)) {  //if controller is in full data return mode, get the rest of data
  110.                    for (int i = 0; i<12; i++) {
  111.                                 PS2data[i+9] = _gamepad_shiftinout(dword2[i]);
  112.                    }
  113.           }
  114.                
  115.             ATT_SET(); // HI disable joystick
  116.           // Check to see if we received valid data or not.  We should be in analog mode for our data
  117.           // to be valie
  118.           if ((PS2data[1] & 0xf0) == 0x70)
  119.                 break;
  120.        
  121.         // If we got to here, we are not in analog mode, try to recover...
  122.         reconfig_gamepad();        // try to get back into Analog mode.
  123.         delay(read_delay);
  124.   }
  125.   
  126.   // If we get here and still not in analog mode, try increasing the read_delay...
  127.   if ((PS2data[1] & 0xf0) != 0x70) {
  128.         if (read_delay < 10)
  129.                 read_delay++;        // see if this helps out...
  130.   }       

  132.        
  133.         #ifdef PS2X_COM_DEBUG
  134.     Serial.println("OUT:IN");
  135.                 for(int i=0; i<9; i++){
  136.                         Serial.print(dword[i], HEX);
  137.                         Serial.print(":");
  138.                         Serial.print(PS2data[i], HEX);
  139.                         Serial.print(" ");
  140.                 }
  141.                 for (int i = 0; i<12; i++) {
  142.                         Serial.print(dword2[i], HEX);
  143.                         Serial.print(":");
  144.                         Serial.print(PS2data[i+9], HEX);
  145.                         Serial.print(" ");
  146.                 }
  147.         Serial.println("");       
  148.         #endif
  149.        
  150.   last_buttons = buttons; //store the previous buttons states

  152. #if defined(__AVR__)
  153.    buttons = *(uint16_t*)(PS2data+3);   //store as one value for multiple functions
  154. #else
  155.    buttons =  (uint16_t)(PS2data[4] << 8) + PS2data[3];   //store as one value for multiple functions
  156. #endif
  157.    last_read = millis();
  158.    return ((PS2data[1] & 0xf0) == 0x70);
  159. }

  161. byte PS2X::config_gamepad(uint8_t clk, uint8_t cmd, uint8_t att, uint8_t dat) {
  162.         return config_gamepad(clk, cmd, att, dat, false, false);
  163. }


  166. byte PS2X::config_gamepad(uint8_t clk, uint8_t cmd, uint8_t att, uint8_t dat, bool pressures, bool rumble) {

  168.    byte temp[sizeof(type_read)];
  169.   
  170. #ifdef __AVR__
  171. _clk_mask = digitalPinToBitMask(clk);
  172. _clk_oreg = portOutputRegister(digitalPinToPort(clk));
  173. _cmd_mask = digitalPinToBitMask(cmd);
  174. _cmd_oreg = portOutputRegister(digitalPinToPort(cmd));
  175. _att_mask = digitalPinToBitMask(att);
  176. _att_oreg = portOutputRegister(digitalPinToPort(att));
  177. _dat_mask = digitalPinToBitMask(dat);
  178. _dat_ireg = portInputRegister(digitalPinToPort(dat));
  179. #else

  181.         uint32_t            lport;                   // Port number for this pin
  182.         _clk_mask = digitalPinToBitMask(clk);
  183.         lport = digitalPinToPort(clk);
  184.         _clk_lport_set = portOutputRegister(lport) + 2;
  185.         _clk_lport_clr = portOutputRegister(lport) + 1;

  187.         _cmd_mask = digitalPinToBitMask(cmd);
  188.         lport = digitalPinToPort(cmd);
  189.         _cmd_lport_set = portOutputRegister(lport) + 2;
  190.         _cmd_lport_clr = portOutputRegister(lport) + 1;

  192.         _att_mask = digitalPinToBitMask(att);
  193.         lport = digitalPinToPort(att);
  194.         _att_lport_set = portOutputRegister(lport) + 2;
  195.         _att_lport_clr = portOutputRegister(lport) + 1;
  196.   
  197.         _dat_mask = digitalPinToBitMask(dat);
  198.         _dat_lport = portInputRegister(digitalPinToPort(dat));

  200. #endif  

  202.   pinMode(clk, OUTPUT); //configure ports
  203.   pinMode(att, OUTPUT);
  204.   pinMode(cmd, OUTPUT);
  205.   pinMode(dat, INPUT);

  207. #if defined(__AVR__)
  208.   digitalWrite(dat, HIGH); //enable pull-up
  209. #endif
  210.    
  211.    CMD_SET(); // SET(*_cmd_oreg,_cmd_mask);
  212.    CLK_SET();
  213.    
  214.    //new error checking. First, read gamepad a few times to see if it's talking
  215.    read_gamepad();
  216.    read_gamepad();
  217.    
  218.    //see if it talked
  219.    if(PS2data[1] != 0x41 && PS2data[1] != 0x73 && PS2data[1] != 0x79){ //see if mode came back. If still anything but 41, 73 or 79, then it's not talking
  220.       #ifdef PS2X_DEBUG
  221.                 Serial.println("Controller mode not matched or no controller found");
  222.                 Serial.print("Expected 0x41 or 0x73, got ");
  223.                 Serial.println(PS2data[1], HEX);
  224.           #endif
  225.          
  226.          return 1; //return error code 1
  227.         }
  228.   
  229.   //try setting mode, increasing delays if need be.
  230.   read_delay = 1;
  231.   
  232.   for(int y = 0; y <= 10; y++)
  233.   {
  234.    sendCommandString(enter_config, sizeof(enter_config)); //start config run
  235.    
  236.    //read type
  237.            delayMicroseconds(CTRL_BYTE_DELAY);

  239.         CMD_SET();
  240.     CLK_SET();
  241.     ATT_CLR(); // low enable joystick
  242.        
  243.     delayMicroseconds(CTRL_BYTE_DELAY);

  245.     for (int i = 0; i<9; i++) {
  246.           temp[i] = _gamepad_shiftinout(type_read[i]);
  247.     }

  249.         ATT_SET(); // HI disable joystick
  250.        
  251.         controller_type = temp[3];
  252.    
  253.    sendCommandString(set_mode, sizeof(set_mode));
  254.    if(rumble){ sendCommandString(enable_rumble, sizeof(enable_rumble)); en_Rumble = true; }
  255.    if(pressures){ sendCommandString(set_bytes_large, sizeof(set_bytes_large)); en_Pressures = true; }
  256.    sendCommandString(exit_config, sizeof(exit_config));
  257.    
  258.    read_gamepad();
  259.    
  260.    if(pressures){
  261.         if((PS2data[1] == 0x79) || (PS2data[1] == 0x41))
  262.                 break;
  263.         if(PS2data[1] == 0x73)
  264.                 return 3;
  265.    }
  266.    
  267.     if(PS2data[1] == 0x73)
  268.       break;
  269.       
  270.     if(y == 10){
  271.                 #ifdef PS2X_DEBUG
  272.                 Serial.println("Controller not accepting commands");
  273.                 Serial.print("mode stil set at");
  274.                 Serial.println(PS2data[1], HEX);
  275.                 #endif
  276.       return 2; //exit function with error
  277.           }
  278.    
  279.     read_delay += 1; //add 1ms to read_delay
  280.   }
  281.    
  282. return 0; //no error if here
  283. }



  287. void PS2X::sendCommandString(byte string[], byte len) {
  288.   

  290.   #ifdef PS2X_COM_DEBUG
  291.   byte temp[len];
  292.   ATT_CLR(); // low enable joystick
  293.   delayMicroseconds(CTRL_BYTE_DELAY);
  294.        
  295.   for (int y=0; y < len; y++)
  296.     temp[y] = _gamepad_shiftinout(string[y]);
  297.    
  298.   ATT_SET(); //high disable joystick  
  299.    delay(read_delay);                  //wait a few
  300.   
  301.   Serial.println("OUT:IN Configure");
  302.   for(int i=0; i<len; i++){
  303.                         Serial.print(string[i], HEX);
  304.                         Serial.print(":");
  305.                         Serial.print(temp[i], HEX);
  306.                         Serial.print(" ");
  307.                 }
  308.    Serial.println("");
  309.   
  310.   #else
  311.   ATT_CLR(); // low enable joystick
  312.   for (int y=0; y < len; y++)
  313.     _gamepad_shiftinout(string[y]);
  314.    
  315.    ATT_SET(); //high disable joystick  
  316.    delay(read_delay);                  //wait a few
  317.    #endif
  318. }



  322. byte PS2X::readType() {
  323. /*
  324.         byte temp[sizeof(type_read)];
  325.        
  326.         sendCommandString(enter_config, sizeof(enter_config));
  327.        
  328.         delayMicroseconds(CTRL_BYTE_DELAY);

  330.         CMD_SET();
  331.     CLK_SET();
  332.     ATT_CLR(); // low enable joystick
  333.        
  334.     delayMicroseconds(CTRL_BYTE_DELAY);

  336.     for (int i = 0; i<9; i++) {
  337.           temp[i] = _gamepad_shiftinout(type_read[i]);
  338.     }
  339.        
  340.         sendCommandString(exit_config, sizeof(exit_config));
  341.          
  342.         if(temp[3] == 0x03)
  343.                 return 1;
  344.         else if(temp[3] == 0x01)
  345.                 return 2;
  346.        
  347.         return 0;
  348.         */
  349.        
  350.         if(controller_type == 0x03)
  351.                 return 1;
  352.         else if(controller_type == 0x01)
  353.                 return 2;
  354.        
  355.         //return 0;
  356.         return controller_type;
  357.        
  358. }

  360. byte PS2X::readMode() {
  361.         return PS2data[1];       
  362. }

  364. void PS2X::enableRumble() {
  365.   
  366.      sendCommandString(enter_config, sizeof(enter_config));
  367.      sendCommandString(enable_rumble, sizeof(enable_rumble));
  368.      sendCommandString(exit_config, sizeof(exit_config));
  369.      en_Rumble = true;
  370.   
  371. }

  373. bool PS2X::enablePressures() {
  374.   
  375.      sendCommandString(enter_config, sizeof(enter_config));
  376.      sendCommandString(set_bytes_large, sizeof(set_bytes_large));
  377.      sendCommandString(exit_config, sizeof(exit_config));
  378.          
  379.          read_gamepad();
  380.          read_gamepad();
  381.          
  382.           if((PS2data[1] != 0x79)  && (PS2data[1] != 0x41))
  383.                 return false;
  384.                
  385.      en_Pressures = true;
  386.          return true;
  387. }

  389. void PS2X::reconfig_gamepad(){
  390.   
  391.    sendCommandString(enter_config, sizeof(enter_config));
  392.    sendCommandString(set_mode, sizeof(set_mode));
  393.    if (en_Rumble)
  394.       sendCommandString(enable_rumble, sizeof(enable_rumble));
  395.    if (en_Pressures)
  396.       sendCommandString(set_bytes_large, sizeof(set_bytes_large));
  397.    sendCommandString(exit_config, sizeof(exit_config));
  398.    
  399. }


  402. #ifdef __AVR__
  403. inline void  PS2X::CLK_SET(void) {
  404.        
  405.    register uint8_t old_sreg = SREG;
  406.    cli();
  407.    *_clk_oreg |= _clk_mask;
  408.    SREG = old_sreg;
  409. }

  411. inline void  PS2X::CLK_CLR(void) {
  412.    register uint8_t old_sreg = SREG;
  413.    cli();
  414.    *_clk_oreg &= ~_clk_mask;
  415.    SREG = old_sreg;
  416. }

  418. inline void  PS2X::CMD_SET(void) {
  419.    register uint8_t old_sreg = SREG;
  420.    cli();
  421.    *_cmd_oreg |= _cmd_mask; // SET(*_cmd_oreg,_cmd_mask);
  422.    SREG = old_sreg;
  423. }

  425. inline void  PS2X::CMD_CLR(void) {
  426.    register uint8_t old_sreg = SREG;
  427.    cli();
  428.    *_cmd_oreg &= ~_cmd_mask; // SET(*_cmd_oreg,_cmd_mask);
  429.    SREG = old_sreg;
  430. }

  432. inline void  PS2X::ATT_SET(void) {
  433.    register uint8_t old_sreg = SREG;
  434.    cli();
  435.   *_att_oreg |= _att_mask ;        
  436.    SREG = old_sreg;
  437. }

  439. inline void PS2X::ATT_CLR(void) {
  440.    register uint8_t old_sreg = SREG;
  441.    cli();
  442.   *_att_oreg &= ~_att_mask;
  443.    SREG = old_sreg;
  444. }

  446. inline bool PS2X::DAT_CHK(void) {
  447.         return (*_dat_ireg & _dat_mask)? true : false;
  448. }

  450. #else
  451. // On pic32, use the set/clr registers to make them atomic...inline void  PS2X::CLK_SET(void) {
  452.         *_clk_lport_set |= _clk_mask;
  453. }

  455. inline void  PS2X::CLK_CLR(void) {
  456.         *_clk_lport_clr |= _clk_mask;
  457. }

  459. inline void  PS2X::CMD_SET(void) {
  460.         *_cmd_lport_set |= _cmd_mask;
  461. }

  463. inline void  PS2X::CMD_CLR(void) {
  464.         *_cmd_lport_clr |= _cmd_mask;
  465. }

  467. inline void  PS2X::ATT_SET(void) {
  468.         *_att_lport_set |= _att_mask;
  469. }

  471. inline void PS2X::ATT_CLR(void) {
  472.         *_att_lport_clr |= _att_mask;
  473. }

  475. inline bool PS2X::DAT_CHK(void) {
  476.         return (*_dat_lport & _dat_mask)? true : false;

  478. }


  481. byte PS2X::psxType() {
  482.         /*if(PS2data[1] == 0x41) {
  483.                 return 1;
  484.         } else if(PS2data[1] == 0x79) {
  485.                 return 2;
  486.         }*/
  487.        
  488.         return PS2data[1];
  489.         //return 0;
  490. }

  492. #endif
复制代码





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

使用道具 举报

沙发
ID:32574 发表于 2018-10-17 14:06 | 只看该作者
谢谢楼主分享，学习了
回复

使用道具 举报

板凳
ID:349169 发表于 2018-10-20 22:14 | 只看该作者
谢谢楼主
回复

使用道具 举报

地板
ID:417151 发表于 2018-10-29 11:24 | 只看该作者
谢谢楼主
回复

使用道具 举报

5#
ID:422153 发表于 2018-12-3 11:52 | 只看该作者
谢谢分享
回复

使用道具 举报

6#
ID:708902 发表于 2020-3-15 16:32 | 只看该作者
谢谢楼主
回复

使用道具 举报

7#
ID:757507 发表于 2020-5-21 16:18 | 只看该作者

谢谢楼主
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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