kramann.info
© Guido Kramann

Login: Passwort:










5.1 Prozeßsynchronisierung bei dem Funktionsmodell einer geregelten Laufkatze

Funktionsmodell einer Laufkatze

Bild 5.1-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 5.1-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:
  1. Wenn C bei A auf den digitalen Leitungen liest, darf A nicht schreiben.
  2. Wenn A schreibt, darf C nicht auf den Leitungen zu A lesen.
  3. Wenn C bei B auf den digitalen Leitungen liest, darf B nicht schreiben.
  4. 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 5.1-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 5.1-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 5.1-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 5.1-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 5.1-5: Synchronisierungsmechanismus im Mikrocontroller-Programm für C