Raspberry Pi – Arduino – Lier les deux via le bus I2C


Achtung : Dieser Artikel wurde automatisch von Bing Translate übersetzt


Advertencia : Este artículo ha sido traducido automáticamente por Bing Translate

Certains disent qu’on ne lie pas des chiens avec des saucisses mais des fois pourquoi pas. Alors le Raspberry Pi et l’Arduino ne sont pas forcement aussi opposés, avec même des points communs mais chacun à des avantages qui peuvent être bons de combiner.

RaspArduinoI2CAvec le Raspberry Pi vous pouvez via les ports GPIO contrôler des composants externes et faire de la bidouille en électronique. Mais j’imagine que certains maitrisent déjà bien leur Arduino, qu’ils ont le matériel, etc. Et puis ça fait un tuto en plus 😀

Pour lier les deux, nous allons passer par le protocole I2C. Plusieurs raisons à ça : ne pas utiliser le port USB, le Raspberry Pi étant limité (si vous voulez le faire quand même il y a un article dans le MagPi #15 et j’en ferai un moi même plus tard). Et ne pas utiliser le port série. Ici c’est un peu plus personnel, car j’ai une carte Slice Of Pi sur un Raspberry pour la station météo et elle utilise le port série pour les sondes sans fil.

Le protocole I2C, créé par Philips avec une orientation domotique, permet à plusieurs composants de dialoguer entre eux de manière bidirectionnel mais en half-duplex uniquement. Comme d’habitude, plus d’infos chez Wikipedia.

Il y a un principe de maitre et esclave. Ici nous allons donc utiliser le Raspberry Pi en tant que maitre et l’Arduino en tant qu’esclave.

Avant tout pour connecter les deux appareils il faut savoir quelles broches utiliser !
Pour le raspberry c’est sur les GPIO 2 et 3 (pour les cartes à partir du modèle B révision 2, ceux avec les trous de fixation dans la carte)

raspberry-i2c

Pour l’Arduino, ça se passe sur les broches A4 et A5 pour les cartes de type Arduino Uno. Pour les autres cartes, vous trouverez plus d’informations sur le site officiel d’Arduino.

arduino-i2c-2Il faudra ajouter une connexion à la masse entre les deux. Donc vous aurez besoin de trois fils.

Avant de connecter nos deux appareils, il faut s’assurer qu’ils vont pouvoir communiquer. Toutes les informations sont sur le site d’adafruit mais en gros, voici ce qu’il faut faire.

Définir l’Arduino comme esclave

C’est relativement simple en incluant le module Wire dans le programme. J’ai pris l’adresse 0x12 mais vous pouvez choisir de 0x03 à 0x77 (en hexa) :

#include <Wire.h>

#define SLAVE_ADDRESS 0x12
int dataReceived = 0;

void setup() {
    Serial.begin(9600);
    Wire.begin(SLAVE_ADDRESS);
    Wire.onReceive(receiveData);
    Wire.onRequest(sendData);
}

void loop() {
    delay(100);
}

void receiveData(int byteCount){
    while(Wire.available()) {
        dataReceived = Wire.read();
        Serial.print("Donnee recue : ");
        Serial.println(dataReceived);
    }
}

void sendData(){
    int envoi = dataReceived + 1;
    Wire.write(envoi);
}

Vous l’aurez compris, le programme initialise l’Arduino avec l’adresse 0x12, définit la méthode de réception des données, la méthode d’envoi des données et c’est parti pour l’envoyer vers la carte avec l’interface.

Activer la gestion I2C sur le Raspberry Pi

Par défaut, des distributions de type Raspbian désactivent la gestion I2C pour économiser la mémoire utilisée par le module. Pour réactiver, rien de plus simple et c’est dans le fichier /etc/modprobe.d/raspi-blacklist.conf. Il faut mettre en commentaire avec un # la ligne :

blacklist i2c-bcm2708

Reste à activer le module lors de chaque démarrage. C’est dans le fichier /etc/modules, en y ajoutant à la fin une nouvelle ligne :

i2c-dev

Ensuite vous installez la suite des outils de gestion I2C

apt-get install i2c-tools

Il va vous falloir redémarrer le Raspberry pour faire apparaitre deux fichiers :

1._ssh-2
Grâce à eux vous allez pouvoir communiquer sur le bus I2C !

Vous pouvez lister les périphériques avec la commande :

i2cdetect -y 1

Pour les modèles 256Mo (comme celui que j’utilise pour mes tests) :

i2cdetect -y 0

Voilà. Etape suivante : connecter l’Arduino et lui parler !

Communiquer avec l’Arduino

Vous pouvez maintenant relier l’Arduino au Raspberry et allumer tout ce petit monde !

Attention, sur le schema, le raccordement SDA et SCL est inversé ! Le rouge en A5 et le balnc va en A4 😉

ArduinoRaspberry

Une fois fait, vous vous connectez sur le Raspberry Pi et vous relancez la commande i2cdetect avec le bon paramètre :

1._ssh-2

Le paramètre défini dans le sketch envoyé à l’Arduino, 0x12, apparait dans les périphériques détectés. On progresse !

Il nous faut maintenant mettre en place le script sur le Raspberry Pi qui va envoyer/recevoir avec l’Arduino. Pour cela, le plus simple c’est d’installer le support d’I2C dans les scripts Python. C’est ce que va faire python-smbus

apt-get install python-smbus

Nous sommes donc maintenant équipé pour parler à notre Arduino. Pour ça un petit programme tout simple. Envoyer un chiffre entre 0 et 8 et nous retourner ce chiffre plus un :

import smbus
import time

# Remplacer 0 par 1 si nouveau Raspberry
bus = smbus.SMBus(0)
address = 0x12

print "Envoi de la valeur 3"
bus.write_byte(address, 3)
# Pause de 1 seconde pour laisser le temps au traitement de se faire
time.sleep(1)
reponse = bus.read_byte(address)
print "La reponse de l'arduino : ", reponse

Le résultat de l’exécution :

1._ssh-2

Laisser parler votre imagination pour maintenant diriger l’Arduino en lui envoyant des demandes un peu plus complexes en fonction de ce que vous aurez de branché dessus !

Source et inspiration : un article d’Oscar

Vous aimerez aussi...