Réalisation d'une maison intelligente IOT: raspberry-pi,arduino,node-red...

Notre but de ce projet est de réalisation d'une maison intelligente En premier lieu notre but c'est la commande de l'éclairage, TV, laveuse... a distancé, au deuxième lieu notre but c'est le contrôle de la maison par caméra, message téléphonique, adresse email, mot de passe, ... aussi GPS, envoyée images après 1h sur téléphone, température, post twitter, reconnaissance faciale.
alors le plan d'une maison est comme suite:

Node-red Pg

pour la commande on utilise node-red (pour l'installation voir article) , alors choisissez les nodes suivantes:

• switch Node Input,

• Freebord Node,

• Arduino out node-red
• Inject-node
• Function node
• sms-free-mobile-node
• slider-node
• http in node
• camerapi-takephoto node
• twitter out node
• http reponse node
• e-mail node
• text input node
• edit sentiment node

La programmation pour notre projet est traduit sur l'image suivante par l'utilisation des nodes sur un langage de programmation IOT node-red.ce dernier est développée par l'IBM

selon les nodes choisissez on fera les designs hardware donc on a besoin des;

• Mobile android

• Carte rasberry-pi

• Arduino

• des resistances 

• des relais 5v

• des transistors

• des optocoupleur

• camera 15MPX

• servo-moteur

• clavier 4*4

Les autres composants sont purement software (les rôles principaux sur un carte raspberry-pi) premièrement on installe le carte de commande pour les lampes, les ventilateurs, TV, laveuse... sur la carte de commande pour cela on utilise l'arduino, transistors, optocoupleurs et relais pour chaque charge

Alors le relais se compose de deux parties. Une partie commande à droite sur la photo et composée d’une broche d’alimentation de 5 v pour le relais lui-même, une masse et une broche de commande pour faire basculer l’état. De l’autre côté, à gauche donc on trouve la partie basse tension. C’est cette dernière partie qui sera connectée à votre dispositif. Dans l’exemple ça sera une lampe. Se coter se composent de 3 fiches:

• NC : signifie ‘NORMALEMENT FERME’. Cela veut dire que lorsque le relais n’a pas de signal d’entrée (0 sur la broche de commande), le circuit haute tension connecté sera actif. Si on câble comme cela il faut donc envoyer du courant à la partie commande pour faire basculer le relais.
• NO signifie ‘NORMALEMENT OUVERT’. Cela veut dire qu’à contrario, une valeur de 5V appliqué au relais (1 sur la broche de commande) coupera le circuit haute tension et inversement.
• COM: la masse.

L'arduino envoie un faible courant sur ses ports GPIO qu’ils soient à 1 ou à 0. Ce faible courant suffit à déclencher le relais. Certain peuvent donc directement utiliser le relais. Je vous conseil de le tester. Il vous suffit pour cela de brancher les trois broches du arduino comme suit:

• 5v  du arduino -> Vcc 5V du relais
• Ground du arduino -> GND du relais
• L’un des port arduino -> La patte de commande du relais (numéroté IN1, IN2, etc.. généralement)

Si la diode du relais s’allume quelque soit l’état du port ARDUINO (LOW ou HIGH), c’est que vous êtes dans le même cas. Il vous faut alors un composant supplémentaire pour bloquer ce courant. Pour cette tache on va utiliser un MOSFET. Un MOSFET est un composant électronique permettant de faire de la commande en puissance. Le principe du fonctionnement de ce type de transistor est que lorsque la tension de la Gate atteint une valeur suffisante, le courant passe entre le Drain et la Source. Certains transistors sont commandés en courant, le Mosfet est commandé en tension.  

• 1 = G = GATE : broche de commande. La commande ici sera le port GPIO.
• 2 = D = DRAIN : broche qui draine le courant (la charge quoi… c’est ici que l’on va raccorder le relais pour le déclencher)
• 3 = S = SOURCE : broche source de courant (ou le courant est collecté pour être envoyé vers la charge… dans notre cas, il s’agit de la masse)

Voila le schéma de la petite installation. J’ai utilisé ici un MOSFET 

Pour la tester vous pouvez réutiliser le code précédent, ce qui aura pour effet d’enclencher et de déclencher le relais toute les secondes.

Une fois que tout cela fonctionne, il ne vous reste plus qu’a interfacer de l’autre coté l’élément basse tension que vous souhaitez contrôler et bien sur écrire un bout de code qui correspond à vôtre besoin.

Fonctionnement:

On applique un signal de commande de 5𝑉 sur la base du transistor via de la résistance, d’ou le transistor fonctionne comme un interrupteur qui relie la bobine du relais à la masse. Cette dernière est parcourue par un courant, alors le relais est actionné. La diode placée en parallèle de la bobine nous permet d'éviter de détruire le transistor lors de son ouverture. Qui l’on appelle généralement "la diode de roue libre" : cette diode est très importante et ne doit pas être négligée. En effet le pilotage du relais se fait via une bobine : l’ouverture du transistor se fait lors du passage de 1 à 0 logiques à l’entrée. Or le courant ne peut pas s’annuler immédiatement dans l’inductance. Ce qui est créé une surtension au niveau du collecteur du transistor qui peut être très élevée et ainsi supérieure a la tension de claquage Vce max (tension collecteur émetteur maximale préconisée par le constructeur). Les données sont: 

T: transistor NPN, 𝛽 = 200, 𝑉𝑐𝑒_𝑠𝑎𝑡 = 0.2𝑉, 𝑉𝑏𝑒_𝑠𝑎𝑡 = 0.7𝑉, 

REL: relais,𝑅𝑟𝑒𝑙 = 0.288 𝐾Ω.

D: diode de roue libre. Cette diode sert uniquement à protéger le transistor lorsqu'on le bloque (supprime l’arduino de tension du au relais).

Ve vaut 0 ou 5𝑉. Lorsque 𝑉𝑒 = 0, on veut que le relais ne soit pas alimenté (soit 𝑈𝑟𝑒𝑙 = 0), et lorsque 𝑉𝑒 = 5𝑉, on veut que le relais soit alimenté .

 On commence par vérifier pour 𝑉𝑒 = 0: 

Si 𝑉𝑒 = 0, alors 𝑉𝑏𝑒 = 0, et 𝐼𝑏 = 0 (la "diode" base émetteur est bloquée). 

Donc le transistor est bloque,𝐼𝑐 = 𝐼𝑒 = 0. Donc 

𝑈𝑟𝑒𝑙 = 𝑅𝑒𝑙 × 𝐼𝑐  

= 288 × 0 = 0. 

 On fait le calcul de 𝑅 pour 𝑉𝑒 = 5𝑉: 

On a 𝑉𝑐𝑐 = 𝑉𝑐𝑒 + 𝑈𝑟𝑒𝑙 

Or il faut que le transistor soit saturé. 

Donc 𝑉𝑐𝑒 = 𝑉𝑐𝑒_𝑠𝑎𝑡. 

D'autre part, 𝑈𝑟𝑒𝑙 = 𝑅𝑟𝑒𝑙 × 𝐼𝑐 

 Donc V𝑐𝑐 = 𝑉𝑐𝑒_𝑠𝑎𝑡 + 𝑅𝑟𝑒𝑙 × 𝐼

calcul de 𝑅:

 Il faut se souvenir que la jonction base émetteur se comporte comme une diode. 

On a 𝑉𝑒 = 𝑈𝑟 + 𝑉𝑏𝑒. 

Or 𝑉𝑏𝑒 = 𝑉𝑏𝑒_𝑠𝑎𝑡 = 0.7𝑉 (𝑑𝑖𝑜𝑑𝑒) 

Donc 𝑉𝑒 = 𝑅 × 𝐼𝑏_𝑠𝑎𝑡 + 𝑉𝑏𝑒_𝑠𝑎𝑡 

Soit

𝑅 = (𝑉𝑒 – 𝑉𝑏𝑒𝑠𝑎𝑡) /𝐼𝑏𝑠𝑎𝑡 

 = (5 − 0.7)/ 0.00030 

= 14333 𝑂ℎ𝑚𝑠 

= 14 𝑘Ω

Alors on a réalisé un "interrupteur" commandé électriquement: 

*Lorsque à la journée : 𝑉𝑒 = 0, le transistor est bloqué, le relais n'est pas aliment donc la lampe éteint. 

*Lorsque au nuit : 𝑉𝑒 = 5𝑉, Ib est un "faible" courant de commande, qui laisse passer un "fort" courant entre le colleteur et l'émetteur, d’ou le relais est alimenté donc la lampe est allumée

pour commander fenetre, port... à distance on utilisé un servo-moteur relié automatiquement par un condensateur

C’est un moteur un peu particulier, puisqu’il confond un ensemble de mécanique et d’électronique , mais son principe de fonctionnement reste assez simple. Les parties seront donc assez courtes dans l’ensemble car les servomoteurs contiennent dans leur « ventre » des moteurs à courant continu que vous connaissez à présent. Un servomoteur se décompose essentiellement d’un : 

• Moteur à courant continue 
•  Système réducteur de vitesse a roues dentées 
• Potentiomètre 
• Circuit électronique 

La consigne doit être donnée par l’utilisateur (dans notre cas il va s’agir du signal envoyé par la carte Arduino), est comparée par rapport à la position réelle de l’axe du moteur. Ainsi, s’il y a une différence d’angle entre la consigne et l’angle mesuré par le capteur (le potentiomètre qui est fixé sur l’axe du servomoteur) le comparateur va commander le moteur et le faire tourner jusqu’à ce que cette différence s’annule.

Un comparateur est un composant électronique de la famille des circuits intégrés car, il contient en vérité d’autres composants, essentiellement des semi-conducteurs (diodes, transistors) et des résistances. Par la suite le shéma de montage d’un servomoteur est comme suit :

Le comparateur est donné : -

Si 𝑉1 > 𝑉2, alors 𝑉𝑠 = +Vcc

- Si 𝑉1 < 𝑉2, alors 𝑉𝑠 = −𝑉𝑐𝑐 

À la place du potentiomètre de commande manuelle on peut utiliser un couple résistance/ condensateur avec 𝑅 et 𝐶, qui permet d’extraire la tension continue du signal dont le rapport cyclique varie de 0 à 100%.

 Le signal de commande d'un servomoteur est un signal PWM( pulse wide modelation) de fréquence 50𝐻𝑧 et dont le niveau haut doit être compris entre 1 𝑒𝑡 2𝑚𝑠 (en théorie). 

1𝑚𝑠 ∶ −90° en angle de sortie 

1.5𝑚𝑠 ∶ 0° en angle de sortie

2𝑚𝑠 ∶ +90° en angle de sortie

 Pour utiliser le servomoteur comme un moteur de propulsion (pouvant tourner normalement), il est nécessaire d’effectuer une modification mécanique, pour 0.25𝑠 le servomoteur tourne à 180° donc on détermine la vitesse de rotation :

0.25𝑠--> 180°  

0.25×180 /60 = 0.50𝑠 -->360° 

Le servomoteur tourne 1 tour en 0.5𝑠 ce qui est permet de déterminer la vitesse de rotation 𝑁𝑠 

 1𝑡𝑟 -->0.5𝑠 

60/ 0.5 = 120𝑡𝑟/𝑚𝑖𝑛 -->60𝑠 

D’après la règle de trois 𝑁𝑠 = 120𝑡𝑟/𝑚𝑖𝑛 Par suite on calculer la vitesse angulaire de notre servomoteur :

Ω = 2𝜋𝑁𝑠 /60  

= 2×3.14×120 /60 

= 12.5𝑟𝑑/𝑠 

Le servomoteur consomme 250𝑚𝐴 sous 5𝑉, on calcul la puissance absorbé Pabs 

𝑃𝑎𝑏𝑠 = 𝑈 × 𝐼 = 5 × 0,250 = 1,25𝑊 

𝐶 = 0.08𝑁. 𝑚 et Ω = 12.5𝑟𝑑/𝑠 donc on calculer la puissance mécanique

 𝑃𝑠 = 𝐶 × Ω 

= 0,08 × 12.5 

= 1𝑊  

Par suite on déduire le rendement de notre servomoteur :

rendement = 𝑃𝑠 /𝑃𝑎𝑏𝑠 

= 1 /1.25 

= 0.8𝑊 

Alors le rendement de notre servomoteur est égale à 80%

Nous essayé le servomoteur mais il vibre sans rotation ce qui est indique l’existence d’une chute de tension pour cela on utilise un condensateur dans le but d’avoir une tension sensiblement constante, donc on propose de brancher un ou plusieurs condensateurs en parallèle. Théoriquement plus la valeur de condensateur sera élevée plus le filtrage sera mieux. 

𝐶 = 𝐼 /(𝛽×𝑈×F)

Avec : 𝛣 = 20 %, 𝐹 = 50𝐻𝑍 

𝐶 = 0.250 /(0.2×5×50) = 4000µf

Vidéo démonstration:

Après l'installation servo-moteur .on passe pour les caméras pour programmation on utilise le langage python et open CV pour reconnaissance et suiveur facial
Détecter un visage
La première fonctionnalité dont nous aurions besoin pour effectuer la reconnaissance faciale est de détecter, dans le champ de vision actuel, un visage est présent. En utilisant la bibliothèque OpenCV, vous pouvez utiliser les filtres en cascade de HAAR pour le faire efficacement.

Au cours de la mise en œuvre, nous avons utilisé Anaconda avec Python 3.5, OpenCV 3.1.0 et dlib 19.1.0. Si vous souhaitez utiliser le code dans cet article, assurez-vous que vous avez ces versions (ou plus récentes).

Afin de faire la détection de visage, nous devons d'abord effectuer quelques initialisations:

import cv2
faceCascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
OUTPUT_SIZE_WIDTH = 775  
OUTPUT_SIZE_HEIGHT = 600
capture = cv2.VideoCapture(0)
cv2.namedWindow("base-image", cv2.WINDOW_AUTOSIZE)  
cv2.namedWindow("result-image", cv2.WINDOW_AUTOSIZE)
cv2.moveWindow("base-image",0,100)  
cv2.moveWindow("result-image",400,100)
cv2.startWindowThread()
rectangleColor = (0,165,255)  

Le reste du code sera une boucle infinie qui récupère la dernière image de la webcam, détecte tous les visages dans l'image, dessine un rectangle autour du plus grand visage et enfin affiche la sortie dans une fenêtre.

Ce qui précède peut être réalisé avec le code suivant dans une boucle infinie:

rc,fullSizeBaseImage = capture.read()
baseImage = cv2.resize( fullSizeBaseImage, ( 320, 240))
pressedKey = cv2.waitKey(2)  
if pressedKey == ord('Q'):  
cv2.destroyAllWindows()  
exit(0)
resultImage = baseImage.copy()
gray = cv2.cvtColor(baseImage, cv2.COLOR_BGR2GRAY)  
faces = faceCascade.detectMultiScale(gray, 1.3, 5)
maxArea = 0  
x = 0  
y = 0  
w = 0  
h = 0
for (_x,_y,_w,_h) in faces:  
    if  _w*_h > maxArea:
        x = _x
        y = _y
        w = _w
        h = _h
        maxArea = w*h
    if maxArea > 0 :
        cv2.rectangle(resultImage,  (x-10, y-20),
                    (x + w+10 , y + h+20),
                    rectangleColor,2)

largeResult = cv2.resize(resultImage,  
             (OUTPUT_SIZE_WIDTH,OUTPUT_SIZE_HEIGHT))
cv2.imshow("base-image", baseImage)  
cv2.imshow("result-image", largeResult)  

Suivre le visage
Le code ci-dessus pour la détection de visage présente certains inconvénients:

Le code peut être coûteux en termes de calcul
Si la personne détectée tourne légèrement la tête, la cascade du haar pourrait ne plus détecter le visage
Il est très difficile de garder la trace d'un visage entre des images (c'est-à-dire de ne plus faire face à un visage détecté qu'une fois et pas dans chaque boucle).
Une meilleure approche pour cela est de faire la détection du visage une fois et ensuite utiliser le tracker de corrélation de l'excellente bibliothèque dlib pour garder une trace de la région pertinente d'une image à l'autre.

Pour que cela fonctionne, nous devons importer une autre bibliothèque et initialiser des variables supplémentaires:

import dlib
tracker = dlib.correlation_tracker()
trackingFace = 0

Dans la boucle for infinie, nous devrons maintenant déterminer si le traqueur de corrélation dlib suit actuellement une région dans l'image. Si ce n'est pas le cas, nous utiliserons un code similaire comme précédemment pour trouver le plus grand visage, mais au lieu de dessiner le rectangle, nous utilisons les coordonnées trouvées pour initialiser le tracker de corrélation.

if not trackingFace:
    gray = cv2.cvtColor(baseImage, cv2.COLOR_BGR2GRAY)
    faces = faceCascade.detectMultiScale(gray, 1.3, 5)
    print("Using the cascade detector to detect face")
    maxArea = 0
    x = 0
    y = 0
    w = 0
    h = 0
    for (_x,_y,_w,_h) in faces:
        if  _w*_h > maxArea:
            x = int(_x)
            y = int(_y)
            w = int(_w)
            h = int(_h)
            maxArea = w*h
    if maxArea > 0 :
        tracker.start_track(baseImage,
                            dlib.rectangle( x-10,
                                            y-20,
                                            x+w+10,
                                            y+h+20))

     
        trackingFace = 1

Maintenant, le dernier bit dans la boucle infinie consiste à vérifier à nouveau si le suiveur de corrélation suit activement un visage (c'est-à-dire qu'il peut simplement détecter un visage avec le code ci-dessus). Si le tracker suit activement un visage dans l'image, nous allons maintenant mettre à jour le tracker. En fonction de la qualité de la mise à jour (c'est-à-dire de la confiance du traqueur sur le suivi du même visage), soit nous dessinons un rectangle autour de la région indiquée par le tracker, soit nous indiquons que nous ne suivons plus aucun visage:

