Clonage d'une télécommande infrarouge avec un Arduino (3)

Cette rubrique fait suite à Clonage d'une télécommande infrarouge avec un Arduino (1) et Clonage d'une télécommande infrarouge avec un Arduino (2), où nous avons appris comment capter les impulsions infrarouges émises par une télécommande de téléviseur, et à les réémettre au moyen d'un Arduino.

Aujourd'hui, il ne me reste plus qu'à ajouter quelques boutons à l'Arduino afin de produire une télécommande pleinement fonctionnelle.


Voici le problème:  j'utilise un vieux téléviseur analogique muni d'une boîte de conversion analogique-numérique.  Pour allumer ou éteindre le téléviseur, ou encore pour changer le volume, il faut utiliser la télécommande du téléviseur.  Mais pour changer de chaîne, il faut utiliser la télécommande du convertisseur analogique-numérique...en gros, la famille n'utilise que 5 boutons, mais ils sont disposés sur deux télécommandes différentes!

J'ai donc assemblé un prototype de télécommande ne comportant que 6 boutons correspondant aux fonctions fréquemment utilisées:  marche/arrêt, channel up, channel down, volume up, volume down et input. Bien entendu, une LED infrarouge est branchée à la sortie numéro 3 de l'Arduino.

Voici les détails du circuit:

Et voici mon sketch, mais bien sûr les messages envoyés au téléviseurs sont très spécifiques au modèle que je possède (vous devrez procéder tel que décrit dans les rubriques précédentes pour connaître les codes de votre modèle de télécommande).

	/*
	Sketch pour télécommande à 6 boutons permettant
	de contrôler mon téléviseur (ça ne fonctionnera
	probablement pas pour votre modèle!)
	LED infrarouge branchée à la pin 3
	https://electroniqueamateur.blogspot.com/2013/01/clonage-dune-telecommande-infrarouge_21.html
	*/
	#include <IRremote.h>
	IRsend irsend;
	// là où sont branchés les boutons
	int on_off_button = 8;
	int ch_down_button = 9;
	int ch_up_button = 10;
	int vol_down_button = 11;
	int vol_up_button = 12;
	int input_button = 13;
	unsigned int L = 1800; //durée d'un 1
	unsigned int C = 800; //durée d'un 0
	unsigned int X = 300; // durée d'une impulsion lumineuse
	unsigned long time;
	// signal on-off
	unsigned int on_off_1[] = {
	X,L,X,C,X,C,X,C,X,C,X,C,X,L,X,L,X,C,X,L,X,C,X,C,X,C,X,L,X,C,X};
	unsigned int on_off_2[] = {
	X,L,X,C,X,C,X,C,X,C,X,L,X,C,X,C,X,L,X,C,X,L,X,L,X,L,X,C,X,L,X};
	// signal vol up
	unsigned int vol_up_1[] = {
	X,L,X,C,X,C,X,C,X,C,X,C,X,C,X,L,X,C,X,L,X,C,X,C,X,C,X,L,X,C,X};
	unsigned int vol_up_2[] = {
	X,L,X,C,X,C,X,C,X,C,X,L,X,L,X,C,X,L,X,C,X,L,X,L,X,L,X,C,X,L,X};
	// signal vol down
	unsigned int vol_down_1[] = {
	X,L,X,C,X,C,X,C,X,C,X,L,X,C,X,L,X,C,X,L,X,C,X,C,X,C,X,L,X,C,X};
	unsigned int vol_down_2[] = {
	X,L,X,C,X,C,X,C,X,C,X,C,X,L,X,C,X,L,X,C,X,L,X,L,X,L,X,C,X,L,X};
	// signal input
	unsigned int input_1[] = {
	X,L,X,C,X,C,X,C,X,C,X,L,X,L,X,C,X,C,X,L,X,C,X,C,X,C,X,L,X,C,X};
	unsigned int input_2[] = {
	X,L,X,C,X,C,X,C,X,C,X,C,X,C,X,L,X,L,X,C,X,L,X,L,X,L,X,C,X,L,X};
	void setup()
	{
	pinMode(on_off_button, INPUT);
	pinMode(ch_down_button, INPUT);
	pinMode(ch_up_button, INPUT);
	pinMode(vol_down_button, INPUT);
	pinMode(vol_up_button, INPUT);
	pinMode(input_button, INPUT);
	}
	void loop() {
	if (digitalRead(on_off_button))
	{
	irsend.sendRaw(on_off_1, 31, 38);
	delay(30);
	irsend.sendRaw(on_off_2, 31, 38);
	delay(30);
	irsend.sendRaw(on_off_1, 31, 38);
	delay(200);
	}
	if (digitalRead(vol_up_button))
	{
	irsend.sendRaw(vol_up_1, 31, 38);
	delay(30);
	irsend.sendRaw(vol_up_2, 31, 38);
	delay(30);
	irsend.sendRaw(vol_up_1, 31, 38);
	delay(200);
	}
	if (digitalRead(vol_down_button))
	{
	irsend.sendRaw(vol_down_1, 31, 38);
	delay(30);
	irsend.sendRaw(vol_down_2, 31, 38);
	delay(30);
	irsend.sendRaw(vol_down_1, 31, 38);
	delay(200);
	}
	if (digitalRead(input_button))
	{
	irsend.sendRaw(input_1, 31, 38);
	delay(30);
	irsend.sendRaw(input_2, 31, 38);
	delay(30);
	irsend.sendRaw(input_1, 31, 38);
	delay(200);
	}
	if (digitalRead(ch_up_button))
	{
	for (int i = 0; i < 3; i++) {
	irsend.sendNEC(0xFDB04F, 32);
	delay(40);
	}
	}
	if (digitalRead(ch_down_button))
	{
	for (int i = 0; i < 3; i++) {
	irsend.sendNEC(0xFD8877, 32);
	delay(40);
	}
	}
	}

