Allumer un chenillard à LED

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, LED RGB

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 (+). 

LED rouge

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. 

 

Résistance

Pour connaitre la valeur de la résistance, on utilise un code couleur.

 code couleur de la résistance

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

schéma de câblage pour allumer le LED

Diagramme de câblage pour allumer une LED.

Voici le diagramme de câblage pour allumer une LED

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 

 

 

 résultat de test pour allumer une LED

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%.  

PWM pour allumer une LED RGB

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. 

Diagramme de cablage pour allumer une 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 initiation électronique

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. 

  • Une carte de contrôle Arduino : cette carte permet de programmer les taches à réaliser et permet de piloter les actionneurs. 
  • Une table électronique : cette table permet de connecter les composants passif comme résistance, capacité avec la carte Arduino pour que ca fonctionne. 
  • un câble USB pour télécharger les logiciels qui sont sur le PC. 
  • fils, câble et faisceau pour connecter les cartes. 

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

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

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

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

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

  • Il y a un registre qui a des entrées en série et une horloge.
  • On peut tout arrêter avec un reset. 
  • On peut conserver son horloge. 
  • On utilise une sortie que l'on est capable d'activer. 
  • Ensuite, on configure les 7 pins en entrées pour chaque segment. QA..QG

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