public class HelloWorld {

if trackingFace:
    trackingQuality = tracker.update( baseImage )
    if trackingQuality >= 8.75:
        tracked_position =  tracker.get_position()

        t_x = int(tracked_position.left())
        t_y = int(tracked_position.top())
        t_w = int(tracked_position.width())
        t_h = int(tracked_position.height())
        cv2.rectangle(resultImage, (t_x, t_y),
                                    (t_x + t_w , t_y + t_h),
                                    rectangleColor ,2)

    else:
        trackingFace = 0

  Comme vous pouvez le voir dans le code, nous imprimons un message à la console chaque fois que nous utilisons à nouveau le détecteur et envoyée sur telephone du client. Si vous regardez la sortie de la console lors de l'exécution de cette application, vous remarquerez que même si vous vous déplacez un peu sur l'écran, le tracker est assez bon pour suivre un visage une fois qu'il est détecté. Lorsque vous utilisez le code ci-dessus, vous devriez voir un écran similaire au suivant, où le programme indique qu'il a détecté mon visage:

Vidéo Demonstration

Sécurisation par clavier et code de vérification Mobile:
  Après détection et suiveur de vissage on parle maintenant sur la sécurisation pour Sela on utilise un clavier 4*4 pour gérer le mot de passe .et si le mot de passe fault le client recevoir un code de vérification sur téléphone (le programme de vérification mobile se fait par le programme node-red. voir partie Node-red pg au-dessus) .alors le fonctionnement de clavier et comme suite:

Nous utiliserons la librarie Password and Keypad pour arduino, en plus d'utiliser la servo-librairie, mais cette partie peut aussi être modifiée en changement le servo-moteur, un moteur pas à pas, ou toute autre idée...

Étape 1: Les pièces de ce partie:

Nous aurons besoin de ces pièces pour ce parties:

Quatre résistances de 910 ohms

Une résistance de 1k

Arduino UNO ou similaire

Servomoteur - Large

CLAVIER 4X4 (ou similaire)

plaque à essai

fils jumper

Étape 2: Préparation du clavier

Eh bien, maintenant nous devons mettre les résistances, rappelez-vous la potion des broches du clavier.

Goupilles de sortie du clavier:

1 pin = col 1
2 pin = col 2
3 pin = col 3
4 pin = col 4

5 pin = row 1
6 pin = row 2
7 pin = row 3
8 pin = row 4

Maintenant, ils doivent mettre trois résistances 10 kohms sur les broches 1, 2 et 3 du clavier, puis mettre dans les broches numériques arduino du formulaire NEXT:

pins keypad  |  pins arduino

---------------------------------------
          1           |           8
          2           |           7
          3           |           6
          4           |           9        
          5           |           5
          6           |           4
          7           |           3
          8           |           2

Étape 3: Préparation du servo

Étape 4: Connexion des LED

Vous devez placer la LED Acceptée (verte) et la LED Refusée (rouge) de cette manière:

Étape 5: (UPDATE) et maintenant, la programmation

Vous avez besoin de ces bibliothèques:

Mot de passe librarie

Keypad librarie

Eh bien, c'est le code pour arduino, il vous suffit de changer cette écriture en gras et de mettre votre mot de passe.

#include <Password.h> /

#include <Keypad.h> /

#include <Servo.h> 

Servo myservo; 

Password password = Password( "your_password" ); 

const byte ROWS = 4; 

char keys[ROWS][COLS] = {

{'1','2','3','A'},

{'4','5','6','B'},

{'7','8','9','C'},

{'*','0','#','D'}

};

byte rowPins[ROWS] = { 5, 4, 3, 2 };

byte colPins[COLS] = { 8, 7, 6, 9 };

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

void setup(){

  Serial.begin(9600);

  Serial.write(254);

  Serial.write(0x01);

  delay(200); 

  pinMode(11, OUTPUT);  

  myservo.attach(13); 

  keypad.addEventListener(keypadEvent); 

  }

void loop(){

  keypad.getKey();

  myservo.write(0);

  }

