C-Programmierung mit AVR-GCC/ IO-Ports

Aus Wikibooks
Zur Navigation springen Zur Suche springen

Was sind Ports und wie kann man sie benutzen?[Bearbeiten]

Ein Port bezeichnet beim AVR die Zusammenfassung einzelner Pins. Ein Pin wiederum ist ein Anschlussbeinchen am Mikrocontroller. Ein Port hat für gewöhnlich 8 Anschlüsse, also auch 8 Pins. Nur vereinzelt kann es sein, dass ein Port aus Platzmangel nicht die vollen 8 Anschlüsse hat.

Am Beispiel eines ATmega8 kannst du erkennen, dass die einzelnen Pins doppelt oder sogar dreifach Belegt werden. Das macht man, um Platz zu sparen und trotzdem mehrere Funktionen auf dem Controller zu vereinen. Atmega8 pinout

IO-Ports sind Ein- und Ausgänge des Mikrocontrollers. Diese kannst du digital und einige sogar analog benutzen. Ein einzelner Port kann sowohl als Eingang als auch als Ausgang konfiguriert werden.

Genauer gesagt, kannst du

  • digitale Signale aus einem Ausgang ausgeben
  • digitale Signale in einen Eingang geben
  • analoge Signale in einen Eingang geben
  • keine echten analogen Signale aus einem Ausgang ausgeben – aber dafür PWM-Signale, welche zu analogen Signalen gewandelt werden können

Trotz der Mehrfachbelegung einzelner Pins, kann ein Pin natürlich nur eine Aufgabe erledigen. Die Entscheidung welche Aufgabe er übernimmt, kannst du über Konfigurationsregister einstellen. Dazu aber später mehr.

Erforderliche Register[Bearbeiten]

Damit du einen Port benutzen kannst, musst du ihn vorher noch konfigurieren.

Als erstes stellst du das Datenrichtungsregister (Data-Direction-Register) kurz DDRx ein. Dabei gibt das kleine x an, welchen Port (PORTA, PORTB, ...) du konfigurieren willst.

Eine logische Null an der Stelle eines Pins ergibt für diesen Pin einen Eingang. Eine logische Eins hingegen einen Ausgang. Wichtig beim Konfigurieren ist, dass du nur die Pins setzt, die du auch nutzen möchtest. Damit vermeidest du Seiteneffekte, die den Programmablauf stören können. Um das zu erreichen solltest du Bitmanipulation anwenden. Bitmanipulation habe ich schon im Kapitel Register erklärt.

Um zum Beispiel den Pin PB0 als Eingang und PB1 als Ausgang zu nutzen stellst du in deinem Code folgendes ein.

#include <avr/io.h>

int main() {
  DDRB &= ~(1 << PB0);
  DDRB |= (1 << PB1);
}

Das Datenrichtungsregister brauchst du auch nur einmal einzustellen. Danach kannst du den Pin weiter so benutzen, wie du ihn konfiguriert hast. Nur wenn sich die Konfiguration ändern sollte, musst du DDRx neu beschreiben.

Ist ein Pin als Ausgang konfiguriert, kannst du über das Register PORTx den Pin auf High oder Low schalten und so Einsen und Nullen ausgeben. Auch hier gibt das kleine x wieder an, welchen Port du konfigurierst.

#include <avr/io.h>

int main() {
  DDRB &= ~(1 << PB0);
  DDRB |= (1 << PB1);

  PORTB |= (1 << PB1);  //PB1 High
  PORTB &= ~(1 << PB1); //PB1 Low
}

Die Konfiguration für einen Eingang ist etwas komplizierter und wird unten im eigenen Abschnitt erklärt.

Digitale Ausgänge benutzen[Bearbeiten]

Die wohl meist genutzte Funktion digitaler Ports ist der digitale Ausgang. Ist ein Pin als Ausgang konfiguriert, kannst du beispielsweise eine LED oder ein Display anhängen und damit schalten.

Datenrichtung setzen[Bearbeiten]

Wie oben schon erwähnt füllst du das Datenrichtungsregister mit Einsen an den Stellen der Pins, welche als Ausgang genutzt werden sollen.

Wenn PB0 (also Anschlusspin 14 des ATmega8) ein Ausgang sein soll, dann muss im Datenrichtungsregister DDRB das Bit an der Stelle PB0 gesetzt sein.

DDRB
PB7 PB6 PB5 PB4 PB3 PB2 PB1 PB0
0 0 0 0 0 0 0 1
DDRB |= (1 << PB0);

Pins setzen[Bearbeiten]

Wir haben den Port nun richtig konfiguriert. Jetzt möchten wir aber eine angeschlossene LED einmal blinken lassen. Dazu geben wir eine logische Eins auf dem Pin aus. Damit wird die LED eingeschaltet. Danach werden wir eine logische Null ausgeben, um die LED wieder aus zu schalten.

