Light-emitting Diode (LED)

Notwendiges Wissen: [HW] Controllermodul, [HW] Digitales Input-Output Modul, [ELC] Berechnung des LED-Widerstands, [AVR] Register, [AVR] Digitale Inputs/Outputs, [LIB] Pins

5 mm legged LED

Leuchtdioden sind Halbleiter die Licht abstrahlen, wenn Strom in Durchlassrichtung durch die Diode fließt. Die Abkürzung LED steht für “light-emitting diode”. Es gibt verschiedenfarbige Leuchtdioden, mittlerweile ist sogar weißes Licht möglich. Wie jede normale Diode auch hat die LED 2 Kontakte - Anode und Kathode. In Zeichnungen ist die Anode mit einem “+” markiert und die Kathode mit einem “-”.

Schematic symbol of LED and it's polarity

Wenn Strom in Durchlassrichtung durch die LED fließt, ist die Anode mit der positiven Spannung und die Kathode mit der negativen Spannung verbunden. Die Spannung der LED hängt von der Farbe der LED ab: lange Wellenlängen (rot) ~2V, kürzere Wellenlängen (blau) ~3V. Die Stromverbrauch einer LED ist in der Regel nicht mehr als ein paar Dutzend mW. Die Stromstärke darf daher nicht zu hoch sein, wenn größere Stromstärken oder Spannungen verwendet werden kann die LED zerstört werden.

Wenn die LEDs nur zur Beleuchtung verwendet werden, sollte man spezielle elektrische Schaltkreise verwenden welche die Spannung und die Stromstärke für die LEDs regulieren. Jedoch werden LEDs sehr oft als Indikatoren genutzt und werden direkt vom Microcontroller mit Strom versorgt. Da die Betriebsspannung eines Microcontrollers höher ist, als die der LEDs, muss ein Widerstand in Serie mit der LED geschaltet werden um die Stromstärke zu reduzieren. Anleitungen wie man den richtigen Widerstand errechnet können im Kapitel Elektronik gefunden werden.

LEDs werden in vielen Formen gefertigt. Die meisten LEDs haben eine 3mm oder 5mm Durchmesser große runde Hülle und zwei lange metallische Pins. Der längere Pin ist die Anode, der kürzere die Kathode. “Surface mounted casing” LEDs (SMD - Surface Mounted Device) haben ein T Symbol unten um die Polarität anzugeben. Das Dach des T's steht für die Anode und der Fuß des T für die Kathode.

Polarity of legged and SMD LED's

Das HomeLab Controller Control Modul hat eine rote LED, dessen Anode ist über einen Widerstand an die +5V Stromversorgung angeschlossen und die Kathode am ATmega128 pin PB7. Um die LED an und auszuschalten muss PB7 als Output Pin definiert werden und entweder High/Low gesetzt werden. Wenn der Pin high gesetzt wird ist die LED aus, wenn der Pin low gesetzt wird ist die LED an. Grundsätzlich ist es möglich die LED zu anzubringen, dass die Anode am PB7 angeschlossen wird und die Kathode geerdet wird (Widerstand nicht vergessen) - Dann leuchtet die LED wenn der Pin high gesetzt ist und der LED ist aus wenn der PIN low ist.

Alle praktischen Beispiele für das HomeLab Kit, inklusive LEDs schalten, nutzen die HomeLab Pin Library. Die Pins Library hat den Datentyp pin, welcher die Addressen des Pins mit Register und Bitmaske des Pins enthält. Wenn man eine Pin Typ Variable im Programm erschaffen möchte kann man es mit der Macrofunktion PIN machen, der Pin kann im ganzen Programm genutzt werden, ohne Register benutzen zu müssen. Hier sind 2 Beispielprogramme, welche exakt das gleiche machen. Das eine Programm nutzt die Homelab Library, das andere nicht.

//
// 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);
}

Das erste Beispiel nutzt die Pins Library (pin.h Datei). Zuerst wird eine Pin Typ Variable genannt debug led erschaffen, welche die Information über den LED Pin erhält. Im Hauptprogramm wird dieser Pin mit pin_setup_output als Output gesetzt. Danach wird der Pin als Low gesetzt: pin_clear. Das Ergebnis: die LED leuchtet. Im zweiten Beispiel werden keine Variablen genutzt. Um den LED Output zu verändern wird die Port B Datenrichtung und Output Registerwerte verändert. Der Leser der mehr über den AVR weiss merkt, dass in beiden Beispielen kein Befehl nötig ist um die LED zum leuchten zu bringen, da der Standardoutput des AVR 0 ist. Der Vollständigkeit halber wird es jedoch hier beschrieben.

Was ist der Unterschied zwischen dem Gebrauch von Library und Register? Der Unterschied ist Komfort - Library ist einfacher, weil man die Registernamen nicht wissen muss und deren Auswirkungen. Der wichtigste Vorteil an der Library ist jedoch die Anpassbarkeit. Mit Registern muss man jedes mal im Programm die Registernamen und Bitmasken ändern um einen Pin zu ändern. Mit der Library muss man nur am Anfang des Programms die Variable initialisieren. Wenn man mit Registern arbeitet gibt es jedoch einen Vorteil - wenn man einen Pin nutzt macht man das sofort und nicht über den Programmspeicher und zeitfressenden Funktionen. Jedoch sind die neuren AVR-GCC Kompiler Versionen so schlau, dass sie die Library Funktionen direkt so transformieren, dass sie direkte Befehle für die Registermanipulation ausführen, so als würde man die Register direkt im Programm ansprechen. Die Compiler können aber nur den Code optimieren wenn sie meine konstanten Variable arbeiten und nicht mit unbeständigen Variablen die sich während des Programms oder mit Arrays ändern.

Der folgende Programmcode ist eine partielle Pin Operations Library, um die Prozeduren mit Pinvariblen zu erklären. Es wird für Anfänger nicht einfach sein es zu verstehen, da es C-Sprache Pointer nutzt die nicht in diesem Buch beschrieben werden, aber eine Menge Material über Pointer kann in Büchern und natürlich im Internet gefunden werden.

// 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);
}

Zusätzlich zum Controllermodul sind LEDs auch am digtalen I/O Modulboard. Sie sind elektrische genau so angeschlossen wie auf dem Controllerboard, also die Kathode ist am AVR Pin angeschlossen. Die Rote LED ist am PC5 Pin angeschlossen, die Gelbe am PC4, und die Grüne am PC3. Das HomeLab Library basierende Beispielprogramm sieht wie folgt aus:

//
// HomeLab Digital i/o module LED 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);
}

~~DISCUSSION~~