  void keypadEvent(KeypadEvent eKey){

  switch (keypad.getState()){

  case PRESSED:

  

  Serial.print("Enter: ");

  Serial.println(eKey);

  delay(10);

  

  Serial.write(254);

  

  switch (eKey){

    case 'A': checkPassword(); delay(1); break;

    

    case 'B': password.reset(); delay(1); break;

    

     default: password.append(eKey); delay(1);

}

}

}

void checkPassword(){

  

if (password.evaluate()){  

    

    Serial.println("Accepted");

    Serial.write(254);delay(10);

    //Add code to run if it works

    myservo.write(5); 

        digitalWrite(11, HIGH);

    delay(500); //wait 5 seconds

    digitalWrite(11, LOW);

}else{

    Serial.println("Denied"); 

    Serial.write(254);delay(10);

    myservo.write(0);

    digitalWrite(12, HIGH); 

    delay(500); //wait 5 seconds

    digitalWrite(12, LOW);

    

}

}

et voila le code arduino et bibliothèques:

code/bib

Comme mentionné ci-dessus, s'il y a une erreur dans le mot de passe, une code de vérification  est envoyé sur le télephone du client par l'utilisation d'un logiciel IOT node-red
Comm Raspberry-pi/Arduino
Maintenant il est  temps de communication carte IOT dite raspberry-pi avec la carte arduino.

Et alors Pourquoi voudrait-on établir une communication entre un Raspberry Pi et un Arduino? Maintenant que nous avons appris comment utiliser les pins GPIO du Raspberry Pi, ce dernier n'est-il pas capable d'agir de façon autonome?

Voici quelques raisons possibles:

• Le Raspberry Pi n'est pas idéal pour accomplir des actions avec un timing précis, car  Linux pourrait décider de se consacrer temporairement à une autre tâche.   Par exemple, si vous contrôlez un moteur pas à pas,servo-moteur... avec le Raspberry Pi, le moteur pourrait s'arrêter momentanément, de temps à autres. L'Arduino est plus fiable dans ce genre de situation.
• Vos capteurs peuvent se trouver sur un shield conçu pour être inséré sur un Arduino.  Évidemment, la disposition des pins GPIO du Raspberry Pi n'est pas la même.
• Si vous êtes déjà un utilisateur expérimenté de l'Arduino mais un néophyte en Python/Linux/Raspberry Pi, il y a certaines choses que vous savez déjà faire très facilement avec l'Arduino, mais que vous ne savez pas encore comment faire avec le Raspberry Pi.
• Vous désirez établir un réseau de plusieurs capteurs satellites qui se rapportent à une seule station centrale, et plusieurs Arduinos coûtent moins cher que plusieurs Raspberry Pi.
• La raison la plus importante pour notre projet ce qui est le rôle principal que vous souhaitez jouer carte raspberry-pi est seulement IOT pas d'autre.

