Le générateur de sons bizarres

J'ai construit le "Weird Sound Generator" proposé sur le site Music from Outer Space.  En fait, c'est un projet que j'avais amorcé il y a plusieurs mois, et que j'avais mis de côté parce la sortie filtrée ne fonctionnait pas du tout.  J'ai ressorti le circuit cette semaine et j'ai réglé le problème assez rapidement.




Il s'agit donc d'un gadget qui émet des sons étranges.

C'est amusant pendant un certain temps, mais puisqu'il ne s'agit pas d'un véritable instrument de musique, je dois avouer que j'ai eu plus de plaisir à le construire qu'à l'utiliser...  Si c'était à refaire, je me contenterais probablement d'une version temporaire montée sur un breadboard.

Une fois sur la page du Weird Sound Generator, utilisez le menu de gauche pour accéder au schéma du circuit.  En fait, ce schéma n'est pas tout à fait identique à celui que j'ai utilisé, et que je ne retrouve plus!

Voici une démonstration sur vidéo (réalisée par quelqu'un d'autre):

Fabrication d'un générateur de fonctions

J'ai construit avec succès mon propre générateur de fonctions, qui permet de produire un signal électrique périodique (sinus, dents de scie ou carré) dont la fréquence et l'amplitude sont réglables à volonté.

Pour ce faire, j'ai utilisé le schéma de circuit du modèle FG500K, disponible ici.   La pièce maîtresse de ce circuit est le circuit intégré XR-2206 (qui n'est plus en production, si j'ai bien compris, mais il est néanmoins possible de s'en procurer sur eBay).   N'ayant pas sous la main d'interrupteur rotatif à 6 positions (permettant de faire varier la fréquence en sélectionnant un des 6 condensateurs), j'ai dû me rabattre sur une paire d'interrupteurs rotatifs à 4 positions.  Un premier potentiomètre permet un ajustement plus fin de la fréquence, un deuxième permet d'ajuster l'amplitude.

Une sortie est réservée aux ondes carrée (dont l'amplitude n'est pas ajustable).  L'autre sortie fournit une onde sinusoïdale ou en dent de scie, dépendant de la position d'un interrupteur.

Il ne me reste plus qu'à mettre ça dans un boîtier, et à tenter de lui ajouter un fréquencemètre (probablement à base d'Arduino: on s'en reparlera...).

Phototransistor et LED infrarouge

J'ai réalisé cette expérience très simple pour tester les paires de phototransistors et de diodes infrarouges que je me suis procurées.

Lorsque le phototransistor reçoit de la lumière infrarouge provenant de la LED infrarouge, il laisse circuler le courant, ce qui allume la LED rouge.

Lorsqu'un obstacle opaque est placé entre la LED infrarouge et le phototransistor, celui-ci bloque le courant, et la LED rouge s'éteint.

Yves Pelletier (Twitter: @ElectroAmateur)

Module à ultrasons HC-SR04 et Arduino

Les modules à ultrasons HC-SR04 sont facile à obtenir sur eBay, pour quelques dollars (ou euros) seulement.  Ils permettent de détecter la présence d'obstacles au  moyen d'ultrasons, et de mesurer la distance de ces obstacles.

Ils sont extrêmement faciles d'utilisation avec un Arduino, il n'y a que 4 connexions à faire:

VCC du HC-SR04 --> 5V de l'Arduino
Trig du HC-SR04 ---> digital 7 de l'Arduino
Echo du HC-SR04 ---> digital 6 de l'Arduino
GND du HC-SR04 --> Gnd de l'Arduino

