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)


Related Posts Plugin for WordPress, Blogger...