view raw telecommande.ino hosted with ❤ by GitHub

Ça fonctionne à la perfection!  Il ne reste plus qu'à trouver un réceptacle pour en faire un objet un peu plus...design.   Pour ce faire, je prévois construire mon appareil autour un Atmega 328 autonome (tel qu'expliqué ici).

Yves Pelletier (Twitter: @ElectroAmateur)

Clonage d'une télécommande infrarouge avec un Arduino (2)

Cette rubrique fait suite à "Clonage d'une télécommande infrarouge avec un Arduino (1)".  Cette fois, je vais décrire comment j'ai cloné la télécommande d'un téléviseur de marque Sharp (modèle G1395SA), dont le protocole n'a pas été reconnu par la librairie IRremote.

J'effectue donc les mêmes étapes décrites à la rubrique précédente, en pointant la télécommande vers un détecteur à infrarouge TSOP4836 branché à la pin 11 d'un Arduino qui exécute le sketch "IRrecvDump", et voici ce qu'affiche le moniteur série de l'IDE:

6D5D1DB3
Unknown encoding: 6D5D1DB3 (32 bits)
Raw (32): 22194 350 -1750 300 -700 350 -700 350 -700 350 -700 350 -700 300 -1750 350 -1750 350 -700 300 -1750 350 -700 350 -700 350 -700 350 -1750 300 -700 350

Pas de panique:  bien que la librairie n'ait pas reconnu le protocole utilisé, elle  fournit malgré tout les données brutes, c'est à dire une liste de durées, en microsecondes, pendant lesquelles la LED est soit allumée (nombres positifs), soit éteinte (nombres négatifs).  En principe, il s'agit de mettre ces valeurs dans un "array", d'utiliser la commande "sendRaw" 3 fois de suite, et tout fonctionne à merveille!

...Sauf que dans mon cas, ça n'a pas fonctionné du tout:  le téléviseur restait obstinément sourd à toutes mes tentatives de le soumettre aux ordres de l'Arduino.

J'ai donc été obligé d'observer directement le signal émis par la télécommande au moyen d'un oscilloscope (l'oscilloscope est branché à la sortie du détecteur TSOP4836).