  La bonne nouvelle, c'est que c'est tout à fait possible, et même relativement facile, d'établir une communication entre un Raspberry Pi et un Arduino.  Et ce ne sont pas les options qui manquent:  communication série (UART),  I2C, Ethernet, communication sans fil...

  Dans cette partie, nous abordons l'option qui s'avère probablement la plus simple:  la communication série par l'entremise d'un câble USB:  vous allez simplement brancher l'Arduino à un des deux ports USB du Raspberry Pi, de la même façon que vous le faites lorsque vous désirez programmer l'Arduino avec un ordinateur conventionnel. Mais attention: avant de brancher l'Arduino au Raspberry Pi, assurez-vous que l'Arduino dispose de sa propre alimentation;  le Raspberry Pi pourrait avoir des ratés si sa propre alimentation devait, en plus, alimenter l'Arduino par le port USB.

Installation de la bibliothèque pyserial

Installons d'abord la bibliothèque pyserial dans le Raspberry Pi:  elle nous facilitera grandement la tâche lors de la conception de nos scripts en Python.  Pour ce faire, vous utilisez cette commande pendant que le Raspberry Pi est branché à l'internet:

sudo apt-get install python-serial

Envoi d'un message de l'Arduino vers le Raspberry Pi 
 Commençons par une communication unidirectionnelle de l'Arduino vers le Raspberry Pi. Du côté Arduino, l'envoi de messages se fait par la commande "Serial.println". Par exemple, le sketch ci-dessous envoie un message toutes les 3 secondes. J'ai ajouté un compteur pour que le message ne soit pas rigoureusement identique d'une fois à l'autre. Nous pourrons donc vérifier que tous les messages envoyés par l'Arduino sont bel et bien captés par le Raspberry Pi.

int compteur = 0;

void setup(){
  Serial.begin(9600);
}

 
void loop(){
  Serial.print("Message numero ");
  Serial.println(compteur);
  Serial.println("Bonjour, la Framboise, ici l'Arduino!");
  compteur++;
  delay(3000);
}

Comme vous pouvez le constater, c'est exactement comme si vous vouliez afficher un message sur le moniteur série de l'environnement de programmation Arduino; vous pouvez d'ailleurs utiliser le moniteur série pour vérifier dès maintenant que le sketch fonctionne de la façon prévue. Du côté Raspberry Pi, à la condition que la bibliotèque PySerial ait été préalablement installée, la fonction "serial.Serial" nous permet de lire les messages reçus . Le premier paramètre de cette fonction est le nom du port usb occupé par l'Arduino: dans mon cas, c'était ttyACM0; ce sera peut-être la même chose pour vous aussi, mais ce n'est pas certain. Pour en avoir le coeur net, vous pouvez écrire cette ligne de commande:

ls /dev/tty*

Vous devriez avoir un résultat légèrement différent selon que l'Arduino est connecté ou non au Raspberry Pi. Le nom correct devrait être celui qui apparaît dans la liste pendant que l'Arduino est branché, mais qui n'y apparaît pas quand l'Arduino est débranché du port USB. Voici donc un sketch en Python qui permettra au Raspberry Pi d'écouter ce que lui dit l'Arduino, et d'afficher le résultat. (Personnellement, j'utilise le logiciel WinSCP pour installer le fichier dans le Raspberry Pi).