Côté logiciel, rien de très compliqué non plus (aucune bibliothèque spécialisée n'est nécessaire):  il s'agit de mettre la pin "Trig" à 5 volts pendant quelques microsecondes, puis la remettre à 0.  Si le module reçoit un écho, la pin "Echo" devient haute (5 V) pendant une durée équivalente à l'allée retour de l'ultrasons.  Il ne reste plus qu'à calculer la distance qui correspond au délai mesuré.

Voici un sketch qui montre comment afficher sur le moniteur série la distance mesurée par le module HC-SR04 (en centimètres).

Il s'agit ensuite d'orienter le capteur vers un objet pour que la distance en centimètres s'affiche sur le moniteur série.

	/*******************ULTRASONS HC-SR04*************************
	*
	* Démonstration de l'utilisation du module à ultrasons HC-SR04
	* avec un Arduino. La distance mesurée par le module est affichée
	* sur le moniteur série.
	*
	* Connexions:
	*
	* Le module HC-SR04 ne comporte que 4 pins:
	*
	* VCC du HC-SR04 ---> 5V de l'Arduino
	* Trig du HC-SR04 ---> digital 7 de l'Arduino
	* Echo du HC-SR04 ---> digital 6 de l'Arduino
	* GND du HC-SR04 ---> Gnd de l'Arduino
	*
	* https://electroniqueamateur.blogspot.com/2011/10/module-ultrasons-hc-sr04.html
	*
	**************************************************************/
	// définition des connexions
	int trigPin = 7; // pin "trig" branchée dans le 7 de l'Arduino
	int echoPin = 6; //pin "echo" branchée dans le 6 de l'Arduino
	void setup() {
	// prépration du moniteur série
	Serial.begin(9600);
	pinMode(echoPin, INPUT);
	pinMode(trigPin, OUTPUT);
	digitalWrite(trigPin, LOW);
	}
	void loop()
	{
	// les variables qui nous seront utiles
	long temps, distance;
	// Nous envoyons un signal haut d'une durée de 10 microsecondes, en sandwich
	// entre deux signaux bas. Des ultrasons sont émis pendant que le signal est haut
	digitalWrite(trigPin, HIGH);
	delayMicroseconds(10);
	digitalWrite(trigPin, LOW);
	// Lors de la réception de l'écho, le module HC-SR04 émet
	// un signal logique haut (5 v) dont la durée est égale au
	// temps écoulé entre l'émission et la réception de l'ultrason.
	pinMode(echoPin, INPUT);
	temps = pulseIn(echoPin, HIGH);
	// Maintenant, nous convertissons la durée en distance
	// puisque la vitesse du son est de 340 m/s , le temps est en microsecondes
	// et les ultrasons parcourent le double de la distance par rapport à l'obstacle,
	// la distance en cm sera:
	distance = temps * 340/(2*10000);
	// on affiche l'information sur le moniteur série:
	Serial.print("Distance: ");
	Serial.print(distance);
	Serial.println(" cm");
	delay(500);
	}

view raw Ultrasons_moniteur_serie.ino hosted with ❤ by GitHub

À lire aussi:

Vous trouverez aussi sur ce blog des conseils pour utiliser le télémètre HC-SR04 avec un Raspberry Pi, avec un ATTiny85,  avec une carte STM32 Nucleo programmée avec mbed, avec un microcontrôleur PIC et avec un micro:bit.

Yves Pelletier   (Twitter: @ElectroAmateur)

Livre: Beginning Arduino par Michael McRoberts

J'aime bien ce livre publié chez Apress:  au cours des derniers mois, il a constitué ma principale source de documentation dans mon apprentissage de l'Arduino.  On y trouve 50 projets avec des instructions détaillées et des explications claires sur leurs principes de fonctionnement.

La démarche du livre me convient parfaitement:  on commence par réaliser le circuit et charger le code, on constate avec émerveillement que tout fonctionne tel que prévu, et finalement on essaie de comprendre comment ça fonctionne.

En plus de l'incontournable introduction consistant à faire clignoter une LED (...), on y apprend comment utiliser l'Arduino avec des moteurs (DC, servos, pas à pas),  des afficheurs à cristaux liquide, des matrices de LEDs, des capteurs à ultrason, des lecteurs de carte SD, etc.

Ne cherchez pas dans ce livre d'idées révolutionnaires, toutefois:  on nous présente des utilisations classiques de l'Arduino et toute l'information contenue dans ce livre peut facilement être trouvée un peu partout sur Internet.

À ce jour, Apress a publié pas moins de 8 livres sur l'Arduino.

Badge clignotant pour l'Halloween

Le soir de l'Halloween, c'est important d'être bien visible!  J'ai fabriqué pour mes petits vampires ce badge clignotant:  les yeux d'un squelette sont constitués de deux LEDs qui s'allument et s'éteignent par alternance.

Encore une fois, le circuit est issu du livre "Getting Started in Electronics" par Forrest M. Mimms.  Deux transistors PNP, deux condensateurs, 4 résistances et deux LEDs, c'est tout!   Ça s'appelle un "free-running multivibrator".  En augmentant la capacité des condensateur, la fréquence de clignotement diminue.

J'ai tout soudé ensemble sans même utiliser de carte perforée (bien entendu, il me reste à isoler les broches les unes des autres; dans l'état actuel du circuit, un court-circuit serait vite arrivé...).

Rien de très ambitieux, mais ça fonctionne et ça ne coûte pratiquement rien.

Fabrication de shields Arduino sur une plaque perforée

J'étais un peu irrité de devoir brancher 8 fils chaque fois que je voulais utiliser un afficheur à cristaux liquides avec mon Arduino, j'ai donc décidé de construire moi-même un "shield":  il s'agira, à l'avenir, d'insérer le shield dans les connecteurs de l'Arduino pour que toutes les connections s'effectuent correctement sans que j'aie à m'en préoccuper.  Il existe bien sûr des shields déjà prêts dans le commerce, mais ils sont plus chers, et j'avais le goût de tout construire moi-même.


Je me suis procuré des barrettes de 40 connecteurs mâles et femelles.  Il s'agit de casser les barrettes de connecteurs mâles (par groupes de 6 ou 8 broches).  Pour les connecteurs femelles, c'est un peu plus compliqué:  il faut les scier à la taille désirée.  Il existe des connecteurs comportant à la fois la partie mâle et femelle, mais ils sont plus difficile à trouver (et plus cher aussi).  Les broches de ces connecteurs sont espacés de 0,1 pouce, ce qui correspond parfaitement aux trous d'une plaque perforée conventionnelle.

L'Arduino est toutefois affecté d'un irritant défaut de conception: la distance entre ses broches 7 et 8 est de 0,16 pouce:  les broches 8 à 13 sont donc décalées par rapport aux trous de la plaquette!    Massimo Banzi a révélé qu'il s'agit d'une erreur qu'il a commise lors du dernier sprint avant de manufacturer les tous premiers circuits imprimés de l'Arduino.

Alors comment s'y prend-on pour produire son propre shield?

