Diode électroluminescente

Necessary knowledge: [HW] Controller module, [HW] User Interface Module, [ELC] LED Resistor Calculation, [AVR] Registers, [AVR] Digital Inputs/Outputs, [LIB] Pins

Connaissances nécessaires: [HW] controller, [HW] digi, [ELC] Calcul d'une LED, [AVR] Registres, [AVR] Entrées/sorties numériques, [LIB] Broches

LED avec pattes de 5 mm

La diode électroluminescente est un semi-conducteur qui émet de la lumière lorsqu’on lui applique une tension. L’acronyme pour diode électroluminescente est DEL (LED en Anglais). Il existe différentes combinaisons de couleurs de diodes et les diodes peuvent émettre une lumière blanche. Tout comme une diode classique, la LED a deux contacts – une anode et une cathode. Schématiquement, l’anode est marquée d’un “+” et la cathode d’un “-“.

Symbole schématique de la LED et de sa polarité

Lorsqu’on applique une tension, l’anode de la LED est connectée à la tension positive tandis que la cathode est connectée à la tension négative. La tension de la LED dépend de sa couleur : longueur d’onde la plus longue (rouge) ~ 2V, longueur d’onde la plus courte (bleu) ~ 3V. En général, l’énergie d’une LED n’excède pas la dizaine de milliWatts, cela signifie que le courant électrique doit être dans la même gamme. Lorsqu’on applique une tension ou un courant trop important, la LED peut griller.

Si la LED est utilisée spécifiquement pour l’éclairage, il est conseillé d’utiliser des circuits électroniques spécifiques qui régulent le courant ainsi que la tension qui conviennent aux LEDs. Néanmoins les LEDs sont le plus souvent utilisées comme des voyants et elles sont directement alimentées par les broches du micro-contrôleur. La tension d’alimentation (et donc le courant) pour les micro-contrôleurs est habituellement plus importante que la tension (et donc le courant) nécessaire à la LED, il est donc nécessaire de connecter des résistances en série aux LEDs, résistances qui réduisent le courant et créent la baisse de tension nécessaire. Les instructions permettant de calculer la résistance correcte sont dans le chapitre Electronique.

Il existe une grande variété de LEDs. Les LEDs à pattes les plus communes ont un corps de 3mm ou 5mm de diamètre ainsi que deux longues broches de connexion en métal. La broche la plus longue est celle de l’anode, la plus courte celle de la cathode. Les LED destinées aux circuits fabriqués par la technique SMD (Surface Mounted Device) porte le symbole en forme de T sur la partie inférieure afin d’indiquer la polarité, où la partie supérieure du T marque la position de l’anode.

Polarité des pattes et LEDs pour SMD

Le module de contrôle du HomeLab contient une seule LED rouge, dont l’anode est connectée via une résistance à l’alimentation de puissance à +5V et la cathode est connectée à la broche numéro PB7 de l'ATmega128. Afin d’allumer et d’éteindre cette LED, PB7 doit être définie comme une sortie et doit être respectivement configurée au niveau haut et bas. Cela signifie que si la broche est définie au niveau haut, la LED s’éteint et si elle est définie au niveau bas la LED s’allume. Fondamentalement il serait possible de connecter la LED de manière à ce que l’anode soit reliée à la broche du micro-contrôleur et la cathode soit reliée à la terre (qui joue le même rôle qu’une résistance) – dans ce cas lorsque la broche est définie au niveau haut, la LED s’allume et vice et versa.

Tous les exercices pour le HomeLab, y compris l’utilisation de la LED, reposent sur la bibliothèque des broches du HomeLab. Cette bibliothèque contient les types de données des broches, dont les adresses des registres liées aux broches ainsi que le masque de bits des broches. Si pour créer une variable de type broche dans le programme et ensuite l’initialiser en utilisant la fonction macro PIN, la broche peut être utilisée librement avec cette variable (pin) dans tout le programme sans qu’il soit nécessaire d’utiliser les registres. Ci-dessous deux exemples de programme réalisent exactement la même chose, sauf que l’un est créé sur la base de la bibliothèque HomeLab, alors que l’autre ne l’est pas.

//
// Homelab controller module LED test program.
// The code is base on homelab library.
//
#include <homelab/pin.h>
 
//
// LED pin configuration.
//
pin debug_led = PIN(B, 7);
 
//
// Main program
//
int main(void)
{
	// Configuring LED pin as an output
	pin_setup_output(debug_led);
 
	// Lighting up LED
	pin_clear(debug_led);	
}

//
// Homelab controller module LED test program.
// The code directly accesses registers.
//
#include <avr/io.h>
 
