mardi 29 décembre 2015

Processing sur Raspberry Pi: "Etch A Sketch" à 5 boutons poussoirs


Dans un précédent article, nous avons vu comment utiliser le langage Processing pour contrôler des pins GPIO du Raspberry Pi configurées en sortie.

Cette fois, nous allons utiliser Processing pour lire l'état logique de pins GPIO configurées en entrées.  L'état de ces entrées sera contrôlé par des boutons poussoirs.

Quand j'étais petit, nous allions parfois visiter mes grands-parents, chez qui les jeux pour enfants se résumaient à 3 ou 4 aventures de Martin le Malin, et un écran magique "Etch A Sketch".  Il s'agissait d'une espèce de tablette sur laquelle on dessinait en tournant deux boutons:  un bouton qui permettait de tracer des lignes horizontales, et un bouton qui permettait de tracer des lignes verticales.  Pour effacer le dessin, il s'agissait de retourner la tablette à l'envers et la secouer. 



Pour illustrer comment lire l'état de boutons poussoirs au moyen de Processing, je vous propose de transformer (temporairement) votre Raspberry Pi en écran Etch A Sketch:   un programme tracera à l'écran des lignes horizontales et verticales qui seront contrôlées par 5 boutons:  "vers le haut", "vers le bas", "vers la gauche", "vers la droite" et "effacer".

