mardi 28 février 2017

Bip bip: 5 circuits qui produisent un son

Que ce soit pour un système d'alarme, une sonnette,  ou simplement pour irriter son entourage, il arrive parfois qu'on veuille produire un son au moyen d'un circuit électronique.  Cet article montre quelques façons différentes de procéder.

Le point commun de tous les circuits présentés ici, c'est qu'ils permettent de produire un son au moyen d'un petit haut-parleur chaque fois qu'on appuie sur un bouton.



Premier circuit:  un oscillateur constitué de 2 transistors

Notre premier circuit, que nous avions déjà exploré dans un précédent article,  ne comporte pas le moindre circuit intégré: il s'agit d'un oscillateur constitué de deux transistors (un transistor PNP et un transistor NPN).  J'ai utilisé un 2N3904 et un 2N3906, mais le circuit devrait fonctionner avec d'autres paires de transistors d'usage général.
L'oscillation est produite par une succession rapide de charges et de décharges du condensateur: lorsque le condensateur est chargé, les deux transistors deviennent conducteurs, ce qui cause la décharge du condensateur.  Une fois le condensateur déchargé, les transistors ne sont plus conducteurs, et le condensateur peut se charger à nouveau.

Vous pouvez obtenir un son plus aigu en diminuant un peu la capacité du condensateur, ou en diminuant la valeur de la résistance R2.


Deuxième circuit:  un timer 555

Un grand classique:  l'incontournable timer 555 en mode multivibrateur astable.  Encore une fois, vous pouvez sans problème modifier la fréquence en utilisant un condensateur de capacité différente (plutôt que 100 nF) ou des résistances de valeur différente.  Il s'agit du même circuit que j'avais jadis utilisé pour fabriquer un oscillateur pour pratiquer le code morse.

Troisième circuit:  porte NON

Le circuit intégré CD40106 comporte 6 portes NON à bascule de Schmitt, mais je n'en ai utilisé qu'une seule pour la réalisation de ce circuit.  Lorsque l'entrée de la porte est à un niveau logique haut, la sortie se règle à un niveau logique bas, et vice versa.  Si on redirige le signal de sortie vers le signal d'entrée, en prenant soin d'ajouter un délai grâce à un condensateur et une résistance, on obtient une oscillation.

La sortie du CD40106 ne procure pas suffisamment de courant pour alimenter le haut-parleur, toutefois, ce qui explique la présence du transistor.

Ici encore, il est parfaitement possible d'obtenir un son de fréquence différente en remplaçant le condensateur ou la résistance de 100 kΩ.
Dans le passé, nous avions expérimenté quelques synthétiseurs rudimentaires basés sur le CD40106.

Quatrième circuit:  un oscillateur constitué d'un amplificateur opérationnel

On peut faire un tas de choses formidables avec un amplificateur opérationnel; parmi celles-ci:  un multivibrateur astable.  J'ai choisi un LM358, ce qui m'a permis d'utiliser une alimentation simple (d'autres modèles d'amplificateurs opérationnels nécessitent une alimentation symétrique).

Tout comme le CD40106 dont nous parlions plus haut, la sortie du LM358 ne transporte pas assez de courant pour alimenter un haut-parleur, d'où l'ajout d'un transistor.



Cinquième circuit:  Arduino

Les 4 circuits précédents devraient vous avoir convaincu qu'il n'est pas nécessaire d'utiliser un microcontrôleur pour une tâche aussi simple que produire un son lorsqu'on appuie sur un bouton.

Pas nécessaire, mais quand même possible, et même plutôt facile.

Voici un circuit et un sketch permettant d'accomplir cette action au moyen d'une carte Arduino Uno. Cette fois, le transistor sert surtout à protéger la sortie numéro 8 de votre microcontrôleur préféré, car un courant trop intense risquerait de l'endommager.







Yves Pelletier   (TwitterFacebook)

jeudi 23 février 2017

Utilisation d'un régulateur de tension linéaire

De façon générale, un régulateur de tension est utilisé lorsqu'on désire une valeur précise de tension (par exemple:  5 V), qui demeurera constante malgré d'éventuelles fluctuations de la tension d'alimentation ou de la résistance du circuit alimenté.

Par exemple, après qu'une tension alternative ait été convertie en tension continue grâce à un rectificateur à double alternance,  nous obtenons un signal à peu près continu, mais qui comporte une légère ondulation, qui peut se révéler indésirable:  l'utilisation d'un régulateur de tension permet d'éliminer cette oscillation.

Dans d'autres situations, nous voudrons utiliser une pile pour produire une tension de 5 V... mais il n'existe pas vraiment de piles de 5 V.

Dans cet article, je me limite aux régulateurs linéaires conventionnels, qui ont l'avantage d'être très peu coûteux, en plus d'être facile à utiliser.   Comme nous le verrons,  ils ont toutefois l'inconvénient de gaspiller une proportion non négligeable d'énergie sous forme de chaleur.  Pour un circuit plus économe en énergie, un régulateur à découpage pourrait être plus approprié.

Régulateurs de tension fixe:  LM7805, LM7809, LM7812, etc.

