kramann.info
© Guido Kramann

Prozeßsynchronisierung bei dem Funktionsmodell einer geregelten Laufkatze

Bild 0-1: Funktionsmodell einer Laufkatze

Eine durch einen Elektromotor angetreiebne Laufkatze soll Positions-geregelt werden.
Ferner soll das Pendeln der Last zur Ruhe gebracht werden.
Mit zwei Abstandssensoren sollen von außen Wagenposition und Lastposition erfaßt werden.
Beide Abstände sollen unabhängig voneinander durch den A/D-Wandler jeweils eines Mikrocontroller (A und B) in digitale Signale umgewandelt werden.
Auf einen dritten Mikrocontroller C sollen die digitalen Werte für die beiden Abstände über digitale Ein/Ausgangsleitungen parallel übertragen werden.
Dieser Generiert auf Grundlage dieser Informationen ein PWM-Stellsignal für den Antrieb der Laufkatze.
Im folgenden ist das entsprechende Schaltungslayout dargestellt:

Layout mit zwei Mikrocontrollern zur Erfassung je eines Abstandssignals (oben links und rechts) und eines weiteren zur Verarbeitung der Abstandssignale und zur Generierung eines PWM-Stellsignals für den Laufkatzenmotor.

Bild 0-2: Layout mit zwei Mikrocontrollern zur Erfassung je eines Abstandssignals (oben links und rechts) und eines weiteren zur Verarbeitung der Abstandssignale und zur Generierung eines PWM-Stellsignals für den Laufkatzenmotor.

Nun kann folgendes Zugriffsproblem auftreten:
Sollte Mikrocontroller A gerade die Bits auf dem parallelen Ausgang aktualisieren, während Mikrocontroller C gerade diese Bits einliest, kann es zu unkontrollierbaren Fehlerwerten für die durch C erfassten Abstände kommen.
Beispiel: Springt gerade die Bitfolge 0111 auf 1000 und wurden die unteren drei Bits bereits vorher von C gelesen und erst dann das höchstwertigste Bit, nachdem die Änderung eingetreten ist, so kommt bei C 1111 an statt 1000 oder 0111.
Auf den drei Mikrocontrollern laufen tatsächlich drei unabhängige unsynchronisierte Prozesse ab.
Im Moment des Datenaustausches zwischen A und C, bzw. B und C müssen diese Prozesse aber synchronisiert werden.

Eine einfache Möglichkeit hierzu besteht darin, Signalleitungen zu verwenden, über die C und A, bzw. C und B sich wechselseitig anzeigen können, ob der jeweils andere Partner lesen, bzw. schreiben darf.
Eine einfache Regel könnte lauten:

Wenn C bei A auf den digitalen Leitungen liest, darf A nicht schreiben.
Wenn A schreibt, darf C nicht auf den Leitungen zu A lesen.
Wenn C bei B auf den digitalen Leitungen liest, darf B nicht schreiben.
Wenn B schreibt, darf C nicht auf den Leitungen zu B lesen.

Folgende Festlegungen werden für die Verwendung der 12 Leitungen zwischen C und A und für die weiteren 12 zwischen C und B getroffen:

Übertragung des 10-Bit Sensorsignals von A nach C:
       A    nach    C
Bit0: PC0          PA0
Bit1: PC1          PA1
Bit2: PC2          PA2
Bit3: PC3          PA3
Bit4: PC4          PA4
Bit5: PC5          PA5
Bit6: PC6          PA6
Bit7: PC7          PA7
Bit8: PD2          PB2
Bit9: PD3          PB3
Signalleitung von A nach C: PD0 nach PB0
Signalleitung von C nach A: PB1 nach PD1
       B    nach    C
Bit0: PC0          PC0
Bit1: PC1          PC1
Bit2: PC2          PC2
Bit3: PC3          PC3
Bit4: PC4          PC4
Bit5: PC5          PC5
Bit6: PC6          PC6
Bit7: PC7          PC7
Bit8: PD0          PD2
Bit9: PD1          PD3
Signalleitung von B nach C: PD2 nach PD4
Signalleitung von C nach B: PD7 nach PD3

Code 0-1: Verwendung der digitalen Leitungen.

Folgender Mechanismus kann nun für das Einhalten obiger Regeln sorgen:

Regeln auf A und B:
while(true)
{
    Messe und skaliere A/D-Werte
    Prüfe, ob C gerade liest
    wenn nein
    {
        Zeige C an, dass nun C nicht mehr anfangen darf zu lesen
            Schreibe Werte auf die digitalen Leitungen.
        Zeige C an, dass nun C wieder lesen darf
    }
}
Regeln auf C:
while(true)
{
    Prüfe, ob A gerade schreibt
    wenn nein
    {
        Zeige A an, dass nun A nicht mehr anfangen darf zu schreiben
            Lese Sensorwert von A
        Zeige A an, dass nun A wieder schreiben darf
    }
    Prüfe, ob B gerade schreibt
    wenn nein
    {
        Zeige B an, dass nun B nicht mehr anfangen darf zu schreiben
            Lese Sensorwert von B
        Zeige B an, dass nun B wieder schreiben darf
    }
}

Code 0-2: Regeln auf A, B un C.

Wenn nun die Signalleitungen verwendet werden, um dem jeweilig anderen Mikrocontroller die eigene Aktivität auf den Datenleitungen anzuzeigen, so können die wesentlichen Passagen entsprechender Mikrocontroller-Programme folgendermaßen aussehen:

while(true)
{
    if( (PIND & (1<<PD1)) == 0 ) //wenn C nicht bei A liest
    {
        PORTD |= (1<<PD0);    //C anzeigen, dass nun A schreibt
            Werte schreiben
        PORTD &= ~(1<<PD0);  //C anzeigen, dass nun A nicht mehr schreibt.
    }
}

Code 0-3: Synchronisierungsmechanismus im Mikrocontroller-Programm für A

while(true)
{
    if( (PIND & (1<<PD3)) == 0 ) //wenn C nicht bei B liest
    {
        PORTD |= (1<<PD2);    //C anzeigen, dass nun B schreibt
            Werte schreiben
        PORTD &= ~(1<<PD2);  //C anzeigen, dass nun B nicht mehr schreibt.
    }
}

Code 0-4: Synchronisierungsmechanismus im Mikrocontroller-Programm für B

while(true)
{
    if( (PINB & (1<<PB0)) == 0 ) //wenn A nicht schreibt
    {
        PORTB |= (1<<PB1);    //A anzeigen, dass nun C liest
            Sensorwert von A lesen
        PORTB &= ~(1<<PB1);   //A anzeigen, dass nun C nicht mehr liest.
    }
    if( (PIND & (1<<PD4)) == 0 ) //wenn B nicht schreibt
    {
        PORTD |= (1<<PD7);    //B anzeigen, dass nun C liest
            Sensorwert von B lesen
        PORTD &= ~(1<<PD7);   //B anzeigen, dass nun C nicht mehr liest.
    }
    PWM-Stellsignal berechnen und setzen
}

Code 0-5: Synchronisierungsmechanismus im Mikrocontroller-Programm für C