mardi 10 janvier 2017

Fabrication d'un pilote pour moteur pas à pas

Je vous présente aujourd'hui un petit compte rendu de la réalisation d'un pilote de moteur pas à pas: vous y branchez un moteur et une alimentation, et il s'agit d'appuyer sur quelques boutons pour faire tourner le moteur dans un sens ou dans l'autre, modifier sa vitesse de rotation, etc.

Cet appareil peut se révéler utile lorsque vous désirez vérifier si un moteur pas à pas fonctionne correctement, ou pour utiliser un moteur pas à pas de façon manuelle, sans que son fonctionnement soit automatisé par des capteurs.

À la base de notre circuit:  le traditionnel duo Arduino/L293D, dont j'avais déjà parlé dans ce blog il y a quelques années déjà.  Mais cette fois, puisque je veux un produit autonome, j'ai choisi d'utiliser un circuit intégré Atmega 328 plutôt qu'une carte Arduino complète.

Un petit cahier des charges:
  • Une seule alimentation permet d'alimenter à la fois le moteur pas à pas et les circuits intégrés Atmega et L293D.  Ces circuits intégrés nécessitent une tension de 5 V, alors que les moteurs requièrent souvent une plus grande tension:  un régulateur de tension est donc nécessaire.
  • Un bouton poussoir  marche/arrêt permet de mettre le moteur en marche, ou de l'arrêter. Une LED s'allume pour indiquer si ce bouton  est à l'état "marche".
  • Un bouton poussoir "marche inverse" permet d'inverser le sens de rotation du moteur.  Lui aussi est accompagné d'une LED indiquant si le mode "marche arrière" est en fonction.
  • Un potentiomètre permet de modifier la vitesse de rotation du moteur.
  • Un dernier bouton permet de faire tourner le moteur d'un seul pas à la fois.
Premier prototype, comportant une carte Arduino Uno

Même si le but final était de produire un circuit autonome comportant un microcontrôleur Atmega 328, j'ai tout de même commencé, dans une première phase de développement et de débogage, par un prototype sur platine d'essai branché à une carte Arduino Uno.

À cette étape, la carte Arduino fournit l'alimentation du circuit intégré, mais le moteur est alimenté par une source de tension externe.

Pour les 3 boutons, j'ai choisi d'utiliser les résistances pull-up interne de l'Arduino.  C'est pour cette raison que mes boutons ne comportent pas de résistance pull-up ou pull-down visible sur le circuit.

Le schéma ci-dessous montre où brancher chaque pin du L293D.


Et voici un schéma du circuit complet...



Sketch

Le sketch utilise la bibliothèque "stepper" qui est fournie avec l'IDE Arduino.  Puisque j'utilise les résistances pullup internes, digitalRead retourne "0" quand les boutons sont enfoncés, et "1" quand ils ne le sont pas.



Deuxième prototype, comportant un Atmega 328 sur breadboard

Rien ne vous empêche de vous arrêter à cette étape du circuit et, par exemple, en faire un shield pour votre carte Arduino.  Mais comme je le mentionnais au début de l'article, je préférais produire un circuit pouvant fonctionner de façon parfaitement autonome.

L'étape suivante consistait donc à graver le bootloader sur un Atmega 328 vierge, puis à y graver mon sketch. Pour une marche à suivre détaillée, je vous invite à consulter mon vieil article intitulé "Fabriquer son propre Arduino sur une breadboard".

Il restait ensuite à migrer les connexions de la carte Uno vers l'Atmega, d'ajouter un quartz de 16 MHz, ainsi qu'un régulateur de tension LM7805.

Le schéma ci-dessous indique où est branchée chaque pin de l'Atmega 328.


Du côté, du L293, ça demeure la même chose que dans le circuit précédent:


Les deux circuits intégrés demandent des tension d'alimentation de 5 V, alors que notre moteur pas à pas en exigera peut-être plus, d'où l'utilisation d'un régulateur linéaire  LM7805 qui abaissera la tension de départ (7 V ou plus) en une tension de 5 V.  J'en ai profité pour ajouter une LED qui indique que la carte est alimentée.

