kramann.info
© Guido Kramann

Login: Passwort:










EmbSyst
1 day_by_day
2 Eingebettete_Systeme
..2.1 Softwareentwicklung
....2.1.1 AgileSoftwareentwicklung
....2.1.2 Verhalten
....2.1.3 Entwurfsmuster
....2.1.4 FuzzyRegler
....2.1.5 Uebung
..2.2 Arduino
....2.2.1 Uebung1
..2.3 Android
....2.3.1 UML
......2.3.1.1 Volumenberechnung
......2.3.1.2 UML_Klassendiagramm
......2.3.1.3 Konstruktor
......2.3.1.4 Statische_Variable
....2.3.2 bluej
....2.3.3 Threads
....2.3.4 Interfacedesign
....2.3.5 Android
......2.3.5.1 Getting_Started
......2.3.5.2 App
......2.3.5.3 Beispielprojekt
........2.3.5.3.1 Richtlinien
........2.3.5.3.2 Anforderungen
........2.3.5.3.3 Layout
........2.3.5.3.4 Projekt_einrichten
........2.3.5.3.5 Refactoring
........2.3.5.3.6 Icon
........2.3.5.3.7 Icon2
........2.3.5.3.8 Kurzanleitung
........2.3.5.3.9 Architektur
........2.3.5.3.10 Anwendungsklasse
......2.3.5.4 Threads
......2.3.5.5 Activities
......2.3.5.6 Was_ist_wo
......2.3.5.7 Regelungssysteme
........2.3.5.7.1 Servo
........2.3.5.7.2 Fahrzeug
......2.3.5.8 ADB_Apps
......2.3.5.9 Veroeffentlichen
......2.3.5.10 Einzelheiten
........2.3.5.10.1 Bildschirmaufloesung
........2.3.5.10.2 Parameter
........2.3.5.10.3 Permission
........2.3.5.10.4 Latenzzeit
......2.3.5.11 Tonerkennung
........2.3.5.11.1 Wahrscheinlichkeitsrechnung
........2.3.5.11.2 Kovarianz_Scilab
........2.3.5.11.3 Java_Threads
........2.3.5.11.4 Java_Reflection
....2.3.6 Processing
......2.3.6.1 Installation
......2.3.6.2 Erste_Schritte
......2.3.6.3 Mechatronik
......2.3.6.4 Bibliotheken
......2.3.6.5 Uebung
......2.3.6.6 Snippets
........2.3.6.6.1 Dateioperationen
........2.3.6.6.2 Bilder
........2.3.6.6.3 GUI
........2.3.6.6.4 Text
........2.3.6.6.5 PDF
........2.3.6.6.8 Maus
........2.3.6.6.10 Zeit
........2.3.6.6.13 Animation
........2.3.6.6.15 Simulation
......2.3.6.7 Referenzen
....2.3.7 Android_Processing
......2.3.7.1 Basics
......2.3.7.2 Einrichten
......2.3.7.3 Crossplattform
......2.3.7.4 sinus
......2.3.7.5 sample
......2.3.7.6 analyse
......2.3.7.7 synthese
......2.3.7.8 Hilfsapps
......2.3.7.9 Eigene_Library
....2.3.8 Processing_VR
....2.3.9 Shapes3D
....2.3.10 TextToSpeech
....2.3.11 Internetprogrammierung
......2.3.11.1 Codegenerierung
......2.3.11.2 PHP_Programmierung
......2.3.11.3 PHP_OOP
......2.3.11.4 Java
......2.3.11.5 UDP
......2.3.11.6 Internetkontrolle
........2.3.11.6.1 Kamerabild
....2.3.12 OSC
......2.3.12.1 Datenaustausch
......2.3.12.2 i2audiolab
......2.3.12.3 Ardour
....2.3.13 Netzwerkprogrammierung
....2.3.14 JNI
....2.3.15 Erweitern
......2.3.15.1 sprich
......2.3.15.2 spiel
....2.3.16 thbvr
....2.3.17 Reflection
....2.3.18 Script
....2.3.19 Java3D
3 Echtzeitprogrammierung
..3.1 Echtzeit
..3.2 Korrektheit
..3.2 Semaphoren
..3.3 Hardware
..3.5 Synchronprogramm
..3.6 Zustandsmaschine
..3.7 Arduino
....3.7.1 Uebung
....3.7.2 RTOS
....3.7.3 Scheduler
....3.7.4 Semaphor
......3.7.4.1 Laufkatze
......3.7.4.2 Java
......3.7.4.3 Semaphor
....3.7.5 Messages
..3.8 Android
....3.8.2 Threads
......3.8.2.1 Java
......3.8.2.2 Synchronisierung
..3.9 Petrinetze
....3.9.1 Installation
....3.9.2 Test
4 KI
..4.1 Unueberwachtes_Lernen
..4.2 Agentensysteme
....4.2.1 Architekturen
......4.2.1.1 Verhalten
......4.2.1.2 Entwurfsmuster
....4.2.2 SUMO
......4.2.2.1 GettingStarted
......4.2.2.2 Antrieb
......4.2.2.3 Sensoren
......4.2.2.4 Zeitbasis
......4.2.2.5 Fernsteuerung
......4.2.2.6 Umsetzung_Fernst
......4.2.2.7 Fernsteuerung3
......4.2.2.10 Umsetzung
......4.2.2.11 Sockelsoftware
......4.2.2.12 Plan
......4.2.2.13 Lernen
........4.2.2.13.1 Parameter
........4.2.2.13.2 Identifikation
........4.2.2.13.3 Java
..4.3 Genetische_Algorithmen
....4.3.1 Heuristiken
....4.3.2 Genalgorithmus
..4.4 Kalmanfilter
....4.4.1 Vorarbeit
....4.4.2 Minimalversion
....4.4.3 Beispiel
5 Bildverarbeitung
..5.1 Gestalttheorie
..5.2 Bildverarbeitung
6 Technische_Systeme
..6.1 Kulturgeschichte
..6.2 Technikphilosophie
..6.3 Anthropozaen
7 Literatur
kramann.info
© Guido Kramann

Login: Passwort:




Prozeßsynchronisierung bei dem Funktionsmodell einer geregelten Laufkatze

Funktionsmodell einer 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:
  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 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