Commander une sortie de la carte Arduino





       Présentation :

       On va rendre bi-directionnelle cette communication


       En envoyant une commande logique de la carte Raspberry vers la carte Arduino, elle permettra d'allumer ou d'éteindre une Del (Del: Diode Electroluminescente).


       Pour réaliser cette communication on va modifier les programmes "A0_i2c_VotreNom.ino" et "A0_i2c_VotreNom.py"


               

Le premier "A0_i2c_VotreNom.ino", ce programme implanté dans le calculateur de la carte Arduino (ATMEGA2560) doit pouvoir maintenant recevoir un octet de commande.

Cette octet sera stocké dans une variable nommée "dataReceived" dans une procédure de réception "receiveData".

On sauvegardera le programme sous le nom: "A0_i2c_Led_VotreNom.ino" .

On pourra ensuite exploiter sa valeur dans le programme principale pour commander la Del.


Le deuxième "A0_i2c_VotreNom.py" sera dupliquer en 2 procédures :

"A0_i2c_CommandLed_On_VotreNom.py" pour allumer la Del,

"A0_i2c_CommandLed_Off_VotreNom.py" pour l'éteindre.


       


Prototypage :



       Documents implantation de la Del sur la sortie N°13 de la carte Arduino.

               Réaliser avec le logiciel Fritzing l'implantation de la Del (reprendre votre schéma)

               Le résistor en série avec la Del a été fixée à 470Ω.


       



       Photo du prototypage:



Logiciel :


       Les modifications du programme son en rouge dans le listing qui suit.


       Elles concernent quatre points:


               1:        Déclarer le numéro de pin sur laquelle on va connecter la Del.

Déclarer une variable "dataReceived" pour stocker la commande reçue.

               2:        Dans l'initialisation on fixe la pin en sortie.

               3:        Dans le programme principale on applique la commande sur la Del.

               4:        Sous-programme de réception de la commande.



       Programme Arduino: Ouvrir le logiciel "Arduino" et copier/coller les lignes suivantes dans l'interface utilisateur.



/*  Nom du programme :  "A0_i2c_Led_VotreNom.ino"

*  Programme test de la liaison I2C entre la carte Raspberry et la carte Arduino.

* Auteur:

* Date:

*  Le Raspberry est maitre de la communication et l'Arduino esclave.

*  Utilisation de la librairie Wire:

*  https://www.arduino.cc/en/Reference/Wire

*  http://www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.LibrairieWire

*  Le Programme suivant fait l'acquisition de l'entrée analogique A0 dans son programme principale, il commande une Del connectée à sortie numérique N°13 de la carte Arduino.

*  Il intègre deux sous-programmes "sendData" et "receiveData" pour répondre aux sollicitations de la carte Raspberry via le bus i2c.

*    L'utilisation de la librairie "Wire"

*    L'adresse de la carte Arduino est déclaré en hexadécimale.

*/

#include <Wire.h>


#define SLAVE_ADDRESS 0x10        // Déclaration de l'adresse de la carte Arduino ici 16 en décimale.


int valA0 = 0;                                  // valeur de conversion de l'entrée A0 sur 16 bits

byte valA0h = 0;                        // Octet de poids fort de valA0

byte valA0l = 0;                        // Octet de poids faible de valA0

int tabcap[2] = {valA0h,valA0l};        //tableau de 2 valeurs

int i=0; //index du tableau

const byte Led = 13;                        // Déclaration du N° de la sortie logique commandée par la carte Raspberry

int dataReceived = 0;                        // Déclaration et initialisation de la variable "dataReceived" qui contiendra la commande reçue.


// Initialisation

void setup() {

   Wire.begin(SLAVE_ADDRESS);        // Initialisation de la liaison i2c

   Wire.onRequest(sendData);                // init sous-programme émission  sur le bus i2c

   Wire.onReceive(receiveData);        // initialisation sous-programme réception sur le bus i2c

   Serial.begin(9600);                        // Initialisation vitesse de communication de la liaison serie (USB) 9600 baud

   pinMode(Led, OUTPUT);                // La pin N°13 est déclarée en sortie pour piloter la Del

}


// Programme principal

void loop() {

   valA0 = analogRead(A0);                // Conversion de l’entrée A0, converti en un integer sur 16 bits (int val=).

   Serial.println (valA0);                      // Écriture de la valeur "val" sur le terminal (via la liaison serie).

   valA0h = (char)highByte(valA0);        // Isolation de l'octet de poids fort.

   tabcap[0] = valA0h;                            // Stockage dans le tableau, attention [0] correspond au premier emplacement du tableau.

   valA0l = (char)lowByte(valA0);          // Isolation de l'octet de poids faible.

   tabcap[1] = valA0l;                            // Stockage dans le tableau, attention [1] deuxième emplacement.

   digitalWrite(Led, dataReceived);        // Commande appliquée à la Del

   delay(20);                                // Pause 20 ms

   

}


// Sous-programme émission bus i2c

