Hackeando Controle de Playstation com Arduino em Controle Remoto para projetos, Modelos e Miniaturas – V08

Arduino é um Ótimo hobby, com ele você mesmo consegue construir várias coisas legais, desenvolvendo suas habilidades e criatividade, este será, com certeza, o primeiro de muitos projetos que você ainda irá desenvolver com Arduino.

Controle de Playstation com Arduino em Controle Remoto para projetos, Modelos e Miniaturas – V08. Arduino Para Modelismo – 1 de set. de 2018

Neste vídeo Arduino Para Modelismo mostra um pouco de como modificou um Controle de Playstation para fazer um controle remoto sem fio usando Arduino e o Módulo NRF24l01. Pode ser usado para carrinho, caminhão, barco e projetos em geral. Esse é um método bem simples, mais indicado para quem está começando. Existe outros métodos onde se utiliza a própria eletrônica do controle de Playstation2.

Para a montagem da Eletrônica do controle remoto foram usados os seguintes componentes:

• 1 Controle de playStation 2
• 1 Arduino Pro Mini 5v
• 1 Módulo NRF24L01+
• 1 Regulador de tenção
• 1 Resistor de 100 Ohms
• 1 Capacitor eletrolítico 47 uF superior a 5 volts
• 1 Célula de Bateria de notebook ( ou 1 bateria 18650)
• 1 Buzzer Passivo
• Fios para as conexões e solda

Connections from PS2 PCB to Arduino Mini pins

The PS2 controller signal transmission project via radio used an Arduino Nano that read the PS2 signals and transmitted them with an nRF24l0 module, inspired by Fabio’s blog, which led to the incorporation of the battery, the charging circuit and the Arduino directly on the controller. Shepherding electrons – June 11, 2019

• “Long range” modules nRF24l01+PA/LNA – which are supposed to have a range of up to 1000 meters…!
• an Arduino Mini module, using the Atmega328 AVR at 3.3V, mainly because of its small form factor
• a USB port
• charging circuit for a 1S LiPo battery
• a red LED which is controlled by the Arduino for a visual indication
• a green LED
• a yellow LED has been added to indicate charging status and an SPDT button on the side controls power
• a mini piezo buzzer to provide feedback on radio status, etc.

nRF24l01 with color-coded Arduino Pro Mini pin connections

Power management and reduced space inside the controller were addressed with a very small 1S LiPo battery and a modified TP4056 charging module, as the “resting” voltage of a 1S LiPo battery is 3.7V, fully charged is 4.2V and about 3.3V at minimum load. The Arduino board is clocked at 8MHz and should be able to step up to 5.5V without any problems. The nRF24l01 module is out of specification as it is a 3.3 – 4.2 V module, and could/should have used a 3.3 V linear regulator with low voltage drop (or MCP1700-3302E).

TP4056 charging circuit with a 1S LiPo battery.  Some components were desoldered, LEDs were connected and a power switch attached.

The TP4056 module USB port was desoldered (to save space), and the IN+ and IN- were connected to VBUS (5.0V) and GND of the mini-USB port breakout module.  Further, the two charge indicator LEDs were removed and 3 mm yellow and green LEDs were connected.  Finally BAT+ and BAT- were soldered to the battery VERY CAREFULLY, ACCIDENTAL HEAT ON A LiPo BATTERY CAN CAUSE FIRES! The Vcc from the switch was connected to Vcc of the rest of the circuit – i.e. to power the Arduino, PS2 PCB and nRF24l01 radio module.

A small piezo speaker (3.3V), added to report radio packet acknowledgment status – a low, monotone tone every second when the radio fails to send, and a musical trill when a radio packet is sent successfully.

The software to run on the PS2 controller is fairly straightforward.  We’ll need a PS2 controller library from here and the Mirf radio library from here.  We setup the radio module (with ACK acknowledgements enabled), then the PS2 controller (the code is inherited directly from the PS2 library example).

Modified PS2 Controller with Arduino and NRF24L01+ in action part 1 – dgmark. 24 de ago. de 2017

PS2 controller + Arduino + NRF24L01+ controlling a modified toy RC car. dgmark

Gathering Materials