Um den Ausgang zu setzen beschreiben wir das Register PORTB.

#include <avr/io.h>

int main(void){
    DDRB |= (1 << PB0);       // damit ist dann PB0 ein Ausgang

    while(1){
        PORTB |= (1 << PB0);  //PB0 im PORTB setzen
        PORTB &= ~(1 << PB0); //PB0 im PORTB löschen
    }

    return 0;
}

Technisch ist unser erste Programm total in Ordnung. Wenn wir es auf den Mikrocontroller laden, würden wir aber keinen Wechsel des LED-Status sehen. Das liegt daran, dass die Ausführung unseres Programmes für das menschliche Auge viel zu schnell ist. Daher müssen wir zwischen den einzelnen Anweisungen eine gewisse Zeit warten. Darum enthält das nun folgende komplette Programm Verzögerungen.

#define F_CPU 1000000UL       //Taktfrequenz 1MHz

#include <avr/io.h>
#include <util/delay.h>

int main(void){
    DDRB |= (1 << PB0);       // damit ist dann PB0 ein Ausgang

    while(1){
        PORTB |= (1 << PB0);  //PB0 im PORTB setzen
        _delay_ms(250);       //250ms warten

        PORTB &= ~(1 << PB0); //PB0 im PORTB löschen
        _delay_ms(250);       //250ms warten
    }

    return 0;
}

Wir haben nun das Beispiel aus dem Anfang des Buches nachprogrammiert und die Hintergründe der einzelnen Anweisungen verstanden.

Digitale Eingänge benutzen[Bearbeiten]

Jeder Port lässt sich auch als digitaler Eingang verwenden. Ein Eingang ermöglichet es dir, Ereignisse von außen zu erkennen und darauf zu reagieren.

Datenrichtung setzen[Bearbeiten]

Einen Eingang kannst du im Datenrichtungsregister mit einer logischen Null konfigurieren. Möchtest du beispielsweise PB1 als Eingang benutzen, sollte im Datenrichtungsregister an der Stelle PB1 eine Null stehen.

DDRB
PB7 PB6 PB5 PB4 PB3 PB2 PB1 PB0
0 0 0 0 0 0 0 1
DDRB &= ~(1 << PB1);

Im nächsten Schritt ist es wichtig deine Hardware zu kennen, denn du solltest noch den internen Pull-Up Widerstand konfigurieren. Der interne Pull-Up Widerstand zieht den Pin auf einen definierten Zustand, in diesem Fall logisch Eins, wenn dieser nicht beschaltet ist. Wichtig wird das unter anderem bei Schaltern bzw. bei Tastern, die schließlich nicht immer aktiv sind und meist in einer Ruhephase sind. Hast du allerdings einen externen Pull-Up Widerstand verbaut, oder willst dass der Pin in der Ruhephase auf Masse liegt, musst du den internen Pull-Up abschalten. Das erreichst du, indem du im PORTx-Register ebenfalls an die Stelle PB1 eine logische Null schreibst. Möchtest du den internen Pull-Up benutzen schreibst du an die Stelle eine Eins.

PORTB
PB7 PB6 PB5 PB4 PB3 PB2 PB1 PB0
0 0 0 0 0 0 0 0
PORTB &= ~(1 << PB1);

Damit ist der Pin nun im sogenannten Tri-State. Das ist ein spezieller dritter Zustand, den ein Pin annehmen kann. Dieser Zustand hat den Vorteil, dass der Mikrocontroller den Pin nicht selbst beeinflusst und damit die Signale, die am Pin anliegen, nicht verfälscht werden.

Aber Vorsicht! Setzt du den Eingang als Tri-State und setzt keinen externen Pull-Up oder Pull-Down Widerstand ein, hat der Pin in der Ruhephase einen undefinierten Zustand.

Pinzustand lesen[Bearbeiten]

Den Pinzustand kannst du im Register PINx abrufen. Dieses Register hat 8 Bit und symbolisiert den Zustand des gesamten Ports. Wenn du eine Maske über den Registerwert legst, kannst du auf einzelne Pinzustände prüfen.

Nehmen wir einmal an, dich interessiert der Zustand von Pin PB1, den wir vorhergehend als Eingang konfiguriert haben. Dazu legst du einfach eine Maske auf den Wert in PINB und prüfst, ob dieser ungleich Null ist.

#include <avr/io.h>
 
int main(void){
    DDRB &= ~(1 << PB1);      // damit ist dann PB1 ein Eingang
    PORTB &= ~(1 << PB1);     // PB1 als Tri-State

    if(PINB & (1 << PB1)) {
        //PB1 ist gesetzt
    }
 
    return 0;
}