void sendData(){

   int envoi = tabcap[i];                      // envoi contient l'octet à transmettre

   if (i==0) {                                  // écrire dans la console Arduino l'octet transmis

     Serial.print("valA0h = ");                  // son nom

   }

    if (i==1) {

     Serial.print("valA0l = ");                // son nom

   }

   Serial.println(tabcap[i]);                  // sa valeur

   Wire.write(envoi);                          // émission de l'octet sur le bus

   i=i+1;                                        // pointe l'octet suivant

   if (i==2) {                                  // initialiser le pointeur

     i=0;                                              // si on dépasse le tableau

   }

}


// Sous-programme Réception bus i2c

void receiveData(int byteCount){

   while(Wire.available()) {

       dataReceived = Wire.read();                // Sauvegarde de la commande reçue dans la variable "dataReceived"

       Serial.print("Commande reçue : ");        // Écriture dans la console de la commande reçue

       Serial.println(dataReceived);

   }

}  


Sauvegarder votre fichier sous le nom: "A0_i2c_Led_VotreNom.ino"

Téléverser votre programme dans la carte Arduino.



       Programme Python (carte Raspberry)


Les modifications des programmes sont en rouge dans les listing qui suivent.


               On va écrire deux procédures, une pour allumer la Del et une pour l'éteindre.

                       "A0_i2c_CommandLed_On_VotreNom.py" pour allumer la Del,

"A0_i2c_CommandLed_Off_VotreNom.py" pour l'éteindre.

La modification du programme "A0_i2c_VotreNom.py" ne présente aucune difficulté.

On a besoin de déclarer une variable "commadLed", si commandLed=0 extinction de la Del et si commandLed=1 allumage.

Dans le programme on envoie la commande grâce à la commande "bus.write_byte(address, commandLed)"

Cette commande peut être introduite avant la boucle ou dans la boucle en fonction de vos besoins!


Premier programme extinction de la Del:


Copier/coller le listing qui suis dans un éditeur de texte.

Sauvegarder ce fichier sous le nom : « A0_i2c_CommandLed_Off_VotreNom.py »  


Utiliser WinSCP pour stocker ce fichier dans le répertoire "home/pi/" de votre carte Raspberry


Listing procédure "A0_i2c_CommandLed_Off_VotreNom.py "


#!/usr/bin/python

# -*- coding: ISO-8859-1 -*-


import smbus

import time


valA0h = 0 # Déclaration et initialisation des variables du programme

valA0l = 0

valA0 = 0

commandLed = 0 # Commande d'extinction de la Del


bus = smbus.SMBus(1) # Déclaration du bus i2c et initialisation de l'adresse de la carte Arduino (esclave) ici 0x10 soit 16 en décimale

address = 0x10


bus.write_byte(address, commandLed)

       

time.sleep(0.05)


while 0==0:


       reponse = bus.read_byte(address) #Lecture du premier octet valA0h

       valA0h = reponse


       reponse = bus.read_byte(address) #Lecture du deuxième octet valA0l

       valA0l = reponse


       valA0 = valA0h*256 + valA0l # On calcul la valeur 16bits valA0


       print "valA0 =", valA0 # On affiche dans le console le résultat du calcul et les deux valeurs reçues valA0h et valA0l

       print "valA0h =", valA0h

       print "valA0l =", valA0l

       

       time.sleep(0.05) # Temporisation avant de relancer une acquisition        


Deuxième programme allumage de la Del:


Copier/coller le listing qui suis dans un éditeur de texte.

Sauvegarder ce fichier sous le nom : « A0_i2c_CommandLed_On_VotreNom.py »  


Utiliser WinSCP pour stocker ce fichier dans le répertoire "home/pi/" de votre carte Raspberry


Listing procédure "A0_i2c_CommandLed_On_VotreNom.py "


#!/usr/bin/python

# -*- coding: ISO-8859-1 -*-


import smbus

import time


valA0h = 0 # Déclaration et initialisation des variables du programme

valA0l = 0

valA0 = 0

commandLed = 1 # Commande d'allumage de la Del


bus = smbus.SMBus(1) # Déclaration du bus i2c et initialisation de l'adresse de la carte Arduino (esclave) ici 0x10 soit 16 en décimale

address = 0x10


bus.write_byte(address, commandLed)

       

time.sleep(0.05)

       


while 0==0:


       reponse = bus.read_byte(address) #Lecture du premier octet valA0h

       valA0h = reponse


       reponse = bus.read_byte(address) #Lecture du deuxième octet valA0l

       valA0l = reponse


       valA0 = valA0h*256 + valA0l # On calcul la valeur 16bits valA0


       print "valA0 =", valA0 # On affiche dans le console le résultat du calcul et les deux valeurs reçues valA0h et valA0l

       print "valA0h =", valA0h

       print "valA0l =", valA0l

       

       time.sleep(0.05) # Temporisation avant de relancer une acquisition        



Résultats des simulations :


Présenter dans une même image les consoles Raspberry (LXTerminal) et Arduino lors de l'exécution des deux scripts python.


Commande Del=1


Commande Del=0




Créé avec HelpNDoc Personal Edition: Générateur complet de livres électroniques Kindle