jeudi 16 février 2017

Communication entre Raspberry Pi et Arduino avec modules nRF24L01

Nous voyons aujourd'hui comment établir une communication entre un Raspberry Pi et un Arduino (si vous le préférez, ce tutoriel vous permettra également d'établir une communication entre deux Rasbperry Pi).

Pour des raisons de simplicité, je vous propose des scripts qui permettent une communication unidirectionnelle:  un des deux appareils émet des informations, et l'autre appareil les capte.

Les possibilités sont donc:

- Un Raspberry Pi émetteur qui envoie des informations à un Arduino récepteur.
- Un Arduino émetteur qui envoie des informations à un Raspberry Pi récepteur.
- Un Raspberry Pi émetteur qui envoie des informations à un Raspberry Pi récepteur.

Les modules nRF24L01 offrent beaucoup plus de possibilités, comme par exemple une véritable conversation entre deux cartes (chacune agissant tour à tour comme émetteur et comme récepteur)­. Nous y reviendrons peut-être dans un futur article.

Réglages de l'Arduino

Si la communication que vous désirez établir implique la présence d'un Arduino (peu importe qu'il soit émetteur ou récepteur), référez-vous à cet article pour programmer la carte et y brancher convenablement le module nRF24L01.

Réglages du Raspberry Pi

Il faut tout d'abord s'assurer que le protocole SPI est activé.

Pour ce faire, on va dans le menu "Préférences", "Configuration du Raspberry Pi'.


Sous l'onglet "Interfaces", activer SPI, si ce n'est pas déjà fait.


Installation de la bibliothèque RF24

Après avoir tourné en rond pendant un certain temps, je me suis résigné à lire attentivement la documentation disponible sur la page de la bibliothèque RF24.  Voici ce que j'ai écrit dans le terminal pour télécharger et installer la bibliothèque:

--------------------
git clone https://github.com/TMRh20/RF24.git
cd RF24
sudo make install -B
sudo apt-get install python-dev libboost-python-dev
sudo apt-get install python-setuptools
cd pyRF24
./setup.py build
sudo ./setup.py install
------------------------

L'installation de la bibliothèque "libboost" et l'étape "setup.py build" nécessitent plusieurs minutes. L'installation des "setuptools" est probablement superflue (ils étaient déjà installé sur les deux modèles de Raspberry Pi que j'ai essayés).

Sur mon vieux Rasbperry Pi modèle B, une augmentation temporaire de la mémoire virtuelle s'est avérée nécessaire pour compléter avec succès l'étape "setup.py build".  Ça n'a pas été nécessaire sur mon Raspberry Pi 2, par contre.

Le circuit:

Voici d'abord un schéma identifiant les différents connecteurs du module nRF24L01:
Les connexions entre le module nRF24L01 et le Raspberry Pi sont:

GND du nRF24L01 : une des pins GND du Raspberry Pi (board 6: fil noir sur le schéma ci-dessous)
Vcc du nRF24L01 : une des pins 3V3 du Raspberry Pi (board 1: fil rouge)
CE du nRF24L01 : GPIO22 du Raspberry Pi (board 15: fil bleu)
CSN du nRF24L01 : GPIO8 du Raspberry Pi (board 24: fil vert)
SCK du nRF24L01 : SCKL du Raspberry Pi  (board 23:  fil orange)
MOSI du nRF24L01:  MOSI du Raspberry Pi (board 19:  fil rose)
MISO du nRF24L01:  MISO du Rasbperry Pi (board 21:  fil jaune)




Lors de mes tests, il n'a pas été nécessaire d'ajouter un condensateur de 10 μF en parallèle avec l'alimentation du nRF24L01,  C'est parfois conseillé.

Script en python pour que le Raspberry Pi agisse en émetteur





Script en python pour que le Raspberry Pi agisse en récepteur





Notez qu'il est important d'utiliser les privilèges de superutilisateur pour que ces scripts fonctionnent correctement  (par exemple:  "sudo python RF24Emetteur").  Sinon, le script sera rapidement interrompu avec la mention "erreur de segmentation".

De plus, même si les scripts eux-même ne font aucune vérification, la bibliothèque s'assure que le module nRF24L01 est correctement branché.  Si ce n'est pas le cas, le message "radio not responding" s'affiche à l'écran.

Notez finalement qu'il existe bien d'autres façons d'établir une communication entre un Raspberry Pi et un Arduino, et nous en avons exploré quelques-unes dans le passé:  communication par USB et communication RF 433 MHz.

Yves Pelletier   (TwitterFacebook)

mardi 14 février 2017

Communication par nRF24L01 entre deux cartes Arduino


Aujourd'hui, nous établissons une communication sans fil entre deux cartes Arduino, au moyen d'une paire de récepteurs-émetteurs nRF24L01.

Les habitués de ce blog me feront peut-être remarquer (à juste titre) qu'un tutoriel similaire avait déjà été publié dans un lointain passé. Mais à l'époque, j'avais utilisé la veille bibliothèque "mirf", qui est devenue quelque peu désuète. Cette fois-ci, j'utilise la bibliothèque RF24, plus récente.

