Allumer un chenillard à LED
Présentation du chenillard à LED.
Schéma de câblage
diagramme de câblage pour allumer un chenillard à LED.
Programme de câblage
Allumer une LED
Tout d'abord, pour bien comprendre le fonctionnement d'un module Arduino, on réalise 2 étapes :
On allume la LED interne du module UNO Arduino pour faire fonctionner un programme Arduino et ensuite on allume un LED en externe pour s'assurer que les interfaces fonctionnent correctement.
Cet exemple est concret et permet de démarrer le module Arduino.
Pour ceci, on branche le câble USB et ensuite on lance le programme pour allumer la LED "blink".
Programme pour allumer la LED blink
int led=13;
Permet d'affecter la LED à une valeur numérique 13.
on définit le set up
void setup() {
pinModel (led, OUTPTU);
}
Ensuite on crée une boucle (loop).
void loop(){
digitalWrite(led, HIGH);
delay(1000);
digitalWrite(led, LOW);
delay(1000);
]
voilà, après avoir téléchargé le programme, la LED "Blink" s'allume et clignote.
Une LED
Une LED est composé d'une anode (-) et d'une cathode (+).
Pour allumer une LED, il faut limiter le courant, c'est pour cela que l'on utilise une résistance.
Résistance
Voici une résistance.
Pour connaitre la valeur de la résistance, on utilise un code couleur.
Pour ma part, j'utilise une phrase mémo technique pour se rappeler des codes couleurs.
"Ne manger rien ou jeuner, voila bien votre grande bétise". c'est une phrase que l'on peut se rappeler rapidement.
Vous prenez les premières lettres et vous avez les codes couleurs.
Noir Marron Rouge Orange Jaune Vert Bleu Violet Gris Blanc
Pour les 2 V, d'abord le vert et ensuite le violet
Pour les 2 B, d'abord le bleu et après le blanc.
On encadre le code avec 0 pour noir et 9 pour le blanc.
Ensuite les anneaux, c'est 3 premiers chiffres pour la valeur, ensuite le 4ème pour les puissance (rouge =10²), le dernier pour la tolérance.(5% or).
Pour réussir à allumer, on réalise un schéma avec une LED et une résistance.
Schéma de câblage pour allumer une LED.
Voici le schéma de câblage
Diagramme de câblage pour allumer une LED.
Voici le diagramme de câblage pour allumer une LED
Après avoir câbler correctement, il faut créer un programme.
Programme pour allumer la LED.
Pour le programme, vous réutiliser le programme pour allumer une LED et vous l'adaptez pour votre configuration.
Ainsi, on réalise le programme suivant.
Résultat de test pour allumer une LED.
Après avoir lancé le programme, vous pourrez allumer la LED.
cet exercice parait simple mais cet exercice est très important car il valide la structure avec la carte UNO d'arduino avec ses interfaces, le téléchargement et la validation du programme et c'est essentiel pour la suite, car après, on peut
Avec une résistance plus faible, on a une luminosité plus puissante.
Allumer une LED tricolore RGB
Ensuite vous pourrez allumer une LED tricolore RGB.
une LED tricolore RGB est composé de 3 leds Rouge, bleu et verte. ces 3 couleurs vont permettre de pouvoir réaliser toutes les couleurs de l'arc en ciel.
Présentation de la LED RGB
Pour allumer une LED RGB, on utilise un PWM pour allumer cette LED.
Un PWM possède une fréquence F et un rapport cyclique RC.
Pour commander les différents couleurs, on utilise un rapport cyclique différent. au minimum, on prend un RC de 5%, ensuite en nominal, on peut prendre un RC de 50% et en maximum, on peut prendre un RC de 90%.
Pour réussir toutes les couleurs, on utilise une variation du PWM pour réaliser l'allumage de la LED RGB progressive.
Diagramme de câblage de la LED RGB.
Programme de la LED RGB.
Après avoir câblé la LED suivant le diagramme de câblage, on réalise le programme pour allumer la LED.
// Define Pins
#define BLUE 3
#define GREEN 5
#define RED 6
void setup()
{
pinMode(RED, OUTPUT);
pinMode(GREEN, OUTPUT);
pinMode(BLUE, OUTPUT);
digitalWrite(RED, HIGH);
digitalWrite(GREEN, LOW);
digitalWrite(BLUE, LOW);
}
// define variables
int redValue;
int greenValue;
int blueValue;
// main loop
void loop()
{
#define delayTime 10 // fading time between colors
redValue = 255; // choose a value between 1 and 255 to change the color.
greenValue = 0;
blueValue = 0;
// this is unnecessary as we've either turned on RED in SETUP
// or in the previous loop ... regardless, this turns RED off
// analogWrite(RED, 0);
// delay(1000);
for(int i = 0; i < 255; i += 1) // fades out red bring green full when i=255
{
redValue -= 1;
greenValue += 1;
// The following was reversed, counting in the wrong directions
// analogWrite(RED, 255 - redValue);
// analogWrite(GREEN, 255 - greenValue);
analogWrite(RED, redValue);
analogWrite(GREEN, greenValue);
delay(delayTime);
}
redValue = 0;
greenValue = 255;
blueValue = 0;
for(int i = 0; i < 255; i += 1) // fades out green bring blue full when i=255
{
greenValue -= 1;
blueValue += 1;
// The following was reversed, counting in the wrong directions
// analogWrite(GREEN, 255 - greenValue);
// analogWrite(BLUE, 255 - blueValue);
analogWrite(GREEN, greenValue);
analogWrite(BLUE, blueValue);
delay(delayTime);
}
redValue = 0;
greenValue = 0;
blueValue = 255;
for(int i = 0; i < 255; i += 1) // fades out blue bring red full when i=255
{
// The following code has been rearranged to match the other two similar sections
blueValue -= 1;
redValue += 1;
// The following was reversed, counting in the wrong directions
// analogWrite(BLUE, 255 - blueValue);
// analogWrite(RED, 255 - redValue);
analogWrite(BLUE, blueValue);
analogWrite(RED, redValue);
delay(delayTime);
}
}
explication du programme :
on définit les pins pour le bleu (pin 3), le vert (pin 5) et le rouge (pin 6) car il y a 3 diode.
// Define Pins
#define BLUE 3
#define GREEN 5
#define RED 6
on définit le set up pour les 3 diodes en définissant le pin mode et comment écrire sur cette diode. Les 3 pin mode sont en sorties..
L'écriture des pin sont configurés en mode Low(bas) pour la verte et la bleu et haut pour la rouge.
void setup()
{
pinMode(RED, OUTPUT);
pinMode(GREEN, OUTPUT);
pinMode(BLUE, OUTPUT);
digitalWrite(RED, HIGH);
digitalWrite(GREEN, LOW);
digitalWrite(BLUE, LOW);
}
Ensuite on crée une boucle (LOOP).
On définit les valeurs pour le temps entre les couleurs et les valeurs pour le rouge et les valeurs pour le vert et le bleu.
#define delayTime 10 // fading time between colors
redValue = 255; // choose a value between 1 and 255 to change the color.
greenValue = 0;
blueValue = 0;
on crée une boucle pour afficher la couleur rouge.
on incrémente pour la couleur rouge et on décrémente pour la valeur bleue.
Ensuite on écrit pour la couleur bleu en décrémentant de 255 à 0 pour faire varier la couleur et on décrémente de 255 à 0 pour la valeur bleu et après on temporise de 10.
for(int i = 0; i < 255; i += 1)
{
blueValue -= 1;
redValue += 1;
analogWrite(BLUE, blueValue);
analogWrite(RED, redValue);
delay(delayTime);
}
Ensuite, on fait de même pour le rouge, vert et le vert bleu. le sens n'a pas d'importance.
Résultat de test de la LED RGB.
On lance le programme et la LED RGB s'allume et passe par toutes les couleurs de l'arc en ciel.
On fait varier la luminosité avec une LED RGB.
Kit Arduino
Voici le Kit Arduino pour débuter au niveau des fonctions électroniques. le Kit Arduino permet de pouvoir réaliser des électroniques rapidement et ainsi de pouvoir s'initier à l'électronique numérique.
Ce kit est composé des outils nécessaires pour faire des électroniques performantes.
Ensuite, il y a tous les actionneurs ou capteur qui permettront de réaliser les fonctions électroniques.
Voici toutes les fonctions que vous pouvez réaliser avec ce kit
 |
 |
 |
