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   (Twitter, Facebook)

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   (Twitter, Facebook)

Une interface graphique pour contrôler les sorties du Raspberry Pi (Python / Tkinter)

Cet article a été mis à jour le 1^er novembre 2020 afin d'être pleinement compatible avec Python 3.

Il y a quelques années, j'avais partagé quelques scripts en Python permettant d'interagir avec les pins GPIO du Raspberry Pi.  Dans cette nouvelle version, j'utilise la bibliothèque Tkinter afin de réaliser en Python un programme comportant une interface graphique.

Lors de l'exécution du programme, une fenêtre comportant 3 cases à cocher s'affiche à l'écran.  Il s'agit de cocher une case pour que la pin GPIO correspondante se mette à l'état logique "haut", et de décocher la case pour que la pin GPIO correspondante se mette à l'état logique "bas".

Le circuit

Afin de pouvoir visualiser facilement l'état logique des pins GPIO, une LED associée à une résistance de protection est branchée à chacune des broches suivantes:  GPIO 2, GPIO 3 et GPIO 4 (notation BCM).

Évidemment, il est facile de modifier le programme afin d'utiliser d'autre sorties.

Le script

Deux bibliothèques sont essentielles au bon fonctionnement de notre programme, et elles sont toutes deux incluses par défaut avec Python dans la distribution de base de Raspbian:  il s'agit de RPi.GPIO et de Tkinter.

Avec la commande "fenetre.geometry("250x150+300+300")", nous créons un objet fenêtre, que nous nommons "fenetre", dont les dimensions initiales sont 250 pixels de large et 150 pixels de hauteur, et positionnée à 300 pixels à droite du côté gauche de la fenêtre, et 300 pixels plus bas que le haut de la fenêtre.

Chaque case à cocher est associée à une variable ainsi qu'à une procédure ("command"):

"bouton = Checkbutton(fenetre, text="GPIO 2", variable=gpio2, command=miseAjour)".

La variable "gpio2" prend automatiquement la valeur "1" lorsque la case est cochée, et "0" lorsque la case n'est pas cochée (c'est géré automatiquement par la bibliothèque).

La routine "miseAjour" se met en branle chaque fois qu'une des cases à cocher est cliquée (que ce soit pour la cocher, pour pour la décocher).  Cette routine règle le niveau logique des broches GPIO 2, 3 et 4 à la valeur de la variable qui leur est associée (gpio2, gpio3 et gpio4).



Yves Pelletier   (Twitter, Facebook)