1. On achète un "protoshield":  une plaquette perforée conçue spécialement pour l'Arduino (avec les trous aux bons endroits).   Mais c'est beaucoup plus cher (environ 20 fois plus cher dans mon cas).
2. On fabrique son propre circuit imprimé:  c'est parfois approprié, mais pas toujours.  Je ne suis pas encore très à l'aise dans ce genre de fabrication.
3. On plie légèrement les broches du shield pour les aligner avec les ports décalés de l'Arduino.
4. On perce dans la plaquette une série de 8 trous supplémentaires décalés par rapport  aux autres.

La quatrième solution m'a semblé la plus élégante, mais je n'ai aucune l'intention de percer 8 trous chaque fois que je désire produire un nouveau shield.

Mon premier shield a donc été un "shield adaptateur" qui sera intercalé entre l'Arduino et mes shields de fabrication maison:  ce shield comporte les broches 8 à 13 mâles à la position du Arduino, mais ses broches 8 à 13 femelles se trouvent aux positions normales d'une plaquette perforée.

Un deuxième adaptateur pourra être construit pour permettre qu'un shield commercial soit ajouté au-dessus des shields de fabrication maison (j'ai a l'esprit mon shield de prototypage muni d'un breadboard, il est plus pratique de le placer sur le dessus de la pile).


Ensuite, fabrication de mon shield muni d'un afficheur à cristaux liquides.  J'ai volontairement installé l'afficheur à l'extérieur de la plaque perforée, afin qu'il demeure bien visible malgré l'ajout de shields supplémentaires par-dessus.  Après une première version qui ne fonctionnait pas correctement (je suis encore un piètre soudeur!), j'ai été obligé de tout reprendre à zéro et ça fonctionne...relativement bien.  À cause de certaines soudures, les connecteurs mâles n'entrent pas toujours à fond dans les connecteurs femelles et il faut insister un peu:  je croise les doigts pour que mes soudures résistent à plusieurs cycles de connexion/reconnexion...

Interrupteur à inclinaison (tilt switch)

Un interrupteur à inclinaison (tilt switch) est un dispositif simple mais peu connu;  comme son nom l'indique, il s'agit d'un interrupteur dont l'état (ouvert ou fermé) dépend de son inclinaison.  J'ai acheté sur eBay un lot de 10 interrupteurs pour 7 USD.


L'interrupteur contient une bille métallique libre de rouler à l'intérieur d'un tube cylindrique.  Lorsque la bille se trouve à une extrémité, elle ferme un contact électrique et le courant passe.  Lorsqu'elle roule à l'autre extrémité, le contact électrique est ouvert et le courant ne passe plus.  Plusieurs modèles comportent une goutte de mercure à la place d'une bille métallique solide, mais le mercure est un polluant dangereux...

Quelques idées d'applications:  avertir l'utilisateur que l'appareil est incliné lorsqu'il ne doit pas l'être (balance électronique, par exemple), déclenchement d'un moteur pas à pas ou d'un servo qui tourne de façon à annuler l'inclinaison indésirable, contrôleur de jeu (un mobile bouge à l'écran dans la direction de l'inclinaison).  L'interrupteur peut aussi se déclencher lorsque l'utilisateur secoue l'appareil.

Pour expérimenter avec ce dispositif, j'ai conçu un petit gadget aussi simple qu'inutile:  4 interrupteurs à inclinaison sont disposés à l'horizontale dans des directions différentes (0° , 90°, 180° et 270°) afin de détecter une éventuelle inclinaison dans chacune de ces directions.  Chaque interrupteur est relié en série avec une diode électroluminescente.  Le but du jeu:  maintenir la plaquette à l'horizontale afin qu'aucune LED ne s'allume.

Plus d'infos sur les interrupteurs à inclinaison (Ladyada.net)

Livre: Teardown, Learn How Electronics Work by Taking Them Apart

L'objectif de ce livre est intéressant:  encourager le lecteur à apprendre l'électronique en démontant quelques appareils qui traînent dans la maison.   L'auteur nous invite donc à la dissection détaillée d'un détecteur de fumée, d'une lampe automatique munie d'un détecteur infrarouge, d'un pèse-personne, d'une ampoule fluo-compacte,  d'un humidificateur à ultrasons, d'un amplificateur stéréo, d'un multimètre, d'une guitare électrique, etc.

Pour chaque appareil, l'auteur explique le principe de fonctionnement de l'appareil et la fonction de chaque composant.  Il explique les avantages et inconvénients des choix faits par le fabricant, suggère quelques modification que le lecteur pourrait apporter à l'appareil ou comment les composants récupérés peuvent être utilisés ailleurs.

Bryan Bergeron est éditeur des magazines Nuts and Volts et Servo, il enseigne au MIT et à la Harvard Medical School, en plus de diriger une compagnie spécialisée dans le développement de matériel militaire...de toute évidence, il sait de quoi il parle.

J'aurais préféré un meilleur arrimage entre le texte et les photographies (l'utilisation de textes à l'intérieur des photos pour identifier les composants aurait été approprié, il me semble) et un peu moins de consignes de sécurité paranoïaques (les avocats de la maison d'édition ont visiblement pris toutes les précautions nécessaires pour éviter toute poursuite...) mais j'ai beaucoup apprécié la lecture de ce livre.