| Affichage 64 segment | alimentation | Bouton poussoir |
 |
 |
 |
| cellule photo | chenille de LED | Commande Moteur |
 |
 |
 |
| ecran LCD | infra-rouge | Module active buzzer |
 |
 |
 |
| Module Affichage Digital 7 segments | Module Affichage Digital 4x7 | Module Capteur de son |
 |
 |
 |
| Module capteur ultra son | Module detection de mouvement | Commande Moteur |
 |
 |
 |
| Module inertie | Module infra rouge | Module joystick |
 |
 |
 |
| Module LED | Module mouvement inclinaison | Module niveau d'eau |
 |
 |
 |
| Module passive buzzer | Module pavé numérique | Module RFID |
 |
 |
 |
| Module rotationel | Module télécommande | Module température et humidité |
 |
 |
 |
| Moniteur série | Moteur avec ventilateur | Moteur pas à pas |
 |
|
 |
| Obstacle | photo cellule | Potentiomètre |
 |
 |
 |
| Relais | téléchargement | Thermomètre |
Afficheur 4 cadrans avec 7 segments.
Pour bien comprendre, il faut d'abord regarder l'afficheur 7 segments.
1) Présentation afficheur 4 cadrans avec 7 segments.
voici l'afficheur 4 cadrans avec 7 segments.
Afficheur 4 digit avec 7 segments
Pour afficher les 4 digits avec 7 segments, il faut connecter cet afficheur. Par contre, il faut utiliser une anode commune à l'alimentation et la cathode commune à la masse pour cet afficheur pour que ça fonctionne.
On utilise le même principe pour un afficheur sauf que l'on multiplie par 4 ces actions pour avoir un afficheur à 4 digit.
Package et circuit de l'afficheur 4 cadrans.
Pour réussir cet affichage, il faut faire le schéma de câblage de cet afficheur.
Schéma de câblage de l'afficheur à 4 cadrans.
Au niveau matériel électronique(hardware) , on utilise un micro arduino pour réaliser le programme et définir les entrées et sorties, ensuite on utilise un circuit intégré 74HC595 qui permet de pouvoir afficher les 7 segments, ensuite pour s'interfacer avec l'afficheur, on prend des résistances de 220ohm.
Pour la justification des résistances 220 ohm (voir afficheur 7 segments).
Pour le circuit intégré, on utilise le même circuit pour un afficheur 7 segments sauf que l'on utilise différemment (voir diagramme ci dessus). le principe est simple, on crée une table de vérité ou on configure chaque pin pour chaque chiffre de 0 à 9999. Pour l'instant, on va aller jusqu'à 12, et ensuite, pour afficher jusqu'à 9999, il faudra créer des boucles pour répéter les actions en incrémentant certaines variables. (voir programme ci dessous)
Diagramme de câblage
Voici le diagramme de câblage pour cet afficheur.
Programme pour faire afficher les 4 cadrans.
il faut réaliser un programme pour faire afficher à 4 cadrans (digit).
int latch=9; //74HC595 pin 9 STCP
int clock=10; //74HC595 pin 10 SHCP
int data=8; //74HC595 pin 8 DS
unsigned char table[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c, ,0x39,0x5e,0x79,0x71,0x00};
void setup() {
pinMode(latch,OUTPUT);
pinMode(clock,OUTPUT);
pinMode(data,OUTPUT);
}
void Display(unsigned char num)
{
digitalWrite(latch,LOW);
shiftOut(data,clock,MSBFIRST,table[num]);
digitalWrite(latch,HIGH);
}
void loop() {
Display(1);
delay(500);
Display(2);
delay(500);
Display(3);
delay(500);
Display(4);
delay(500);
Display(5);
delay(500);
Display(6);
delay(500);
Display(7);
delay(500);
Display(8);
delay(500);
Display(9);
delay(500);
Display(10);
delay(500);
Display(11);
delay(500);
Display(12);
delay(500);
Display(13);
delay(500);
Display(14);
delay(500);
Display(15);
delay(500);
}
Le programme est constitué en plusieurs parties : on définit les entrées 9 pour le latch, 10 pour l'horloge et 8 pour les données,
int latch=9; //74HC595 pin 9 STCP
int clock=10; //74HC595 pin 10 SHCP
int data=8; //74HC595 pin 8 DS
après on créé une table pour afficher les segments
unsigned char table[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c, ,0x39,0x5e,0x79,0x71,0x00};
Par exemple : 0X3F pour 1, 0X006 pour 2 ... et ainsi de suite. pour chaque chiffre, il faut configurer les segments.
Ensuite, on met en place un setup pour le latch, l'horloge et les donnée.
void setup() {
pinMode(latch,OUTPUT);
pinMode(clock,OUTPUT);
pinMode(data,OUTPUT);
}
void Display(unsigned char num)
{
Après on crée une fonction affichage (display) avec une variable interne num qui sera utilisé pour le tableau.
void Display(unsigned char num)
{
digitalWrite(latch,LOW);
shiftOut(data,clock,MSBFIRST,table[num]);
digitalWrite(latch,HIGH);
}
Ensuite, on crée une boucle (LOOP) en affichant les chiffres de 0 à 15 en utilisant la fonction
void loop() {
Display(1);
delay(500);
....
Display(15);
delay(500);
}
voilà, on a fini le programme pour afficher le cadran de 0 à 15.
Résultat de test pour l'afficheur 4 cadrans.
On alimente avec le câble USB branché au PC, on charge le programme et on peut voir l'afficheur s'allumer et afficher les chiffres de 0 à 15.
Pour l'instant, c'est le début, on commence avec des applications assez simple et après on complexifiera.
Afficheur 7 segments
1) Présentation de l'afficheur 7 segments :
Au départ, pour afficher les chiffres, on utilisait 7 segments et ainsi on pouvait afficher les chiffres de 0 à 9.
je vous propose de vous expliquer comment on réussit à afficher les chiffres de 0 à 9.
Voici l'affichage 7 segments.
Affichage 7 segments
Un affichage 7 segments est composé de 7 segments A, B, C, D ,E, F , G.
Affichage des 7 segments
Ensuite pour afficher les 7 segments, on utilise une table de vérité.
Tableau pour l'affichage des 7 segments
Pour chaque chiffre, on définit une règle que l'on affecte à chaque segment et ainsi on fait un programme pour afficher chaque segment.
2) Schéma de l'affichage 7 segments
Au niveau hardware, on définit le schéma électrique suivant :
schéma de câblage affichage 7 segments
Ensuite on présente le diagramme de câblage pour cet afficheur 7 segments
Diagramme de câblage 7 segments
Pour réussir ce diagramme, on met des résistances et un circuit intégré 74HC595.
74HC595
Pour bien comprendre ce composant, on utilise la datsheet du composant.
https://www.onsemi.com/pub/Collateral/MC74HC595-D.PDF
Voici le boitier du composant
Boitier du composant
Le boitier possède des pins avec des critères pour chaque pin. 
Affectation des pins
il y a une alimentation, une masse, des signaux d'horloge, un reset et 7 pin pour chaque segment.
Voici la logique de diagramme
Diagramme de logique du HC74595
On utilise des résistance pour limiter les courants. On prendra des résistances de 220ohm.
Calcul du courant V=R.I Donc I=V/R=12/220=22mA ce qui est suffisant.
P=V²/R=113mW ce qui suffit pour des résistances à piquer car une résistance à piquer peut avoir une puissance de 1/4W soit 250mw, ce qui fait un taux de charge d'environ 50%.
On peut utiliser donc les résistances de 220ohm.
Après avoir câblé l'électronique, il faut programmer le logiciel.
1) partie contrôle avec logiciel.
Au final, voici le programme que l'on utilise pour réaliser cet affichage
// define the LED digit patterns, from 0 - 9
// 1 = LED on, 0 = LED off, in this order:
// 74HC595 pin Q0,Q1,Q2,Q3,Q4,Q5,Q6,Q7
// Mapping to a,b,c,d,e,f,g of Seven-Segment LED
byte seven_seg_digits[10] = { B11111100, // = 0
B01100000, // = 1
B11011010, // = 2
B11110010, // = 3
B01100110, // = 4
B10110110, // = 5
B10111110, // = 6
B11100000, // = 7
B11111110, // = 8
B11100110 // = 9
};
// connect to the ST_CP of 74HC595 (pin 3,latch pin)
int latchPin = 3;
// connect to the SH_CP of 74HC595 (pin 4, clock pin)
int clockPin = 4;
// connect to the DS of 74HC595 (pin 2)
int dataPin = 2;
void setup() {
// Set latchPin, clockPin, dataPin as output
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
}
// display a number on the digital segment display
void sevenSegWrite(byte digit) {
// set the latchPin to low potential, before sending data
digitalWrite(latchPin, LOW);
// the original data (bit pattern)
shiftOut(dataPin, clockPin, LSBFIRST, seven_seg_digits[digit]);
// set the latchPin to high potential, after sending data
digitalWrite(latchPin, HIGH);
}
void loop() {
// count from 9 to 0
for (byte digit = 10; digit > 0; --digit) {
delay(1000);
sevenSegWrite(digit - 1);
}
// suspend 4 seconds
delay(3000);
}
Pour ce programme, on définit au départ, les entrées, ensuite les variables, après, on affiche les 7 segments, après on lance une boucle (loop) pour afficher tous les segments.
Pour écrire un tel programme, il faut être habitué à utiliser les codes liés au code source arduino, mais c'est un programme assez simple à comprendre.
Quand vous avez créé le programme, vous pouvez le lancer et vous pourrez afficher les 7 segments.
3) résultat :
Le résultat est que l'on peut afficher les chiffres de 0 à 9.
Résultat de test pour affichage 7 segments Arduino.
C'est un bon début et ceci vous permet de bien comprendre l'affichage 7 segment et de lancer un premier programme en Arduino.
Sujet suivant : Affichage 4 digit avec 7 segments