Et voici le schéma complet du circuit...




Le produit fini 

Voici le circuit proprement soudé sur une plaque pastillée.  Tout fonctionne tel que désiré.



Yves Pelletier   (TwitterFacebook)

vendredi 6 janvier 2017

Scratch sur Rasbperry Pi (3): Modifions la luminosité d'une LED

Dans ce troisième tutoriel concernant l'électronique avec le logiciel Scratch sur Rasbperry Pi, nous allons modifier l'intensité lumineuse d'une LED au moyen des touches du clavier.

Si ce n'est pas déjà fait, je vous conseille la lecture premier tutoriel de cette série: Scratch sur Raspberry Pi (1): Faisons clignoter une LED. Dans cette activité, la LED ne pouvais avoir que 2 états: complètement éteinte, ou complètement allumée. Dans l'activité d'aujourd'hui, elle pourra prendre plusieurs d'états différents, comme par exemple "allumée à 20% de son intensité maximale" ou "allumée à 60% de son intensité maximale".

Construction du circuit

Nous allons utiliser exactement le même circuit que dans le premier tutoriel: une LED (peu importe la couleur) est branchée en série avec une résistance (la résistance doit avoir une valeur se situant quelque part entre 100 Ω et 300 Ω).

La broche la plus longue de la LED est reliée à la pin 14 du Raspberry Pi (il s'agit de la quatrième pin de la rangée du haut,  tel qu'illustré), alors qu'à l'autre extrémité du circuit, la résistance est reliée à une des pins GND (la troisième pin de la rangée du haut, tel qu'illustré).

La LED sera allumée quand la pin 14 sera à 3,3 V, et éteinte quand elle sera à 0 V. Comment varier son intensité lumineuse?  En la faisant clignoter très rapidement.  Cette façon de contrôler la luminosité de la LED s'appelle "modulation par largeur d'impulsion", ou PWM (pour "pulse width modulation").

Construction du programme dans Scratch

Démarrons le logiciel Scratch (il se trouve dans le menu "Programmation").

Nous allons d'abord nous occuper de ce qui se produira au début du programme, lorsqu'on clique sur le bouton en forme de drapeau.

Dans la catégorie "contrôle", nous prenons un bloc "quand drapeau pressé", ainsi qu'un bloc "envoyer à tous".

Comme message dans le bloc envoyer à tous, nous écrivons:  "gpioserveron ".


Ce message démarrera le serveur GPIO, qui permet à nos programmes Scratch de contrôler les pins GPIO du Raspberry Pi.  Une autre méthode aurait consisté à démarrer nous-mêmes le serveur GPIO en choisissant "Start GPIO Server" dans le menu "Éditer", mais grâce à ce bloc, ce sera fait automatiquement.

Ajoutons un autre bloc "envoyer à tous".  Celui-ci enverra le message "config14outputpwm".  Ce message signifie que la pin 14 à laquelle nous avons branché la LED sera une sortie qu'il sera possible de faire clignoter très rapidement.


L'étape suivante consiste à créer une variable qui contiendra un nombre correspondant à la luminosité de la LED.  Dans la catégorie "Variables", cliquez sur le bouton "Nouvelle variable".


Nous donnons à cette variable le nom "luminosité".


Quand la variable "luminosité" contiendra la valeur "0", la LED sera éteinte.  Quand sa valeur sera "30", la LED sera allumée à 30% de son intensité maximale, etc.  Au moyen d'un bloc "à luminosité attribuer", nous allons régler sa valeur initiale à 50, ce qui correspond à 50% de la valeur maximale.


La variable "luminosité" contient le nombre 50.  Nous allons maintenant envoyer un message pour ordonner à la LED se s'allumer avec cette luminosité.  Nous ajoutons donc un nouveau bloc "envoyer à tous":


Nous nous rendons ensuite dans la catégorie "Opérateurs" pour prendre un bloc "joindre salut monde" que nous faisons glisser à l'intérieur du bloc "envoyer à tous":


Retour à la catégorie "variables" afin de faire glisser le bloc "luminosité" au-dessus du deuxième élément du bloc "joindre":


Et nous remplaçons le mot "salut" par "gpio14pwm":


Puisque la variable "luminosité" contient le nombre 50, le message envoyé sera "gpio14pwm50", ce qui obligera la pin 14 à clignoter rapidement, en étant allumée 50% du temps.

La suite de notre programme consiste à augmenter la luminosité de la LED lorsque l'utilisateur appuie sur la touche "flèche vers le haut du clavier".

Dans la catégorie "Contrôle", nous choisissons le bloc "quand espace est pressé", et nous remplaçons "espace" par "flèche haut".


Lorsque l'utilisateur pressera la flèche vers le haut, nous voulons que la variable "luminosité" augmente de 10.  Dans la catégorie "Variables", nous utilisons un bloc "à luminosité ajouter 1" et nous remplaçons 1 par 10:


...et nous ordonnons à la LED de briller selon cette nouvelle valeur:


(une façon simple consiste à faire un clic droit sur le bloc identique situé plus haut, et choisir "dupliquer").

Quand c'est la flèche vers le bas qui est pressée, nous voulons soustraire 10 de la variable "luminosité", ce qui revient à lui additionner "-10":


Et notre programme est complet!

Mise à l'essai du programme

Vous cliquez sur le bouton en forme de drapeau pour démarrer le programme.  La LED devrait devenir plus lumineuse quand vous appuyez sur la touche "flèche vers le haut" du clavier, et moins lumineuse quand vous appuyez sur la touche "flèche vers le bas".

Observation du signal PWM

Voici ce qu'on obtient lorsqu'on branche un oscilloscope à la pin 14 du Raspberry Pi...

... pendant que la variable "luminosité" est à 0 (la tension est toujours 0 V):


Pendant que la variable "luminosité" vaut 30 (la sortie est à 3 V 30% du temps, et à 0 pendant 70% du temps):


Pendant que luminosité est à 50 (sortie à 3 V 50% du temps):


Pendant que "luminosité" est à 80:



Et, finalement, quand luminosité est à 100:



Yves Pelletier   (TwitterFacebook)

lundi 2 janvier 2017

Utiliser un afficheur LCD 2 X 16 avec une carte Arduino

Il est souvent utile d'afficher des informations numériques ou textuelles produites par une carte Arduino (une mesure effectuée par un capteur, par exemple).   Aussi longtemps que l'Arduino est branché à un ordinateur, on peut utiliser le moniteur série intégré à l'IDE pour afficher ces informations.  Mais si vous désirez mettre au point un dispositif autonome qui pourra fonctionner loin de l'ordinateur, un afficheur à cristaux liquides (ou LCD, pour "liquid crystal display") s'avère une solution pratique, et relativement simple.

Nous parlons aujourd'hui des afficheurs compatibles avec le pilote Hitachi HD44780, qui permettent d'afficher des nombres et des lettres de l'alphabet (2 lignes comportant 16 caractères chacune).  Si vous avez besoin d'afficher des illustrations, un afficheur LCD Nokia 5110 correspondra peut-être mieux à vos besoins.

Connexions

Les afficheurs compatibles avec le pilote HD44780 comportent 16 connecteurs.  Les connexions que je vous propose ici vous permettront d'utiliser sans modification les exemples de sketches fournis avec la bibliothèque LiquidCrystal.  Pour certains projets, il est possible que vous soyez obligé de modifier certaines de ces connexions si d'autres périphériques occupent déjà les mêmes entrées/sorties de l'Arduino.



Les pins 1 et 2 servent à alimenter l'afficheur:
  • Pin 1 de l'afficheur --- GND de la carte Arduino
  • Pin 2 de l'afficheur --- 5 V de la carte Arduino
La pin 3 sert à régler le contraste de l'afficheur:  on la relie à un potentiomètre de 10 kΩ qui permet de faire d'ajuster sa tension à une valeur située entre 0 et 5 V.
  • Pin 3 de l'afficheur --- Curseur d'un potentiomètre dont les deux autres broches sont reliées respectivement à GND et à 5 V.
  • Pin 4 "RS" de l'afficheur --- Pin 12 de l'Arduino
  • Pin 5 "R/W" de l'afficheur --- GND de l'Arduino
  • Pin 6 "Enable" de l'afficheur --- Pin 11 de l'Arduino
Les pins 7, 8, 9 et 10 de l'afficheur ne sont pas branchées, car nous utiliserons l'afficheur en mode 4 bits plutôt qu'en mode 8 bits (ce qui permet d'économiser les entrées/sorties de l'Arduino).
  • Pin 11 "D4" de l'afficheur --- Pin 5 de l'Arduino
  • Pin 12 "D5" de l'afficheur --- Pin 4 de l'Arduino
  • Pin 13 "D6" de l'afficheur --- Pin 3 de l'Arduino
  • Pin 14 "D7" de l'afficheur --- Pin 2 de l'Arduino
Les pins 15 et 16 servent à alimenter le rétroéclairage.  Sur certains modèles d'afficheur, le rétroéclairage n'est pas indispensable (sauf pour lire l'affichage dans l'obscurité), alors que pour d'autres modèles l'affichage est illisible si le rétroéclairage n'est pas activé.
  • Pin 15 de l'afficheur --- Résistance d'environ 100 Ω*  --- 5 V de l'Arduino
  • Pin 16 de l'afficheur --- GND de l'Arduino
(* j'ai un afficheur dont le rétroéclairage ne s'allume qu'à la condition que je n'ajoute aucune résistance)

La bibliothèque LiquidCrystal

Pour présenter les informations sur l'afficheur, nous utiliserons la bibliothèque "LiquidCrystal", qui a été spécialement conçue à cette fin.  Nul besoin de l'installer, puisqu'elle est fournie avec l'IDE.



Pour vérifier rapidement que votre afficheur est bel et bien fonctionnel, téléchargez l'exemple "HelloWord" dans votre Arduino.  Vous devriez voir le message "hello, world!" apparaître sur la première ligne de l'afficheur, alors que sur la deuxième ligne un compteur s'incrémente à chaque seconde.


Si rien ne s'affiche, pas de panique!  Tournez le bouton du potentiomètre qui contrôle le contraste. Sinon, vérifiez à nouveau toutes les connexions.  

Pour afficher un texte, on utilise la commande "print".  Le texte débute toujours à la position du curseur.   Lorsque vous écrivez quelque chose, le curseur se déplace automatiquement à la position qui suit immédiatement le texte affiché.

La position du curseur se règle au moyen de la commande "setCursor(colonne, ligne)".  Il est important de noter que la première ligne en haut porte le numéro 0, et la première colonne à gauche porte le numéro 0.  L'instruction "lcd.setCursor(0,0)" positionnera donc le curseur en haut à gauche.
Si vous désirez que l'utilisateur entre du texte qui apparaîtra à l'afficheur, il peut être utile de montrer un symbole clignotant qui indique la position du curseur, en utilisant la commande "blink".  Pour des exemples de situation où on affiche du texte tapé par l'utilisateur, vous pouvez vous référer à mon article Arduino, clavier numérique et afficheur LCD.

Je vous propose ci-dessous un sketch de mon crû, qui a l'avantage d'être commenté en français.  

Dans un premier temps, un texte fixe apparaît, centré sur l'écran.  Je fais ensuite défiler un texte vers la gauche et vers la droite, j'affiche un texte caractère par caractère, je fais clignoter un texte, puis je fais apparaître un curseur clignotant et je change sa position (voir l'afficheur en action sur la vidéo ci-dessous).





Vous serez peut-être intéressé par cet article qui montre comment produire une progress bar sur un LCD.

Pour quelques exemples d'utilisation d'un afficheur LCD à l'intérieur d'un projet impliquant l'Arduino, vous pouvez consulter les articles suivants:  Arduino, clavier numérique et afficheur LCDUne horloge pour votre Arduino et Mesurer une température avec un Arduino.

Vous pouvez également apprendre à utiliser un afficheur LCD avec un Raspberry Pi, une carte MSP430 Launchpad, ou une carte Pinguino ou une carte STM32 Nucleo.

Yves Pelletier   (TwitterFacebook)