Modification d'une alimentation d'ordinateur

Voici un projet qui s'est révélé étonnamment facile d'exécution.  J'ai obtenu gratuitement cette alimentation d'ordinateur, elle était destinée à être jetée aux ordures.  Je ne sais pas exactement ce que son propriétaire lui reprochait, mais après avoir connecté le fil vert ("Power On")  avec un des fils noirs et inséré une résistance de 5 watts entre un fil rouge et un fil noir, j'ai constaté que tous les fils étaient au voltage correct ( noir:  0 V, orange: 3,3 V, rouge:  5 V, jaune 12 V, blanc -5 V et bleu -12 V).

Il ne me restait plus qu'à percer 6 trous dans le boîtier pour installer un connecteur pour chaque tension disponible, plus un septième trou plus petit pour une LED qui s'allume pour indiquer que l'appareil est en marche.  Il s'agit d'un modèle comportant déjà un interrupteur, je n'ai donc pas eu besoin d'en installer un moi-même.

En gros, j'ai suivi les instructions détaillées fournies ici.

Et ça fonctionne!

Pour lire mes articles subséquents concernant la transformation d'une alimentation ATX:
Deuxième modèle (tension variable)
Troisième modèle (moins compact, mais plus facile à construire)

Démontage d'un kymographe

La semaine dernière, j'ai eu le plaisir de trouver quatre kymographes à côté des poubelles d'une école, chacun portant l'inscription "à jeter".  Je me suis évidemment empressé de les réquisitionner.  Bien sûr, je n'ai aucunement besoin de cet antique instrument de laboratoire à la maison (et surtout pas en quatre exemplaires), mais j'avais remarqué la présence de deux potentiomètres, d'un interrupteur rotatif, d'un interrupteur à levier (de fort bonne qualité) et de cinq connecteurs pour fiches bananes (binding posts) que je pourrais récupérer afin de les utiliser dans d'autres projets;  j'étais aussi très curieux de voir ce qu'il y avait d'autre à l'intérieur.

J'ai été particulièrement impressionné par l'arbre de transmission, qui permet de régler la vitesse de rotation du cylindre:  il est constitué d'une douzaine de roues dentées métalliques, toutes du même pas, qui me seront certainement utiles un jour.

Vous pouvez agrandir les photos en cliquant dessus.

Clavier d'orgue électronique et sa matrice

Maintenant que mon Arduino est capable de converser en langage MIDI, ce serait chouette de lui annexer un clavier.  Il existe des solutions plutôt simples comme le shield MidiVox, qui permet de relier un clavier compatible MIDI à l'Arduino; mais je dispose, dans ma caverne d'Ali Baba, de deux claviers récupérés d'un orgue électronique Yamaha Electone des années 1980 et j'aimerais bien les utiliser.