import serial
ser = serial.Serial('/dev/ttyACM0', 9600)
while 1 :
   print(ser.readline())

Pour interrompre le script, vous pouvez utiliser la combinaison Ctrl-C au clavier.
 Envoi d'un message du Raspberry Pi vers l'Arduino 
 Essayons maintenant l'autre direction: branchons quelques LEDs à l'Arduino, et c'est le Raspberry Pi qui indiquera à l'Arduino quelles LEDs il doit éteindre ou allumer.
 Donc, une LED (accompagnée de sa résistance protectrice) est branchée à chacune des pins suivantes de l'Arduino: 2, 3 et 4 (attention: le schéma ci-dessous montre par erreur des connexions aux pins 1, 2, et 3!).

Commençons par le sketch Arduino. Grâce à la fonction Serial.read, le sketch ci-dessous allume ou éteint les LEDs en fonction du message reçu: il allume la LED 1 (pin 2) s'il reçoit le message "1", il éteint la LED 2 (pin 3) s'il reçoit le message "5", etc.

#define LED1 2
#define LED2 3
#define LED3 4

int message = 0;


void setup()
{
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  
  Serial.begin(9600);
}

void loop()
{
  if (Serial.available())  {
    message = Serial.read()-'0';  // on soustrait le caractère 0, qui vaut 48 en ASCII
    
    switch (message) {
    case 1:
      digitalWrite(LED1, HIGH);
      break;
    case 2:
      digitalWrite(LED2, HIGH);
      break;
    case 3:
      digitalWrite(LED3, HIGH);
      break;
    case 4:
      digitalWrite(LED1, LOW);
      break;
    case 5:
      digitalWrite(LED2, LOW);
      break;
    case 6:
      digitalWrite(LED3, LOW);
      break;
    }
  }
}

