Datenübertragung zwischen AVR

• Gemeinsamer bekannter Takt: Beide Parteien haben in diesem Falle eine gemeinsame Information, nämlich mit welcher Frequenz die Zeichen gesendet werden. Genau in diesem Takt kann nun der Empfänger ebenfalls horchen und die Zeichenpegel abtasten. Sollten die Taktraten ggf. auseinanderlaufen, oder Zeichenfehler auftreten, so werden diese Abweichungen durch Stopbits und Paritätsbits ausgemerzt. Diese Art der Übertragung wird beispielsweise mit der seriellen Schnittstelle verwirklicht, das ist ebenfalls ein Grund, warum bei dieser Art der Übertragung beim AVR ein externer Quarz vorhanden sein muß, der interne RC - Oszillator hat zu große Abweichungen in seiner Ganggenauigkeit.
  
  
• Synchronisiert: Hierbei gibt der Empfänger den Takt vor, braucht er länger zur Verarbeitung der Daten, so muss auch der Sender warten, bis er weitere Daten senden kann, signalisiert der Empfänger, dass er weitere Daten lesen kann, so kann der Sender dies dann tun. Nachteil hierbei ist, dass eine weitere Leitung neben den eigentlichen Datenleitungen nötig ist, doch es kommt zu keinen Taktproblemen.

• Busy Waiting: Auf die Signale vom langsameren Prozessor könnte man beispielsweise mit einer "while"-Schleife warten, sobald das Signal eintritt, springt man aus der Schleife heraus und setzt die Datenübertragung fort. Diese Art nennt man "Busy waiting", der Prozessor hat während dieser Zeit nichts anderes zu tun als zu warten. Die Hauptschleife eines jeden Mikroprozessorprogramms in "main" wird komplett blockiert. Allerdings könnte man andere Aufgaben in einem Timer-Interrupt abhandeln, das ist jedoch sehr unschön konstruiert.
  
  
• Interrupt/Threading: Dreht man Lösungsvorschlag 1 herum, so landet man zwangsläufig bei diesem Lösungsansatz. Das Warten auf die Signale erfolgt in einem Timer-Interrupt, die Hauptschleife in "main" wird zyklisch von diesem unterbrochen. Hiermit wird die Hauptschleife extrem belastet, ebenfalls wird ein wertvoller Timer-Interrupt verschwendet. Andere Lösungen sind nur auf Mehrprozessorsystemen oder threadfähigen Betriebssystemen als untergelagerte Prozessverwaltung möglich, das ist jedoch auf kleinen Mikroprozessoren im Moment noch Utopie.
  
  
• Schrittkette/Funktionsblock: Diese Idee stammt aus der Automatisierungstechnik und ist ein ganz anderes Programmierparadigma als die serielle Anwendungsprogrammierung. Hierbei wird zwar auch imperativ programmiert, allerdings wird der Programmcode, der "länger" dauert, also hier die Kommunikation, in eine eigene Funktion ausgelagert. Diese Funktion wird aus der Hauptschleife in "main" zyklisch aufgerufen, arbeitet intern jedoch mit einer Schrittkette. Mit jedem Aufruf der Funktion wird in der Schrittkette auf das Signal vom langsameren Prozessor geprüft, ist es da, wird beim nächsten Aufruf ein anderer Schritt in der Funktion ausgeführt. Dafür bedarf es jedoch statischen Variablen in dieser Funktion oder einer größeren "Arbeitsstruktur" als Parameter, die in jedem Schritt modifiziert wird. Ist der letzte Schritt durchlaufen, so signalisiert sie ein "fertig" nach draußen, womit das empfangene Zeichen weiter verarbeitet werden kann.
  
  Nun kann komplett ohne systemabhängige Interrupts programmiert werden, ebenfalls läuft die "main"-Schleife fast im Leerlauf durch, in der Schrittkette geht es in winzigen Schritten voran, die die restlichen Programmteile kaum ausbremsen.

Master-/Slavestruktur

Headerfiles und IO-Ports

#define LED1_DDR  DDRB
#define LED1_PORT PORTB
#define LED1_PIN  PB0

LED1_DDR |= (1<<LED1_PIN); 
LED1_PORT |= (1<<LED1_PIN);

#define LED1_DDR  DDRB
#define LED1_PORT PORTB
#define LED1_PIN  PB0

configureAsOutput(LED1_DDR, LED1_PIN);
switchHigh(LED1_PORT, LED1_PIN);

volatile unsigned char * LED1_DDR;
volatile unsigned char * LED1_PORT;
volatile unsigned char   LED1_PIN;
            
LED1_DDR = &DDRB;
LED1_PORT = &PORTB;
LED1_PIN = PB0;

configureAsOutput(*LED1_DDR, LED1_PIN);
switchHigh(*LED1_PORT, LED1_PIN);

#include "transmit.h" // Header für Kommunikation

 // Struktur, wo Variablen für die Kommunikation zu anderem AVR aufbewahrt werden 
struct Transmitter connect2Avr;

int main() {
    // IO-Ports konfigurieren
    connect2Avr.in.config.OutputSCL_DDR = &DDRB;
    connect2Avr.in.config.OutputSCL_PORT = &PORTB;
    connect2Avr.in.config.OutputSCL_PIN = PB4;
    
    connect2Avr.in.config.OutputSDA_DDR = &DDRB;
    connect2Avr.in.config.OutputSDA_PORT = &PORTB;
    connect2Avr.in.config.OutputSDA_PIN = PB5;
    
    connect2Avr.in.config.InputSCL_DDR = &DDRD;
    connect2Avr.in.config.InputSCL_PORT = &PIND;
    connect2Avr.in.config.InputSCL_PIN = PIND2;
    
    connect2Avr.in.config.InputSDA_DDR = &DDRD;
    connect2Avr.in.config.InputSDA_PORT = &PIND;
    connect2Avr.in.config.InputSDA_PIN = PIND3;

    // dieser AVR ist Master
    FB_TransmitMaster(&connect2Avr);  // Erster Aufruf = Ports konfigurieren

    unsigned char step = 0;

    while(1) {	
        // Byte senden und empfangen
        switch(step) {
            case 0:
                connect2Avr.in.sendByte = 65; // Byte, das gesendet werden soll
                connect2Avr.in.cmdSend = 1; // Senden anstoßen
                step = 1;
                break;
            case 1:
                FB_TransmitMaster(&connect2Avr);

                if (connect2Avr.out.ready == 1) {
                    uint8_t result = connect2Avr.out.receiveByte; // empfangenes Byte
            	    
                    // irgendwas mit empfangenen Zeichen tun...
					
                    // wieder zum Anfang
                    step = 0;
                }

                break;
        }
    }

    return 0;
}