Les deux claviers sont identiques (sur l'orgue, un d'entre eux servait pour la main droite, l'autre pour la main gauche); ils comportent 37 touches (3 octaves) et dans la mesure du possible, j'aimerais bien utiliser tel quel leur circuit de matrice constitué de 37 interrupteurs et 37 diodes reliés à un connecteur à 20 broches (4 des broches de ce connecteur sont inutilisées).

En observant la platine de circuit intégré et en testant mes hypothèses au moyen d'un multimètre, j'ai pu déterminer que toutes les notes séparées d'un intervalle d'un octave sont reliées entre elles par un conducteur ( par exemple, toutes les touches "ré" sont directement reliées à la première broche du connecteur, en haut à gauche).   L'autre côté de chaque interrupteur est relié à une diode, puis à une autre broche du connecteur.  Ainsi, si j'appuie sur le ré le plus grave, on peut faire circuler un courant entre la première broche à gauche et la dernière à droite.  Pour le ré qui se trouve un octave plus haut, le seul trajet conducteur se trouve entre la première broche à gauche et l'avant-dernière broche à droite, etc.

Les paires de broches qui sont reliées par un trajet conducteur permettent de déterminer quelles touches du clavier sont enfoncées.

Maintenant, il reste à voir comment relier tout ça à l'Arduino (je suppose qu'il faudra multiplexer tout ça, question de diminuer un peu le nombre de sorties nécessaires sur l'Arduino), puis concevoir un sketch qui balaiera les différentes paires de connecteur afin de déterminer quelles touches sont enfoncées.

On va bien s'amuser!

(Pour un peu plus d'info sur les matrices de clavier)

Mise à jour (8 mai 2012):  Cet article a maintenant une suite:  Décodage d'un clavier d'orgue par un Arduino

Communication MIDI OUT avec un Arduino

Cet article a été mis à jour le 13 décembre 2020 

J'ai  exploré la communication entre un Arduino et un clavier musical par l'entremise du protocole MIDI.  J'ai d'abord réalisé le circuit (très simple) proposé ici :  il est constitué de quelques fils, une résistance de 220 Ω et un jack MIDI femelle, aussi appelés DIN5 (j'allais en commander un quand je me suis souvenu de mon antique interface Mac Man qui ne fonctionne plus avec mes ordinateurs actuels:  j'ai donc récupéré ses 4 jacks MIDI).

Le code proposé sur la même page web se contente de jouer toutes les notes en ordre croissant.  En plus d'émettre des message "note on", je voulais utiliser plusieurs canaux MIDI en même temps, chacun produisant le son d'un instrument distinct.  C'est ce que j'ai réalisé avec le sketch ci-dessous.

J'ai assigné un son d'instrument aux canaux MIDI 0, 1 et 2 en me basant sur les spécifications du General MIDI .  Par convention, le canal 10 est réservé aux percussions et n'est pas affecté par les messages "program change".

On joue une note par un message "note on" en spécifiant le canal, le numéro de la note (référence ici) et sa vélocité (son volume sonore, en gros).  On interrompt la note de la même façon, en lui assignant une vélocité de zéro.  Lorsqu'on oublie d'interrompre la note, ça peut être très laid!

Cette première expérimentation pourrait ouvrir la voie à des projets plus ambitieux comme exécuter des fichiers MIDI stockés sur une carte SD, ou construire un contrôleur MIDI...

-

	/*********************************************************************************************
	MIDI OUT DEMO
	Ce sketch permet à l'Arduino de jouer une mélodie sur un clavier MIDI.
	Plus d'infos:
	http://electroniqueamateur.blogspot.com/2011/07/communication-midi-avec-un-arduino.html
	**********************************************************************************************/
	/* On définit quelques notes qu'on va utiliser: ce sera plus pratique que les valeurs hexadécimales!
	Voir http://www.wavosaur.com/download/midi-note-hex.php */
	#define NOTE_G2 0x2B
	#define NOTE_C3 0x30
	#define NOTE_C4 0x3C
	#define NOTE_D4 0x3E
	#define NOTE_E4 0x40
	#define NOTE_F4 0x41
	#define NOTE_G4 0x43
	#define NOTE_A4 0x45
	#define NOTE_B4 0x47
	#define NOTE_C5 0x48
	#define NOTE_D5 0x4A
	#define NOTE_E5 0x4C
	#define NOTE_F5 0x4D
	#define NOTE_G5 0x4F
	#define NOTE_A5 0x51
	#define NOTE_B5 0x53
	// appelé pour jouer une note
	void noteOn(int cmd, int pitch, int velocity) {
	Serial.write(cmd);
	Serial.write(pitch);
	Serial.write(velocity);
	}
	// appelé pour modifier le timbre de l'instrument
	void ProgChange(int channel, int prognumber) {
	Serial.write(0xC0 + channel);
	Serial.write(prognumber);
	}
	void setup() {
	Serial.begin(31250); // réglage du baud rate à la norme MIDI
	}
	void loop() {
	// préparation des instruments:
	ProgChange(0, 34); // Bass guitar sur le canal 0
	ProgChange(1, 16); // orgue sur le canal 1
	ProgChange(2, 80); // synthé sur le canal 2
	// le canal 9 joue toujours des percussions
	// on joue une courte mélodie:
	noteOn(0x99, 42, 0x45); // Closed Hi-Hat
	noteOn(0x99, 36, 0x45); // Bass Drum
	noteOn(0x90, NOTE_C3, 0x45); // Basse
	noteOn(0x92, NOTE_E5, 0x50); // Synthé
	delay(200);
	noteOn(0x99, 42, 0x00); // Closed Hi-Hat fin
	noteOn(0x99, 36, 0x00); // Bass Drum fin
	noteOn(0x92, NOTE_E5, 0x00); // Synthé fin
	noteOn(0x99, 42, 0x45); // Closed Hi-Hat
	noteOn(0x92, NOTE_D5, 0x50); // Synthé
	delay(200);
	noteOn(0x99, 42, 0x00); // Closed Hi-Hat fin
	noteOn(0x90, NOTE_C3, 0x00); // Basse fin
	noteOn(0x92, NOTE_D5, 0x00); // Synthé fin
	noteOn(0x99, 42, 0x45); // Closed Hi-Hat
	noteOn(0x99, 38, 0x45); // Bass Drum
	noteOn(0x91, NOTE_C4, 0x65); // orgue
	noteOn(0x91, NOTE_E4, 0x65); // orgue
	noteOn(0x91, NOTE_G4, 0x65); // orgue
	delay(200);
	noteOn(0x99, 42, 0x00); // Closed Hi-Hat fin
	noteOn(0x99, 38, 0x00); // Bass Drum fin
	noteOn(0x99, 42, 0x45); // Closed Hi-Hat
	delay(200);
	noteOn(0x99, 42, 0x00); // Closed Hi-Hat fin
	noteOn(0x91, NOTE_C4, 0x00); // orgue fin
	noteOn(0x91, NOTE_E4, 0x00); // orgue fin
	noteOn(0x91, NOTE_G4, 0x00); // orgue fin
	noteOn(0x99, 42, 0x45); // Closed Hi-Hat
	noteOn(0x99, 36, 0x45); // Bass Drum
	noteOn(0x90, NOTE_G2, 0x45); // Basse
	noteOn(0x92, NOTE_G5, 0x50); // Synthé
	delay(200);
	noteOn(0x99, 42, 0x00); // Closed Hi-Hat fin
	noteOn(0x99, 36, 0x00); // Bass Drum fin
	noteOn(0x92, NOTE_G5, 0x00); // Synthé fin
	noteOn(0x99, 42, 0x45); // Closed Hi-Hat
	noteOn(0x92, NOTE_E5, 0x50); // Synthé
	delay(200);
	noteOn(0x99, 42, 0x00); // Closed Hi-Hat fin
	noteOn(0x90, NOTE_G2, 0x00); // Basse fin
	noteOn(0x92, NOTE_E5, 0x00); // Synthé fin
	noteOn(0x99, 42, 0x45); // Closed Hi-Hat
	noteOn(0x99, 38, 0x45); // Bass drum
	noteOn(0x91, NOTE_C4, 0x65); // orgue
	noteOn(0x91, NOTE_E4, 0x65); // orgue
	noteOn(0x91, NOTE_G4, 0x65); // orgue
	delay(200);
	noteOn(0x99, 42, 0x00); // Closed Hi-Hat fin
	noteOn(0x99, 38, 0x00); // Bass drum fin
	noteOn(0x99, 42, 0x45); // Closed Hi-Hat
	delay(200);
	noteOn(0x99, 42, 0x00); // Closed Hi-Hat fin
	noteOn(0x91, NOTE_C4, 0x00); // orgue fin
	noteOn(0x91, NOTE_E4, 0x00); // orgue fin
	noteOn(0x91, NOTE_G4, 0x00); // orgue fin
	}

view raw MIDI_OUT_demo.ino hosted with ❤ by GitHub

-

À lire également

Beaucoup d'autres projets MIDI avec l'Arduino:

• Fabrication d'un module MIDI (in et out) pour Arduino
• S'entraîner à lire les notes sur une portée avec Arduino
• Jouer des fichiers MIDI avec Arduino
• Séquenceur MIDI à base d'Arduino
• Arpégiateur MIDI à base d'Arduino
• Identificateur d'accords MIDI
• Clavier MIDI à base d'Arduino
• Pédalier d'orgue MIDI à base d'Arduino
• Flûte à bec MIDI à base d'Arduino
• MIDI par usb avec Arduino Leonardo
• MIDI sans fil avec Arduino

Yves Pelletier (Twitter:  @ElectroAmateur)

Diagramme en bâton sur un afficheur à cristaux liquides

Comme petit exercice d'appropriation de l'Arduino et des afficheurs à cristaux liquide (ACL ou LCD en anglais), j'ai décidé de réaliser ce montage dans lequel la longueur d'une barre horizontale varie selon la valeur d'un voltage appliqué sur une des entrées analogiques.

Je m'attendais à quelque chose de moyennement compliqué, comme par exemple être obligé de créer mes propres polices de caractères en forme de rectangle, mais c'est finalement assez simple:  il s'agit d'afficher des rectangles noirs ou blancs aux endroits appropriés.

Dans le schéma de circuit illustré ci-dessus, R1 est un potentiomètre de 5 kΩ qui permet de faire varier la tension à l'entrée analogique numéro 2 de l'Arduino et, par conséquent, de faire varier la longueur de la barre indicatrice sur l'afficheur.  Bien entendu, dans un projet utile, ce voltage pourrait provenir d'un capteur afin d'afficher une valeur mesurée.  La barre horizontale pourrait également indiquer la valeur d'un paramètre modifiable par l'utilisateur, comme par exemple le volume sonore.

Pour plus de détails sur le reste du circuit, consultez cet article plus complet .   R2 est un potentiomètre de 10 kΩ qui ne sert qu'à modifier le contraste de l'afficheur (vous pouvez le remplacer par une résistance fixe lorsque vous connaissez la valeur qui permet un affichage net).


-

	/******************************************************************************************
	Valeur analogique mesurée sur l'entrée A2 affichée sur un LCD sous la forme d'un bargraphe.
	http://electroniqueamateur.blogspot.ca/2011/07/diagramme-en-baton-sur-un-afficheur.html
	*******************************************************************************************/
	#include <LiquidCrystal.h> // LiquidCrystal Library
	int analogPin = 2; // Voltage mesuré sur la broche 2
	float d = 0;
	float oldit = 0;
	LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //afficher à cristaux liquides
	// branché sur les broches
	// 12, 11, 5, 4, 3 et 2
	void setup() {
	lcd.begin(16, 2);
	lcd.setCursor(0, 0); // curseur dans le coin supérieur droit
	lcd.println("Tension "); // on écrit le mot "Tension"
	}
	void loop() {
	float num = analogRead(analogPin); // on récupère le voltage sur la broche 2
	float it = map(num, 0, 1023, 0, 16); // on sépare la valeur en 16 morceux
	lcd.setCursor(8, 0);
	lcd.print(num/1024*5); // on écrit la valeur numérique du voltage
	if (it > oldit) { // on vérifie si le nombre a augmenté
	for (d = 0; it >= d; d++) {
	lcd.setCursor(d, 1); // curseur dans la deuxième ligne
	lcd.write(1023); // écriture d'un rectangle noir
	}
	}
	if (it <= oldit) { // si le nombre a diminué
	for (d = 15; it <= d; d--) { //compte à rebours
	lcd.setCursor(d, 1); // curseur dans la deuxième ligne
	lcd.write(1022); // écriture d'un rectangle blanc
	}
	}
	oldit = it;
	}

view raw LCD_bargraph.ino hosted with ❤ by GitHub

-

À lire également:

Le guide complet pour utiliser un afficheur LCD 16 X 2 avec une carte Arduino.

Yves Pelletier   (Twitter, Facebook)

Fritzing: de la platine d'essai jusqu'au circuit imprimé

J'ai découvert le logiciel Fritzing hier, en parcourant les premières pages du livre "Beginning Arduino" par Michael McRoberts (Apress).  Il s'agit d'un logiciel open-source gratuit, disponible sur plusieurs plate-formes, qui permet de documenter les prototypes qu'on construit sur un breadboard de façon à en faire une représentation schématique, ou même un circuit imprimé.


En gros, il s'agit de reproduire sur une platine d'essai virtuelle affichée à l'écran un circuit qu'on a préalablement réalisé sur une véritable platine d'essai.  Pour ce faire, il s'agit de placer sur la platine virtuelle les éléments de circuit désirés: résistances, condensateurs, LEDs, circuits intégrés...et même un Arduino!  On relie le tout par des fils (virtuels) et hop! en deux temps trois mouvements, notre prototype est documenté.

Il s'agit ensuite de cliquer sur l'onglet "Vue schématique" pour accéder au schéma de notre circuit, ou de cliquer sur l'onglet "Circuit imprimé" pour obtenir, vous l'aurez deviné, le design d'un circuit imprimé.

Je n'ai exploré le logiciel que pendant quelques minutes, mais ça me semble très bien fait, et extrêmement facile à utiliser.  La documentation parle de plantages relativement fréquents, mais ça ne m'est pas encore arrivé.

Site web officiel de Fritzing
Téléchargement
Documentation en français

Fabrication de mes propres circuits imprimés: deuxième essai (réussi!)

Cette fois ça y est:   j'ai réussi à fabriquer mon propre circuit imprimé:  il suffisait de préparer la surface de cuivre en la frottant au moyen d'une éponge à récurer, puis de garder le fer à repasser plus longtemps sur le papier, en le déplaçant pour bien répartir la chaleur et la pression.  Sur la photographie ci-contre, on peut voir que pratiquement toute l'encre de l'imprimante laser qui se trouvait sur le papier (à gauche) a été transféré sur la feuille de cuivre (à droite).


Ensuite j'ai plongé ça dans une solution acide pour dissoudre le cuivre qui n'était pas couvert par de l'encre (50% acide muriatique, 50% peroxyde d'hydrogène), puis finalement j'ai enlevé l'encre en frottant la feuille avec un peu d'acétone.  Le résultat final est visible sur la photographie de gauche.

Je dispose maintenant d'un circuit imprimé conçu pour la réalisation de la boîte d'effet "Rebote Delay", qui n'avait pas parfaitement fonctionné lors de ma première tentative sur une plaquette perforée.

Lien vers ma première tentative (qui n'avait pas fonctionné...)

Fabrication de mes propres circuits imprimés: premier essai (raté!)

J'ai fait une première tentative de circuit imprimé fabrication maison en utilisant une imprimante laser, un fer à repasser et le papier spécial "PCB Fab in a Box".  Comme vous pouvez le constater sur la photo ci-contre, au moins le tiers du circuit est resté sur le papier sans être transféré sur la feuille de cuivre...

Prochain essai:  j'appuierai le fer plus longtemps, en prenant soin de le déplacer pour être bien certain d'appliquer de la pression partout.  Et j'essaierai de sabler légèrement la surface du cuivre; j'avais oublié cette étape...

Sonde à effet Hall Allegro A1302

Ce minuscule circuit intégré qui ressemble un peu à un transistor émet un voltage de sortie proportionnel au champ magnétique dans lequel il se trouve.  Une application évidente est la construction d'un gaussmètre permettant de mesurer un champ magnétique, mais ça peut aussi servir dans un compte-tour dans lequel un aimant passerait périodiquement devant le détecteur, etc.

Vous ne pouvez pas vous imaginer le temps que j'ai perdu à chercher pourquoi ma sonde ne fonctionnait pas:  j'avais beau approcher un aimant relativement puissant (récupéré d'un vieux disque dur d'ordinateur), le voltage de sortie conservait toujours la même valeur de 0,7 V.  J'ai même commandé un deuxième exemplaire, croyant l'avoir endommagé...  Jusqu'à ce que je réalise que j'avais mal interprété le pinout indiqué dans le datasheet (j'avais utilisé les numéro de broches du package LH alors que j'utilisais le package UA!!!).

Avec les branchements corrects, les résultats sont probants.  En absence de champ magnétique, le voltage de sortie est de 2,35 V, mais on peut facilement le faire passer à 0,15 V ou 4,75 V en approchant l'un ou l'autre des pôles d'un aimant.

Tout ça pour environ $1.

À lire également:

• Capteur de champ magnétique à effet Hall KY-024
• Magnétomètre/boussole HMC5883L

Arduino: premières impressions

Je crois que ça va être pour moi un été Arduino.

Je viens tout juste de recevoir mon premier Arduino Duemilanove.  Comment aurais-je pu éviter la vague Arduino?  Tous les magazines d'électronique en parlent sans arrêt.  Ça semble être devenu le jouet incontournable de tout électronicien amateur.

J'en suis encore à mes balbutiements:  j'ai installé le logiciel, branché le circuit dans un port USB, téléchargé dans le microcontrôleur l'inévitable premier programme consistant à faire clignoter une LED...  Il y a quelques semaines, j'avais fait la même chose avec un microcontrôleur PIC: c'était plus compliqué, moins amusant, et beaucoup plus intimidant.

Le IDE Arduino est beaucoup plus simple que celui le MPLAB de Microchip.  Le langage me semble beaucoup plus intuitif également:  digitalWrite, digitalRead:  je comprend immédiatement ce que ça signifie avant même d'avoir lu la moindre documentation (); alors que "TRISA4 = 0" c'est un peu plus nébuleux au départ...

J'aime la philosophie Arduino:  permettre à des artistes et à des amateurs de concevoir rapidement des prototypes  sans êtres handicapés par un manque de connaissances en électronique.  Ça me rappelle quand je programmais avec Hypercard sur mon premier ordinateur Macintosh (il y a 20 ans!).   On commençait par un simple assemblage d'images et de textes liés par des hyperliens, puis on apprenait progressivement à programmer en langage Hypertalk, en s'amusant, sans même s'apercevoir qu'on apprenait à programmer.  Les premiers résultats venaient rapidement.  Quand plus tard on se lançait dans un "vrai" langage de programmation, on ne pouvait pas s'empêcher de se demander pourquoi c'était si compliqué, par comparaison.

VU-metre à 9 DELs et une quarantaine de diodes...

Je voulais construire un alignement de DELs qui s'allumeraient progressivement à mesure qu'on augmenterait le voltage les alimentant:  le genre de truc qui indiquaient le niveau sonore dans les chaînes stéréo des années '80.

Lorsque le voltage est d'environ 1 volt, seule la première DEL s'allume.  À mesure qu'on augmente le voltage, les autres DELs s'allument une par une.  Elles sont toutes allumées lorsque le voltage atteint 7 V environ.

La meilleure méthode consisterait probablement à utiliser des diodes zener de valeurs différentes, mais je n'en avais pas sous la main.  J'ai donc associé en série à chaque DEL, en plus d'une résistance de protection,  un nombre croissant de diodes conventionnelles (des 1N4003) qui absorbent chacune environ 0,7 V en polarisation directe (et ce, peu importe l'intensité du courant qui les traverse).


Ça fonctionne exactement comme prévu, mais le circuit contient une quantité impressionnante de composants pour effectuer une tâche aussi simple...

C'est une idée que j'avais lue quelque part, mais je ne me souviens pas où...  (Il existe bien sûr des "LED bar graph displays" tout faits dans le commerce, mais c'est un peu cher et pas aussi amusant).

Son dont la fréquence dépend de l'intensité lumineuse

Le circuit ci-contre est simple à réaliser et donne un résultat amusant (bien que d'une utilité discutable):  il produit un son dont la fréquence dépend de l'intensité de la lumière qui atteint la photorésistance:   dans l'obscurité, le haut parleur produit un son grave, et le son devient de plus en plus aigu à mesure qu'on approche une source lumineuse.

J'ai trouvé ça dans le livre "Getting Started in Electronics", par Forrest Mims (le circuit s'intitule "Audible Light Probe").

Oscillateur à deux transistors

J'ai essayé avec succès cette petite expérience trouvée dans le numéro de mars 2011 du magazine Nuts & Volts.  Deux transistors (un NPN et un PNP) sont reliés à un haut-parleur avec trois résistances, un condensateur et une pile de 9 V (5 volts font parfaitement l'affaire).  Il en résulte un son (pas très agréable) dont la fréquence avoisine les 500 Hz.

Le résultat est quand même fascinant, quand on considère la simplicité du circuit.

Ajout d'un socket ZIF

J'ai dû ajouter un socket ZIF (force d'insertion nulle) à mon circuit destiner à tester les programmes de mon microcontrôleur:  après une dizaine d'utilisations avec le socket conventionnel, mon microcontrôleur était devenu inutilisable, ayant perdu une broche.