Pourquoi soustraire le caractère '0'? C'est parce qu'au départ, lorsque l'Arduino reçoit le message "1", il s'agit d'un caractère dont le code ASCII est 49. En soustrayant le caractère '0' (dont le code ASCII est 48), le caractère '1' qui a été reçu devient le nombre entier 1. Si vous le désirez, vous pouvez vérifier que ce sketch fonctionne correctement à l'intérieur de l'environnement de programmation Arduino, avant même de brancher l'Arduino au Raspberry: dans le moniteur Série, tapez des nombres entre 1 et 6 et voyez que les LEDs s'allument ou s'éteignent en fonction des nombres que vous envoyez. Et voici le script en Python qui sera exécuté par le Raspberry Pi: c'est maintenant lui qui envoie des informations à l'Arduino:

import serial  
import time    
ser = serial.Serial('/dev/ttyACM0', 9600)
compteur = 0
while True:     
    if compteur < 6:
     compteur = compteur + 1
    else:
     compteur = 0
    ser.write(str(compteur))
    time.sleep(1)   

Communication bidirectionnelle entre le Raspberry Pi et l'Arduino

Finalement, voici un exemple où le Raspberry Pi demande une information à l'Arduino (l'état d'un potentiomètre dont le curseur est branché à A0 ), et affiche la réponse que lui a retournée l'Arduino.