Commençons par la série LM78XX, qui permet d'obtenir une tension fixe.  Les deux derniers chiffres du numéro de modèle nous indiquent la tension de sortie.  Ainsi, le LM7805 produit une tension de 5 V, le LM7809 produit une tension de 9 V, le LM7824 produit une tension de 24 V, etc.

Ces régulateurs sont généralement vendus en format TO-220.  Ils comportent 3 broches: la tension d'entrée (1), la masse qui est commune à l'entrée et à la sortie (2), et la tension de sortie (3).

Ces régulateurs consomment eux même un minimum d'environ 2 V; pour cette raison, la tension d'entrée doit être d'au moins 2 V de plus que la tension de sortie désirée.  Par exemple, pour obtenir une tension de 5 V au moyen d'un LM7805, il faut utiliser une alimentation d'au moins 7 V.  Cette tension d'entrée peut être aussi grande que 35 V, mais attention:  plus votre tension d'entrée est grande par rapport à la tension de sortie, plus votre régulateur dissipera une grande quantité de chaleur, ce qui représente beaucoup d'énergie gaspillée, d'une part, en plus de vous obliger à fixer au régulateur un radiateur qui évitera la surchauffe.

On recommande généralement d'ajouter un condensateur à l'entrée, et un condensateur à la sortie, pour améliorer la stabilité de la tension.  La fiche technique du fabriquant recommande 0,33 µF à l'entrée et 0,1 µF à la sortie. Toutefois, il n'est pas rare de voir des circuits dans lesquels on recommande deux condensateurs de 1 µF ou 10 µF, ou une combinaison de deux condensateurs en parallèle (afin de filtrer à la fois les perturbation de haute et de basse fréquence).

Pour la plupart des utilisations, la valeur exacte de ces condensateurs ne semble pas avoir une très grande importance.



Le schéma ci-dessous montre un circuit intégré alimenté en 5 V par un LM7805.


Par curiosité, j'ai mesuré le rendement d'un LM7805 alimentant une résistance de 1 kΩ, pour deux tensions d'entrée différentes:

Tension d'entrée:  7,0 V           Courant d'entrée:  8,3 mA           Puissance d'entrée:  0,059 W
Tension de sortie:  4,95 V        Courant de sortie:  4,9 mA         Puissance de sortie:  0,024 W

Rendement:  41%

Tension d'entrée:  10,0 V       Courant d'entrée:  8,3 mA        Puissance d'entrée = 0,083 W
Tension de sortie:  4,95 V      Courant de sortie:  4,9 mA       Puissance de sortie = 0,024 W

Rendement:  29%

Conclusion:  Le rendement est médiocre; plus de la moitié de l'énergie initiale est dissipée sous forme de chaleur dans le régulateur lui-même.  Et le rendement est pire encore lorsque l'écart entre la tension de sortie et la tension d'entrée est grand.


Régulateurs de tension réglables: le LM317

Le LM317 est un régulateur de tension ajustable:  sa tension de sortie dépend de la valeur des résistances qu'on lui associe.  Le même circuit intégré vous permettra donc d'obtenir, au besoin, une tension de 3,3 V, ou de 12 V, ou encore une tension ajustable au moyen d'un potentiomètre.

Même s'il ressemble à s'y méprendre à un LM7805, la disposition des broches du LM317 est totalement différente:

La broche 1 "ADJ" est la broche d'ajustement.  La tension de sortie est à la broche 2, et la tension d'entrée est à la broche 3.

Voici le schéma classique qu'on retrouve dans la fiche technique du LM317:



Attention, sur le  schéma ci-dessus, les broches du LM317 ne sont pas représentées dans l'ordre.

Voici une autre façon de représenter le même circuit:


L'équation qui permet de déterminer les résistances qu'il faut choisir afin d'obtenir la tension de sortie désirée est:

         Vsortie = 1,25 * (1 + R2/R1) + IADJ * R2

Le fabriquant recommande une résistance R1 d'environ 240 Ω.

Le courant  IADJ est de quelques dizaines de microampères seulement.  Pour cette raison, le terme  IADJ * Rest presque toujours négligeable.

L'équation devient donc     Vsortie = 1,25 * (1 + R2/R1)

Et c'est souvent plus pratique d'isoler R2:

           R2 = R1 ((Vsortie/1,25) - 1)

Donc si je désire une tension de sortie de 9 V, j'utilise R1 = 240 Ω et R2 = 1488 Ω.

Petit essai (avec des résistances quelque peu approximatives):


Vous aimeriez utiliser une sortie USB de votre ordinateur (5 V) pour alimenter un circuit intégré fonctionnant sur 3,3 V?  Pourquoi pas?

Avec R1 = 240 Ω, l'équation nous donne R2 = 394 Ω.  Voici ce que ça donne:



En remplaçant R2 par un potentiomètre (de 5 kΩ, par exemple), on obtient une source de tension variable.


Yves Pelletier   (TwitterFacebook)


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)


lundi 6 février 2017

Communication par nRF24L01 entre deux MSP430 Launchpads

