Raspberry Pi 2 verso Arduino: Comunicazione a 433 Mhz
In questo articolo vi spiegerò come far comunicare il vostro raspberry pi con il vostro arduino tramite economici moduli a 433Mhz. Questa è la base della domotica wireless !
Prezzo: Tra i 50 e i 70 euro stimati.
Hardware Necessario
Arduino Uno / Nano / etc
Prezzo: meno di 30 euro (Amazon) / Arduino Nano (meno di 10 euro se lo comprate su ebay chinese)
Un Raspberry Pi
Sito: http://www.raspberrypi.org/
Prezzo: meno di 50 euro (Amazon)
Il mio è: Raspberry Pi 2 Model B Quad Core CPU 900 MHz, 1 GB RAM ma va bene qualsiasi versione.
Moduli 433Mhz RF
Prezzo: meno di 5 euro (Ebay) / se li prendete dalla cina costano sui 2 dollari.
Librerie che utilizzeremo per il progetto
Qui di seguito sono presenti le 3 librerie che useremo per il progetto. Scaricate la prima. Le altre 2 poi le scaricheremo direttamente dal nostro Raspberry Pi. Queste librerie sono perfettamente compatibili con gli standard per la comunicazione a radiofrequenza.
- Arduino: https://code.google.com/p/rc-switch/
- Raspberry Pi: https://github.com/r10r/rcswitch-pi
- 433Utils mixing both librairies: https://github.com/ninjablocks/433Utils
Arduino Software: https://www.arduino.cc/en/Main/Software
Per prima cosa scarica la libreria Rc-Switch per Arduino ed inseriscila nella cartella dove Arduino vede le librerie (nel mio caso è C:\Users\MyPCName\Documents\Arduino\libraries\rc-switch-master). Connetti ora l’arduino al PC e se quest’ultimo è originale allora verrà subito riconosciuto ed istallato mentre se è un clone è necessario installare prima i driver (nel mio caso l’arduino nano cinese usa il chipset CH341SER e quindi userò il seguente driver: https://www.dropbox.com/s/s2lo67mfjlbhltw/CH341SER.rar?dl=0). Per controllare che la libreria sia stata riconosciuta correttamente, andate in File -> Esempi. Se vedete la scritta rc-switch-master avete fatto tutto correttamente !!
Spiegazione Dispositivi a 433Mhz
Come puoi vedere il trasmettitore ha 3 pin ed il ricevitore 4 ma quest’ultimo ha un pin non usato. Quindi il tutto risulta molto semplice. Basta alimentare trasmettitore e ricevitore e con un singolo cavetto possiamo inviare o ricevere dati.
Trasmettitore
L’unità adibita a trasmettere dati verso l’esterno sarà il nostro Raspberry Pi. Di seguito le connessioni:
I pin hanno parecchi nomi diversi in base al fatto di leggeri come fisici o come GPIO. Quelli che vedi nell’iimagine di sopra non sono i pin fisici ma i pin chiamati GPIO o BCM. Su raspberry dire collega il pin X non è immediato. Dopo che installeremo wiringpi su raspberry pi vedrai che il mapping dei pin del raspberry pi (nel mio caso la verione 2) ti verrà mostrato così:
Ma come va letto questo coso ?? Bisonga guardare la parte centrale che corriponde alle 2 linee di pin presenti sul raspberry. Vedilo in quest’altro modo:
Per wiring pi dire GPIO o dire BCM è la stessa cosa. Essendo il nostro raspberry pi il B+ prendiamo l’immagine più a destra e confrontiamola con quella in bianco e nero di wiring pi. Noterai che corrispondono! Però l’immagine in bianco e nero ha la colonna wPi. In questa colonna è presente il numero di come viene chiamato per wiring pi. Quindi per esempio il pin FISICO 3 sarà anche chiamato GPIO 2 e anche chiamato wPi 8. Il pin FISICO 11 verrà anche chimato GPIO 17 oppure wPi 0 (zero).
Ho voluto soffermarmi su questa parte perchè io l’ho trovata la prima volta confusionaria.
Accendiamo il nostro raspberry Pi e colleghiamoci in SSH o come vogliamo al dispositivo (questo punto lo do come già fatto, se avete dubbi scrivetelo nei commenti). Il raspberry ovviamente dovrà essere connesso alla vostra rete wifi in quanto ora scaricheremo le librerie. Per prima cosa installiamo WiringPI, un tool utilissimo per lavorare con i pin del raspberry pi. Per scaricarlo eseguiamo questo comando:
pi@raspberrypi ~ $ sudo su root@raspberrypi ~ $ cd /home/pi root@raspberrypi:/home/pi# mkdir domotica root@raspberrypi:/home/pi# cd domotica/ root@raspberrypi:/home/pi/domotica# git clone git://git.drogon.net/wiringPi ...qui vedrai il download del progetto root@raspberrypi:/home/pi/domotica# cd wiringPi/ root@raspberrypi:/home/pi/domotica/wiringPi# ./build ...vedrai la costruzione dei dati
ora avete il tool wiringPi. Potete vedere la vostra configurazione del raspberry eseguendo questo comando:
Attenzione !!! Il risultato di questo comando varia a seconda della versione del vostro raspberry pi.
root@raspberrypi:/home/pi/domotica/wiringPi# gpio readall +-----+-----+---------+------+---+---Pi 2---+---+------+---------+-----+-----+ | BCM | wPi | Name | Mode | V | Physical | V | Mode | Name | wPi | BCM | +-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+ | | | 3.3v | | | 1 || 2 | | | 5v | | | | 2 | 8 | SDA.1 | IN | 1 | 3 || 4 | | | 5V | | | | 3 | 9 | SCL.1 | IN | 1 | 5 || 6 | | | 0v | | | | 4 | 7 | GPIO. 7 | IN | 1 | 7 || 8 | 1 | ALT0 | TxD | 15 | 14 | | | | 0v | | | 9 || 10 | 1 | ALT0 | RxD | 16 | 15 | | 17 | 0 | GPIO. 0 | OUT | 0 | 11 || 12 | 0 | IN | GPIO. 1 | 1 | 18 | | 27 | 2 | GPIO. 2 | IN | 0 | 13 || 14 | | | 0v | | | | 22 | 3 | GPIO. 3 | IN | 0 | 15 || 16 | 0 | IN | GPIO. 4 | 4 | 23 | | | | 3.3v | | | 17 || 18 | 0 | IN | GPIO. 5 | 5 | 24 | | 10 | 12 | MOSI | IN | 0 | 19 || 20 | | | 0v | | | | 9 | 13 | MISO | IN | 0 | 21 || 22 | 0 | IN | GPIO. 6 | 6 | 25 | | 11 | 14 | SCLK | IN | 0 | 23 || 24 | 1 | IN | CE0 | 10 | 8 | | | | 0v | | | 25 || 26 | 1 | IN | CE1 | 11 | 7 | | 0 | 30 | SDA.0 | IN | 1 | 27 || 28 | 1 | IN | SCL.0 | 31 | 1 | | 5 | 21 | GPIO.21 | IN | 1 | 29 || 30 | | | 0v | | | | 6 | 22 | GPIO.22 | IN | 1 | 31 || 32 | 0 | IN | GPIO.26 | 26 | 12 | | 13 | 23 | GPIO.23 | IN | 0 | 33 || 34 | | | 0v | | | | 19 | 24 | GPIO.24 | IN | 0 | 35 || 36 | 0 | IN | GPIO.27 | 27 | 16 | | 26 | 25 | GPIO.25 | IN | 0 | 37 || 38 | 0 | IN | GPIO.28 | 28 | 20 | | | | 0v | | | 39 || 40 | 0 | IN | GPIO.29 | 29 | 21 | +-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+ | BCM | wPi | Name | Mode | V | Physical | V | Mode | Name | wPi | BCM | +-----+-----+---------+------+---+---Pi 2---+---+------+---------+-----+-----+
Ora installiamo la libreria 433Utils che conterrà tutti gli scripts utili ad inviare segnali o addirittura riceverne dall’esterno.
root@raspberrypi:/home/pi/domotica/wiringPi# cd /home/pi/domotica/ root@raspberrypi:/home/pi/domotica/wiringPi# git clone https://github.com/ninjablocks/433Utils.git ... root@raspberrypi:/home/pi/domotica/wiringPi# cd 433Utils/RPi_utils root@raspberrypi:/home/pi/domotica/433Utils/RPi_utils# ls -l total 44 -rw-r--r-- 1 root root 1038 Feb 19 15:52 codesend.cpp -rw-r--r-- 1 root root 327 Feb 19 15:52 Makefile -rw-r--r-- 1 root root 17686 Feb 19 15:52 RCSwitch.cpp -rw-r--r-- 1 root root 3838 Feb 19 15:52 RCSwitch.h -rw-r--r-- 1 root root 820 Feb 19 15:52 README.md -rw-r--r-- 1 root root 1227 Feb 19 15:52 RFSniffer.cpp -rw-r--r-- 1 root root 1087 Feb 19 15:52 send.cpp
Come puoi notare, la cartella RPi_utils contiene del codice scritto in c++. Il codice che ci servirà per inviare i messaggi dal nostro trasmettitore è contenuto in codesend.cpp.
Apriamolo e commentiamolo con il comando nano codesend.cpp:
/* 'codesend' hacked from 'send' by @justy - The provided rc_switch 'send' command uses the form systemCode, unitCode, command which is not suitable for our purposes. Instead, we call send(code, length); // where length is always 24 and code is simply the code we find using the RF_sniffer.ino Arduino sketch. Usage: ./codesend decimalcode (Use RF_Sniffer.ino to check that RF signals are being produced by the RPi's transmitter) */ #include "RCSwitch.h" //Liberia appena scaricata #include <stdlib.h> #include <stdio.h> int main(int argc, char *argv[]) { //Passerò un intero al codice chiamato // This pin is not the first pin on the RPi GPIO header! // Consult https://projects.drogon.net/raspberry-pi/wiringpi/pins/ // for more information. int PIN = 0; //<--- Questo numero è il pin wPi. Ti ricordo che wPi=0 vuol dire GPIO=17 e pin FISICO=11 (tabella in bianco e nero) // Parse the firt parameter to this command as an integer int code = atoi(argv[1]); //Questo è il numero che gli passerò. Per ora possiamo inviare solo interi. if (wiringPiSetup () == -1) return 1; printf("sending code[%i]\n", code); //Lo stampo RCSwitch mySwitch = RCSwitch(); mySwitch.enableTransmit(PIN); //Abilito il pin alla trasmissione mySwitch.send(code, 24); //Lo trasmetto al pin GPIO=17 cioè wPi=0 cioè FISICO=11 codificato a 24 bit return 0; }
Ora compiliamo il codice. Per funzionare abbiamo bisogno del tool g++. Per installarlo eseguite questo comando:
sudo apt-get install build-essential
Ora che g++ è installato compiliamo il codice codesend.cpp semplicemente con il comando make
root@raspberrypi:/home/pi/domotica/433Utils/RPi_utils# make codesend
Lato raspberry abbiamo finito ! Ci ritorneremo per inviare i dati una volta finito di montare il nostro arduino.
Ricevitore
Il ricevitore sarà arduino (o saranno tanti arduino 😉 ). Questo è il diagramma di connessione.
Aprite ora il software dell’Arduino e caricateci sopra il codice per ricevere dati in input.
/* RF_Sniffer Hacked from http://code.google.com/p/rc-switch/ by @justy to provide a handy RF code sniffer */ #include "RCSwitch.h" #include <stdlib.h> #include <stdio.h> RCSwitch mySwitch = RCSwitch(); void setup() { Serial.begin(9600); mySwitch.enableReceive(0); // <--- Questo è il pin 2 dell'arduino } void loop() { if (mySwitch.available()) { int value = mySwitch.getReceivedValue(); if (value == 0) { Serial.print("Unknown encoding"); } else { Serial.print("Received "); Serial.print( mySwitch.getReceivedValue() ); Serial.print(" / "); Serial.print( mySwitch.getReceivedBitlength() ); Serial.print("bit "); Serial.print("Protocol: "); Serial.println( mySwitch.getReceivedProtocol() ); } mySwitch.resetAvailable(); } }
Tenete ora aperto il Monitor Seriale:
Avviamo la comunicazione
Ritorniamo al nostro Raspberry PI e inviamo un qualsiasi numero intero grazie al codice compilato poco fa.
root@raspberrypi:/home/pi/domotica/433Utils/RPi_utils# ./codesend 1233434 sending code[12345] root@raspberrypi:/home/pi/domotica/433Utils/RPi_utils# ./codesend 128899 sending code[46356] root@raspberrypi:/home/pi/domotica/433Utils/RPi_utils# ./codesend 34689 sending code[21376] root@raspberrypi:/home/pi/domotica/433Utils/RPi_utils# ./codesend 390678 sending code[29292]
Sul monitore seriale del nostro Arduino vedremo:
Received 1233434 / 24bit Protocol: 1 Received 128899 / 24bit Protocol: 1 Received 128899 / 24bit Protocol: 1 Received 128899 / 24bit Protocol: 1 Received 34689 / 24bit Protocol: 1 Received 34689 / 24bit Protocol: 1 Received 34689 / 24bit Protocol: 1 Received 34689 / 24bit Protocol: 1 Received 390678 / 24bit Protocol: 1
Finito !!!!
Per qualsiasi dubbio scrivete nei commenti.
Attualmente ho notato che il range massimo di funzionamento wireless è intorno ai 2 metri. Un po pochino. Per risolvere il problema in maniera supereconomica prendete un cavetto da 15 cm circa e collegatelo al buchetto ANT del trasmettitore. Facendo questo sono riuscito a trasmettere dati anche a 10 metri di distanza con 5 muri in mezzo.