Un aspect intéressant de cette bibliothèque, c'est qu'elle peut aussi être installée sur un Raspberry Pi, ce qui facilite grandement l'établissement d'une communication entre un Arduino et un Raspberry Pi.

Installation de la bibliothèque RF24

J'ai utilisé la version de la bibliothèque RF24 mise au point par TMRh20 (d'après la bibliothèque créée par ManiacBug).   Après l'avoir téléchargée, vous l'installez dans l'IDE Arduino de la façon habituelle.

Les connexions du nRF24L01

Chaque module nRF24L01 peut émettre et recevoir des données.  Il existe principalement deux modèles sur le marché:  l'un d'entre eux est vert, alors que l'autre est noir.  Le schéma ci-dessous pourrait vous être utile pour identifier les connecteurs du module, particulièrement si vous utilisez le modèle noir (sur lequel les broches ne sont pas identifiées).


Connexion du nRF24L01 à l'Arduino

Ce circuit doit être réalisé en deux exemplaires, de façon à obtenir un circuit émetteur, et un circuit récepteur.

Le module nRF24L01 fonctionne a un  niveau logique de 3,3 V, mais il supporte les signaux logiques de 5 V.  Il peut donc être branché directement aux sorties numériques de l'Arduino sans qu'il soit nécessaire d'utiliser un convertisseur de niveau logique.  Par contre, il est important de l'alimenter en 3,3 V et non en 5 V.

C'est une bonne idée d'ajouter un condensateur d'environ 10 μF branché en parallèle avec l'alimentation, question de stabiliser la tension.  Dépendant du matériel dont vous disposez, l'ajout de ce condensateur peut s'avérer nécessaire, préférable ou carrément superflu.  Pendant la réalisation de cet article, toute communication était impossible si ma carte réceptrice n'était pas munie d'un tel condensateur.  Pour l'autre carte, la présence ou l'absence du condensateur d'entraînait pas la moindre différence.

Les connexions entre le module nRF24L01 et la carte Arduino Uno sont:

GND du nRF24L01 : GND de l'Arduino
Vcc du nRF24L01 : 3V3 de l'Arduino
CE du nRF24L01 : pin 7 de l'Arduino
CSN du nRF24L01 : pin 8 de l'Arduino
SCK du nRF24L01 : pin 13 de l'Arduino
MOSI du nRF24L01:  pin 11 de l'Arduino
MISO du nRF24L01:  pin 12 de l'Arduino

Les pins CE et CSN peuvent être branchées ailleurs à la condition de modifier les sketches ci-dessous.  En ce qui concerne les pins consacrées au protocole SPI (11, 12, 13), elle sont différentes sur certains modèles d'Arduino (comme, par exemple, le Mega).




Exemples fournis avec la bibliothèque


De nombreux exemples sont fournis avec la bibliothèque.

Parmi ceux-ci, j'ai essayé l'exemple intitulé "GettingStarted", avec un succès mitigé:  la connexion entre les deux cartes s'établissait, mais au moins 10% des transmissions se terminaient en queue de poisson ("failed").

J'ai donc entrepris de rédiger une paire de sketches présentant le strict minimum:  un émetteur simple qui envoie chaque seconde un nombre croissant, et un récepteur simple qui affiche dans le moniteur série tous les messages qu'il reçoit.

Il n'y a aucune vérification d'erreurs, et le récepteur n'envoie pas d'accusé de réception à l'émetteur.

Ces sketches sont donc loin d'utiliser à fond les possibilités des modules nRF24L01.  Toutefois, je crois qu'ils sont facile à comprendre, et pendant mes tests ils fonctionnaient à la perfection, sans le moindre échec de transmission.

Le sketch de l'émetteur

Chaque seconde, un nombre entier augmente d'une unité.  Le nombre est diffusé par le module nRF24L01, et affiché dans le moniteur série.







Le sketch du récepteur

Chaque fois que le récepteur reçoit un message en provenance de l'émetteur, il l'affiche dans le moniteur série.



Si certains messages n'arrivent pas à destination, c'est facile de le constater:  certains nombres seront manquants.

Yves Pelletier   (TwitterFacebook)

jeudi 9 février 2017

Scratch sur Raspberry Pi (4): Contrôler un moteur cc

Après avoir appris comment faire clignoter une LED, comment lire un bouton poussoir et comment faire varier l'intensité lumineuse d'une LED, nous allons aujourd'hui contrôler un moteur à courant continu grâce au logiciel Scratch sur un Raspberry Pi.  Au moyen des touches du clavier, nous pourrons faire tourner le moteur et modifier sa vitesse ainsi que le sens de sa rotation­.



Matériel nécessaire

En plus d'un Raspberry Pi et d'un petit moteur électrique, nous aurons besoin d'une source d'alimentation pour le moteur (une pile, par exemple) et d'un circuit appelé "pont en H" spécialement conçu pour contrôler un moteur.  Je vous recommande l'utilisation d'une petite carte prête à l'emploi et comportant un L298N, tel qu'illustré ci-contre (si vous préférez, vous pouvez aussi utiliser un circuit intégré L293D).