• 1 x Wired PS2 controller (clone)
• 1 x Arduino nano
• 1 x NRF24L01+PA+LNA
• 1 x Socket Adapter Module Board for NRF24L01+ (or you can try to directly power it using the 3.3v of the arduino but put a capacitor to make the voltage smoother)
• 2 x 16340 Li-ion battery
• 1 x USB Lithium Battery Charger Module Board
• 1 x toggle switch
• 1 x small dc motor (optional)
• 1 x L293D motor driver (optional, only if you add dc motor for vibration)

PS2 controller code:

DATA HOSTED WITH ♥ BY PASTEBIN.COM – DOWNLOAD RAW – SEE ORIGINAL

1. #include <PS2X_lib.h>
3. #include <SPI.h>
4. #include <Mirf.h>
5. #include <nRF24L01.h>
6. #include <MirfHardwareSpiDriver.h>
8. #define PS2_DAT        4
9. #define PS2_CMD        3
10. #define PS2_SEL        2
11. #define PS2_CLK        5
13. #define MY_LED 6
14. #define SPEAKER 9
16. PS2X ps2x; // create PS2 Controller Class  
18. uint8_t tx_address[5] = {0xE7, 0xE7, 0xE7, 0xE7, 0xE7};
19. uint8_t rx_address[5] = {0xD7, 0xD7, 0xD7, 0xD7, 0xD7};
21. #define toggle_pin(port, pin) port^=(1<<pin)
23. struct radio_packet
24. {
25.  uint8_t buttons1;
26.  uint8_t buttons2;
27.  uint8_t leftX;
28.  uint8_t leftY;
29.  uint8_t rightX;
30.  uint8_t rightY;
31. }radioData;
33. enum connection_state {WAITING=0, POOR=1, GOOD=2};
35. void playMelody(void)
36. {
38.  for (uint8_t i=10;i>0;i–)
39.  {
40.  // pin, freq (Hz), duration (ms)
41.     tone(SPEAKER, 100+(uint16_t)i*50,100);
42.     delay(100);
43.  }
44. }
46. void ConnectedBeep(void) // This function has the potential to block radio calls if we’re moving between poor and good
47. {  // threshold every second… Can this be made non-blocking?
48.  for (uint8_t i=0;i<10;i++)
49.  {
50.     tone(SPEAKER, 100+(uint16_t)i*50,50);
51.     delay(50);
52.  }
53. }
55. void WaitingBeep(void)
56. {
57.   tone(SPEAKER, 100, 200); 
58. }
60. void LowSignalBeep(void)
61. {
62.   tone(SPEAKER, 900,200);
63. }
66. // the setup function runs once when you press reset or power the board
67. void setup() {
68.   Serial.begin(115200);
70.   Serial.println(“Setup radio…”);
72.   Mirf.spi = &MirfHardwareSpi;
73.   Mirf.init();
74.   Mirf.payload = sizeof(radio_packet);
75.   Mirf.channel = 2;
76.   Mirf.config();
78.   Mirf.configRegister(EN_AA, (1 << ENAA_P0)| (1 << ENAA_P1));
80.   Mirf.setTADDR(tx_address);
81.   Mirf.setRADDR(rx_address);
83.   Mirf.configRegister(SETUP_RETR, 0b0000 | 0b1111); // MAX auto re-transmit time, max 15 retries (MAX)
85. // Setup PS2 controller:
86.  uint8_t error=1, pressures=0,rumble=0;
88.   Serial.println(“Connecting to PS2 controller…”);
89.  while(error==1)
90.  {
91.     error = ps2x.config_gamepad(PS2_CLK, PS2_CMD, PS2_SEL, PS2_DAT, pressures, rumble);
93.  if(error == 0){
94.     Serial.print(“Found Controller, configured successful “);
95.     Serial.print(“pressures = “);
96.  if (pressures)
97.     Serial.println(“true “);
98.  else
99.     Serial.println(“false”);
100.   Serial.print(“rumble = “);
101.  if (rumble)
102.     Serial.println(“true)”);
103.  else
104.     Serial.println(“false”);
105.  } 
106.  else if(error == 1)
107.     Serial.println(“No controller found, check wiring, see readme.txt to enable debug. visit http://www.billporter.info for troubleshooting tips”);
109.  else if(error == 2)
110.     Serial.println(“Controller found but not accepting commands. see readme.txt to enable debug. Visit http://www.billporter.info for troubleshooting tips”);
112.  else if(error == 3)
113.     Serial.println(“Controller refusing to enter Pressures mode, may not support it. “);
115.  } // End while
116.   Serial.println(“DONE”);
118.  uint8_t type = ps2x.readType();
119.  switch(type) {
120.  case 0:
121.       Serial.print(“Unknown Controller type found “);
122.  break;
123.  case 1:
124.       Serial.print(“DualShock Controller found “);
125.  break;
126.  case 2:
127.       Serial.print(“GuitarHero Controller found “);
128.  break;
129.  case 3:
130.       Serial.print(“Wireless Sony DualShock Controller found “);
131.  break;
132. }
134.    pinMode(MY_LED, OUTPUT);
135.    toggleLED(10, 100);
137.    playMelody();
138. }
140. void toggleLED(uint8_t flashes, uint8_t spacing)
141. {
142.  for (uint8_t i=0; i<flashes; i++)
143.  {
144.     digitalWrite(MY_LED,HIGH);
145.     delay(spacing); // in milliseconds
146.     digitalWrite(MY_LED,LOW);
147.     delay(spacing); // in milliseconds
148.  }
149. }
151. void flushTx(void)
152. {
153.     Mirf.csnLow(); // Pull down chip select
154.     Mirf.spi->transfer( FLUSH_TX );  // Write cmd to flush tx fifo
155.     Mirf.csnHi(); // Pull up chip select
156. }
158. // the loop function runs over and over again forever
159. void loop() {
161.  enum connection_state radio_state;
162.  long mytime=0;
163.  uint16_t packets_sent=0;
165.   radio_state = WAITING;
167.   Mirf.flushRx();
168.   flushTx();
170.   mytime = millis();
172.  while(1)
173.  {
174.   ps2x.read_gamepad(false, 0); //read controller and set large motor to spin at ‘vibrate’ speed
176.   radioData.buttons1 = ps2x.Button(PSB_L1)<<7 | ps2x.Button(PSB_L2)<<6 | ps2x.Button(PSB_R1) << 5 | ps2x.Button(PSB_R2) << 4 | ps2x.Button(PSB_PAD_UP) << 3 | ps2x.Button(PSB_PAD_RIGHT)<<2 | ps2x.Button(PSB_PAD_DOWN)<<1 | ps2x.Button(PSB_PAD_LEFT);
177.   radioData.buttons2 = ps2x.Button(PSB_CIRCLE)<<7 | ps2x.Button(PSB_CROSS)<<6 | ps2x.Button(PSB_TRIANGLE)<<5 | ps2x.Button(PSB_SQUARE)<<4 | ps2x.Button(PSB_START) << 2 | ps2x.Button(PSB_SELECT)<<1;
178.   radioData.leftX = ps2x.Analog(PSS_LX);
179.   radioData.leftY = ps2x.Analog(PSS_LY);
180.   radioData.rightX = ps2x.Analog(PSS_RX);
181.   radioData.rightY = ps2x.Analog(PSS_RY);
183.  // Send radio data  
184.           Mirf.setTADDR(tx_address);
185.           Mirf.send((uint8_t *)&radioData);
187.  //while(Mirf.issending());
189.  uint8_t status, sending;
190.           sending=1;
192.  while(sending)
193.  {
194.             status=Mirf.getStatus();
195.  if (status & ((1 << TX_DS) | (1 << MAX_RT)) ) sending=0;
196.  }
198.           Mirf.isSending(); // Make a call to this so that powerUpRx is called and handled correctly (could also just call powerUpRx ourselves but this feels safer)
200. if (status & (1 << TX_DS))
201.             packets_sent++;
203. if (millis()-mytime>=1000)
204. {
205.           Serial.print(“Packets sent:”); Serial.println(packets_sent);
207.  if (packets_sent==0) {WaitingBeep(); radio_state=WAITING;}
208.  else if (packets_sent<200) {LowSignalBeep();radio_state=POOR;}
209.  else if (radio_state!=GOOD) {ConnectedBeep();radio_state=GOOD;}
211.  if (radio_state==GOOD) toggle_pin(PORTD, 6); //pin PD6 – slow flash
212.  else if (radio_state==WAITING) PORTD |= (1<<6); // set pin high – constant if waiting (plus hear low beep)
213.           packets_sent=0;
214.           mytime=millis();
215. }
217. } // end while
219. } // end loop

On the receiver side, we just need a simple sketch that initialises the Mirf radio with the correct RX and TX addresses, enables ACK and then waits for a packet from the PS2 remote. NanJing Top Power ASIC Corp.

DATA HOSTED WITH ♥ BY PASTEBIN.COM – DOWNLOAD RAW – SEE ORIGINAL

2. #include <SPI.h>
3. #include <Mirf.h>
4. #include <nRF24L01.h>
5. #include <MirfHardwareSpiDriver.h>
7. struct radio_packet
8. {
9.  uint8_t buttons1;
10.  uint8_t buttons2;
11.  uint8_t leftX;
12.  uint8_t leftY;
13.  uint8_t rightX;
14.  uint8_t rightY;
15. }radioData;
17. uint8_t rx_address[5] = {0xE7, 0xE7, 0xE7, 0xE7, 0xE7};
18. uint8_t tx_address[5] = {0xD7, 0xD7, 0xD7, 0xD7, 0xD7};
21. void setup() {
22.   Serial.begin(115200);
24.   Serial.println(“Setup radio…”);
26.  // put your setup code here, to run once:
27.   Mirf.spi = &MirfHardwareSpi;
29.   Mirf.cePin = 5; // PD5 = 5 (was 8)
30.   Mirf.csnPin = 17; // PC3 = 17 (was 7)
32.   Mirf.init();
33.   Mirf.payload = sizeof(radio_packet);
34.   Mirf.channel = 2;
35.   Mirf.config(); //powers up RX by default
37.   Mirf.configRegister(EN_AA, (1 << ENAA_P0)| (1 << ENAA_P1));
38.   Mirf.configRegister(RF_SETUP, 0b1111); // 2 MBps rather than 2Mps (for reasons of signal
40.   Mirf.setRADDR(rx_address);
42.   Mirf.configRegister(SETUP_RETR, 0b0000 | 0b1111); // MAX auto re-transmit time, max 15 retries (MAX)
44.   Mirf.setTADDR(tx_address); 
45. }
47. void flushTx(void)
48. {
49.     Mirf.csnLow(); // Pull down chip select
50.     Mirf.spi->transfer( FLUSH_TX );  // Write cmd to flush tx fifo
51.     Mirf.csnHi(); // Pull up chip select
52. }
54. void loop() {
55.  static long mytimer=0;
56.  static uint8_t index=0,sending=0; // start not sending
57.  uint16_t packet=0;
58.  long mytime=millis();
59.  struct radio_packet old_packet;
61.  while(1)
62.  {
63.  if (Mirf.dataReady())
64.  {
65.      Mirf.getData((uint8_t*) &radioData); // transfer all data (payload = 1 in this case)
67. if (radioData.buttons1!=old_packet.buttons1) Serial.println(“Buttons 1 changed!”);
68. if (radioData.buttons2!=old_packet.buttons2) Serial.println(“Buttons 2 changed!”);
70.      old_packet=radioData;
71. /*Serial.println(“****************************************”);
72.      Serial.println(radioData.buttons1,BIN);
73.      Serial.println(radioData.buttons2,BIN);
74.      Serial.print(radioData.leftX);Serial.print(“,”); Serial.print(radioData.leftY);Serial.print(“,”);
75.      Serial.print(radioData.rightX);Serial.print(“,”); Serial.println(radioData.rightY);*/
76.      packet++;
77.  }
78.  if (millis()-mytime>=1000)
79.  {
80.     Serial.print(“Packets per second:”); Serial.println(packet);
81.       packet=0;
82.       mytime=millis();
83.  }
84.  }
86. }

Others controls: Rota evolution, A evolução dos videogames: uma linha do tempo da história do brinquedo, Jogo com 18 quintilhões de planetas exploráveis, A história do Linux – História da Tecnologia