Puisque ma dernière utilisation d'un MSP430 Launchpad date de bien longtemps, et que ma dernière utilisation d'un module émetteur-récepteur nRF24L01 date d'encore plus longtemps encore, ce petit tuto portera sur la communication entre deux MSP430 Launchpads au moyen de modules nRF24L01, en utilisant l'IDE Energia.

Matériel:

Il vous faut deux cartes MSP430 Launchpad et deux modules nRF24L01.  Lors des tests décrits ici, chaque Launchpad était branché par USB à son propre ordinateur (qui se trouvaient dans la même maison, mais pas sur le même étage).

La bibliothèque Enrf24

La bibliothèque Enrf24, developpée par Spirilis, est d'une étonnante simplicité d'utilisation.  Notre première étape consiste donc à télécharger et installer cette bibliothèque.

Branchements du module nRF24L01 au MSP430 Launchpad

Je connais deux modèles différents de modules nRF24L01:  les modules verts, comportant 10 connecteurs clairement identifiés, et les modules noirs, comportant 8 connecteurs qui ne sont pas du tout identifiés!

La photo ci-contre devrait vous aider à identifer correctement les connections, surtout si vous utilisez le modèle noir.

Les modules nRF24L01 communiquent par le protocole SPI, à un niveau logique de 3,3 V, tout comme les cartes Launchpad.  Nous n'aurons donc pas à nous préoccuper de convertir le niveau logique comme nous l'aurions fait avec une carte Arduino fonctionnant sous 5 V:  un problème de moins.

Notez que le schéma ci-dessous est pour le modèle d'entrée de gamme MSP-EXP430G2.  Si vous utilisez une autre carte de la famille Launchpad, il se peut que les pins réservées à la communication SPI soient différentes (je sais que les pins MOSI et MISO sont parfois inversées).  Dans le doute, vous pouvez vous référer aux schémas de brochage publiés sur le site d'Energia.

Les connexions sont les suivantes:

GND du nRF24L01 --- GND du Launchpad
Vcc du nRF24L01 --- Vcc du Launchpad
SCK du nRF24L01 --- P1.5 du Launchpad
MOSI du nRF24L01 --- P1.7 du Launchpad
MISO du nRF24L01 --- P1.6 du Launchpad
CE du nRF24L01 --- P2.0 du Launchpad*
CSN du nRF24L01 --- P2.1 du Launchpad*
IRQ du nRF24L01 --- P2.2 du Launchpad*

* Nous spécifions les pins CE, CSN et IRQ dans le sketch.  Il est donc possible de les brancher ailleurs à la condition de modifier le sketch en conséquence.

Les connexions sont identiques pour les deux Launchpad, peu importe qu'il s'agisse de l'émetteur ou du récepteur (notez bien que chaque module nRF24L01 peut à la fois envoyer et recevoir des données).



Une première paire de sketches

Dans ce premier exemple, notre Launchpad émetteur va émettre des nombres entier croissant au rythme de 1 par seconde, alors que le Launchpad émetteur va afficher ce qu'il reçoit dans le moniteur série.

Cette paire de sketch est particulièrement utile pour effectuer un premier test.  D'une part, il ne nécessite aucun composant supplémentaire dans notre circuit et, d'autre part, puisque chaque message est numéroté, nous aurons la preuve que tous les messages émis sont bel et bien reçus.

Sketch de l'émetteur:


Sketch du récepteur:


Si tout fonctionne correctement, vous devriez voir une liste de messages numérotés en ordre croissant dans le moniteur série d'Energia (associé au récepteur).



Un deuxième exemple

Dans ce deuxième exemple, un bouton relié au Launchpad émetteur permettra de contrôler l'état de deux LEDs branchées au Launchpad récepteur.

Le Launchpad émetteur est donc muni d'un bouton poussoir associé à une résistance de tirage (pull-down) de 10 kΩ.  (J'ai aussi ajouté un condensateur de 100 nF en parallèle avec le bouton afin d'atténuer les rebonds; il est optionnel).  Le bouton est branché à la broche P1.0.

Le Launchpad récepteur, quant à lui, est relié à deux LEDs associées à une résistance de protection.  Au début, j'avais envisagé d'utiliser simplement les deux LEDs intégrées à la carte, mais l'une d'entre elles est associée à la pin P1.6, qui est déjà utilisée par notre module nRF24L01.  Une première LED est branchée à la broche P1.0, alors que l'autre est branchée à la broche 1.4.

Circuit de l'émetteur



Circuit du récepteur



Sketch de l'émetteur


Sketch du récepteur


Lorsqu'on appuie sur le bouton une première fois, le message "1" est envoyé et une des LEDs branchée au récepteur s'allume.

Un deuxième appuie sur le bouton (message "2"):  c'est l'autre LED qui s'allume.

Troisième appui sur le bouotn (message "3"):  les deux LEDs sont allumées.

Quatrième appui sur le bouton (message "4"): les deux LEDs sont éteintes.


(Source d'inspiration:  une discussion concernant la bibliothèque Enrf24, sur le forum 43oh.)


Yves Pelletier   (TwitterFacebook)

Related Posts Plugin for WordPress, Blogger...