Contrairement au Raspberry Pi, ces circuits intégrés sont capables de supporter les courants intenses qui sont nécessaires provoquer la rotation du moteur.   Ne branchez pas votre moteur directement aux pins GPIO du Raspberry Pi:  vous risqueriez d'endommager votre Rasbperry Pi!



Fabrication du circuit

La carte L298 permet de contrôler deux moteurs (ce qui est pratique, par exemple, pour le contrôle d'une plateforme robotique), mais nous nous contenterons aujourd'hui d'un seul moteur.

Les connexions qu'il faut faire sont illustrées ci-dessous:

  • Le moteur est branché dans les sorties OUT1 et OUT2 du module L298
  • La borne positive de l'alimentation pour le moteur est branchée dans l'entrée +12 V du module L298 (l'alimentation peut être inférieure à 12 V)
  • La borne négative de l'alimentation pour le moteur est branchée dans l'entrée GND du module L298.
  • Une des pins GND du Raspberry Pi est branchée dans l'entrée GND du module L298.
  • La pin BCM 23 du Raspberry Pi est branchée dans l'entrée IN1 du module L298.
  • La pin BCM 24 du Raspberry Pi est branchée dans l'entrée IN2 du module L298.
  • La pin BCM 25 du Raspberry Pi est branchée dans l'entrée ENA du module L298.



Si vous préférez utiliser un circuit intégré L293, voici le schéma du circuit.



Construction du programme

Le temps est venu de démarrer le logiciel Scratch (il se trouve dans la section "Programmation").

Notre programme va comporter 6 parties:
  1. Ce qui doit être fait au démarrage du programme, lorsqu'on clique sur le drapeau
  2. Ce qui doit être fait lorsqu'on appuie sur la touche "espace" (arrêt du moteur)
  3. Ce qui doit être fait lorsqu'on appuie sur la flèche vers le haut (augmentation de la vitesse)
  4. Ce qui doit être fait lorsqu'on appuie sur la flèche vers le bas (diminution de la vitesse)
  5. Ce qui doit être fait lorsqu'on appuie sur la flèche vers la droite (marche avant)
  6. Ce qui doit être fait lorsqu'on appuie sur la flèche vers la gauche (marche arrière)
Commençons par ce que doit faire le programme lorsqu'on clique sur le drapeau...


Nous envoyons le message "gpioserveron" qui démarre le serveur GPIO (ce qui permettra à Scratch d'interagir avec les entrées et les sorties du Raspberry Pi).


Ensuite, nous définissons la pin 25 comme une sortie PWM, ce qui signifie qu'elle alternera très rapidement entre 0 et 3,3 V.  Pour ce faire, nous envoyons le message "config25outputpwm".  Dans l'article précédent, le signal PWM servait à contrôler la luminosité d'une LED.  Ici, le signal PWM servira à contrôler la vitesse du moteur.


Cette vitesse sera stockée dans une variable que nous nommons "vitesse" (cliquez sur le bouton "Nouvelle variable" dans la catégorie "Variables".


Au démarrage du programme, nous donnons à la variable "vitesse" la valeur 50 (ce qui est une vitesse moyenne).

...et nous réglons le moteur à cette vitesse:


Nous configurons maintenant la pin 23 comme une sortie, grâce au message "config23out".  Il s'agit d'une sortie conventionnelle, et non d'une sortie PWM (sa tension conservera une valeur stable de 3,3 V ou de 0 V, sans oscillation rapide).


Au départ, nous réglons cette sortie à "off" (0 volt).



Même chose pour la pin 24:  nous en faisons une sortie, que nous réglons ensuite à off:


C'est terminé pour la partie du programme qui s'exécute au démarrage.

Occupons-nous maintenant de ce que le programme doit faire lorsqu'on appuie sur la touche "flèche vers le haut" ou "flèche vers le bas" sur le clavier.  Cette partie est identique à ce que nous avions fait dans le dernier article, pour rendre la LED plus brillante ou moins brillante.

Quand nous appuyons sur la flèche vers le haut, la valeur de la variable vitesse augmente de 10, et nous faisons tourner le moteur à cette vitesse.  Lorsque nous appuyons sur la flèche vers le bas, la valeur de la variable "vitesse" diminue de 10.



La touche "flèche vers la droite" mettra le moteur en marche avant, alors que la touche "flèche vers la droite" le mettra en marche arrière.  Pour que le moteur tourne, il faut qu'une (et seulement une) des pins 23 et 24 soit "on".



La touche "espace" permettra d'arrêter le moteur.  Pour ce faire, il s'agit de mettre à "off" les pins 23 et 24.

Le programme est terminé!

Mise à l'essai du programme

Après avoir cliqué sur le bouton en forme de drapeau afin de démarrer le programme, appuyez sur la flèche vers la droite pour faire tourner le moteur.  Le moteur changera de direction quand vous appuyez sur la flèche vers la gauche.  Il tournera plus vite si vous appuyez sur la flèche vers le haut, et moins vite si vous appuyez sur la flèche vers le bas.  Il s'arrêtera si vous appuyez sur la barre d'espacement.

Yves Pelletier   (TwitterFacebook)


Related Posts Plugin for WordPress, Blogger...