//
// Main program
//
int main(void)
{	
	// Configuring LED pin as an output
	DDRB |= (1 << 7);	
 
	// Lighting up LED
	PORTB &= ~(1 << 7);
}

Le premier exemple utilise la bibliothèque concernant les broches (fichier pin.h). Tout d’abord une variable de type broche nommée debug_led est définie dans le programme, elle contient les informations à propos de la broche ,LED. Dans le programme principal cette broche est configurée en tant que sortie en utilisant la fonction pin_setup_output. Ensuite la broche est configurée en position basse grâce à la fonction pin_clear. Ceci à pour effet que la LED rougeoie. Dans le second exemple les variables ne sont pas utilisées, la configuration de la sortie LED et l’allumage est réalisée en changeant les valeurs de direction des données du port B et des registres de sortie. Pour le lecteur qui en connaît un peu plus sur les notices AVR, tel que dans les exercices précédents, il n’est pas nécessaire de donner la commande afin d’allumer la LED, puisque la valeur de sortie par défaut de l'AVR est 0, ceci dit toutes les étapes sont respectées.

Quelle est la différence entre utiliser la bibliothèque et les registres ? La différence est le confort – la bibliothèque est plus facile, parce qu’il n’est pas nécessaire de connaître le nom des registres et leurs effets par cœur. Le bénéfice le plus important de la bibliothèque est l’adaptabilité. En utilisant les registres, il est nécessaire de changer les noms des registres et les masques de bit tout au long du programme afin de changer de broche. En utilisant la bibliothèque, cela peut être fait uniquement au début du programme où la variable de broche est initialisée. L’utilisation des registres n’a pas d’avantage significatif – l’utilisation des broches est directe et n’est pas réalisée à l'aide de la mémoire du programme et de fonctions nécessitant du temps. Cependant, les nouvelles versions des compilateurs AVR-GCC sont tellement évoluées qu’ils transforment les fonctions de la bibliothèque en commandes directes identiques à celles utilisées en manipulant les registres comme si cela était fait directement dans le programme. Il est nécessaire de préciser que les compilateurs peuvent optimiser le code uniquement quand ils traitent de variables simples constantes, et non pas de variables qui évoluent pendant le travail ou de listes.

Le code suivant est une bibliothèque pour le fonctionnement partielle de broche. Son objectif est d'expliquer les procédures pour les variables de broche. Il est d'un abord difficile pour les débutants car il utilise des pointeurs en langage C qui ne sont pas traités ici. Cependant, de l'information sur les pointeurs peut être facilement trouvées dans des livres ou sur Internet.

// Macro constant for defining register pointer
#define _REG_PTR_ volatile uint8_t *
 
//
// Pin data type
//
typedef struct pin
{
	_REG_PTR_ ddr;
	_REG_PTR_ port;
	_REG_PTR_ pin;
	uint8_t mask;
}
pin;
 
//
// Macro function for pin variable initializing
//
#define PIN(port_char, bit_index) \
{ \
	(_REG_PTR_)&DDR ## port_char, \
	(_REG_PTR_)&PORT ## port_char, \
	(_REG_PTR_)&PIN ## port_char, \
	bit_mask(bit_index) \
}
 
//
// Configuring pin as output
//
inline void pin_setup_output(pin pin)
{
	bitmask_set(*pin.ddr, pin.mask);
}
 
//
// Setting pin high
//
inline void pin_set(pin pin)
{
	bitmask_set(*pin.port, pin.mask);
}
 
//
// Setting pin low
//
inline void pin_clear(pin pin)
{
	bitmask_clear(*pin.port, pin.mask);
}

En plus du module de contrôle, les LEDs sont aussi situées sur la carte entrée-sortie numérique. Elles sont connectées électriquement de la même manière que les LEDs du module de contrôle. Cela signifie que la cathode est reliée à la broche AVR. La LED rouge est connectée à la broche numéro PC5, la jaune en PC4 et la verte en PC3. L'exemple de programme basé sur la bibliothèque HomeLab ressemble à celui-ci :

//
// Homelab digital module LED's test program.
//
#include <homelab/pin.h>
 
//
// LED's pin configuration.
//
pin led_red    = PIN(C, 5);
pin led_yellow = PIN(C, 4);
pin led_green  = PIN(C, 3);
 
//
// Main program
//
int main(void)
{
	// Configuring LED pins as an output
	pin_setup_output(led_red);
	pin_setup_output(led_yellow);
	pin_setup_output(led_green);	
 
	// Lighting up green LED
	pin_clear(led_green);	
 
	// Turn off red and yellow LED
	pin_set(led_red);
	pin_set(led_yellow);
}