Si j'avais lu un peu plus loin mon livre "123 PIC Microcontroller Experiments for the Evil Genius", j'aurais dès le départ conçu mon circuit autour d'un socket ZIF (ils conseillent de faire cette modification à la page 51).  Ne désirant pas refaire mon circuit à partir de zéro, j'ai plutôt choisi de relier par des fils les broches correspondantes des deux sockets.  Ce n'est pas spécialement esthétique, mais ça fonctionne.

Avec un peu de chance, mon deuxième microcontrôleur aura une durée de vie plus longue que le premier!

Rebote 2 Delay: demi succès

J'ai tenté de constuire le Rebote 2 Delay de TonePad.  Il s'agit d'une boîte de délai/écho pour guitare électrique qui utilise le circuit intégré PT2399.  Le circuit est nettement plus complexe que les autres effets pour guitare que j'avais réalisés auparavant et j'ai eu un peu de difficulté à tout faire tenir sur ma petit plaquette perforée (j'aurais dû mieux planifier avant de commencer à souder!).

Le circuit fonctionne, mais le potentiomètre qui devrait contrôler le nombre de répétitions de l'écho ne fonctionne pas:  peu importe son réglage, je n'obtiens qu'une seule répétition (je peux toutefois, au moyen des autres potentiomètre, régler le délai entre le son d'origine et son écho, ainsi que le volume de l'écho).

De toute évidence, j'ai commis une erreur quelque part, et je ne parviens pas à la trouver...

Je vais mettre le projet en veilleuse pour quelques semaines, et je le recommencerai probablement à partir du point de départ (possiblement sur un breadboard pour commencer).