Voici ce que ça donne:

Chaque fois que j'appuie sur le bouton "on/off", la télécommande émet 3 salves consécutives de signaux qui, à première vue, pourraient sembler identiques.

Je fais un zoom sur la première salve:

Le protocole est de type "pulse distance encoding", ce qui signifie que c'est le temps écoulé entre deux allumages successifs de la LED qui détermine la valeur logique "1" ou "0". Pour cette télécommande, la LED s'allume pendant 300 microsecondes (le signal mesuré sur le détecteur TSOP4836 est alors de 0 volt) .  Pour envoyer le signal "0", elle demeure éteinte pendant 800 microsecondes avant l'allumage suivant.  Pour envoyer le signal "1", elle demeure éteinte deux fois plus longtemps, soit 1600 microsecondes.

Cette première salve peut donc se résumer par le nombre binaire 100000110100010.

Voyons maintenant la deuxième salve, émise environ 45 millisecondes plus tard:

Elle est différente de la première, puisqu'elle correspond au message 100001001011101 (les cinq premiers bits sont identiques à ceux de la première salve, mais les 10 derniers sont inversés).

Quand à la troisième salve, elle est identique à la première.

Je comprend maintenant pourquoi ma première tentative n'avait pas fonctionné:  la librairie irRemote ne m'a fourni que les durées de la première salve; en émettant cette même salve 3 fois de suite, l'Arduino émettait un signal incorrect.

Voici le sketch permettant d'allumer et éteindre mon téléviseur toutes les 5 secondes (une LED infrarouge doit être branchée dans la sortie numéro 3 de l'Arduino).

	/*
	Sketch permettant d'allumer et éteindre mon téléviseur toutes les 5 secondes
	https://electroniqueamateur.blogspot.com/2013/01/clonage-dune-telecommande-infrarouge_17.html
	*/
	#include <IRremote.h>
	IRsend irsend;
	unsigned int L = 1800; //durée d'un 1
	unsigned int C = 800; //durée d'un 0
	unsigned int X = 300; // durée d'une impulsion lumineuse
	unsigned long time;
	// signal on-off
	unsigned int salve1[] = {
	X,L,X,C,X,C,X,C,X,C,X,C,X,L,X,L,X,C,X,L,X,C,X,C,X,C,X,L,X,C,X};
	unsigned int salve2[] = {
	X,L,X,C,X,C,X,C,X,C,X,L,X,C,X,C,X,L,X,C,X,L,X,L,X,L,X,C,X,L,X};
	void setup()
	{
	Serial.begin(9600);
	}
	void loop() {
	irsend.sendRaw(salve1, 31, 38);
	delay(30);
	irsend.sendRaw(salve2, 31, 38);
	delay(30);
	irsend.sendRaw(salve1, 31, 38);
	delay(5000);
	}

view raw send_raw.ino hosted with ❤ by GitHub

Yves Pelletier (Twitter: @ElectroAmateur)

Clonage d'une télécommande infrarouge avec un Arduino (1)

Construire votre propre télécommande de téléviseur au moyen d'un Arduino?  Bonne idée!

Vous pourriez, par exemple, réunir sur une même télécommande les fonctions les plus utilisées de plusieurs télécommandes différentes (oui, je connais l'existence des télécommandes universelles, mais c'est une solution beaucoup trop simple!).   Ou encore construire une télécommande qui limitera automatiquement le temps d'utilisation du téléviseur, l'éteignant au bout d'un certain délai, ou refusant de le mettre en marche aux heures interdites...  Ça pourrait aussi être un dispositif qui allume et éteint automatiquement le téléviseur en votre absence, pour que les cambrioleurs ne sachent pas que vous êtes parti en voyage depuis 3 semaines.

1° Décoder le signal