Nous supposons que Processing est déjà installé sur votre Raspberry Pi (si ce n'est pas le cas, prière de vous référer à ce précédent article).

Le circuit:

Chaque bouton est associé à une résistance de tirage vers le haut (pull up).  De cette façon, le signal sera de 3,3 V quand le bouton est relâché, et de 0 V quand il est enfoncé.  Prévoyez une résistance suffisamment grande pour que le courant circulant à travers les pins GPIO ne soit pas trop élevé (10 kΩ, par exemple).



Pour les boutons, je propose les branchements suivant (la numérotation utilisée est BCM, en jaune sur le schéma ci-dessous):
  • Bouton "Vers le haut":  pin GPIO 2
  • Bouton "Vers le bas":  pin GPIO 3
  • Bouton "Vers la gauche":  pin GPIO 4
  • Bouton "Vers la droite":  pin GPIO 17
  • Bouton "Effacer":  pin GPIO 27

Puisque nous avons également besoin d'une pin "3,3 V" et d'une pin "GND", nous utilisons 7 pins adjacentes, tel qu'illustré ci-dessous:



Le programme:

Rien de très compliqué:  on vérifie l'état des boutons associés aux pins GPIO 2, 3, 4, 17 et 27, et on trace un bout de ligne dans la direction appropriée.  Il faut aussi s'assurer qu'on ne sort pas à l'extérieur des limites de la fenêtre.


Le résultat:

En appuyant sur les différents boutons,  vous pouvez tracer de jolis dessin...


Et maintenant, on démonte tout!  Je viens de réaliser à quel point ce jouet m'ennyait quand j'étais petit...

Yves Pelletier   (TwitterFacebook)


dimanche 27 décembre 2015

Pédalier d'orgue MIDI (Arduino)


Ce projet consiste à transformer un vieux pédalier d'orgue électronique en contrôleur MIDI.  De cette façon, on obtiendra quelque chose d'assez similaire au mythique pédalier Taurus de la compagnie Moog, sauf que notre instrument, plutôt que synthétiser ses propres sons, enverra des messages MIDI vers un autre instrument (ou vers un ordinateur exécutant un logiciel compatible MIDI).   Et tout ça ne nous coûtera vraiment pas cher (contrairement aux instruments professionnels du même genre, qui sont généralement hors de prix).


Le pédalier, avant transformation

Mon pédalier a été récupéré d'un vieil orgue Yamaha Elektone manufacturé à la fin des années 1970.  Dans ce genre d'instrument, l'organiste utilise son pied gauche pour jouer les notes de basse.  Une fois modifié, il pourra jouer n'importe quel timbre supporté par l'instrument hôte:  contrebasse, trompette, violon, banjo...

Le pédalier comporte 13 pédales formant un octave complet, de do jusqu'au do suivant.  Chaque pédale active un interrupteur:  circuit ouvert en temps normal, circuit fermé lorsque la pédale est enfoncée.

En cherchant un peu, vous pouvez probablement dénicher un orgue électronique de ce genre, en état de marche ou non, pour vraiment pas cher.  J'en ai même déjà vu un abandonné sur le trottoir, dans l'attente des éboueurs.  La principale difficulté, souvent, est de le transporter jusqu'à votre domicile (c'est beaucoup moins lourd qu'un piano, mais ça demeure assez volumineux).

Si vous n'avez pas accès à un vieux pédalier d'orgue, vous pouvez aussi en fabriquer un vous-mêmes en utilisant 13 gros interrupteur (par exemple, le genre d'interrupteurs utilisés dans les pédales d'effet pour guitare).  Ça pourrait donner quelque chose similaire à ce qui est illustré ci-contre.


Le circuit

Il s'agit d'un projet très similaire au clavier MIDI Arduino que j'avais réalisé auparavant:  l'Arduino est le cerveau de l'instrument.  Sa tâche consiste à détecter si une pédale a été enfoncée (ou relâcher), et à envoyer un message MIDI lorsqu'un tel événement a lieu.  Bien entendu, n'importe quel autre microcontrôleur pourrait faire l'affaire, mais l'Arduino est particulièrement facile d'utilisation, et il fonctionne déjà avec un niveau logique de 5 V, qui est la norme en MIDI.

Alors que mon clavier MIDI comportait 37 touches, mon pédalier n'en comporte que 13.  Plutôt que câbler mes 13 interrupteurs sous forme de matrice comme je l'avais fait pour le clavier (ce qui complique sensiblement le programme à exécuter par l'Arduino), j'ai choisi de câbler mes 13 interrupteurs de façon très classique, avec une résistance de tirage vers le haut.  Chaque pédale génère donc un signal de 5 V lorsqu'elle n'est pas enfoncée, et de 0 V lorsqu'elle est enfoncée.


Chaque pédale est reliée à sa propre résistance.  La valeur de la résistance n'a pas une très grande importance:  10 kΩ ou plus pour éviter une trop grande consommation. 

Pour ne pas accaparer 13 entrées de l'Arduino, j'ai utilisé deux registre à décalage hc165 (dont j'avais déjà exploré le fonctionnement dans cet article).  Chaque hc165 comporte 8 entrées, donc l'Arduino pourra vérifier l'état de mes 13 pédales au moyen de 3 de ses pins seulement (2, 3 et 4).


L'envoi des messages MIDI s'effectue par la pin 1 (TX) de l'Arduino.  Pour plus de détail, vous pouvez vous référer à cet article sur la transmission MIDI par l'Arduino.

J'ai aussi ajouté une paire de boutons poussoirs permettant de monter ou descendre d'un octave ou deux ("octave up", "octave down") et une paire de boutons poussoirs permettant de changer le timbre ("program up" et "program down").  J'ai utilisé un CD40106 (bascules de Schmitt) pour éviter les rebonds.




Sur mon prototype, il s'agit de petit boutons poussoirs mais pour un modèle plus professionnel, il serait logique d'utiliser des gros boutons sur lesquels on appuierait avec le pied.

De plus, le volume sonore (vélocité) est contrôlé  par un potentiomètre.

Finalement, toutes ces caractéristiques (numéro de programme, d'octave et volume sonore) s'affichent sur un LCD.





Le sketch Arduino

À chaque passage dans la boucle principale, l'Arduino vérifie l'état des pédales et, s'il y a eu un changement, il envoie un message MIDI de type "NoteOn" ou "NoteOff".


dimanche 20 décembre 2015

Transformation d'une tension alternative en tension continue


Aujourd'hui, pour passer le temps, nous allons nous amuser à transformer une tension alternative en une tension continue.

Courant alternatif, courant continu:  quelle est la différence?

Un courant continu est constant, et circule toujours dans la même direction (il est causé par un mouvement d'électrons qui se déplacent dans le sens contraire au courant).  Les piles produisent un courant continu.

Un courant alternatif change de direction plusieurs fois par seconde (les électrons oscillent autour d'une position d'équilibre).  Votre compagnie d'électricité vous distribue du courant alternatif.


Choix d'une source de tension alternative sécuritaire

Si vous désirez réaliser vous-mêmes cette petite expérience, l'idéal est d'utiliser une source de tension alternative de faible puissance.  Si vous disposez d'un générateur de fonction pouvant produire une tension alternative de quelques volts, c'est parfait.  Sinon, pouvez construire votre propre oscillateur sinusoïdal au moyen d'un amplificateur opérationnel en vous référant à ce précédent article (c'est ce que j'ai moi-même utilisé lors de cette expérience).   Surtout, ne vous branchez pas directement dans une prise de courant!!!

Observons d'abord notre tension alternative sans la modifier:  je l'ai branchée à une résistance de 270 Ω et à un oscilloscope.



La tension varie de façon sinusoïdale et, tel que prévu, elle est parfois positive (courant dans un sens), parfois négative (courant dans l'autre sens).  Ici, l'amplitude est légèrement inférieure à 5 volts, et la fréquence est de 1,7 kHz.




1ère étape de la transformation:  rectification de la tension

La rectification consiste à éliminer le changement de polarité, pour que la tension soit toujours positive.  Pour ce faire, nous allons d'abord utiliser une diode (une diode est un composant qui laisse circuler le courant dans une seule direction, et qui  l'empêche de circuler dans l'autre sens).


En ajoutant une diode, un courant circulera dans la résistance uniquement lorsque la tension alternative et positive.  Lorsque la tension alternative est négative, la diode bloque le courant, et il en résulte une tension nulle aux bornes de la résistance (U = RI...).  C'est ce qui s'appelle un rectificateur à simple alternance.


Si vous comparez cette nouvelle tension à celle que nous avions auparavant, vous pouvez constater qu'il n'y a plus de tension positive.  D'autre part, l'amplitude n'est plus que de 4 volts (il y a une chute de tension d'environ 0,7 V aux bornes de la diode).

Vous remarquez, toutefois, que la tension est nulle la moitié du temps, ce qui est très loin du comportement final désiré.  Nous pouvons faire mieux: l'agencement de 4 diodes illustré ci-dessous est un rectificateur à double alternance.  Peu importe la polarité de la source de tension alternative, le courant traversera la résistance dans la même direction (vers le bas sur le dessin).  La tension aux bornes de la résistance est donc toujours positive.


Trajet du courant si la tension est positive:


Trajet du courant si la tension est négative:


Voilà qui est mieux:  plutôt qu'annuler la tension lorsqu'elle est négative, nous la rendons positive.  Petit effet secondaire:  l'amplitude a encore un peu diminué, puisque maintenant le courant doit traverser 2 diodes plutôt qu'une seule (chute de potentiel de 0,7 V par diode).



2e étape de la transformation:  filtrage

Notre tension garde toujours la même polarité, mais elle varie beaucoup! L'ajout d'un condensateur en parallèle avec notre résistance de charge permettra d'atténuer cette oscillation:  le condensateur se charge lorsque la tension d'entrée est grande et, lorsqu'elle est faible,  il se décharge lentement (ce qui maintient un courant dans la résistance).







3e étape de la transformation:  régulation

À cette étape, la tension est presque continue, et pour bien des applications elle fera parfaitement l'affaire.  Mais si vous désirez éliminer l'oscillation résiduelle de la tension ("ripple"), vous pouvez ajouter un régulateur de tension.

Ici, j'ai utilisé un LM317 réglé à sa valeur minimale de 1,25 V.





Mission accomplie:  nous avons transformé une tension alternative en tension continue.

Yves Pelletier   (TwitterFacebook)

dimanche 6 décembre 2015

Matrice de 64 LEDs, Max7219 et Arduino

Aujourd'hui, je vous présente quelques petits conseils qui vous permettront de contrôler une matrice de 64 LEDs (8 X 8) au moyen d'une carte Arduino et d'un pilote de LEDs Max7219.

La matrice de LEDs

J'ai utilisé une matrice constituée de 64 LEDs rouges et munie de 16 pins:  chacune des 8 lignes est associée à une pin, et chacune des 8 colonnes est associée à une autre pin.

Il ne faudrait pas croire que toutes les matrices 8 X 8 sont identiques.  Dans certains cas, les lignes sont des cathodes et les colonnes sont des anodes (ce qui signifie que la LED s'allume si la pin qui contrôle sa colonne est à un potentiel plus élevé que la pin qui contrôle sa ligne).  Mais il existe également des matrices dont les lignes sont des anodes et les colonnes sont des cathodes (et alors la LED s'allume si la pin qui contrôle sa ligne est à un potentiel plus élevé que la pin qui contrôle sa colonne).

Pour compliquer les choses encore un peu plus, les pins situées sous la matrice ne sont pas disposées dans l'ordre, et j'ai cru comprendre que la disposition des pins peut être très différente d'une matrice à l'autre.

Puisque j'avais l'intention d'utiliser la bibliothèque LEDControl et que cette bibliothèque a été conçue en fonction des matrices "ligne = cathode et colonne = anode", j'ai opté pour une matrice de LEDs dont le brochage est illustré ci-contre (le numéro inscrit sur ma matrice est HSN-1088AS).

D'après ce schéma, pour allumer la première LED en haut à droite, il faut soumettre la pin numéro 13 à un potentiel plus élevé que la pin numéro 9.  Pour allumer sa voisine de droite, il faut que la pin numéro 3 soit à une tension plus élevée que la pin numéro 9, etc.

Il reste à déterminer quelle pin porte le numéro 13, etc.  Au verso de ma matrice, il y a un petit chiffre "1" sous la pin 1, et un petit chiffre 9 vis-à-vis la pin 9.



Donc si je place la matrice du côté des LEDs, avec le numéro situé en bas, les pins sont numérotées de la même façon que sur un circuit intégré:


Si vous ne disposez pas d'un schéma indiquant le brochage de votre matrice de LED, vous devriez pouvoir le déduire par vous mêmes en effectuant des tests au moyen d'une source de tension et d'une résistance de protection.

Si votre matrice est de type "ligne = anode et colonne = cathode", pas de panique; ça va quand même fonctionner, à la condition d'en tenir compte lors de la connexion avec le Max7219 et de la conception du programme.

Bien entendu, si vous préférez, vous pouvez construire votre propre matrice au moyen de 68 LEDs individuelles que vous aurez patiemment soudées ensemble.

À l'autre extrême, vous pouvez utiliser un module comportant une matrice 8 X 8 déjà connectée à un Max7219 (vous en trouverez facilement sur eBay), auquel cas il ne vous reste plus qu'à programmer l'Arduino...

Le circuit intégré Max7219 (ou Max7221)

Les circuits intégrés Max7219 et Max7221 sont pratiquement interchangeables:  ils sont spécialement conçus pour allumer et éteindre un grand nombre de LEDs en maintenant dans celles-ci un courant constant.

Dans le schéma ci-contre, "Dig" et "Seg" font référence aux digits et aux segments d'un afficheur à 7 segments.

Pour piloter notre matrice de LEDs, il s'agit de brancher chaque pin "Dig" à une pin contrôlant une ligne de la matrice, et chaque pin "Seg" à une pin contrôlant une colonne de la matrice (mais c'est le contraire si vous utilisez une matrice de type "ligne = anode et colonne = cathode").

Pin 1 (DIN) du Max7219 : Pin 12 de l'Arduino
Pin 2 (DIG 0) du Max7219:  Ligne 1 de la matrice (1ère en haut) (pin 9*)
Pin 3 (DIG 4) du Max7219:  Ligne 5 de la matrice (pin 1*)
Pin 4 (GND) de Max7219:  GND de l'Arduino
Pin 5 (DIG 6) du Max7219:  Ligne 7 de la matrice (pin 2*)
Pin 6 (DIG 2) du Max7219:  Ligne 3 de la matrice (pin 8*)
Pin 7 (DIG 3) du Max7219:  Ligne 4 de la matrice (pin 12*)
Pin 8 (DIG 7) du Max7219:  Ligne 8 de la matrice (pin 5*)
Pin 9 (GND) du Max7219:  GND de l'Arduino
Pin 10 (DIG 5) du Max7219:  Ligne 6 de la matrice (pin 7*)
Pin 11 (DIG 1) du Max7219:  Ligne 2 de la matrice (pin 9*)
Pin 12 (LOAD) du Max7219:  Pin 10 de l'Arduino
Pin 13 (CLK) du Max7219:  Pin 11 de l'Arduino
Pin 14 (SEG A) du Max7219:  Colonne 2 de la matrice (2e à gauche) (pin 3*)
Pin 15 (SEG F) du Max7219:  Colonne 7 de la matrice (pin 15*)
Pin 16 (SEG B) du Max7219:  Colonne 3 de la matrice (pin 4*)
Pin 17 (SEG G) du Max7219: Colonne 8 de la matrice (pin 16*)
Pin 18 (ISET) brancher une résistance de 33 kΩ entre cette pin et 5 V
Pin 19 (V+) du Max7219:  sortie 5 V de l'Arduino
Pin 20 (SEG C) du Max7219:  Colonne 4 de la matrice (pin 10*)
Pin 21 (SEG E) du Max7219:  Colonne 6 de la matrice (pin 11*)
Pin 22 (SEG DP) du Max7219:  Colonne 1 de la matrice (1ère à gauche) (pin 13*)
Pin 23 (SEG D) du Max7219: Colonne 5 de la matrice (pin 6*)
Pin 24 (DOUT):  utile pour brancher plusieurs matrices en cascade

*Les numéros de pin en rouge sont valides pour la matrice que j'ai utilisée, mais pas nécessairement pour toutes les matrices.

La bibliothèque LEDControl:

Pour faciliter la programmation, j'ai utilisé la bibliothèque LEDControl (voir ici pour des instructions détaillées).

Pour allumer une LED individuelle sur la matrice, on utilise cette syntaxe:

setLed(adresse,ligne,colonne,état)
  • "adresse" est le numéro de la matrice (le nombre "0" si vous n'en avez qu'une)
  • "ligne" est le numéro de la ligne (en commençant par "0" pour la première en haut)
  • "colonne" est le numéro de la colonne (en commençant par "0" pour la première à gauche)
  • "état" est un booléen:  true pour allumer la LED, false pour l'éteindre
Pour une matrice de type "ligne = anode et colonne = cathode", les lignes et les colonnes sont inversées:  vous faites donc setLed(adresse,colonne,ligne,état)


samedi 14 novembre 2015

Processing sur Raspberry Pi: clignotement d'une LED

Il y a quelques jours, on annonçait sur le blog officiel de Raspberry Pi le lancement d'une nouvelle version de l'environnement de programmation Processing.  L'intérêt de cette nouvelle version, c'est qu'elle supporte officiellement le Raspberry Pi et est accompagnée d'une bibliothèque permettant l'accès aux pins GPIOs.

Pour installer ce nouveau logiciel, il s'agit de coller la ligne suivante dans le terminal:

curl https://processing.org/download/install-arm.sh | sudo sh



(L'installation a pris 4 minutes dans mon cas).

Suite à l'installation, on peut accéder au logiciel dans la catégorie "Programmation".


L'interface épurée rapelle un peu l'IDE Arduino.


Processing est très utile, entre autres choses, pour produire des effets graphiques à l'écran.  Nous aurons certainement l'occasion d'exploiter ce genre de caractéristiques un de ces jours mais, la priorité de ce blog étant l'électronique, cette première exploration de Processing consistera à faire clignoter une LED.

Le circuit:

Le circuit est constitué d'une LED branchée en série à une résistance de protection (220 Ω, par exemple). Le tout est branché à la pin BCM 14 et à une des pins GND, tel qu'illustré ci-dessous. (GND est la 3e pin en haut à partir de la gauche, alors que 14 est la 4e pin en haut à partir de la gauche.)

Attention, la LED n'est pas réversible: c'est sa broche la plus longue qui doit être du côté de la pin 14.


Le sketch:

Ça ressemble beaucoup à un sketch Arduino!  La principale différence est que, puisque processing est généralement utilisé sur des ordinateurs conventionnels, une bibliothèque est nécessaire pour le contrôle des pins GPIO.  Et plutôt que s'appeler "loop", la boucle principale qui s'exécute à répétition pendant toute la durée du programme s'appelle "draw".


Pour exécuter ce sketch, vous cliquez sur le bouton en haut à gauche de la fenêtre de Processing (ou vous choisissez "Exécuter" dans le menu "Sketch").  Au bout de quelques secondes, une petite fenêtre carrée grise apparaît.  Il s'agit de cliquer dans cette fenêtre pour démarrer ou interrompre le clignotement de la LED.


Si vous préférez, vous pouvez également faire clignoter une LED branchée au Raspberry Pi en utilisant Python ou Scratch.

Yves Pelletier   (TwitterFacebook)

lundi 9 novembre 2015

Une sortie analogique pour l'Arduino: réseau R2R

Il y a quelques mois, nous avions exploré une première méthode pour produire un signal analogique au moyen d'une carte Arduino:  en faisant passer le signal modulé en largeur d'impulsion (pwm) par un filtre passe-bas (constitué d'une résistance et d'un condensateur), nous pouvions obtenir n'importe quelle tension continue située entre 0 et 5 V.  Il s'agit d'une méthode simple et efficace si nous désirons obtenir un signal continu, ou de basse fréquence. La présence du filtre passe-bas, toutefois, rend cette méthode peu satisfaisante si nous avons besoin d'un signal analogique qui varie rapidement.

Qu'à cela ne tienne, nous explorons aujourd'hui une autre façon d'ajouter une sortie analogique à notre carte Arduino:  nous allons construire un convertisseur numérique-analogique de type "réseau R-2R".

Combien de bits?

Plus notre système comporte un grand nombre de bits, meilleure sera la résolution du signal de sortie. Une meilleure résolution signifie que notre signal de sortie, tout en étant restreint à une valeur située entre 0 et 5 V, pourra prendre un plus grand nombre de valeurs possibles.

Par exemple, chaque sortie numérique de l'Arduino corespond à 1 bit:  elles peuvent prendre deux valeurs possibles:  0 ou 1 (0 ou 5 V).

Un système à 2 bits peut prendre 4 valeurs possibles:  les valeurs binaires 00, 01, 10 et 11 (qui pourraient correspondre, par exemple, à 0 V, 1,7 V, 3,3 V et 5 V).

Un système à 3 bits peut prendre 8 valeurs possibles:  les valeurs binaires 000, 001, 010, 011, 100, 101, 110 et 111 (si on sépare 5 volts en 8 parts égales, on obtient 0 V, 0,7 V, 1,4 V, 2,1 V, 2,9 V, 3,6 V, 4,3 V et 5 V).

Par contre, chaque bit étant contrôlé par une sortie de l'Arduino, plus notre système comporte un grand nombre de bits, plus il accaparera un grand nombre de sorties sur l'Arduino.

Je vous propose ici un réseau R-2R à 8 bits, ce que correspond à 256 valeurs possibles:  la tension de sortie pourra donc prendre n'importe quelle valeur située entre 0 et 5 volts, par bonds de 0,02 volts.

Le circuit

Le circuit s'appelle "réseau R-2R" parce qu'il est constitué d'une alternance de résistances identiques (R) et de leur double (2R).  J'ai utilisé des résistances R de 10 kΩ et des résistances 2R de 20 kΩ.

(Vous pouvez cliquer sur le schéma pour le voir en plus gros).



Attention à la précision des résistances:  si elles ne sont qu'approximativement égales, votre signal analogique risque de varier avec des bonds irréguliers.  J'ai mesuré chaque résistance utilisée, en ne retenant que celles qui se situaient à l'intérieur d'une tolérance de 0,5%.


Dans ce circuit, la sortie 2 de l'Arduino représente le bit de poids faible, alors que la sortie 9 représente le bit de poids fort.  Ainsi, si toutes les sorties sont à 0 sauf la numéro 2, ça correspond au nombre binaire 00000001, alors que si toutes les sorties sont à 0 sauf la numéro 9, ça correspond au nombre binaire 10000000.  La tension de sortie est nulle quand toutes les sorties sont à 0 (nombre binaire 00000000) et elle est à son maximum (presque 5 V) quand toutes les sorties sont à 5 V (nombre binaire 11111111).


Sketch

Voici d'abord un sketch qui permet à l'utilisateur d'entrer la valeur numérique de la tension de sortie qu'il désire au moyen du moniteur série.  Vous pouvez tester ce sketch en branchant un voltmètre à la sortie.







Dans ce deuxième sketch, les sorties de l'Arduino prennent successivement toutes les valeurs binaires situées entre 00000000 et 11111111:  il en résulte un signal en dent de scie.  Ce signal pourrait être capté avec un oscilloscope, mais ici je l'ai mesuré au moyen de l'entrée A0 de l'Arduino.  On peut visualiser les valeurs numériques dans le moniteur série ou, mieux encore, visualiser le signal dans le nouveau traceur série de l'environnement de programmation Arduino.






Yves Pelletier   (TwitterFacebook)

mardi 3 novembre 2015

Le traceur série (Arduino IDE version 1.6.6)

La version 1.6.6 de l'environnement de programmation Arduino a été lancée aujourd'hui et, parmi les nouveautés, mon attention a été attirée par le traceur série ("serial plotter").  Ce nouvel outil vous permet de représenter sous forme de graphique les données numériques acheminées vers le moniteur série.

Par exemple:  je vais faire varier le signal à l'entrée A0 au moyen d'un potentiomètre.



Pour le sketch, rien de bien compliqué:  je fais exactement comme si je désirais accumuler les données dans le moniteur série.


Mais plutôt qu'ouvrir le moniteur série, j'ouvre le traceur série, disponible dans le menu "Outils".



Et voilà ce que j'obtiens en tournant le bouton du potentiomètre:



D'après ce que j'ai pu constater, le traceur série affiche un nombre fixe de données.  Plus vous insérez un long délai dans la boucle (entre deux mesures successives), plus vous pourrez afficher dans la même fenêtre des données échelonnées sur une longue période de temps.

Yves Pelletier   (TwitterFacebook)

dimanche 1 novembre 2015

Contrôler un servomoteur en python avec un Raspberry Pi

Dans le passé, nous avons vu comment faire en sorte que notre Raspberry Pi contrôle un moteur dc et un moteur pas à pas au moyen d'un script en python.  Aujourd'hui, c'est le tour d'un servomoteur.

Comment ça fonctionne

Un peu comme le moteur pas à pas, le servomoteur peut être contrôlé de façon à lui faire prendre une position angulaire très précise.  Une différence importante, c'est qu'avec le moteur pas à pas, on contrôle le déplacement (comme dans "tourne de 5° vers la gauche") alors qu'avec le servomoteur, on contrôle la position (comme dans "va à la position 17°").  

Cette position se contrôle au moyen d'un signal en modulation de largeur d'impulsion (PWM:  voir cet article pour plus de détails):  il s'agit d'une succession de signaux logiques hauts (5 V) et bas (0 V).

En général, le signal est envoyé toutes les 20 ms (donc la fréquence est de 50 Hz).  Si le signal demeure haut pendant 1 ms (ce qui correspond à un rapport cyclique de 5 %), le servomoteur se place à sa position minimale, s'il demeure haut pendant 1,5 ms (rapport cyclique de 7,5%), il se place à sa position médiane, et s'il demeure haut pendant 2 ms (rapport cyclique de 10 %), il se place à sa position maximale.

Les valeurs exactes varient d'un servomoteur à l'autre, toutefois, et le mieux est d'effectuer quelques tests avec celui que vous utiliserez, afin de connaître les rapports cycliques nécessaires pour lui faire occuper ses positions extrêmes (le premier exemple de script, présenté un peu plus loin dans cet article, nous permettra d'atteindre cet objectif).

Le circuit

Le servomoteur est muni de trois connecteurs:  le fil noir (ou marron) est la masse (GND), le fil rouge est l'alimentation (5 V) et le fil jaune (ou autre couleur) transmet le signal PWM.

Il est risqué d'alimenter directement votre servomoteur avec une sortie 5 V du Raspberry Pi, car il pourrait consommer un courant trop intense.  Autant que possible, utilisez une alimentation externe pour votre servomoteur.

(Quelques petits futés me feront remarquer que la photographie présentée au début de cet article montre clairement que je n'ai pas suivi mes propres recommandations: faites comme vous voulez, mais ne venez pas vous plaindre si ensuite votre Raspberry Pi ne fonctionne plus...)

Il est important que toutes les masses soient connectées ensemble (celle du Raspberry Pi, celle du servomoteur, et celle (borne négative) de l'alimentation utilisée pour le servomoteur).

Le fil qui achemine le signal PWM est branché la la pin 12 (numérotation board), aussi appelée GPIO 18 (numérotation BCM).



Des exemples de script

Le premier script nous permettra de trouver par essai/erreur les valeurs de rapport cyclique correspondant aux positions extrêmes de votre servomoteur.  Au départ, le rapport cyclique est réglé automatiquement à 7 (ce qui devrait avoir pour effet de placer votre servomoteur environ à sa position médiane).  On demande ensuite à l'utilisateur d'entrer au clavier le rapport cyclique désiré.  Avec mon servo, la position minimale était atteinte avec un rapport cyclique de 3 (si j'entrais 2, le servo demeurait à la même position qu'à 3), et la position maximale était atteinte avec un rapport cyclique de 11 (là encore, si j'entrais 12, le servo demeurait à la même position qu'à 11).  Notez que vous n'êtes pas limité aux nombres entiers:  vous pouvez écrire "9,35", par exemple.



Vous remarquerez peut-être que plutôt que demeurer sagement immobile à la position que vous avez demandée (comme il le ferait si vous le contrôliez avec un Arduino), votre servomoteur tremblote un peu.  Si j'ai bien compris, c'est l'aspect "multitâche" du système d'exploitation du Raspberry Pi qui est la cause de ces vibrations.  Le Raspberry Pi ne consacre pas 100% de son temps à votre programme en python, ce qui cause certaines irrégularités dans le signal PWM transmis au servomoteur.

Si ce tremblement constitue un irritant majeur, vous pouvez déléguer le contrôle du servomoteur à un dispositif en temps réel comme l'Arduino (vous pouvez vous référer à de précédents articles de blog pour établir une communication entre le Raspberry Pi et l'Arduino par USB, ou par RF 433 MHz); vous pouvez également utiliser un circuit intégré spécialement conçu pour cette tâche.

Voici un deuxième script grâce auquel le servomoteur est toujours en mouvement:  il tourne lentement dans une direction, puis revient rapidement à son point de départ afin de recommencer son cycle.  Avant d'exécuter ce script, il est préférable d'avoir d'abord trouvé les valeurs limites du rapport cyclique au moyen du script précédent, et d'utiliser ces valeurs à la place de celles que j'ai placées (qui correspondent au caractéristiques de mon servo).




Yves Pelletier   (TwitterFacebook)
Related Posts Plugin for WordPress, Blogger...