Le sketch Arduino:

int message = 0;
void setup()
{ 
  Serial.begin(9600);
}

void loop()
{
  if (Serial.available())  {
    message = Serial.read()-'0';  
    if (message == 5){
      Serial.println(analogRead(A0),DEC);
    }
  }
}

Le script en python du Raspberry Pi:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
5oQCPcBGAYYCw/s1600/4.png" />


# Le Raspbery Pi demande une information à l'Arduino,
# puis il affiche la réponse à l'écran

import serial  # bibliothèque permettant la communication série
import time    # pour le délai d'attente entre les messages

ser = serial.Serial('/dev/ttyACM0', 9600)
time.sleep(4)   #on attend un peu, pour que l'Arduino soit prêt.

while True:     # boucle répétée jusqu'à l'interruption du programme
    ser.write('5')
    print(ser.readline())  #on affiche la réponse
    time.sleep(1)               # on attend pendant 1 seconde

--> Puisque notre but de projet est intéressé dans le domaine IOT alors on utilise une carte bassée a ce dernier qui est la carte rasberry-pi comme exemple dans le GPS, SENTIMENT, TAKE PICTURE,TEMPERATURE... tout, est au-dessus dans la partie node-red qui installé par défaut sur le système d'exploitation raspian (systeme d'exploitation sur rasberry-pi)