Lorsque vous appuyez sur un bouton de votre télécommande, celle-ci s'allume et s'éteint plusieurs fois très rapidement de façon à envoyer un message codé à votre téléviseur (ça ressemble un peu à du code morse).  Le rayonnement infrarouge est invisible à l'oeil nu, mais si vous observez l'extrémité de votre télécommande au moyen d'une caméra numérique, vous devriez voir la LED s'allumer brièvement lorsque vous appuyez sur un de ses boutons (par contre vous ne percevez pas les clignotements car ils sont trop rapides).

Pour contrôler votre téléviseur, l'Arduino devra alimenter une LED infrarouge de façon à ce qu'elle émette exactement le même signal.

La première étape consiste donc à capter ce signal et à l'analyser.  Pour ce faire, il vous faut un capteur infrarouge modulé à 38 kHz qui devrait faire l'affaire pour la plupart des télécommandes (dans certains cas, plus rares, il vous en faudra un modulé à 56 kHz).  J'ai utilisé le TSOP4836 de Vishay, mais il existe bien sûr d'autres possibilités (j'avais précédemment tenté l'expérience avec le KSM-2012 de Kodenshi sans le moindre succès).

Le circuit ci-dessous est sorti tout droit de la datasheet du TSOP4836; il sera peut-être un peu différent si vous utilisez un autre modèle.  La sortie du capteur est normalement haute (5 V) mais elle devient basse (0 V) sur réception d'un signal infrarouge qui oscille à 38 kHz.  Lorsqu'on appuie sur un bouton de la télécommande en pointant cette dernière vers le capteur, la tension de sortie du capteur va changer de valeur très rapidement (ce que vous pouvez vérifier si vous disposez d'un oscilloscope à mémoire).

Mais pour décoder ce signal, l'Arduino est encore plus pratique qu'un oscilloscope!  Surtout si vous avez préalablement installé la librairie IRRemote mise au point par Ken Shirriff.  (Je suis toujours un peu dérouté par l'interface du site GitHub:  il y a un bouton "ZIP" qui vous permet de downloader tous les fichiers nécessaires en un seul clic).

Une fois la librairie IRRemote installée dans votre répertoire "Libraries", vous branchez votre capteur infrarouge à l'arduino (la sortie du capteur va à l'entrée 11 de l'Arduino), vous téléversez dans l'Arduino le sketch "IRrecvDump" disponible dans le menu des exemples sous l'onglet IRRemote,  vous affichez le moniteur série (en vous assurant qu'il est bien réglé à 9600 bauds), et vous appuyez sur un bouton de la télécommande en visant le capteur.

Voici ce qu'affiche le moniteur série lorsque j'appuie sur le bouton "channel up" de ma télécommande:

Decoded NEC: FDB04F (32 bits)
Raw (68): 4450 8950 -4500 550 -550 600 -500 600 -550 550 -550 600 -500 600 -550 550 -550 600 -500 600 -1650 600 -1650 550 -1700 600 -1650 550 -1650 550 -1700 600 -500 550 -1700 550 -1700 550 -550 550 -1700 550 -1700 550 -550 550 -550 550 -600 550 -550 550 -550 550 -1700 550 -550 550 -600 550 -1650 600 -1650 550 -1700 550 -1650 600

La librairie a reconnu le protocole NEC à 32 bits, et la commande se traduit par la valeur hexadécimale "FDB04F".  C'est tout ce que j'ai besoin de savoir; puisque le protocole a été reconnu, je n'ai nullement besoin d'utiliser les données brutes qui apparaissent dans les lignes suivantes.


2° Émettre le signal

Pour émettre le signal, le circuit est simple:  une LED infrarouge branchée à la sortie 3 de l'Arduino.  On parle souvent d'une résistance de protection de 100 Ω, mais j'ai constaté deux inconvénients:  le signal émis par la LED est peu intense, et la transition entre les signaux numériques "hauts" et "bas" est plus lente (courbe exponentielle déterminée par la constante RC du circuit).  Puisque la LED infrarouge ne fonctionne pas en continu, vous pouvez vous permettre de diminuer considérablement cette résistance de protection.

Lorsque la LED pointe vers le téléviseur, le sketch suivant change de chaîne toutes les 5 secondes (le signal est envoyé 3 fois de suite pour chaque changement de chaîne).:


Include IRremote.h

IRsend irsend;

void loop() {

    for (int i = 0; i < 3; i++) {
      irsend.sendNEC(0xFDB04F, 32);
      delay(40);
    }
  delay(5000);
}

En plus de NEC, d'autres protocoles sont aussi reconnus par la librairie IRRemote: Sony SIRC, Philips RC5, Philips RC6.

Il reste quand même la possibilité que le protocole utilisé par votre télécommande ne soit pas reconnu par la librairie IRRemote:  il faut alors utiliser les données brutes (les délais pendant lesquels la LED est allumée ou éteinte) mais comme il ne sont qu'approximatifs, ça peut devenir plus délicat: ce sera le sujet de ma prochaine rubrique.

Plus d'informations sur la librairie IRRemote.
Plus d'informations sur les différents protocoles de télécommandes

Yves Pelletier (Twitter: @ElectroAmateur)

Construction d'une boîte de condensateurs

Une boîte de substitution de condensateurs est un dispositif permettant de sélectionner une capacité précise parmi plusieurs choix disponibles. Ça peut être particulièrement utile lors de la conception d'un circuit sur un breadboard quand on n'est pas certain de la capacité la plus appropriée:  il est alors bien plus pratique de tourner un bouton rotatif que d'essayer plusieurs condensateurs un après l'autre.

Il est possible de se procurer des boîtes de condensateurs dans le commerce, mais à un prix souvent élevé. C'est toutefois un instruments très facile à fabriquer soi-même.


Pour fabriquer le mien, j'ai utilisé deux interrupteurs rotatifs (un pôle, 12 positions) et 22 condensateurs dont les capacités s'étalent de 0,22 nF à 330 nF.  Je n'ai pas pris la peine de me procurer des condensateurs de grande précision, mais j'ai mesuré leur capacité en m'assurant d'utiliser uniquement des condensateurs dont la capacité ne s'éloignait pas significativement de la valeur affichée.


Voici le schéma du circuit:

Comme vous pouvez le constater, n'importe quel condensateur relié au bouton rotatif A peut être mis en parallèle avec n'importe quel condensateur relié au bouton rotatif B:  de cette façon, il est possible d'approximer de nombreuses capacités par combinaison de deux condensateurs en parallèle.


Par exemple:

Bouton A à 0,22 nF et bouton B à 1 nF pour obtenir environ 1,2 nF
Bouton A à 0,47 nF et bouton B à 1 nF pour obtenir environ 1,5 nF
Bouton A à 0,68 nF et bouton B à 1 nF pour obtenir  environ 1,8 nF
Bouton A à 2,2 nF et bouton B à 0,56 nF pour obtenir environ 2,7 nF
Bouton A à 0,68 nF et bouton B à 3,3 nF pour obtenir environ 3,9 nF
Bouton A à 4,7 nF et bouton B à 3,3 nF pour obtenir environ 8,2 nF

Sur chaque bouton, une broche reste libre pour permettre la sélection d'un seul condensateur plutôt que deux condensateurs en parallèles.

Ainsi, toutes les valeurs conventionnelles sont couvertes de 0,22 nF à 1000 nF.

C'est facile à réaliser, et ça fonctionne très bien.  La principale imperfection de ma boîte, c'est que j'ai soudé les condensateurs aux interrupteurs rotatifs dans l'ordre inverse:  je dois tourner le bouton dans le sens antihoraire pour augmenter la capacité.  Je m'en suis aperçu alors que le projet était déjà presque terminé, et je n'avais pas envie de tout reprendre à partir de zéro...  Puisque j'en suis le seul utilisateur et que les valeurs de capacités sont clairement indiquées autour des boutons, ce n'est pas très grave.

Évidemment, on peut fabriquer de la même façon une boîte de résistances ou même une boîte de selfs (j'aurais alors tendance à les placer en série plutôt qu'en parallèle).

Pour cette réalisation, je me suis inspiré du projet décrit ici.

Yves Pelletier (Twitter: @ElectroAmateur)

Afficheur 7 segments, AS1108 et MSP430 Launchpad

J'ajoute ce court addendum à mon article précédent pour faire remarquer que, puisque le circuit intégré AS1108 tolère aussi bien des tension de 3,3 V que des tension de 5 V,  l'afficheur à 7 segments peut facilement fonctionner avec un MSP430 Launchpad.

Je ne répéterai pas les informations déjà mentionnées dans mon autre article concernant les connexions entre l'AS1108 et l'afficheur à 7 segments: elles demeurent évidemment identiques.  L'AS1108 doit être branché au MSP430 Launchpad (version G2553) de la façon suivante:

• Les pins 4 et 7 de l'AS1108 doivent toutes les deux être branchées au GND du Launchpad.
• La pin 16 (VDD) de l'AS1108 est branchée à la sortie VCC du Launchpad
• La pin 2  (Din) de l'AS1108 est reliée à la pin P1.7 du Launchpad.

• La pin 9 (Load/CSN) de l'AS1108 est reliée à la pin P2.0 du Launchpad.

• La pin 10 (CLK) de l'AS1108  est reliée à la pin P1.5 du Launchpad.

Grâce à Energia, on peut programmer le Launchpad au moyen du même sketch que je proposais pour l'Arduino. La seule modification nécessaire est le numéro de la pin "CS" qui passe de 10 à 8 (8 étant le numéro de la pin P2.0 dans Energia):

const int slaveSelect = 8;

C'est tout!

 (Pour l'instant, je n'ai pas le même succès avec le Stellaris Launchpad:  je vous en reparlerai quand ça fonctionnera...)

Yves Pelletier (Twitter: @ElectroAmateur)

Afficheur 7 segments, AS1108 et Arduino

Voici la marche à suivre pour afficher des nombres au moyen d'un afficheur à LED "7 segments" (comportant 4 chiffres), le circuit intégré "AS1108" et un Arduino.

L'AS1108 est un circuit intégré spécialement conçu pour contrôler des matrices de LEDs.   Il est très similaire au MAX7219 et au MAX7221.

La raison pour laquelle j'ai choisi l'AS1108 plutôt qu'autre chose, c'est qu'il s'agit du seul circuit intégré de ce genre qu'ils offraient chez Tayda, mon fournisseur thaïlandais préféré.  C'est également chez Tayda que je me suis procuré l'afficheur, qui doit obligatoirement être à cathode commune.  Dans mon cas, il s'agit du LTC-4727JF fabfriqué par la compagnie Lite-On.

Lorsque j'ai voulu utiliser le matériel pour la première fois, j'ai été déçu (et même un peu découragé) du peu d'informations spécifiques à l'utilisation de l'AS1108 avec un Arduino...jusqu'à ce que je m'aperçoive que, d'un point de vu logiciel, il ne semble y avoir aucune différence entre le pilotage d'un MAX7221 et celui d'un AS1108:  si vous disposez d'un sketch conçu pour le MAX7221, il fonctionnera parfaitement avec un AS1108.

Les différentes entrées et sorties de l'AS1108, toutefois, ne sont pas disposées de la même façon que celles d'un MAX7721.

• La pin 1 (Dout) ne sert que si vous désirez relier plusieurs AS1108 en série (par exemple, pour piloter un afficheur à 8 chiffres).

• La pin 2 (Din) est l'entrée des messages numériques provenant de l'Arduino (on peut aussi l'appeler MOSI, pour Master Out Slave In):  vous la branchez à la sortie 11 de l'Arduino.

• La pin 9 (Load/CSN) est le "chip select".   Je l'ai branchée dans la sortie 10 de l'Arduino.

• La pin 10 (CLK) est branchée dans la sortie 13 de l'Arduino, de façon à recevoir le signal d'horloge.

• Les pins 4 et 7 doivent toutes les deux être branchées au GND de l'Arduino.

• La pin 16 (VDD) doit être branchée à la sortie 5 volts de l'Arduino (ça devrait fonctionner à 3,3 V aussi).

• La pin 15 (Iset) permet de régler l'intensité du courant qui traversera les LEDs de l'afficheur grâce à une résistance placée entre les pins 15 et 16 (33 kΩ devraient faire l'affaire).  Moi j'ai mis un potentiomètre qui me permet de varier l'intensité lumineuse (même s'il est également possible de régler l'intensité lumineuse par logiciel).

• Deux condensateurs (10 µF et 0,1 µF) sont conseillés entre VDD et GND afin d'assurer une alimentation sans perturbations.

• Les pins 3, 8, 5 et 6 contrôlent les 4 chiffres de l'afficheur.

• Les pins 11, 12, 13, 14, 17, 18, 19 et 20 contrôlent les 7 segments de chaque chiffre (le point décimal est le 8ième segment).

Il reste à déterminer la fonction de chaque pin de l'afficheur.  Je présente ci-contre la disposition des pins du LTC-4727JF, je ne sais pas s'il s'agit d'un standard ou non.  Chaque pin de l'afficheur doit être branchée à la pin équivalente du AS1108.

La pin 4 contrôle les deux points au milieu de l'afficheur, qui seraient utiles pour fabriquer une horloge (je ne l'ai pas utilisée).

Et finalement, le codage de l'Arduino.  Comme je le mentionnais plus haut, l'AS1108 se programme exactement de la même façon que le MAX7221.

Il faut donc initialiser l'unité en réglant les différents registres à des valeurs appropriées (voir la datasheet de l'AS1108 pour plus de détails):

SPI.transfer(0x0C);

SPI.transfer(0x01);    // réglage en mode normal

SPI.transfer(0x0F);

SPI.transfer(0x00);    // Display test off

SPI.transfer(0x0A);

SPI.transfer(0x08);     // Réglage de l'intensité lumineuse (valeur moyenne)

SPI.transfer(0x0B);

SPI.transfer(0x03);      // Utilisation des 4 chiffres de l'afficheur

SPI.transfer(0x09);

SPI.transfer(0xFF);     // type de décodage

Pour écrire le nombre "1428":

SPI.transfer(0x00);  // Chiffre 0...

SPI.transfer(0x08);  // ...réglé à la valeur 8

SPI.transfer(0x01);  // Chiffre 1...

SPI.transfer(0x02);  // ...réglé à la valeur 2

SPI.transfer(0x02);  // Chiffre 2...

SPI.transfer(0x04);  // ...réglé à la valeur 4

SPI.transfer(0x03);  // Chiffre 3...

SPI.transfer(0x01);  // ...réglé à la valeur 1

Voici un sketch affichant séquentiellement les nombres 0 à 9999 sur l'afficheur.  Je me suis inspiré d'un sketch trouvé dans le livre "Arduino Cookbook" par Michael Margolis (conçu pour le MAX7221),

	/***************************************************************
	* Contrôle d'un afficheur 7 segments à 4 chiffres
	* Avec un AS1108
	* Basé sur un code pris dans le livre Arduino Cookbook.
	* https://electroniqueamateur.blogspot.com/2013/01/afficheur-7-segments-as1108-et-arduino.html
	****************************************************************/
	#include <SPI.h> // Nous utiliserons la librairie SPI
	const int slaveSelect = 10; //la pin "Chip Select" de l'AS1108
	// branchée à la pin 10 de l'Arduino
	const int numberOfDigits = 4; // nombre de chiffres de l'afficheur
	int number = 0; // valeur initiale du compteur
	void setup()
	{
	SPI.begin(); // initialisation de SPI
	pinMode(slaveSelect, OUTPUT);
	digitalWrite(slaveSelect,LOW); //select slave
	// préparation du AS1108
	sendCommand(0x0C, 0x01); // mode normal
	sendCommand(0x0F, 0x00); // Display test off
	sendCommand(0x0A, 0x08); // intensité lumineuse moyenne
	sendCommand(0x0B, numberOfDigits-1); // nombre de chiffres (0 à 3)
	sendCommand(0x09, 0xFF); // type de codage
	digitalWrite(slaveSelect,HIGH); //périphérique désactivé pour l'instant
	}
	void loop()
	{
	// on compte de 0 à 9999
	while (number <= 9999)
	{
	displayNumber(number);
	delay(500);
	if (number == 9999)
	{
	number = 0;
	}
	else
	{
	number = number + 1;
	}
	}
	}
	// Affichage du nombre
	void displayNumber( int number)
	{
	for(int i = 0; i < numberOfDigits; i++)
	{
	byte character = number % 10; // chiffre le plus à droite
	if(number == 0 && i > 0)
	character = 0xf; // on n'affiche rien, pluôt qu'un zéro inutile
	//envoi de la commande à l'AS1108
	sendCommand(numberOfDigits-i, character);
	number = number / 10;
	}
	}
	// envoi des commandes à l'AS1108
	void sendCommand( int command, int value)
	{
	digitalWrite(slaveSelect,LOW); //on active le périphérique SPI
	SPI.transfer(command); // adresse
	SPI.transfer(value); // commande
	digitalWrite(slaveSelect,HIGH); //on désactive le périphérique SPI
	}

view raw Afficheur_7_segments.ino hosted with ❤ by GitHub

Yves Pelletier (Twitter: @ElectroAmateur)

Allumer une LED avec une vieille pile épuisée (Joule Thief)

Comme toutes les diodes, les LEDs ne laissent circuler aucun courant si la différence de potentiel entre leurs deux électrodes est inférieure à une certaine valeur.  Cette tension est d'environ 0,7 volt pour une diode au silicium, mais il est beaucoup plus élevé pour une LED:  2 volts pour une LED rouge,  3 volts pour une LED bleue...

Pour cette raison, il est impossible d'allumer une LED en la branchant directement aux bornes d'une pile AA de 1,5 V:  il faut mettre 2 ou 3 piles en série pour accomplir quelque chose d'aussi simple qu'allumer une petite lumière colorée!


La solution, pour alimenter une LED au moyen d'une seule pile, consiste à construire un circuit oscillateur qui transforme la faible tension constante fourni par la pile en une tension variable qui atteint périodiquement, pour une courte durée, une valeur supérieure à la tension continue.

Par curiosité, j'ai construit le célèbre "joule thief", un circuit qui permet d'allumer une LED au moyen d'une seule pile AA.  Mieux encore:  nul besoin d'une pile neuve fournissant une tension de 1,5 V:  la LED s'allumera sans problème (et pour plusieurs heures) si on l'alimente avec une vieille pile qui était destinée au recyclage, sa tension étant devenue insuffisante pour alimenter quoi que ce soit d'autre.

Le circuit est facile à réaliser, et les composants nécessaires sont peu nombreux:  une petite bobine toroïdale avec un noyau en ferrite (constituée de deux enroulements d'une dizaine de tours chacun), un transistor NPN (j'ai utilisé un ), une résistance de 1 kΩ, une LED de la couleur de votre choix, et une vieille pile AA.

Si vous avez l'habitude de récupérer des composants dans des appareils qui ne fonctionnent plus, votre "junk box" contient peut être déjà quelques tores de ferrites (un petit morceau métallique en forme de beignet).  J'ai trouvé dans la mienne une bobine toroïdale toute faite qui faisait parfaitement l'affaire.  Si vous devez la bobiner vous-mêmes, vous pouvez vous baser sur les instructions disponibles ici.

Résultat:  la LED s'allume avec comme seule alimentation une pile AA affichant 0,95 V en circuit ouvert et 0,70 V en circuit.  La photo ci-dessous montre la tension aux bornes de la LED bleue alors que l'oscilloscope est réglé à 1 V/div et 10 µs/div: la tension atteint un maximum d'environ 3 volts et la fréquence de 33 kHz est beaucoup trop rapide pour que le clignotement de la LED soit perceptible.

Pour une explication du principe de fonctionnement, vous pouvez lire cette discussion sur le forum Futura Sciences.

Yves Pelletier (Twitter: @ElectroAmateur)