PDV und Feldbusse - · PDF filePDV und Feldbusse Klausur im Sommersemester 2017 Seite 1 von 2 Ostfalia Hochschule für angewandte Wissenschaften Fakultät Elektrotechnik

PDV und Feldbusse Klausur im Sommersemester 2017 Seite 1 von 2

Ostfalia Hochschule für angewandte Wissenschaften Fakultät Elektrotechnik Prof. Dr.-Ing. M. Haas

Aufgabe 1 PDV (70%) Gegeben ist das folgende originale Hauptprogramm für eine digitale Steuerungsaufgabe. // hier der passende Header ... ///////////////////////////////////// int main( int argc, char * argv[] ) { unsigned long adresse_ein, adresse_aus; digiIF_T * interface_ein, * interface_aus; UWORD daten_ein[32], daten_aus[32]; // 1 // if( interface_ein = digiOpen( adresse_ein ) == NULL ) exit( EXIT_FAILURE) ; if( interface_aus = digiOpen( adresse_aus ) == NULL ) exit( EXIT_FAILURE) ; // while( 1 ) {

digiIn_F( interface_ein, & daten_ein ); verknuepfeX( daten_ein, & daten_aus ); digiOut_F( interface_aus, daten_aus );

} return 0; } ///////////////////////////////////////////////////////////////// ( 7%) 1.1 Formulieren Sie zu // 1 // die Übernahme der Interfaceadressen aus dem main-Argument. ( 8%) 1.2 Definieren Sie den Strukturtyp für die Interfaces. Ein- und Ausgabeinterface sind gleich aufgebaut.

Alle Register sind 1 WORD breit. Der Programmzugriff auf die Interfaces ist "memory mapped". Die objektinterne Adressierung ist automatisch richtig, wenn zuerst die Datenregister, dann Steuerregister und Statusregister in der Struktur deklariert werden.

(15%) 1.3 Die Funktion digiIn_F muss bei der Datenübernahme einen Handshake im Statusregister ausführen:

vor der Datenübernahme Flag 7 (Eingabe bereit) auf 1 testen; wenn wahr: Flag 8 auf 1 setzen (Eingabe einfrieren) und die Daten aus den Eingaberegistern übernehmen; danach Flag 8 rücksetzen auf 0 (Eingabe freigegeben). Formulieren Sie den entsprechenden Codeabschnitt.

(20%) 1.4 Das Programm soll auf interruptgetriebene Ausführung umgeschrieben werden: eine ISR (der Inter-

rupthandler) soll nach IRQ die Datenübernahme wie in 1.3 ausführen und das Hauptprogramm be-nachrichtigen. Dies erledigt den Rest. Das Interface wird mit der logischen 1 in Flag 0 seines Statusre-gisters interruptfähig. Dann sendet es bei jeder Änderung eines Werts in einem seiner Datenregister den IRQ (hier: IRQ Nr. 8) an die CPU. Jede ISR des hier vorhandenen Zielsystems hat die Signatur const eventT * handlername( void ); Formulieren Sie die ISR, die Änderungen im Hauptprogramm und den Header für die hier gestellte Aufgabe. Nutzen Sie ggf. Code aus vorigen Aufgaben oder verweisen Sie darauf. Benutzen Sie die Bibliotheksfunktionen int irqAttach(int nr1, eventT event1 * (* handler1)( void ) );

// Übernimmt die ISR handler1 für den IRQ nr1 in die Vektortabelle und gibt einen // Identifier für den IRQ zurück, oder -1 bei Misserfolg. Programmierpraktischer Hinweis: // der kompliziert anmutende zweite formale Parameter ist ein Funktionszeiger. Im Aufruf der // Funktion als aktueller Parameter ist er einfach handlername, der Name der ISR.

void irqEventInit( int id1, eventT * event1 ); // Macht den mit irqAttach angemeldeten IRQ id1 zum Auslöser des Event event1

int eventWait( eventT * event1, void * data1 ); // Wartet blockiert auf das Eintreffen des event1 oder irgendeiner Nachricht ( NULL). Der // Parameter data1 ist hier nicht relevant: übergeben Sie NULL.

(10%) 1.5 Vergleichen Sie den Ablauf des originalen Hauptprogramms mit dem interruptgetriebenen in einem

Sequenzdiagramm (möglichst einfach). (10%) 1.6 In einem Multitasksystem kann das originale Programm mehrere große Probleme verursachen.

Welche?



Aufgabe 2 Feldbusse (30%) Die Tabelle rechts definiert Kommunikationsbezie-hungen in einem CAN 2A. Jedes Feld entspricht einer Nachricht mit Nutzdaten wie eingetragen. Der Zusatz z.B. "2 z" bedeutet: periodischer Sendewunsch mit Zyklusdauer 2 ms; z.B. "1 a" bedeutet: azyklischer Sendewunsch mit Buszugriff spätestens nach 1 ms. 2.1 Definieren Sie für jeden Teilnehmer die Sende- und Empfangsidentifier. 2.2 Geben Sie die kleinste in CAN mögliche Bitrate an, mit der sich die Zeitanforderungen noch erfüllen las-sen, und die dazu passende max. Busentfernung.

Senden

Empfangen T1 T2 T3 T4

T1 - 8 Byte 1 z

4 Byte 1 z

8 Byte 1 z

T2 4 Byte 2 z

- 2 Byte 1 a

-

T3 8 Byte 2 z.

- - -

T4 4 Byte 2 z

- 2 Byte 1 a

-

Aufgabe 3 Feldbusse (30%) Ein Ethernet-Switch kann passend zum Verhalten des ange-schlossenen Endgeräts jeden seiner Ports halb- oder voll-duplex mit 10, 100 oder 1000 Mbit/s betreiben. Im Bild rechts verbindet er die Knoten A - F halbduplex mit 100 Mbit/s. 3.1 Innerhalb eines kurzen Zeitintervalls senden 2 Teilneh-mer Frames zum Switch: A an D und B an E. Können diese Frames Kollisionen mitverursachen? Erklären Sie Ihre Ant-wort mit einem Sequenzdiagramm. 3.2 Knoten F soll eine Anwendung beherbergen, die von Anwendungen der andern LAN-Knoten Daten anfordert, um diese an G weiterzusenden.

Switch

A B

DE

CF

WAN

G

a) Erklären Sie den Datenaustausch anhand der Protokollstapel der beteiligten Knoten. b) Ändern Sie die Zuordnung bestimmter Anwendungen zu den LAN-Knoten, um den Protokollaufwand zu verringern. 3.3 Begründen Sie, welche Veränderung der Netzadapter auf A - F ein annähernd echtzeitfähiges LAN herstellen kann. Aufgabe 4 Feldbusse (10%) Ein bitserielles Buskabel hält über der Bandbreite von 20 MHz das Verhältnis S/N ≥ 1000. Welche max. Bitrate ist möglich

a) bei theoretisch optimaler Bitcodierung? b) bei NRZ? c) bei Manchestercode?



Aufgabe 1 PDV (70%) 1.1 (7%) if( argc != 3 ) exit( EXIT_SUCCESS ); // else adresse_ein = atol( argv[1] ); adresse_aus = atol( argv[2] ); 1.2 (8%) typedef unsigned short int UWORD; struct digiIF_T { UWORD data[32], control, flags; }; 1.3 (15%) void digiIn_F( digiIF_T * digi_in, UWORD * eingabe ) { if( digi_in->flags & (1<<7) ) { digi_in->flags |= (1<<8); for( int i=0 ; i<32 ; ++i ) eingabe[i] = digi_in->data[i]; digi_in->flags &= ~(1<<8); } } 1.4 (20%) // der geänderte Teil des Headers, vorher lokal zu main, nun global: digiIF_T * interface_ein; UWORD daten_ein[32]; // // neu dazu: eventT digi_in_event1; // // der Interrupthandler: const eventT * digi_in_handler1( void ) { digiIn_F( interface_ein, & daten_ein ); // erlaubt, da keine Systemaufrufe enthalten return & digi_in_event1; } // // das geänderte Hauptprogramm //////////////////////////// int main( int argc, char * argv[] ) { unsigned long adresse_ein, adresse_aus; digiIF_T * interface_aus; // interface_ein oben global! UWORD daten_aus[32]; // daten_ein[32] oben global! // // hier die Lösung zu Aufgabe 1 // if( interface_ein = digiOpen( adresse_ein ) == NULL ) exit( EXIT_FAILURE) ; if( interface_aus = digiOpen( adresse_aus ) == NULL ) exit( EXIT_FAILURE) ; // // neu: interface_ein->flags |= (1<<0); // Interface interruptfähig machen if( int irqId1 = irqAttach( 8, digi_in_handler1 ) == -1 ) exit( EXIT_FAILURE ); irqEventInit( irqId1, & digi_in_event1 ); // while( 1 ) {

eventWait( & digi_in_event1, NULL ); // anstelle Aufruf digiIn_F verknuepfeX( daten_ein, & daten_aus ); digiOut_F( interface_aus, daten_aus );

} return 0; } /////////////////////////////////////////////////////////////////



1.5 (10%)

Hauptprogramm neu

E

Interrupthandler

E

V A

IRQ 8

E V A EE VV A A E V

V A

Hauptprogramm original

Zeit

1.6 (10%) Problem 1: Die laufende Task ist dauernd laufbereit, weil ihr Programm keine blockierenden Systemaufrufe enthält. Damit kann sie je evtl. vorhandene andere laufbereite Tasks auf gleicher oder kleinerer Priorität dauerhaft an deren Ausführung hindern. Problem 2: Viele Betriebssysteme unterbrechen eine dauernd laufbereite Task während einer Dauer, die das Betriebssystem bestimmt. Diese Dauer hat i.d.R. keinen Bezug zu den Anforderungen hinsichtlich Zyklus- oder Reaktionszeit an die Task und kann deutlich länger sein. Problem 3: Auch andere Tasks können auf das Interface zugreifen. Das Originalprogramm oben synchronisiert seinen Zugriff aber nicht: keine Semaphore o.ä.



Aufgabe 2 Feldbusse (30%) 2.1

Prioritäten: 1z > 1a > 2z

Senden Empfangen

T1 T2 T3 T4

T1 0x080 8 Byte 1z

0x081 4 Byte 1z

0x082 8 Byte 1z

T2 und T4 (Multicast)

0x090 (4+4)Byte 2z

0x083 (2+2)Byte 1a

T3 0x091 8 Byte 2z

2.2 Worst case der Busanforderung: alle Teilnehmer legen ihre Frames gleichzeitig auf den Bus. Überlegung zum Zeitbedarf:

Alle Telegramme mit 1z bzw. 1a müssen innerhalb von 1ms gesendet worden sein. In demselben 1ms-Intervall muss auch mindestens die Hälfte aller Telegramme mit 2z gesendet worden sein, sonst schafft das Protokoll den Rest im folgenden 1ms-Intervall nicht.

Man kann für das Datenaufkommen in [Bit] aller Telegramme mit 1z den Bezeichner D1z einführen, entspre-chend D1a und D2z. Damit und mit der Bitdauer 1/R [s] gilt für den Zeitbedarf

1ms ‐ 1/R (D1z + D1a) ≥ 1/R D2z/2 und damit für die Bitrate R ≥ ( D2z/2 + D1z + D1a ) / 1ms [Bit/s] = D2z/2 + D1z + D1a [kBit/s]

Bestimmung der ungestopften Anzahl Bits in D1z, D1a und D2z: In jedem CAN 2A - Telegramm belegen Header und Sicherungsteil zusammen 44 Bit. Achtung: die Zeiten zwischen Telegramm und nächster Arbitrierungsphase sind hier vernachlässigt. Dann ist D1z = 2 (44 + 64) + 1 (44+32) = 108 + 108 + 76 (3 Telegramme)

D1a = 76 (1 Telegramm) D2z = 2 (44 + 64) = 108 + 108 (2 Telegramme) Mit max. möglicher Anzahl Stopfbits wird die Größe N Bit eines ungestopften Telegramms zu M = 6 + ( 5 (N‐5) ):4 [Bit]. Der Operator : steht für die ganzzahlige Division ohne Rest. Das Datenaufkommen vergrößert sich auf D1z = 134 + 134 + 94 = 362; D1a = 94; D2z = 134 + 134 = 268 Eingesetzt in die Formel für die Bitrate: R ≥ D2z/2 + D1z + D1a [kBit/s] = 134 + 362 + 94 [kBit/s] = 590 [kBit/s], also bei CAN R = 1 Mbit/s. Die Berechnung des Abstands D [m] mit 1/R = 4 TL und TL = D/2 * 10‐8 s ergibt D = 50 m. Aufgabe 3 Feldbusse (30%) 3.1 (Sequenzdiagramm) - Begründung: Auf den halbduplex betriebenen Verbindungen zwischen Switch und

Endgerät bestehen dieselben Verhältnisse wie auf einem Bus mit 2 Teilnehmern. Also sind Kollisionen möglich.

3.2 a) 7 7

4 4 3 3 ------ 3 3 2 2----2 2 2 2 1 1 1 1 1 1

[F]---[Switch]---[C, LAN] [C, WAN]---[...]----[G] b) Weniger Protokollaufwand: Anwendung von F auf C verlagern, oder Routing LAN-WAN auf F verlagern. 3.3 Nach Umstellung auf voll "duplex-fähige" Netzadapter kann es keine Kollisionen mehr geben. Dem Zufall überlassen bleibt damit nur noch, ob an den Switch sendende Knoten gleichzeitig denselben Ausgabeport adressieren. In der Praxis genügt das meistens sog. weichen Echtzeitanforderungen. Aufgabe 4 Feldbusse (10%)

a) bei theoretisch optimaler Bitcodierung 200 Mbit/s b) bei NRZ 20 Mbits/s c) bei Manchestercode 10 Mbit/s

Prozessdatenverarbeitung Klausur im Wintersemester 2016/17 Seite 1 von 1


Aufgabe 1 PDV ( 30% ) Eine Software für die Steuerung der Zugangstür zu einer Bearbeitungszelle in einer Fertigung soll entwickelt werden. Der Zugang wird durch eine Tür mit motorischer Funktion zum Öffnen bzw. Schließen gesichert. Aktivitäten der Werkzeugmaschinen in der Bearbeitungszelle sind nur möglich, wenn die Tür geschlossen ist. Falls bzw. solange die Türöffnung nicht frei ist oder der Türantrieb Kollision meldet, kann die Tür nicht bewegt werden bzw. wird gestoppt. Sind Werkzeugmaschinen aktiv, kann die Tür nicht aus der geschlos-senen Stellung gebracht werden. Die Steuerung der Werkzeugmaschinen ist hier nicht näher zu betrachten. Folgende Aktor- und Sensorsignale der Peripherie stehen zur Verfügung: Aktor: A1 Tür öffnen, A2 Tür schließen Sensor: S1 Tür soll auf, S2 Tür öffnet, S3 Tür ist offen, S4 Tür soll zu, S5 Tür schließt, S6 Tür ist

geschlossen, S7 Türöffnung nicht frei, S8 Türantrieb ist kollidiert, S9 Werkzeugmaschinen sind aktiv

1.1 Definieren Sie eine Datenstruktur für die Peripherie der Türsteuerung. 1.2 Zeichnen Sie einen Zustandsgraphen (MOORE) der Türsteuerung. 1.3 Entwerfen Sie den Programmcode entsprechend 1.2 für eine parametrische Funktion ohne Ein- und

Ausgabe. 1.4 Geben Sie die Signatur (Funktionsprototyp) dieser Funktion an. Aufgabe 2 PDV ( 30% ) Für die Aus- und Eingabe in dem Projekt der Aufgabe 1 wird ein digitales Interface mit 16 Bit Ausgabe und 16 Bit Eingabe benutzt. Nach Übergabe des Ausgabeworts und Schreiben von Flag0 = 1 im Statusregister führt das Interface selbstständig die Ausgabe an die Peripherie durch. Solange Flag1 = 1 ist, wird der momentane Inhalt des Eingaberegisters eingefroren, damit das Programm das Eingabeabbild übernehmen kann. Die Aktor- und Sensorgrößen dieser Anwendung sollten in der o.a. Reihenfolge jeweils ab Bit 0 des Eingabe- bzw. des Ausgaberegisters aufwärts verdrahtet sein. 2.1 Definieren Sie eine Datenstruktur für das Interface. 2.2 Formulieren Sie eine Funktion, mit der die Anwendung der Türsteuerung in Aufgabe 1 die notwendige

Aus- und Eingabe ausführen kann. Aufgabe 3 Feldbusse ( 30% ) In einer Fertigung mit Echtzeitanforderungen an die Datenübertragung wurde in den 1990 Jahren ein Token-Bus-Protokoll eingesetzt, das 12 Zellenrechner über max. 100 m miteinander verbindet und das bisher zur vollsten Zufriedenheit funktioniert. Das Protokoll hat folgende Eigenschaften: RG-62 Koaxkabel, Sterntopo-logie mit Hub, Bitrate 2,5 Mbit/s, NRZ mit Stopfen von 110 vor jedem Byte im Informationsteil. Es gibt folgen-de Rahmentypen: 1. Paket (Information 0…507 Byte, Header/Sicherung 8 Byte), 2. Token, 3. Aufforderung zum Empfang eines Pakets (jeweils nur Header, 4 Byte), 4. positive und 5. neg. Quittung (jeweils nur Hea-der, 2 Byte). Nach jedem Frame gibt es eine Wartezeit von 12,5 µs. Jede der Anwendungen der Zellenrechner fordert den Bus zeitlich zufällig an, um eine Datenmenge zufälliger Größe bis zur Maximalgröße eines Paketrahmens an einen anderen Rechner zu senden. 3.1 Bestimmen Sie die max. Wartezeit eines Teilnehmers im ungünstigsten Fall. Lassen Sie dabei

Sicherungsfehler und andere Sonderfälle außer Acht. 3.2 a) Welchen prinzipiellen Vorteil hat das Protokoll gegenüber Ethernet über Bus oder Hub?

b) Mit welchem DIN-Feldbusprotokoll hat das Protokoll Ähnlichkeit? Aufgabe 4 Feldbusse ( 30% ) Im Zuge einer durchgreifenden Modernisierung der Fertigungszellen soll die bisher lokale E/A der Zellen-rechner ("zentrale Peripherie") aus Aufgabe 3 durch "dezentrale Peripherie" ersetzt werden. Der Datenver-kehr zwischen einem Zellenrechner und seiner Peripherie soll isochron mit Zykluszeiten unter 1 ms ablaufen. und hat ein Datenaufkommen von bis zu 800 Byte pro Zyklus. Prinzipiell soll die dezentrale Peripherie eines bestimmten Zellenrechners in der Lage sein, auch anderen Zellenrechnern Daten zu senden oder von diesen zu empfangen. 4.1 Erklären Sie, warum das Protokoll der Aufgabe 2 nicht geeignet ist. 4.2 Schlagen Sie ein geeignetes Protokoll vor und erklären Sie seine wichtigsten Eigenschalten. 4.3 Zeichnen Sie die Netzwerktopologie. 4.4 Stellen Sie den Datenaustausch zwischen einer dezentralen Peripheriebaugruppe und einem anderen

Zellenrechner in einem Sequenzdiagramm dar.



Aufgabe 1 PDV ( 30% ) 1.1 struct Tuer { // Aktoren bool a1_toe, a2_tsc; // Sensoren bool s1_tsa, s2_to, s3_tia, s4_tsz, s5_ts, s6_tiz, s7_tnf, s8_tko; bool s9_waktiv; }; 1.2

Transitionen: T01 = s1_tsa && !s2_tsz && !s3_tia && !s7_tnf && !s8_tko && !s9_waktiv; T12 = s1_tia; T14 = s7_tnf || s8_tko; T41 = s1_tsa && !s2_tsz && !s3_tia && !s7_tnf && !s8_tko; T23 = s1_tsz && !s1_tsa && !s6_tiz && !s7_tnf && !s8_tko; T30 = s6_tiz; T34 = T14; T43 = T23; Aktionen: a1_toe = Z1; a2_tsc = Z3; 1.3 #define Z0 0 #define Z1 1 #define Z2 2 #define Z3 3 #define Z4 4 // void tuer_steuern( Tuer * t1 ) { static int zustand_t1 = Z0; bool T01, T12, T14, T41; T23, T34, T30, T34, T43; // T01 = t1->s1_tsa && !t1->s2_tsz && !t1->s3_tia && !t1->s7_tnf && !t1->s8_tko && !t1->s9_waktiv; // wie zu Aufgabe 1.2 // und hier folgend alle weiteren Transitionen wie 1.2 oben //

T01

T12

T23

T30

T34

T43

T14

T41

Z0Geschlossen

Z2Geoeffnet

Z1Oeffnet

Z3Schliesst

Z4Gestoppt

Muste

rlösu

ng



switch( zustand_t1 ) { case Z0: if( T01 ) t1=Z1; break; // case Z1: t1->a1_toe; // Aktion Tür auf if( T12 ) t1=Z2 else if( T14 ) t1=Z4; break; // case Z2: if( T23 ) t1=Z3; break; // case Z3: t1->a1_tsc; // Aktion Tür zu if( T30 ) t1=Z0; else if( T34 ) t1=Z4; break; // case Z4: if( T41 ) t1=Z1; else if( T43 ) t1=Z43; break; // default: fprint( stdout, "\n**** unerwarteter Programmfehler\n" ); } } 1.4 Signatur (Funktionsprototyp) dieser Funktion an steht oben in der Lösung zu 1.3. Aufgabe 2 PDV ( 30% ) 2.1 struct IOdigi16 { unsigned short indigi16; unsigned short outdigi16; unsigned short control; unsigned short status; }; 2.2 void tuer_io(IOdigi16 * io1, unsigned long basisadresse, Tuer * t1 ) { Tuer t1; // Pufferobjekt io1 = (IOdigi16 * ) basisadresse; // Aktion in Bit 0 und Bit 1 des Ausgaberegisters schreiben io1->outdigi16 = 0 | ((t1->a1_toe) << 0) | ((t1->a1_tsc) << 1); // Statusflags 0 und 1 setzen: Ausgabe ausführen, Eingabe einfrieren io->status |= 0x3; // Eingabe lesen t1->s1_tsa = ( io1->indigi16 & (1<<0) ); t1->s1_to = ( io1->indigi16 & (1<<1) ); t1->s3_tia = (io1->indigi16 & (1<<2) ); // usw. bis t1->s9_waktiv = (io1->indigi16 & (1<<8) ); }

Muste

rlösu

ng



Aufgabe 3 Feldbusse ( 30% ) 3.1 Max. Wartezeit eines Teilnehmers im ungünstigsten Fall: der Teilnehmer hat gerade das Token weitergegeben, wenn die höhere Schicht die Schicht 2 zum Senden beauftragt. Dann gilt die Wartezeit Tw = (Anzahl aller anderen Teilnehmer) * (Dauer eines Buszugriffs pro Teilnehmer) Die Dauer eines Buszugriffs pro Teilnehmer ergibt sich aus den Frames sowie den Warte- und den Laufzeiten während der Teilnehmer im Besitz des Tokens ist.

Frame Sendebits Sendedauer (1/R = 0,4 µs ) Wartezeit Laufzeit 2 Token 4 x 8 =32 32 x 0,4µs = 12,8 µs 12,5 µs 0,5 µs 3 Aufforderung 4 x 8 =32 12,8 µs 12,5 µs 0,5 µs 1 Paket 507 x 11 + 8 x 8 = 5641 2256,4 µs 12,5 µs 0,5 µs 4 Quittung 2 x 8 = 16 6,4 µs 12,5 µs 0,5 µs 2288,4 µs 50 µs 2,0 µs

Damit wird Tw = 11 x 2340,8 µs = 25748,4 µs ≈ 25,75 ms. 3.2 a) Prinzipiellen Vorteil gegenüber Ethernet über Bus oder Hub: es entstehen keine Kollisionen, und die Buszuteilung ist deterministisch. b) Das Protokoll (heißt Arcnet und) hat Ähnlichkeit mit PROFIBUS FMS. Aufgabe 4 Feldbusse ( 30% ) Im Zuge einer durchgreifenden Modernisierung der Fertigungszellen soll die bisher lokale E/A der Zellen-rechner ("zentrale Peripherie") aus Aufgabe 3 durch "dezentrale Peripherie" ersetzt werden. Der Datenver-kehr zwischen einem Zellenrechner und seiner Peripherie soll isochron mit Zykluszeiten unter 1 ms ablaufen. und hat ein Datenaufkommen von bis zu 800 Byte pro Zyklus. Prinzipiell soll die dezentrale Peripherie eines bestimmten Zellenrechners in der Lage sein, auch anderen Zellenrechnern Daten zu senden oder von diesen zu empfangen. 4.1 Das Protokoll der Aufgabe 2 ist nicht geeignet aus folgenden Gründen. 1) Der Token Bus läuft zwar zyklisch, aber nicht isochron. 2) Die Zeit Tw aus 3.1 ist die Zyklusdauer bei max. Paketlänge 507 Byte + Header.

Mit 800 Byte werden hier längere Pakete, mit dezentraler Peripherie mehr Teilnehmer verlangt. Die dabei geforderte Zykluszeit von max. 1 ms kann das Protokoll der Aufgabe 3 bei weitem nicht einhalten

4.2 Geeignetes Protokoll: Ethernet in Kombination mit proprietärer Echtzeitvariante, z.B. EtherCat. Die dezentrale Peripherie ist im Ringförmig miteinander und dem Zellenrechner vernetzt. Datenaustausch erfolgt über einen einzigen Ethernetframe, der als Summenrahmen mit Informationsteil für jeden Teilnehmer der dezentralen Preipherie einen eigenen festen Stellenbereich zum Empfangen und zum Senden hat, Bitrate: 1 GiBit/s Zellenrechner sind miteinander über ein schnelles GiBit-Ethernetsegment verbunden (Switches, voll duplex) und enthalten jeweils einen Router zu ihrer DP. 4.3 (Netzwerktopologie entsprechend 4.2) 4.4 (Sequenzdiagramm entsprechend Aufgabe).

Muste

rlösu

ng

Prozessdatenverarbeitung Klausur im Sommersemester 2016 Seite 1 von 1


Aufgabe 1 PDV ( 60% ) Das Programm eines Microcomputers soll die Drehzahlen n=1/T einer Menge Antriebe synchronisieren. Das verwen-dete Interface erkennt in seiner Eingabe mittels Impulsmes-sung für die Kanäle C1 … C4 Drehzahl und Drehrichtung und erzeugt pro Kanal und Umdrehung einen neuen Ein-gabewert. Solange die Bits 0 bis 3 des Statusregisters 1 sind, gelten diese. Für C1 …C4 übernimmt das Interface je einen Ausgabewert als Stellgröße der Antriebsdrehzahl. Die hier eingesetzten Antriebe können mit bis zu 9600 min-1 rotieren. Zur Synchronisation von bis zu 4 Antrieben entwickelt eine andere Projektgruppe die Funktion flag_t syncd( drive_t *d, int n, float s ); mit d Zeiger auf ein Feld von Antriebsobjekten n Länge des Felds im Bereich 1 ... 4 s Drehzahlsollwert für die Antriebe flag_t Statuswortrückgabe

MicrocomputerAntriebe

Interface

C2

C1

C3

C4

1.1 Welche Wiederholrate muss das Programm mindestens haben? 1.2 Dokumentieren Sie eine kleine Funktionsbibliothek für isochrones Timing in (Pseudo-)C mit Funktions-

prototypen und zugehöriger Beschreibung. 1.3 Definieren Sie eine passende Datenstruktur für das Interface. Die Ein- und Ausgabewerte der

Antriebsdrehzahlen sind vorzeichenbehaftete WORDs. 1.4 Die Ein- und Ausgabe mit dem Interface soll hardwarenah per Registerzugriff programmiert werden.

Das Interface wird in der Zielhardware auf die Basisadresse 0xBE000 konfiguriert. Das Zielbetriebssystem erlaubt den Zugriff auf reale Adressen ohne weiteres. Formulieren Sie das Programm in (Pseudo-)C.

Aufgabe 2 Feldbusse ( 60% ) Ein CAN-Bus verbindet 4 Antriebe A1 … A4 als dezentrale Peripherie mit einem zentralen Steuergerät G, auf dem die Drehzahlregelung der Antriebe abläuft. Entsprechend ihrer dynamischen Kenngrößen haben die Antriebsregelungen verschiedene Zykluszeiten: t(A1) = 0,8ms. t(A2) = 2ms, t(A3) = t(A4) = 5ms. 2.1 Definieren Sie alle notwendigen CAN-Nachrichten mit Identifier und erläutern Sie jeweils das Format

des Informationsteils. 2.2 Eine möglichst niedrige Bitrate [Bit/s] soll eingestellt werden. Möglich sind 125k, 250k, 500k und 1M

Welche Bitrate genügt hier, welche Entfernung kann damit überbrückt werden, und welche Leitungs-bandbreite ist erforderlich?

2.3 Das zentrale Steuergerät soll in der Lage sein, Programmupdates an A1 … A4 zu senden, die es von einem entfernten Server S über das Internet empfängt. Erläutern Sie anhand der Begriffe Router und Gateway, welche Protokollschichten und –protokolle auf G, S und den zwischen ihnen liegenden Internetknoten implementiert sein müssen.

2.4 Erklären Sie, wie A1 … A4 ihre Programmupdates ohne zusätzlich implementierte Protokolle nur über CAN erhalten.



Für eine controller-geregelte Antriebsachse soll die Positionierfunktion unsigned short posidrive(int nr, struct rampe * r); realisiert werden. Ein Anwendungsprogramm ruft sie mit den Parametern Zielposition s, Rampengeschwindigkeit v und Rampenbeschleunigung a zyklisch auf. Die Positionierfunktion gibt ein Statuswort an die aufrufende Anwendung zurück. Die Stellen der Flags im Statuswort, s.u., sind durch gleichnamige Makros definiert. posidrive unterscheidet folgende Zustände: Zustand Aktion(en) Transition (0) Leerlauf, Einschaltzustand

Rückgabe Statuswort mit Flag READY an Anwendung

in (1), wenn Aufruf mit neuen Fahrdaten, in (0) bleiben sonst

(1) Starten a. Aufruf move(), mit den Fahrdaten, s.u. b. Rückgabe Statuswort mit Flag BUSY bzw. ERROR an Anwendung

in (2), wenn move() TRUE, in (4) sonst

(2) Fahrt überwachen

a. Aufruf status(), s.u. b. Rückgabe Statuswort mit Flag BUSY bzw. ERROR an Anwendung

in (3), wenn Flag MOVEND in (2), wenn Flag MOVRUN, in (4) wenn Flag MOVERR in der Statusrückgabe von status()

(3) Ankunft Rückgabe Statuswort mit Flag FINISHED an Anwendung

in (0) stets

(4) Fehler a. Aufruf reset(), s.u. b. Rückgabe Statuswort mit Flag FIXED bzw. ERROR an Anwendung

in (0), wenn Rückgabe von reset() =TRUE, in (4) bleiben sonst

Die Anwendung soll nur dann neue Rampenfahrdaten übergeben, nachdem posidrive das Flag READY im Statuswort zurückgegeben hat. In den Zuständen (2) .. (4) reagiert posidrive nicht auf die neuen Daten. - Funktionen des Antriebscontrollers:

bool move( int drive, float s, float v, float a); Startet im Antrieb drive eine Rampenfahrt mit Sollwerten s, v, a. Blockiert nicht und gibt TRUE zurück, wenn der Start erfolgreich war.

unsigned short status( int drive ); Gibt den Status des Antriebs drive zurück, mit den hier relevanten Flags wie in der Tabelle Zeile (2) rechts.

bool reset( int drive ); Führt ein Reset des Antriebscontrollers durch und gibt bei Erfolg TRUE zurück.

Aufgabe 1 (25 %)

Zeichnen Sie den Zustandsgraphen der Positionierfunktion

Aufgabe 2 (25 %)

Formulieren Sie multitasking-kompatiblen Code der Hauptschleife mit dem Aufruf der Positio-nierfunktion in (Pseudo-) C. nr ist die zu bewegende Achse. r soll auf Datenobjekt der An-wendung mit den Sollwerten s, v und a zeigen, wenn posidrive im Zustand (1) aufgerufen wird, oder auf NULL in den Zuständen (2), (3) oder (4). struct rampe eingabe_rampe(void); liefert nicht blockierend die Eingabedaten.

Aufgabe 3 (25 %)

Formulieren Sie den Code der Positionierfunktion in (Pseudo-) C.

Aufgabe 4 (25 %)

struct rampe wird um ein Stoppsignal erweitert. Bei Aufruf reagiert posidrive darauf in jedem Zustand durch Aufruf von reset, was den Antrieb sofort stoppt. Die Achse soll in jedem Fall nach max. 2 mm Bremsweg aus v ≤ v_max = 800 mm/s zum Stillstand kommen. Mit welcher max. Zyklusdauer soll die Hauptschleife wiederholt werden? Nehmen Sie bei Ihrer Überlegung an, dass die Ausführungsdauer der Hauptschleife stets sehr viel kleiner ist als die Zyklusdauer.

Aufgabe 5 (25 %)

Das Stoppen über die Sollwerteingabe im Hauptprogrammzyklus soll durch eine Interrupt-verarbeitung des Stoppsignals ersetzt werden. Zeichnen Sie ein Sequenzdiagramm für den Fall einer Unterbrechung, definieren Sie eine kleine Bibliothek für (Pseudo-) C, und stellen Sie das vorhandene Hauptprogramm entsprechend um.



Aufgabe 1

(0)

(1)

(3)

(4)

(2)

MOVEND && ! MOVERR

MOVERR

reset() == TRUE

move() == TRUE

move() != TRUE

r != NULL

=1

Einschalten

(a) = MOVRUN&& ! MOVEND&& ! MOVERR

Aufgabe 2 // hier denken wir uns die Makros #define READY ... usw. Auf die Pin- und // Stellenbelegung kommt es hier nicht an. unsigned short posidrive( int nr, struct rampe * r ); const int drivenumber = 8; int main( int argc, char * argv[] ) { struct rampe driverampe, * pd = NULL; unsigned short posistatus; posistatus = posidrive( drivenumber, pd ); do { if( posistatus & (1 << READY) ) { driverampe = eingabe_rampe(); pd = & driverampe; } else { pd = NULL; } posistatus = posidrive( drivenumber, pd ); delay( 10 /* ms */ ); // die Dauer ist in dieser Aufgabe beliebig } while( 1 ); return 0; }



Aufgabe 3 unsigned short posidrive( int nr, struct rampe * r ) { static int zustand = 0; bool retval; unsigned short posistatus, drivestatus; switch( zustand ) { case 0: posistatus = ( 1 << READY ); if( r != NULL ) zutand = 1; break; case 1: if( move( nr, r->s, r->v, r->a ) ) { posistatus = ( 1 << BUSY ); zustand = 2; } else { posistatus = ( 1 << ERROR ); zustand = 4; } break; case 2: drivestatus = status( nr ); if( drivestatus & (1 << MOVERR) ) ) { posistatus = ( 1 << ERROR ); zustand = 4; } else if( drivestatus & (1 << MOVEND) ) ) { posistatus = ( 1 << FINISHED ); zustand = 3; } else if( drivestatus & (1<<MOVRUN) ) posistatus = ( 1 << BUSY ); else printf( "unbekannter Fehler: Antriebsstatus\n" ); break; case 3: posistatus = ( 1 << FINISHED ); zustand = 0; break; case 4: if( reset( nr ) ) { posistatus = ( 1 << FIXED ); zustand = 0; } else posistatus = ( 1 << ERROR ); break; default: printf( "unbekannter Fehler: Positionierstatus\n" ); } return posistatus; } Aufgabe 4 Bewegungsgleichungen: (i) s = a/2 * t2

(ii) v=a*t Bremszeit t = 2s/v = 4/800 s = 5 ms

Damit das zyklische Programm in jeder Phasenlage ph(Einschalten Stopp) und ph(Beginn Programmzyklus) rechtzeitig zu bremsen beginnt, muss es mit der halben Bremszeit wiederholt werden TZYK = 2,5 ms.



Aufgabe 4 Sequenzdiagramm: Stoppsignal |-------------------------------------S------------------------------- ISR |--------------------------------------X------------------------------ Timer |-------------T----------------T----------------T----------------T---- Hauptprogramm |-H__E__Z------E__Z-------------E__Z----E__Z-----E__Z-------------E__Z posidrive |--VA-VA--------VA---------------VA------VA-------VA---------------VA- Mit H - Hochlauf, V - Verarbeitung, A - Ausgabe, E - Eingabe, Z - blockierende Zykluskontrolle Der Timer wird gebraucht, weil das blockiert wartende Hauptprogramm sonst nur noch auf das hin und wieder eintreffende Stoppsignal reagiert. Er ersetzt die Wartezeitfunktion, die das Programm daran hindern würde, prompt auf Stopp zu reagieren. Bibliothek: /////////////////////////////////////////////////////////////////////////////////////// // chid_t channel_attach( const char * channel_name ); // Die ausführende Task legt einen Empfangskanal mit Namen channel_name an. // Rückgabe ist die Kanalnummer > 0, oder -1 bei Misserfolg. // void channel_wait( int channel_id, void * message ); // Die ausführende Task wartet blockiert auf eine Nachricht im Objekt message // aus dem Empfangskanal channel_id. // Die Nachricht ist NULL, wenn Sie von einem Timer oder von einer ISR kommt. // void channel_detach( chid_t channel_id ); // Macht channel_attach() rückgängig. // tid_t timer_attach( timer_t * timer, chid_t channel_id ); // Definiert einen neuen Timer und gibt dessen Kennzahl > 0 zurück, // oder -1 bei Misserfolg. // Er kann über den Kanal channel_id Benachrichtigungen senden. // int timer_start( timer_t * timer, long cycletime ); // Startet den Timer mit der Zykluszeit cycletime in Mikrosekunden. // Nach jedem Zyklus sendet der Timer eine Benachrichtigung, s. timer_attach(). // Rückgabe > 0 bei Erfolg, bei Misserfolg -1. // void timer_detach( tid_t timer_id ); // Stoppt den Timer und macht timer_attach() rückgängig. // isr_t irq_attach( int irq_nr, (isr_type) * irqhandler, chid_t channel_id ); // Ersetzt die in Vektortabelle vorhandene ISR für den IRQ irq_nr // // durch die ISR, auf die der 2. Parameter zeigt. // Mit jedem return sendet die ISR eine Benachrichtigung // über den Kanal channel_id. // Rückgabe ist die Interrupt-Kennzahl > 0 oder -1 bei Misserfolg. // int irq_detach( isr_t irq_id ); // Macht irq_attach() rückgängig. // ///////////////////////////////////////////////////////////////////////////////////////

Muste

rlösu

ng



Geändertes Programm: /////////////////////////////////////////////////////////////////////////////////////// // // hier gehören die Makros #define READY etc hin ... #include "realtimelib.h" isr_t stop_event; // Global! struct rampe driverampe; // Global! Jetzt mit Komponente stop isr_t stopunterbrechung( void ) // ISR für Stopsigal-IRQ { driverampe.stop = TRUE; return stop_event; } int main( int argc, char * argv[] ) { struct rampe * pd = NULL; unsigned short posistatus; timer_t rampentimer; tid_t timer_event; chid_t empfangskanal = channel_attach( "rampenfahrt" ); if( empfangskanal < 0 ) return 1 << 0; // Fehler Kanal anlegen und Ende; stop_event = irq_attach( IRQ-NR, & stopunterbrechung, empfangskanal ); if( stop_event < 0 ) return 1 << 1; // Fehler IRQ anmelden und Ende; // Jedes Einschalten des Stoppsignals sendet ab jetzt eine Benachrichtigung. timer_event = timer_attach( & rampentimer, empfangskanal ); if( timer_event < 0 ) return 1 << 2; // Fehler Timer anlegen und Ende; if( timer_start( & rampentimer, 5000 ) < 0 ) return 1 << 3; // Fehler Timer starten und Ende; // Jeder Timerzyklus sendet ab jetzt eine Benachrichtigung // Zu dessen Dauer ist in der Aufgabe nichts gesagt. Richtig ist daher // Zykluszeit > Bremszeit = Reaktionszeit auf Stop. posistatus = posidrive( drivenumber, pd ); do { if( posistatus & (1 << READY) ) { driverampe = eingabe_rampe(); pd = & driverampe; } else { p = NULL; } posistatus = posidrive( drivenumber, pd ); // channel_wait( empfangskanal, NULL ); // blockiert warten auf Timer oder Stopsignal // anstelle von delay( 1 /* ms */ ); } while( 1 ); // Programmende durch Schleifenabbruch wird hier nicht behandelt. // Eigentlich müssen vor Programmende die ..._detach() - Funktionen // in umgekehrter Reihenfolge wie oben die ..._attach-Funktionen // aufgerufen werden. return 0; } // ///////////////////////////////////////////////////////////////////////////////////////

Muste

rlösu

ng



Die Kontrolle der Ein- und Ausfahrt einer Parkgarage für PKW soll durch ein C-programmiertes Steuergerät automatisiert werden. Jeder einfahrende PKW muss zunächst stoppen, damit der/die Fahrer/in per Tasten-druck an der Chip-Ausgabe einen Bezahlchip anfordert und übernimmt. Auf das Tastersignal CS1 reagiert das Steuerprogramm, indem es per Schaltsignal CC1 einen Chip an die Entnahme leitet, per Ausgabewort CW1 dessen Codewort aktualisiert, und mit dem Lichtsignal LG1 (Grün) sowie der Schranke SO1 (Öffnen) die Einfahrt freigibt.. Wenn der Fahrbahnsensor FS1 meldet, dass der PKW die Einfahrt verlassen hat, schließt das Steuerprogramm die Einfahrt durch Umschalten auf Rot (LR1) und Schließen der Schranke (SS1). Für ausfahrende PKW ist der Ablauf ähnlich wie bei der Einfahrt und soll hier nicht näher betrachtet werden. Auf jedem Chip ist ein Codewort gespeichert. Folgende Werte werden unterschieden: "Bereit zur Ausgabe", wenn ein Chip im Vorrat der Chip-Ausgabe liegt, "Ausgegeben", nachdem Fahrer oder Fahrerin eines einfahrenden PKW den Chip übernommen haben, "Bezahlt", nachdem Fahrer/in an einem Kassenautomaten die Parkgebühr entrichtet haben, und "Zurückge-geben", nachdem der Chip im Eingabegerät als bezahlt angenommen wurde.

Einfahrt

CS1

Ausfahrt

CC1 LR1LG1

CS2

FS1

FS2 LR2LG2

SS1SO1

CC2SS2SO2 CW2

CW1

Chip-Ausgabe

Chip-Eingabe

Ein- und Ausgabe laufen über je ein Interface für 16 Schaltgrößen und einen Analogwert. Mit

struct IFX_type{unsigned short digi_io, signed short value_io unsigned short controlreg, statusreg }; steht ein dafür Datenmodell zur Verfügung. Aufgabe 1 (25%) Definieren Sie einen strukturierten Datentyp für die Ein- bzw. Ausfahrt. Aufgabe 2 (25%) Legen Sie eine Verdrahtung der digitalen Prozessgrößen mit den Ein- bzw. Ausgabeinterfaceklemmen fest und definieren Sie entsprechende Präprozessormakros für das C-Programm. Aufgabe 3 (25%) Formulieren Sie eine je parametrische C-Funktion für die Eingabe und die Ausgabe der Prozessgrößen. Die Memory-Adressen der beiden Interfaces übergibt die aufrufende Hauptfunktion. Das Zielsystem adressiert real. Aufgabe 4 (25%) Zeichnen Sie einen Zustandsgraphen für die Einfahrtkontrolle und formulieren Sie die entsprechende parametrische C-Funktion. Aufgabe 5 (25%) Formulieren Sie das Hauptprogramm. Die noch nicht definierte Funktion für die Ausfahrtkontrolle hat dasselbe Formalargument wie die Einfahrtkontrolle.



Aufgabe 1 (25%) //////////////////////////////////////////////////////////////// // struct parkhaus_einausfahrt { bool cs, cc, lr, lg, ss, so, fs; int cw; // die Bezeichnungen der Groessen ohne die Ziffern 1 bzw. 2 // passen sowohl fuer die Einfahrt als auch fuer die Ausfahrt. }; //////////////////////////////////////////////////////////////// Aufgabe 2 (25%) //////////////////////////////////////////////////////////////// // Klemmenverdrahtung: digitale Eingabegrößen #define CS1 0 #define FS1 1 #define CS2 2 #define FS2 3 // // Klemmenverdrahtung: digitale Ausgabegrößen #define CC1 0 #define LR1 1 #define LG1 2 #define SS1 3 #define SO1 4 #define CC2 5 #define LR2 6 #define LG2 7 #define SS2 8 #define SO2 9 // //////////////////////////////////////////////////////////////// Aufgabe 3 (25%) //////////////////////////////////////////////////////////////// // #include A1.h // Definition des Interfacedatentyps aus Aufgabenblatt #include A2.h // und Definitionen aus Aufgabe 1+2 in den Header einfügen // //////////////////////////////////////////////////////////////// void eingabe( IFX_type * e_adresse, parkhaus_einausfahrt * einfahrt, parkhaus_einausfahrt * ausfahrt ) { einfahrt->cs = (bool) e_adresse->digi_io & (1<<CS1); einfahrt->fs = (bool) e_adresse->digi_io & (1<<FS1); ausfahrt->cs = (bool) e_adresse->digi_io & (1<<CS2); ausfahrt->fs = (bool) e_adresse->digi_io & (1<<FS2); einfahrt->cw = e_adresse->value_io; }

Muste

rlösu

ng



void ausgabe( IFX_type * a_adresse, parkhaus_einausfahrt einfahrt, parkhaus_einausfahrt ausfahrt ) { a_adresse->digi_io = 0; a_adresse->digi_io |= (einfahrt.cc && 1) << CC1; a_adresse->digi_io |= (einfahrt.lr && 1) << LR1; a_adresse->digi_io |= (einfahrt.lg && 1) << LG1; a_adresse->digi_io |= (einfahrt.ss && 1) << SS1; a_adresse->digi_io |= (einfahrt.so && 1) << SO1; a_adresse->digi_io |= (ausfahrt.cc && 1) << CC2; a_adresse->digi_io |= (ausfahrt.lr && 1) << LR2; a_adresse->digi_io |= (ausfahrt.lg && 1) << LG2; a_adresse->digi_io |= (ausfahrt.ss && 1) << SS2; a_adresse->digi_io |= (ausfahrt.so && 1) << SO2; a_adresse->value_io = einfahrt.cw; } // //////////////////////////////////////////////////////////////// Aufgabe 4 (25%)

CS1

LR1 = SS1 = TRUELG1 = SO1 = CC1 = FALSE

LR1 = CC1 = SS1 = TRUELG1 = SO1 = FALSECW1 = "Ausgegeben"

LR1 = SS1 = CC1 = FALSELG1 = SO1 = TRUE

=1

FS1

Einfahrbereit

PKW kommt an

Einfahrt abwarten

//////////////////////////////////////////////////////////////// // Header für Aufgabe 4 // // Zustandscode //// // #define Z_EINFAHRBEREIT 0 #define Z_PKW_KOMMT_AN 1 #define Z_EINFAHRT_ABWARTEN 3 #define Z_KEIN_ZUSTAND -1 // // Chipcode //// // #define CWCODE_AUSGABEBEREIT 0 #define CWCODE_AUSGEGEBEN 1 #define CWCODE_BEZAHLT 2 #define CWCODE_ZURUECKGEGEBEN 3 // ////////////////////////////////////////////////////////////////

Muste

rlösu

ng



//////////////////////////////////////////////////////////////// // Loesung zu Aufgabe 4 // int einfahrtkontrolle( parkhaus_einausfahrt * einfahrt ) { static int einfahrtzustand = Z_EINFAHRBEREIT; // Startzustand switch ( einfahrtzustand ) { case Z_EINFAHRBEREIT : // Aktion einfahrt->lr = einfahrt->ss = true; einfahrt->lg = einfahrt->so = einfahrt->cc = false; // Zustandswechsel if ( einfahrt->cs ) { einfahrtzustand = Z_PKW_KOMMT_AN; } break; case Z_PKW_KOMMT_AN : // Aktion einfahrt->lr = einfahrt->cc = einfahrt->ss = true; einfahrt->lg = einfahrt->so = false; einfahrt->cw = CWCODE_AUSGEGEBEN; // Zustandswechsel einfahrtzustand = Z_EINFAHRT_ABWARTEN; break; case Z_EINFAHRT_ABWARTEN : // Aktion einfahrt->lr = einfahrt->cc = einfahrt->ss = false; einfahrt->lg = einfahrt->so = true; // Zustandswechsel if ( einfahrt->fs ) { einfahrtzustand = Z_EINFAHRBEREIT; } break; default: einfahrtzustand = Z_KEIN_ZUSTAND; } return einfahrtzustand; } // //////////////////////////////////////////////////////////////////////////// Aufgabe 5 (25%) //////////////////////////////////////////////////////////////// // Header für Aufgabe 5 // #include A1.h #include A2.h #include A4.h // void eingabe( IFX_type * e_adresse, parkhaus_einausfahrt * einfahrt, parkhaus_einausfahrt * ausfahrt); void ausgabe( IFX_type * a_adresse, parkhaus_einausfahrt einfahrt, parkhaus_einausfahrt ausfahrt ); int einfahrtkontrolle( parkhaus_einausfahrt * einfahrt ); int ausfahrtkontrolle( parkhaus_einausfahrt * ausfahrt ); //

Muste

rlösu

ng



//////////////////////////////////////////////////////////////////////////// // Loesung zu Aufgabe 5 // int main(int argc, char *argv[]) // Bemerkung.: Adresse per argv war nicht gefordert { IFX_type * e_adresse, * a_adresse; parkhaus_einausfahrt einfahrt; parkhaus_einausfahrt ausfahrt; char * p1, * p2; int returncode = 0; if ( argc != 3 ) // Bemerkung.: Adresse per argv war nicht gefordert { // Interfaceadressen fehlen return -1; } else { e_adresse = strtoul( argv[1], & p1 , 16 ); a_adresse = strtoul( argv[2], & p2 , 16 ); if ( p1 != '\0' || p2 != '\0' ) { // Adressenformat ist falsch return -2; } // Bemerkung.: Adresse per argv war nicht gefordert else { do{ eingabe( e_adresse, & einfahrt, & ausfahrt ) if ( einfahrtkontrolle( & einfahrt ) < 0 ) { // schwerer unerwarteter Fehler returncode = -3; break; } if ( ausfahrtkontrolle( & ausfahrt ) < 0 ) { // schwerer unerwarteter Fehler returncode = -4; break; } ausgabe( a_adresse, einfahrt, ausfahrt ) delay( 2 ); }while ( 1 ); // hier nicht gefordert, darf aber i.d. Praxis nicht fehlen //

// notify_operator(); // Betriebspersonal alarmieren shutdown_safely( e_adresse, a_adresse, einfahrt, ausfahrt ); // Peripherie in einen sicheren Zustand bringen //

//////////////////////////////////////////////////////////// return returncode; } } } ////////////////////////////////////////////////////////////////////////////

Muste

rlösu

ng


Ostfalia Hochschule für angewandte Wissenschaften

Fakultät Elektrotechnik Prof. Dr.-Ing. M. Haas

TiefpassMesswert- umformer

A/D-Wandler

Microcomputer

Regeln ÜberwachenProzess

fG = 100Hz

Links sehen Sie den Signalfluss der Analogwerteingabe eines Microcomputers. Das relevante Spektrum aller Prozessgrößen liegt im Bereich unter fG. Darüber gibt es nur Rauschen. Der A/D-Wandler soll die Eingabesignale 4-fach überabtasten.

Der A/D-Wandler ist schon eingestellt und "genügend schnell". Er gehört zu einem Interface mit 4 Eingabe-kanälen. Die digitalisierten Eingabesignale liegen als short int - Werte im memory mapped adressierbaren Registersatz, zu dem auch ein je 16-Bit breites Status- und Kontrollregister gehören. Es gilt fortlaufende Ad-ressierung für Kanal 0 bis 3, Status- und Kontrollregister ab vorgegebener realer ("physikalischer") Interface-adresse aufwärts. Aufgabe 1 ( 50 % ) 1.1 Bestimmen Sie die max. Zyklusdauer des Programms. 1.2 Definieren Sie in C einen Datentyp ad_in_t für das Interface. 1.3 Formulieren Sie in C die Vorbereitung für die Eingabe im Hochlauf eines Programms, das die

Adressen für 2 Interfaces IF1 und IF2 aus seiner Kommandozeile übernimmt und das auf einem real adressierenden Zielbetriebssystem laufen soll.

1.4 Formulieren Sie in C den Teil "E" der Prozessschleife, der das Eingabeabbild möglichst ähnlich wie bei einer SPS liefern soll, als Code in der Funktion main.

1.5 Formulieren Sie eine Lösung zu 1.4 durch Aufrufe der Funktion void ad_in_f( ad_in_t * input, ad_in_t * puffer ); und formulieren Sie die Defini-tion des Codes dieser Funktion.

1.6 Der zu regelnde bzw. überwachende Prozess besteht eigentlich aus 2 eigenständigen Teilen PA und PB, die zueinander eine Erzeuger-Verbraucher-Beziehung haben. Was muss man bei der Verdrah-tung der Signale von PA und PB zu den Interfaces IF1 und IF2 beachten, und warum?

Aufgabe 2 ( 50 % ) Zur Kontrolle der Zykluszeit steht eine kleine Funktionsbibliothek <xcyclecontrol.h> bereit: void xsleep_wait( long microsec ); wartet blockiert eine Anzahl Mikrosekunden ab. void xchannel_wait( int channel_id, void * message );

wartet blockiert auf eine Nachricht aus dem vorher angelegten Empfangskanal mit Kanalnr. channel_id . Die Nachricht kann auch NULL sein, wenn Sie vom Timer kommt.

int xchannel_attach( const char * channel_name ); legt einen Empfangskanal mit Namen channel_name an. Rückgabe ist die Kanalnummer.

int xtimer_attach( xtimer_t * timer, int channel_id, void * message ); wandelt das undefinierte Objekt timer einen definierten Timer um, der über den Kanal channel_id zyklisch eine Nachricht senden soll.

int xtimer_start( xtimer_t * timer, long cycletime ); startet den definierten Timer timer mit der Zykluszeit cycletime in Mikrosekunden.

2.1 Formulieren Sie ergänzend zur Aufgabe 1 eine "ungenaue" Zeitkontrolle der Prozessschleife in C. 2.2 Formulieren Sie alternativ zu 2.1 eine exakte Zeitkontrolle. Aufgabe 3 ( 40 % ) Um auf der sicheren Seite zu sein, wird das Programm gegenüber 1.1 mit halbierter Zyklusdauer getaktet. Daten aus dem A/D-Wandler soll das Programm aber nur einmal lesen, also wenn diese wirklich neu sind. Um das Programm dabei zu unterstützen, bietet das Statusregister folgende Flags (Bits): Flag 2 SET durch A/D-Wandler nach jeder neuen A/D-Wandlung und Aktualisierung aller Datenregister RESET durch A/D-Wandler, nachdem Flag 3 gesetzt ist (Quittung an Programm) Flag 3 SET durch Programm nach Lesen aller Datenregister (Quittung an A/D-Wandler) RESET durch Programm nach Reset von Flag 2. 3.1 Formulieren Sie in C eine Ergänzung des "E"-Teils der Prozessschleife, damit das Programm neu

gewandelte Eingabedaten nur 1x liest.



Fakultät Elektrotechnik Prof. Dr.-Ing. M. Haas Aufgabe 1 ( 50 % ) 1.1 TZyklus = 1/N * ½ * 1/fG , mit N=4 facher Überabtastung: TZyklus = 1/8 * 10 ms = 1,25 ms

1.2

struct ad_in_t {

short in[4]; short status, control;

};

1.3 int main( int argc, char * argv[] ) {

unsigned long adr_if1, adr_if2; ad_in_t * p_if1, * p_if2, buffer_if1, buffer_if2; char * p1, * p2; int returncode; if( argc != 3 ) returncode = -1; else { adr_if1 = strtoul( argv[1], & p1, 16 ); adr_if2 = strtoul( argv[2], & p2, 16 ); if( *p1 != '\0' || *p2 != '\0' ) returncode = -1; else { p_if1 = ( ad_in_t * ) adr_if1; p_if2 = ( ad_in_t * ) adr_if2; // ab hier möglich: E-V-A do { // ... }while( 1 ); } } return returncode;

} 1.4 do { buffer_if1 = * p_if1; // E Interface 1 buffer_if2 = * p_if2; // E Interface 2 // // hier V, A, Z ... }while( 1 ); 1.5 do { ad_in_f( p_if1, & buffer_if1 ); ad_in_f( p_if2, & buffer_if1 ); // hier V, A, Z ... }while( 1 ); void ad_in_f( ad_in_t * input, ad_in_t * puffer ) { * puffer = * input; }

1.6 Die Eingabesignale von PA werden an Interface 1, alle E/A-Signale von PB an Interface 2 angesch-

lossen. Auf diese Weise enthält das Interface 1 einen konsistentes Eingabeabbild des Prozesses A und Interface 2 sinngemäß dasselbe für Prozess B

mh

Textfeld

8

mh

Textfeld

8

mh

Textfeld

12

mh

Unterstreichen

mh

Unterstreichen

mh

Unterstreichen

mh

Unterstreichen

mh

Unterstreichen

mh

Unterstreichen

mh

Unterstreichen

mh

Unterstreichen

mh

Textfeld

6

mh

Textfeld

8

mh

Textfeld

8

mh

Unterstreichen



Fakultät Elektrotechnik Prof. Dr.-Ing. M. Haas Aufgabe 2 ( 50 % ) 2.1 // Header #include <xcyclecontrol.h> int main( int argc, char * argv[] ) {

// ... do { xsleep( (long)1250 ); // ... hier E-V-A }while( 1 );

// ... } 2.2 // main:

xtimer_t timer1; int ch1; if( ch1 = xchannel_attach( "timerchannel" ) ) < 0 ) exit( EXIT_FAILURE ); if( xtimer_attach( & timer, ch1, NULL ) < 0 ) exit( EXIT_FAILURE ); if( xtimer_start( & timer, (long)1250 ) < 0 ) exit( EXIT_FAILURE ); // do { xchannel_wait( ch1, NULL ); // ... hier E-V-A }while( 1 );

// ... Aufgabe 3 ( 40 % ) 3.1 // ... do { xchannel_wait( ch1, NULL ); if( p_if1 -> status & 1<<2 ) { ad_in_f( p_if1, & buffer_if1 ); pf_if1 -> status |= 1<<3; } else pf_if1 -> status &= ~(1<<3); if( p_if2 -> status & 1<<2 ) { ad_in_f( p_if2, & buffer_if2 ); pf_if2 -> status |= |= 1<<3; } else pf_if1 -> status &= ~(1<<3); // ... hier V-A }while( 1 ); // ...

mh

Textfeld

15

mh

Textfeld

15

mh

Textfeld

10

mh

Textfeld

10

mh

Textfeld

10

mh

Textfeld

10

mh

Textfeld

10

mh

Textfeld

10



Der Behälter B1 in einer Chemieanlage stellt eine Flüssigkeit für die Produktion bereit. L1 ist der analoge Füllstandssensor. Das Interface IFX1_AIN liefert seinen Wert als WORD. Die Füllstandshöhen L1L, L1H und L1HH sind Ver-gleichswerte in der Microcontroller-Steuerung, die Sie in C entwickeln sollen. Über das Ventil V3 entnimmt ein Verbraucher V zufällig Flüssigkeit aus B1. Auf V3 hat die Steuerung keinen Zugriff. Nur mit der Pumpe P1 und Ventil V1 soll sie den Füllstand L1 so halten wie im Zustandsgraphen hier unterhalb beschrieben. Zu den Zuständen sind folgende Aktionen definiert: (1) P1 aus, V1 zu (kein Zufluss) (2) V1 auf, P1 Stufe 1 Ein (Zufluss schwach) (3) V1 auf, P1 Stufe 2 Ein (Zufluss stark)

V1P1

V3

L1

L1HH

V

E

L1H

L1LB1

Das digitale Ausgabeinterface IFX1_DOUT steuert P1 und V1 über seine Klemmen Ki wie folgt an. K0: V1 Öffnen, K1: V1 Schließen, K2: P1 Stufe 1 (schwach), K3: P1 Stufe 2 (stark). Die Klemmen entsprechen den Bits im Eingabe- bzw. Ausgabe-WORD.

(1)

(2)

(3)

(0)

L1 >L1HH

L1 > L1H

L1L < L1 <= L1H

L1 > L1H L1 <= L1L

L1 <= L1H

L1 <= L1L

P on

Für die Interfaces existiert eine Funktionsbibliothek mit den nicht blockierenden Funktionen UWORD readIFX_AIN(ADDR basis,WORD * in); // analoge WORD-Eingabe " " " UWORD writeIFX_DOUT(ADDR basis, UWORD out);// digitale WORD-Ausgabe " " " basis ist die reale Adresse mit dem E- oder A-WORD. Die Rückgabe ist ein Statuswort, 0 heißt: alles OK. Die Programmierumgebung definiert in </opt/IFX/include> alles Notwendige für jeden Aufruf. Die analoge Eingabe liefert für den Füllstand im Bereich 0…+500 Liter Werte im Bereich 0…+27648. Änderungen der Füllstandshöhe vollziehen sich sehr langsam ( T > 1s ). Aufgabe 1 ( 30 % ) Definieren Sie einen Strukturtyp "Behälter" und formulieren Sie die damit eine parametrische Funktion für den Zustandsautomaten in C. Aufgabe 2 ( 20 % ) Formulieren Sie den Header und den Hochlauf der Anwendung main. Im Header sollen Werte für L1L, L1H und L1HH sowie die Bits der digitalen Ein-Ausgabegrößen vereinbart sein. main soll über sein Argument die die Interfaceadressen der Ein- bzw. Ausgabe übernehmen. Das Programm läuft auf einem real adressieren-den Zielrechner allein und darf daher ohne Weiteres direkt auf den Speicher zugreifen. Aufgabe 3 ( 30 % ) Vervollständigen Sie das Programm zu einer funktionierenden EVA-Schleife mit möglichst einfacher Kontrolle des Zyklusintervalls. Aufgabe 4 ( 20 % ) Das Programm soll für Multitasksysteme portabel gemacht werden. Die direkte Zuweisung einer Adresse geht dort nicht. Mit void * memmapIFX(ADRR adress,size_t size); erhält man über die Rückgabe Zugriff auf Speicher der Größe size an der realen Adresse adress, oder NULL bei Misserfolg. Wenden Sie die Funktion an. Aufgabe ( 30 % ) Das laufende Programm soll für andere Tasks, z.B. GUI, jederzeit als Server für Füllstands- und Stellgrößen-information ansprechbar sein. Erklären Sie dazu nötige Änderungen/Ergänzungen in Worten und ändern das bestehende Programm entsprechend in C oder Pseudo C.



Aufgabe 1 ( 30 % ) // Beginn des Headerfiles "behaelter.h" /////////////////////////////////////////// // typedef signed short int BOOL; struct behaelter { double e_L1, e_scale_L1; // Füllstandsmesswert und Skalenfaktor double limit[3]; // Vergleichswerte L1HH, L1H, L1L BOOL a_P1Stufe1, a_P1Stufe2, a_V1Auf, a_V1Zu; // dig. Ausgabegrößen }; #define Z0 0 // Zustandscode //// #define Z1 1 // #define Z2 2 // #define Z3 3 //////////////////// // void behaelterfuellstand( behaelter * b1 ); // // Ende des Headerfiles "behaelter.h" ///////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////// #include "behaelter.h" void behaelterfuellstand( behaelter * b1 ) { static int zustand = Z0; BOOL t01, t02, t03, t12, t21, t23, t32; // Eingabe und Grenzwerte zu Schaltgrößen verarbeiten t01 = b1->e_L1 > b1->e_limit[1]; t02 = ( b1->e_L1 <= b1->e_limit[1] && b1->e_L1 < b1->e_limit[0] ); t03 = b1->e_L1 <= b1->e_limit[0]; t12 = b1->e_L1 <= b1->e_limit[1]; t21 = b1->e_L1 > b1->e_limit[2]; t23 = b1->e_L1 <= b1->e_limit[0]; t32 = b1->e_L1 > b1->e_limit[1]; // // Zustandswechsel und Aktion( Zustand ) switch( zustand ) { case Z0: // Initialisierung if( t01 ) zustand = Z1; else if( t02 ) zustand = Z2; else if( t03 ) zustand = Z3; else { b1->a_P1Stufe1 = b1->a_P1Stufe2 = 0; b1->a_V1Auf = 0; b1->a_V1Zu = 1; } break; case Z1: if( t12 ) zustand = Z2; else { b1->a_P1Stufe1 = b1->a_P1Stufe2 = 0; b1->a_V1Auf = 0; b1->a_V1Zu = 1; } break; case Z2: if( t21 ) zustand = Z1; else if( t23 ) zustand = Z3; else { b1->a_P1Stufe1 = 1; b1->a_P1Stufe2 = 0; b1->a_V1Auf = 1; b1->a_V1Zu = 0; } break; case Z3: if( t32 ) zustand = Z2; else { b1->a_P1Stufe1 = 0; b1->a_P1Stufe2 = 1; b1->a_V1Auf = 1; b1->a_V1Zu = 0; } break; default: fprintf( stdout, "*** unerwarteter Fehler beim Zustandswechsel\n" ); exit( EXIT_SUCCESS ); } // // Die Ausgabe führt die Anwendung nach Rückkehr aus dieser Funktion aus } ///////////////////////////////////////////////////////////////////////////////////

Muste

rlösu

ng

mh

Textfeld

8

mh

Textfeld

8

mh

Textfeld

Zustandswort 8

mh

Textfeld

Aktionen 6



Aufgabe 2 ( 20 % ) // Beginn des Headerfiles "behaelteranwendung.h" //////////////////////////////////// // #define L1HH 400 // Füllstandsgrenzen dieser Anwendung #define L1H 300 // #define L1L 200 // #define SCALE (double)500/27648 // Skalierung der Füllstandseingabe dieser Anwendung // #define V1AUF 0 // Dig. Eingabeklemme 0 dieser Anwendung #define V1ZU 1 // Eingabeklemme 1 #define P1ST1 2 // Eingabeklemme 2 #define P1ST2 3 // Eingabeklemme 3 // // Interfaceadresse kommt mit Programmaufruf ... typedef signed short int WORD; // // Ende des Headerfiles "behaelteranwendung.h" ////////////////////////////////////// // Beginn der Anwendung main //////////////////////////////////////////////////////// // #include <cstdio> #include <cstdlib> // #include </opt/IFX/include> // #include "behaelter.h" #include "behaelteranwendung.h" // int main( int argc, char * argv[] ) { behaelter b1; unsigned long ein_adresse, aus_adresse; WORD analogeingabe, digitalausgabe; // in A.2 noch nicht nötig char * p; // Hochlauf if( argc != 3 ) { fprintf( stdout, "*** im Aufruf fehlen Eingabe- und Ausgabeadresse\n" ); return -1; } else { ein_adresse = strtoul( argv[1], & p, 16 ); if( * p != '\0' ) { fprintf( stdout, "*** Formatfehler hex-Eingabeadresse \n" ); return -1; } else { aus_adresse = strtoul( argv[2], & p, 16 ); if( * p != '\0' ) { fprintf( stdout, "*** Formatfehler hex-Eingabeadresse \n" ); return -1; } else { b1.e_limit[0]=L1L; b1.e_limit[1]=L1H; b1.e_limit[2]=L1HH; b1.e_scale_L1 = SCALE; // // Hauptschleife hier ... // } return 0; } } } // // Ende der Anwendung main //////////////////////////////////////////////////////////

Muste

rlösu

ng

mh

Textfeld

5

mh

Textfeld

5

mh

Textfeld

5

mh

Textfeld

5

mh

Textfeld



Aufgabe 3 ( 30 % ) do { // E if( readIFX_AIN( (ADDR)ein_adresse, & analogeingabe ) == 0 ) // Eingabe { b1.e_L1 = analogeingabe * b1.e_scale_L1; // Messwert skalieren + speichern } // V behaelterfuellstand( & b1 ); // A digitalausgabe = 0; // Ausgabeabbild aufbereiten digitalausgabe |= b1.a_P1Stufe1 << P1ST1; digitalausgabe |= b1.a_P1Stufe2 << P1ST2; digitalausgabe |= b1.a_V1Auf << V1AUF; digitalausgabe |= b1.a_V1Zu << V1ZU; writeIFX_DOUT( (ADDR)aus_adresse, digitalausgabe ); // Ausgabe // Z Sleep( 500 ); // } while( 1 ); Aufgabe 4 ( 20 % ) int main( int argc, char * argv[] ) { // Deklarationen wie A.3 // Hochlauf wie A.3 // ... b1.e_limit[0]=L1L; b1.e_limit[1]=L1H; b1.e_limit[2]=L1HH; // // neu für A.4: // ein_adresse = ( unsigned long )memmapIFX( (ADDR)ein_adresse, (size_t) sizeof(WORD) ); aus_adresse = ( unsigned long )memmapIFX( (ADDR)aus_adresse, (size_t) sizeof(WORD) ); if( ein_adresse==NULL || aus_adresse==NULL ) { fprintf(stdout,"*** Fehler beim Anfordern logischer E/A-Adresse\n"); return -1; } else // // Hauptschleife hier ... // } return 0; } } } // // Ende der Anwendung main //////////////////////////////////////////////////////////

Muste

rlösu

ng

mh

Textfeld

12

mh

Textfeld

12

mh

Textfeld

6

mh

Textfeld

5

mh

Textfeld

5

mh

Textfeld

5

mh

Textfeld

Kontrollfluss 5



Aufgabe 5 ( 20 % ) int main( int argc, char * argv[] ) { // Deklarationen wie A.3 unsigned long * ein_adresse_p, * aus_adresse_p; // kommt hinzu // Hochlauf wie A.3 // ... { fprintf(stdout,"*** Fehler beim Anfordern logischer E/A-Adresse\n"); return -1; } else { if( IPC_Kanal == attach_name( "Behaelter", GLOBAL ) == NULL ) fprintf( stdout, "*** Fehler beim Anmelden des Servernamens\n "); else // für den eigenen Timer { if( ( IPC_Verbindung = attach_connect( ZU_MIR, IPC_Kanal->Kanal_ID, RECHTE ) ) == -1 ) fprintf(stdout,"*** Fehler beim Anlegen einer IPC-Verbindung\n"); else { Konfig_IPC_Nachricht(&POSIX_Event,IPC_Verbindung,WECKALARM_TYP); Mytimer=start_realtime_cycletimer( & POSIX_Event, 500 ); // zyklischen Timer mit 500 ms zum Erzeugung einer IPC-Nachricht // via POSIX-Event anfordern und starten // // Hauptschleife hier ... do { ReceiveMessage( FROM_ANYWHRE, & message, sizeof( message ) ); if( message.sender == Mytimer ) // führe die Anwendung wie A.3 aus else if( message.sender == anyClient ) // führe die Behandlung der Nachricht aus // und antworte mit ReplyMessage else // weise illegitime Nachricht zurück } while (1); // } return 0; } } } // // Ende der Anwendung main ////////////////////////////////////////////////////////// Mus

terlö

sung

mh

Textfeld

5

mh

Textfeld

5

mh

Textfeld

5

mh

Textfeld

5

mh

Textfeld

5



Zum Betrieb einer Teilefertigung wird das Steuer-programm für eine modulare Prüfstraße benötigt. Dem Prüfmodul M liefert ein externes Handha-bungssystem oder das Vorgängermodul im Ob-jektfluss das jeweils nächste Prüfobjekt am Ein-gang E ab, falls dieser vom Sensor D0 als frei gemeldet ist. M erkennt im Zustand "Warte auf E" über D0 das gelieferte Objekt und fördert es mit F1 zum Prüfplatz. Seine Ankunft dort meldet D1. D0, D1 und D2 sind Digitaleingänge, F1 und F2 sind Digitalausgänge. P ist der analoge Eingang der Prüfgröße. Erfüllt P nicht die Prüfbedingung PLL < P < PHH, fördert M das Objekt mit F2 zum Ausgang A2, wartet auf Abholung (Sensor D2) durch das externe Handha-bungssystem und geht danach wieder in den An-fangszustand, wo es auf das nächste Objekt an E wartet.

Modul M

Modul M+1

D0

E

F1 D1,P

F2

F1

F2

A1

D1,P

D2

Sensor

D2 A2

Aktor

Ist die Prüfbedingung erfüllt, signalisiert M mit dem OK-Flag dem Nachfolgermodul M+1, dass ein Prüfobjekt abzuholen ist und beobachtet den Sensor D1 am Ausgang A1. Sobald M+1 das Objekt von dort übernommen hat, geht M in den Anfangszustand und wartet auf das nächte Objekt an E. Dem letzten Modul einer Prüf-straße nimmt ein externes Handhabungssystem das Prüfobjekt an A1 ab. Die Prüfstraße kann aus mehreren Modulen bestehen, die alle denselben Ablauf steuern, die Objekte aber auf unterschiedliche Messgrößen prüfen. Alle Module der Prüfstraße sollen zusammen in ein und dem-selben Programm gesteuert werden. Aufgabe 1 ( 20% ) Zeichnen Sie den Zustandsgraphen des MOORE-Automaten für M. Verwenden Sie dabei die Sensoren und Aktoren aus der Beschreibung. Aufgabe 2 ( 20% ) Definieren Sie das softwaretechnische Datenmodell von M als Datentyp in C. Aufgabe 3 ( 30% ) Formulieren Sie eine Funktion in C für den Steuerautomaten M zum zeitzyklischen Aufruf in der Hauptpro-zessschleife einer Anwendung. Nutzen Sie möglichst Ihren in Aufgabe 2 definierten Datentyp und erweitern Sie ihn wo nötig oder sinnvoll. Stellen Sie Eingabe und Ausgabe vorläufig nur in Kommentar dar. Aufgabe 4 ( 30% ) Jedes Modul hat ein eigenes Interface für die Ein- und Ausgabe seiner Sensor- und Aktorgrößen. Es belegt 16 Byte Speicher im Memoryadressraum. Folgende API-Funktion führt mit einem Aufruf gleichzeitig die Ein- und Ausgabe nicht blockierend aus (der Rückgabewert ist hier irrelevant): DWORD readWriteM( DWORD baseadress, UWORD * din, UWORD dout, DWORD * value ); Formulieren Sie eine Anwendung mit 2 Prüfmodulen M1 und M2 für ein Zielsystem mit Speicherschutz und Multitasking. Die Interfaces belegen Adressen 000B 0000 und 000B 0010 für M1 und M2. Die Verdrahtung der Digitalgrößen mit den Interfaceklemmen bestimmen Sie. Erweitern Sie ggf. den Datentyp aus Aufgabe 2. Aufgabe 5 ( 30% ) Es wird überlegt, die Anwendung von zeitzyklischer in ereignisgetriebene Verarbeitung umzustellen. Der Typ Interface der Aufgabe 4 erzeugt bei jeder Änderung des digitalen Eingabeworts einen IRQ, der sich durch Anwendung einer IPC-Spezialbibliothek in eine Message an den blockiert wartenden Anwenderprozess verwandeln lässt. Stellen Sie in Ihren Worten bzw. in geeigneten Diagrammen das Verhalten der Anwendung aus Aufgabe 4 dar, wenn diese ereignisbezogen programmiert wird. Entstehen Probleme? Wenn ja, schlagen Sie Ände-rungen zur Abhilfe vor.



Aufgabe 1 ( 20% )

Bereit(Warten an E)

zum Prüfplatz F1

Zu A2F2, ! OK

Prüfen

Warten A1OK

Warten A2

D0

D1

PLL < P < PHHP <= PLL ||P >= PHH

D2

! D1! D2

Aufgabe 2 ( 20% ) ////////////////////////////////////////////////////////////////// // Datei "mHeader.h" // typedef signed short WORD; typedef unsigned short UWORD; typedef unsigned long DWORD; struct pruefmodul { int d0, d1, d2, f1, f2, ok; WORD p, p_hh. p_ll; void adresse; int vorn; // zu Aufgabe 4;

// = 0, wenn das Prüfmodul einen Vorgänger hat UWORD din, dout;

DWORD value; int zustand; }; // ////////////////////////////////////////////////////////////////// Aufgabe 3 ( 30% ) ////////////////////////////////////////////////////////////////// // #include "mHeader.h" // // zu Aufgabe 3 ///////////////////////////////////////////////////////// #define Z_E 0 // Zustand Bereit (Warten an E) #define Z_F1 1 // Zustand Objekt fördern F1 #define Z_P 2 // Zustand Objekt prüfen #define Z_F2 3 // Zustand Objekt fördern F2 #define Z_A1 4 // Zustand Warten auf Abholen an A1 #define Z_A2 5 // Zustand Warten auf Abholen an A1 //////////////////////////////////////////////////////////////////////////

Muste

rlösu

ng



// void runPruefmodul( pruefmodul * m) { pruefmodul mb = * m; static int zustand = Z_E;

// hier den für Aufgabe 3 markierten Code in Aufgabe 4 einsetzen

p = mb.value; // Zustandswechsel //////////////////////////// switch( zustand ) { case Z_E: if( mb.d0 ) zustand = Z_F1; break; case Z_F1: if( mb.d1 ) zustand = Z_P; break; case Z_P: if( m.p < m.p_ll || m.p > m.p_hh ) zustand = Z_F2; else zustand = Z_A1; break; case Z_A1: if( !mb.d1 ) zustand = Z_E; break; case Z_F2: if( mb.d2 ) zustand = Z_A2; break; case Z_A2: if( !mb.d2 ) zustand = Z_E; break; default: break; } mb.zustand = zustand; // Aktionen //////////////////////////// if( zustand=Z_E || zustand=Z_P || zustand=Z_A1 || zustand=Z_A2 ) { mb.f1=0; mb.f2=0; mb.ok=1; } else if( zustand=Z_F1 ) { mb.f1=1; mb.f2=0; mb.ok=0; } else if( zustand=Z_F2 ) { mb.f1=0; mb.f2=1; mb.ok=0; } * m = mb; // "Rückgabe" an Referenzparameter } // ////////////////////////////////////////////////////////////////// Aufgabe 4 ( 30% ) // zu Aufgabe 4 ////////////////////////////////////////////////////////// #define SE_D0 0 // Verdrahtung an Eingabeinterfaceklemmen // #define SE_D1 1 // #define SE_D2 2 // #define SA_F1 0 // Verdrahtung an Ausgabeinterfaceklemmen #define SA_F2 1 // // ///////////////////////////////////////////////////////////////////////////

Muste

rlösu

ng



// zu Aufgabe 4 /////////////////////////////////////////////////////////// // // void runPruefmodul( pruefmodul * m); DWORD readWriteM(DWORD baseadress,UWORD * din,UWORD dout,DWORD * value ); // int main( int argc, char argv[] ) { pruefmodul m1, m2; // hier m1.p_hh, m1.p_ll Werte zuweisen m1.vorn = 1; m2.vorn = 0; m1.adresse = mmap_device_memory( 0, 16, PROT_READ|PROT_WRITE|PROT_NOCACHE 0, 0x000B0000 ); if ( m1.adresse == MAP_FAILED ) { perror( "mmap_device_memory für m1 fehlgeschlagen\n" ); exit( EXIT_FAILURE ); } m2.adresse = mmap_device_memory( 0, 16, PROT_READ|PROT_WRITE|PROT_NOCACHE, 0, 0x000B0010 ); if ( m2.adresse == MAP_FAILED ) { perror( "mmap_device_memory für m2 fehlgeschlagen\n" ); exit( EXIT_FAILURE ); } do { runPruefmodul( & m1 ); m2.d0 = m1.ok; runPruefmodul( & m2 ); delay( 100 ); } while( 1 ); return 0; } // // /////////////////////////////////////////////////////////////////////////// // void runPruefmodul( pruefmodul * m) { // hier Code wie Aufgabe 3 // zu Aufgabe 4 /////////////////////////////////////////////////////

// hier für den in Aufgabe 3 markierten Kommentar ersetzen durch // // // static int ersteraufruf = 1; if( ersteraufruf ) { mb.f1=0; mb.f2=0; mb.ok=0; ersteraufruf=0; } // if( mb.f1 ) mb.dout |= ( 1<<SA_F1 ); else mb.dout &= ~( 1<<SA_F1 ); if( mb.f2 ) mb.dout |= ( 1<<SA_F2 ); else mb.dout &= ~( 1<<SA_F2 ); // readWriteM( mb.adresse, & mb.din, mb.dout, & mb.value ); // if( mb.vorn) mb.d0 = ( mb.din & ( 1<<SE_D0 ) ) && 1; mb.d1 = ( mb.din & ( 1<<SE_D1 ) ) && 1; mb.d2 = ( mb.din & ( 1<<SE_D2 ) ) && 1; // // // zu Aufgabe 4 //////////////////////////////////////////////////////

Muste

rlösu

ng



// hier wieder Code wie Aufgabe 3 } // // /////////////////////////////////////////////////////////////////////////// Aufgabe 5 ( 30% ) a) Änderung: Im Hochlauf muss je eine IPC-Nachrichtenverbindung zwischen der ISR und dem Anwendungsprozess mit den Prüfmodulen eingerichtet werden. Im Code der Hauptschleife in Aufgabe 4 muss man das delay( 100 ) jetzt ersetzen durch einen Aufruf ReceiveMessage( fromInterface_1 ); oder ReceiveMessage( fromInterface_2 ); b) Problem: Bei Beibehaltung der sequentiellen Programmstruktur muss die eine Prüfanwendung auf das Eingabe-ereignis der anderen warten u.u. Damit ist das Schritthalten eines Prüfmoduls mit Änderungen seiner eigenen Eingabe unmöglich, wenn für das jeweils andere kein Eingabeereignis vorliegt. c) Verbesserung: Damit keines der Prüfmodule vom Warten auf das Ereignis des anderen behindert wird, müssen die beiden aus der sequentiellen in eine parallele Bearbeitung umgestellt werden: Multithreading oder Multitasking. Multithreading: jedes Prüfmodul hat sein eigenes Thread mit Hauptschleife, in welcher es auf Änderungen nur an seinem Interface blockiert wartet. Über globale Variable kann Modul 1 sein OK an das Modul 2 geben. Multitasking: jedes Prüfmodul läuft mit seiner Hauptschleife wie im Multithreading als eigener sequentieller Prozess, mit dem Vorteil, dass im Prinzip nur ein Programm nötig ist, das mit unterschiedlichen Startpara-metern auf seine Anwendung eingestellt wird (Adressen usw.). Das OK an das Nachfolgemodul muss über IPC, eine Datei oder per Semaphor geschütztem Shared Memory übertragen werden.

Muste

rlösu

ng



Für Materialtransporte in einem Industrieunterneh-men soll die Steuerung eines automatischen fahrerlosen Einbahnver-kehrs auf einem zentralen Industriecomputer in C entwickelt werden. Die Fahrzeuge durchfahren ein Netz mit max. 32 Kreuzungen. An jeder Kreuzung gelten folgende Regeln:

Erkennen Lenken, Stoppen Starten

8 m/s

4 m

Ein von Westen ankommendes Fahrzeug fährt je nach Richtungscode seines mitgeführten Funkchips entwe-der geradeaus oder nach rechts. Es muss vorher stoppen, falls ein anderes Fahrzeug von Norden kommt. Dies hat grundsätzlich Vorfahrt und biegt nicht ab. 4 Lichtschranken melden Ankünfte aus West bzw. Nord sowie Ausfahrten nach Ost bzw. Süd. Wenn die Lichtschranke "West" eine Ankunft meldet, übernimmt die Steuerung den Richtungscode aus dem Funkchip am Fahrzeug und gibt den Lenkbefehl und ggf. den Stopp-befehl an den Funkchip zurück. Das Fahrzeug lenkt bzw. stoppt entsprechend und wartet nach Stopp auf den Startbefehl, der ebenfalls per Funkchipausgabe kommt.

Die Fahrzeuge fahren mit 8 m/s, solange Sie nicht stoppen oder anfahren. Der max. Bremsweg ist 4 m. Der Mindestabstand eines Fahrzeugs zum Vorausfahrenden wird im Fahrzeug geregelt und ist 16 m. Aufgabe 1 ( 30% ) Bestimmen Sie die Zykluszeit des Steuerungsprogramms für einen Ablauf ohne IRQ, und formulieren Sie die Zeitkontrolle auf möglichst einfache Art. Nehmen Sie dabei an, dass die Ausführungszeit des Programms gegenüber der Zykluszeit verschwindend klein ist. Aufgabe 2 ( 30% ) Die Lichtschranken aller Kreuzungen K1 - K32 sind in einem digitalen Interface mit 128 Eingängen zusam-mengefasst. Es hat 4 Datenregister DW0 - DW3 von je 32 Bit. Daneben hat das Interface ein Status-WORD und ein Control-WORD. 2.1 Definieren Sie einen Datentyp für das Interface. 2.2 Formulieren Sie den Programmcode für (a) real adressierte und (b) geschützt adressierte Eingabe

aller 4 Datenregister. Die Interfaceadresse wird über die Kommandozeile des Programmaufrufs übergeben.

Aufgabe 3 ( 30% ) 3.1 Definieren Sie den Datentyp für eine Kreuzung. Deklarieren Sie alle Kreuzungsinstanzen. 3.2 Die Lichtschranken der Kreuzungen sind mit dem Interface so verdrahtet, dass K1 die Bits 0 bis 3 im

DW0 belegt. K32 belegt Bits 28 bis 31 im DW3. Alle anderen Ki sind nach diesem Schema belegt. Formulieren Sie die Zuweisung der Interfacedaten an die Kreuzung K24.

Aufgabe 4 ( 30% ) Definieren Sie den Zustandsgraphen für eine Kreuzung. Formulieren Sie eine C-Funktion dazu, in der Sie Ihre Lösung aus 2.4 verwenden. Formulieren Sie die Aufrufe der Funktion für alle Kreuzungen. Benutzen Sie Makros für Zuweisungen spezieller Werte, z.B. ABBIEGEN (nur benutzen, kein #define). Aufgabe 5 ( 30% ) 5.1 Stellen Sie die Zeitkontrolle mit der kleinen Spezialbibliothek ( #include <sys/PDVEvent.h> )

auf ereignisorientierten Ablauf um: int channel_attach( pid_t pid, int mode );

erzeugt einen IPC-Kanal für die Task pid. Mit mode = 0111 Rechte für Alle. Rückgabe: Kanalnr. int irq_connect( int channel, int irq );

schließt die ISR des IRQ irq an den IPC-Kanal channel = Kanalnr aus channel_attach an. int receive_message( int channel, void * message, int size );

Wartet blockiert auf Nachricht über IPC-Kanal channel. Mit message = NULL und size = 0 geeignet zum Wecken durch return einer ISR, die an den IPC-Kanal angeschlossen ist.

5.2 Zeichen Sie ein Sequenzdiagramm für 2 IRQ und diskutieren Sie Vor- und Nachteile dieser Pro-grammierung gegenüber der Zykluszeitprogrammierung.



Aufgabe 1 ( 30% ) // Header ... int main( int argc, char * argv[] ) { // lokale Deklarationen ...

hochlauf(); do { eingabe(); verarbeitung(); ausgabe(); delay( 500 ); // Zeitkontrolle: 500ms langer Lichtschrankenimpuls // entspricht Halbperiode des Prozesssignals } while( 1 ); herunterfahren(); return 0; } Aufgabe 2 ( 30% ) 2.1 // zum Header: struct digiIn128 { unsigned long dw[4]; unsigned short status, control; unsigned long basisadresse; }; 2.2 // zum Header: // ... // globale Variable: struct digiIn128 ls_einpuffer, * ls_einpointer; // void hochlauf( void ) { char * p;

ls_einpuffer.basisadresse = strtoul( argv[1], & p, 16 );

// (a) entweder so: //////////////////////////////////////////////////// ls_einpointer = ls_einpuffer.basisadresse; // // (a) ///////////////////////////////////////////////////////////////// // (b) oder so: //////////////////////////////////////////////////////// ls_einpointer = mmap_device_memory( 0, len, PROT_READ|PROT_WRITE|PROT_NOCACHE, 0, ls_einpuffer.adresse ); //

if (ls_einpointer == MAP_FAILED ) // { //

perror( "mmap_device_memory fehlgeschlagen\n" ); // exit( EXIT_FAILURE ); //

} // // (b) /////////////////////////////////////////////////////////////////

Muste

rlösu

ng



} // void eingabe ( void ) {

int i; for( i=0 ; i<4 ; ++i )

ls_einpuffer.dw[i] = ls_einpointer -> dw[i]; // Weiter wie untern in 3.2 ... // ... } Aufgabe 3 ( 30% ) 3.1 // zum Header: // ... struct kreuzung { int lichtschranke[4]; // 0: W, 1: N, 2: O, 3: S unsigned short richtungscode, lenkbefehl, stop, start; unsigned short error; } KR[32] ; // Typdefinition mit globaler Deklaration. 3.2 void eingabe( void ) { // wie oben in 2.2 // und hier dazu: i=2; // im Kontrollfluss einer Schleife über alle DW[i] j=28; // in der darin enthaltenen Schleife über alle Bits // in Inkrementen von 4 aufwärts for( k=0; k<4 ; ++k ) KR[23].lichtschranke[k] = ls_einpuffer.dw[i] & (1<<j+k); } Aufgabe 4 ( 30% ) Zustände: BEREIT Aktion: warten auf Ankunft einer Fahrzeugs aus West LENKEN Aktion: Eingabe Richtungsinfo, Erzeugen+Ausgabe Lenk-Stoppbefehl STOPP Aktion: Abwarten, bis Fahrzeug aus Nord aus der Kreuzung gefahren ist WARTEN Aktion: Ausgabe Startbefehl an gestopptes Fahrzeug + warten auf Ausfahrt

BEREIT

LENKEN STOPPWARTEN

Ankunft West

! (Ankunft Nord) Ankunft Nord

Ausfahrt Süd

(Ausfahrt Ost) || (Ausfahrt Süd)

Muste

rlösu

ng



// Def. der Verarbeitungsfunktion einer Kreuzung: // void verarbeiteKR( struct kreuzung * kr ) { static int zustand = BEREIT; kr -> error = 0;

switch( zustand ) {

case BEREIT: if( kr -> lichtschranke[0] ) // Ankunft West { kr -> lenkbefehl = lenken( kr -> richtungscode ); zustand = LENKEN; } break; case LENKEN: if( kr -> lichtschranke[1] ) // Ankunft Nord { kr -> stop = 1; zustand = STOPP; }

else { kr -> stop = 0; zustand = WARTEN; } break; case STOPP: if( kr -> lichtschranke[3] ) // Fahrz. von Nord passiert Ausf. Süd { kr -> stop=0; kr -> start = 1; zustand = WARTEN; } break; case WARTEN: if( kr->lichtschranke[2]||kr->lichtschranke[3] ) // Ausf. Ost||Süd { zustand = BEREIT; } break; default: zustand = ERROR; kr -> error = 1; } } } // // zur Funktion void verarbeitung( void ) : // void verarbeite( void ) {

int i; for( i=0 ; i<32 ; ++i )

verarbeiteKR( KR+i ); }

Muste

rlösu

ng



Aufgabe 5 ( 30% ) 5.1 // zum Header: // ... int channel, mode, irq, size; // zum Hochlauf: void hochlauf( void ) { // hier Hochlauf wie in Aufgabe 2.2 // und dazu:

channel = channel_attach( getpid(), 0111 ); if( irq_connect( channel, IRQ_DIGIN128 ) == -1 ) exit( EXIT_FAILURE );

} // in main: int main( aint argc, char * argv[] ) { // ... wie Aufg. 1 // delay( 500 ); //ersetzen durch: receive_message( channel, NULL, 0 ); // ... wie Aufg. 1 } 5.2

Interface

ISR

Task EE V AR.2 R.1 V AR.2 R.1

IRQ

Message

IRQ

Message

Vorteile: + schnelle Reaktion + geringer Ressourcenverbrauch + während des blockierten Wartens durch andere Ereignisse ansprechbar Nachteile; - Risiko für die Systemstabiliät durch hardwarenahe Programmierung - Aufwändige Portierung auf andere Systemtypen -

Muste

rlösu

ng



Ihre Aufgabe ist es, für einen Mikrocomputer ein Reglerprogramm mit folgendem digitalen Algorithmus schrittweise zu entwickeln:

Pn

PIn

Pn

PInnn

KxKKtx

KwKKtwyy

)1()(

)1()()1()(

)(

)(

Ihre API bietet Ihnen folgende Bibliotheksfunktionen, deklariert in <sys/PDVHeader.h> : void RPiParam ( char * pfile, double * ki, double * kp, double * tdelta );

übernimmt die Reglerparameter IK , Kp und t aus der Datei mit Pfad (Namen) an * pfile in das aufrufende Programm.

struct Timetype TimerRequest( void ); fordert einen Timer des Typs struct timetype an. void TimerStart( struct Timetype timer, long int interval ); parametriert das Zyklusintervall interval des Timers timer in Mikrosekunden. void TimerWait ( struct Timetype timer ); wartet blockiert auf das Ende des laufenden Zyklusintervalls des Timers timer. void TimerRelease ( struct Timetype timer ); gibt den Timer timer wieder frei. void REingabe ( struct Interface * if, ULONG base, double * in );

liest einen neuen Wert aus dem Interface if an der Basisadresse base im Memory. Der Aufruf blockiert bei leerem Puffer des ADU für umgewandelte Digitalwerte, bis ein neuer Wert fertig ist.

int REingabe_nonblock( struct Interface * if, ULONG base, double * in ); liest nicht blockierend einen neuen Wert aus dem Interface if; der Rückgabewert -1 zeigt an, dass der ADU mit der Wandlung des neuen Werts noch nicht fertig ist.

void RAusgabe ( struct Interface * if, ULONG base, double out ); schreibt einen Wert nicht blockierend in das Interface if an der Basisadresse base im Memory. Aufgabe 1 1.1 Erklären Sie, welche Zeitbedingung die Messsignalkette erfüllen muss, damit ein Reglerprogramm

stets den jeweils aktuellen Wert der Prozess- und Führungsgröße verarbeitet. 1.2 Formulieren Sie ein möglichst einfaches C-Programm für einen einzelnen Regler. Nehmen Sie dabei

an, dass die Parameter in der Datei "/home/PDV/rparam1.txt" gespeichert sind. Die real adressierten Interfaces der Ein- und Ausgabegröße haben die Basisadressen 0x0000ae00 bzw. 0x0000ce00.

Aufgabe 2 Erweitern Sie das Programm der vorigen Aufgabe um einen zweiten Regler, dessen Parameter in "/home/PDV/rparam2.txt" stehen, und dessen Interfaces die Basisadressen 0x0000be00 (Eingabe) bzw. 0x0000de00 (Ausgabe) haben. Definieren Sie zu diesem Zweck den Datentyp struct Regler. Aufgabe 3 Beide Regler aus Aufgabe 2 schreiben die Prozessgröße ihres Regelkreises jeweils in die Komponente PDVRegelung[i].x einer als Shared Memory namens dev/shmem/prozessDB implementierten Datenstruktur struct RTDatabase, definert in <sys/PDVHeader.h> Erweitern Sie das Programm nach Aufgabe 2 entsprechend, oder formulieren Sie den Programmcode unabhängig von einer Lösung der Aufgabe 2.



Aufgabe 1 1.1

{ Grenzfrequenz der Messsignale von Prozess- und Führungsgröße nach TP-Filterung } ≤ Abtastzyklusdauer ≤ Wandlungsdauer des ADU ≤ Abfragezyklusdauer der Eingabesoftware ≤ Verabeitungszyklusdauer des Reglerprogramms

1.2

#include <sys/PDVHeader.h> int main( void ) { struct Timetype aT; struct Interface * if_inX, * if_inW, * if_outY; double aKI, aKP, aDeltatT, aW_1, aW, aX_1, aX, aY; double aKoeff= aDeltatT*aKI + aKP; RPiParam( "/home/PDV/rparam1.txt", & aKI, & aKP, & aDeltaT ); aT=TimerRequest(); TimerStart( aT, aDelta_T ); do{ aW_1 = aW; aX_1 = aX; REingabe( if_inX, 0x000ae00, & aX ); REingabe_nonblock(if_inW,0x000ae00+sizeof(struct Interface),&aW); // Annahme in dieser Lösung: // Interface für X und W sind im Adressraum Nachbarn aY += (aW-aX)*aKoeff + (aX_1 - aW_1)*aKP; RAusgabe( if_outY, 0x0000ce00, aY ); TimerWait( aT ); }while ( 1 ); }

Aufgabe 2

#include <sys/PDVHeader.h> struct Regler { double KI, KP, DeltatT, W_1, W, X_1, X, Y; double Koeff; struct Interface * if_inW,* if_inX, * if_outY; ULONG base_inX, base_inW, base_outY; }; int main( void ) { struct Regler r1, r2; struct Timetype timer; double delta_t; RPiParam( "/home/PDV/rparam1.txt", & r1.KI, & r1.KP, & r1.DeltaT ); RPiParam( "/home/PDV/rparam2.txt", & r2.KI, & r2.KP, & r2.DeltaT ); r1.Koeff = r1.DeltatT * r1.KI + r1.KP; r2.Koeff = r2.DeltatT * r2.KI + r2.KP; r1.base_inX = 0x0000ae00; r1.base_inW = r1.base_inX + sizeof(struct Interface); r1.base_outY = 0x0000ce00; r2.base_inX = 0x0000be00; r2.base_inW = r2.base_inX + sizeof(struct Interface); r2.base_outY = 0x0000de00; if ( r1.DeltaT < r2.DeltaT ) delta_t = r1.DeltaT / 8; else delta_t = r2.DeltaT / 8; timer = TimerRequest(); TimerStart( timer, delta_t );

Muste

rlösu

ng



do{ //////////////////// Regler 1 ///////////////////////////////// // r1.W_1 = r1.W; r1.X_1 = r1.X; if ( REingabe_nonblock( r1.if_inX, r1.base_in, & r1.X ) != -1 ) { if(REingabe_nonblock( r1.if_inW, r1.base_inW, & r1.W )== -1) { r1.W = r1.W_1; // kein neuer Wert; alten benutzen } r1.Y += (r1.W-r1.X)*r1.Koeff + (r1.X_1 - r1.W_1)*r1.KP; RAusgabe( r1.if_outY, r1.base_outY, r1.Y ); } //////////////////// Regler 2 ///////////////////////////////// // r2.W_1 = r2.W; r2.X_1 = r2.X; if (REingabe_nonblock(r2.if_in, r2.base_in, & r2.W, & r2.X)!= -1) { r2.Y += (r2.W-r1.X)*r2.Koeff + (r2.X_1 - r2.W_1)*r2.KP; RAusgabe( r2.if_out, r2.base_out, r2.Y ); } /////////////////////////////////////////////////////////////// TimerWait( timer ); }while ( 1 ); }

Aufgabe 3 Diese Lösung stützt sich auf POSIX. Der Code dazu ist fett rot hervorgehoben. Zu Aufgabe 2 hinzugenommene, nicht verlangte Änderungen dienen der Vereinfachung und sind fett blau hervorgehoben. #include <sys/PDVHeader.h> #include <fcntl.h> #include <sys/mman.h> #include <sys/types.h> #include <unistd.h> #include <stdlib.h> struct Regler { double KI, KP, DeltatT, W_1, W, X_1, X, Y; double Koeff; struct Interface * if_inW,* if_inX, * if_outY; ULONG base_inX, base_inW, base_outY; char RPiParamPath[161]; }; ULONG pi_regler_nonblock( struct Regler r );int main( void ) { struct Regler r[2]; struct Timetype timer; double delta_t; struct RTDatabase * rtdaten; strncpy( r[0].RPiParamPath, "/home/PDV/rparam1.txt", 161 ); strncpy( r[1].RPiParamPath, "/home/PDV/rparam2.txt", 161 ); r[0].base_inX = 0x0000ae00; r[0].base_inW = r[0].base_inX + sizeof(struct Interface); r[0].base_outY = 0x0000ce00; r[1].base_inX = 0x0000be00; r[1].base_inW = r[1].base_inX + sizeof(struct Interface); r[1].base_outY = 0x0000de00;

Muste

rlösu

ng



for ( int i=0 ; i<2; ++i ) { RPiParam( r[i].RPiParamPath, & r[i].KI, & r[i].KP, & r[i].DeltaT ); r[i].Koeff = r[i].DeltatT * r[i].KI + r[i].KP; } if ( r[0].DeltaT < r[1].DeltaT ) delta_t = r[0].DeltaT / 8; else delta_t = r[1].DeltaT / 8; timer = TimerRequest(); TimerStart( timer, delta_t ); int smhandle = shm_open ("dev/shmem/prozessDB" , O_RDWR|O_CREAT, 0777); if ( smhandle == -1 ) { perror("Shared Memory"); exit (EXIT_FAILURE); } else { ftruncate( smhandle, sizeof( rtdaten+1 ); rtdaten = (struct rtdaten *)mmap( 0, sizeof( * rdaten)+1, PROT_READ|PROT_WRITE, MAP_SHARED, smhandle, (off_t) 0 ); if ( rtdaten == ( struct rtdaten * ) -1 ) { perror("mmap EchtzeitDB"); exit( EXIT_FAILURE ); } { do //// Prozessschleife ////////////////////////////////// { for ( int i=0 ; i<2 ; ++i ) // { pi_regler_nonblock( & r[i] ); // Regler als Function war nicht verlangt rtdaten -> PDVRegelung[i].x = r[i].X; } TimerWait( timer ); // }while ( 1 ); //////////////////////////////////////////// } } } // Implementierung der Regler in einer Function war nicht gefordert ULONG pi_regler_nonblock( struct Regler * r ) { ULONG status; struct Regler rbuf = * r; // Instanz rbuf vermeidet viele Zeigerzugriffe. rbuf.W_1 = rbuf.W; rbuf.X_1 = rbuf.X; if ( REingabe_nonblock( rbuf.if_in, rbuf.base_in, & rbuf.X ) == -1 ) status = -1; // kein neues X else { if ( REingabe_nonblock( rbuf.if_inW, rbuf.base_inW, & rbuf.W ) == -1 ) rbuf.W = rbuf.W_1; // kein neues W rbuf.Y += (rbuf.W-rbuf.X)*rbuf.Koeff + (rbuf.X_1 - rbuf.W_1)*rbuf.KP; RAusgabe( rbuf.if_out, rbuf.base_out, rbuf.Y ); status = 0; * r = rbuf; } return status; }

Muste

rlösu

ng



Für den Betrieb von Lastenaufzügen soll die Steuerung entwickelt werden. 4 Stockwerke sollen erreichbar sein. Zu jedem Stockwerk sind folgende schaltende Eingabesignale vorgesehen: 1x Anfordern des Aufzugs, 1x Ankunft/Anwesenheit der Aufzugs, 1x Sperre der Weiterfahrt (beim Be- oder Entladen), 3x Start an ein neues Ziel, 1x Not-Halt. Für die Eingabesignale ist ein Interface mit 32 digitalen Eingängen vorgesehen. Die Ausgabe an das Antriebssystem geschieht mit 3 exklusiv codierten Schaltgrößen: 1x Auf, 1x Ab, 1x Halt. Die unbeschleunigte Fahrt auf- bzw. abwärts geschieht mit 1 m/s. Beschleunigen und Verzögern ist in der Peripherie implementiert, daher darf die Steuerungssoftware die Bewegung als trägheitsfrei behandeln. Die Ankunft bzw. Anwesenheit wird je Stockwerk in der Peripherie über mehrere Sensoren realisiert, die auf den bewegten Aufzug über 20mm Länge seines Arbeitswegs ansprechen, bzw. auf den Stillstand an der Halte-position. Am Interface des Zielrechners kommt von diesen Sensoren je Stockwerk das Ergebnis ihrer ODER-Verknüpfung an. Damit das Steuerungsprogramm hochfahren kann, muss beim Einschalten aus genau einem Stockwerk die Anwesenheit des Aufzugs gemeldet werden. Erst ab dann kann der Aufzug in ein beliebiges anderes Stock-werk geschickt oder von dort angefordert werden. Der Aufzug setzt sich in Bewegung, sobald die ggf. ge-setzte Sperre im aktuellen Stockwerk aufgehoben worden ist. Eine Warteschlange für auszuführende Fahr-ten gibt es nicht. Aufgabe 1 1.1 Zeichnen Sie ein Anschlussschema für die Eingabe der Signale der peripheren Schaltgrößen an das

Digitalinterface. 1.2 Definieren Sie einen strukturierten Datentyp für die Eingabegrößen eines Stockwerks. Aufgabe 2 2.1 Die Aufzugsteuerung ist als MOORE-Automat implementierbar, der Stockwerke nicht unterscheidet.

Zeichnen Sie den Zustandsgraphen und bezeichnen Sie darin die Transitionen mit symbolischen Schaltvariablen.

2.2 Formulieren Sie die zugehörigen Schaltfunktionen als Legende zum Zustandsgraphen. Aufgabe 3 Formulieren Sie ein Klartext-Grobstruktogramm des Steuerungsprogramms. Aufgabe 4 Mit #include <special/digin.h> definiert der Header einer Anwendung die Treiberbibliothek für das hier verwendete Digitalinterface. In digin.h sind folgende Bibliotheksfunktionen deklariert:

int open_digin ( char * devicepath ); öffnet das Interface zum Lesen und gibt bei Erfolg einen Interface-Identifier >0 zurück, oder -1 bei Misserfolg.

int read_digin( int identifier, UDWORD * input ); gibt bei Erfolg das Makro READ_OK zurück, sowie die Referenz auf die aktuellen Eingabedaten.

int close_digin( int identifier ); schließt das Interface.

4.1 Formulieren Sie alles Nötige zum Öffnen des Digitalinterface in C im Hauptprogramm. Das Interface

wird vom Treiber als Spezialdatei mit dem Pfad "/dev/special/digin" bereitgestellt. 4.2 Formulieren Sie eine Funktion, die pro Aufruf die Eingabegrößen eines Stockwerks liefert. Verwenden

Sie dabei möglichst den strukturierten Datentyp aus Aufgabe 1.2. Formulieren Sie auch den Funktionsaufruf im Hauptprogramm und alles dazu Nötige.

4.3 Markieren Sie im Grobstruktogramm, wo 4.1 bzw. 4.2 formuliert werden. Aufgabe 5 5.1 Muss das laufende Programm evtl. seine Zykluszeit kontrollieren? Wenn ja bzw. unter welchen

Bedingungen mit welcher Zyklusdauer? 5.2 Ergänzen Sie das Struktogramm um den Code für isochrone Zykluszeitkontrolle.



Aufgabe 1 1.1

Klemme Bit

st_1_anford

st_1_ankunft

st_1_sperre

st_1_nothalt

Prozessgröße

...Andere Stockwerke nach gleichem Schema

wie bei Stockwerk 1

st_1_ziel_1

st_1_ziel_2

st_1_ziel_3

st_1_ziel_4

0

1

2

3

4

5

6

7

st_4_ziel_4 31

...st_2_anford 8

st_4_ziel_3 30

0

1

2

3

4

5

6

7

31

8

30

Eingabe-Doppelwort

Signale für Stockwerk 1

Interface

1.2 struct stockwerk { int anford; int ankunft; int sperre; int nothalt; int ziel_1; int ziel_2; int ziel_3; int ziel_4; }; Muste

rlösu

ng



Aufgabe 2 2.1

Halt

Auf

Ab

Angefordert

t_auf t_ab

t_anford

Einschalten

t_halt_angef

t_halt

t_halt

2.2 Hilfsfunktionen: nothalt = st_1_nothalt || st_2_nothalt || st_3_nothalt || st_4_nothalt; sperre = st_1_sperre || st_2_sperre || st_3_sperre || st_4_sperre; ziel_st_1 = st_1_anford || st_2_ziel_1 || st_3_ziel_1 || st_4_ziel_1 && !( ziel_st_2 || ziel_st_3 || ziel_st_4 ); ziel_st_2 = st_2_anford || st_1_ziel_2 || st_3_ziel_2 || st_4_ziel_2 && !( ziel_st_1 || ziel_st_3 || ziel_st_4 ); ziel_st_3 = st_3_anford || st_1_ziel_3 || st_2_ziel_3 || st_4_ziel_3 && !( ziel_st_1 || ziel_st_2 || ziel_st_4 ); ziel_st_4 = st_4_anford || st_1_ziel_4 || st_2_ziel_4 || st_3_ziel_4 && !( ziel_st_1 || ziel_st_2 || ziel_st_3 ); zielwahl = ziel_st_1 || ziel_st_2 || ziel_st_3 || ziel_st_4; ankunft = st_1_ankunft || st_2_ankunft || st_3_ankunft || st_4_ankunft; st_1_erreicht = ziel_st_1 && st_1_ankunft; st_2_erreicht = ziel_st_2 && st_2_ankunft; st_3_erreicht = ziel_st_3 && st_3_ankunft; st_4_erreicht = ziel_st_4 && st_4_ankunft; Transitionen: t_anford = !nothalt && ankunft && zielwahl; t_halt_angef = nothalt || sperre; t_auf = ( st_1_ankunft && (ziel_st_2 || ziel_st_3 || ziel_st_4 ) || st_2_ankunft && (ziel_st_3 || ziel_st_4 ) || st_3_ankunft && ziel_st_4 ) && !t_halt_angef; t_ab = ( st_4_ankunft && (ziel_st_1 || ziel_st_2 || ziel_st_3 ) || st_3_ankunft && (ziel_st_2 || ziel_st_1 ) || st_2_ankunft && ziel_st_1 ) && !t_halt_angef; t_halt = nothalt || st_1_erreicht || st_2_erreicht || st_3_erreicht || st_4_erreicht;

Musterlö

sung



Aufgabe 3

Musterlö

sung



Aufgabe 4 4.1 // im Header: ///////////////////////////////////////////// #include <special/digin.h> // ... /////////////////////////////////////////////////////////// // zu main: char inputpath[] = "/dev/special/digin"; int inputdevice; UDWORD inputdata; if( (inputdevice = open_digin( inputpath )) <= 0 ) {

fprintf( stdout, "*** kann %s nicht oeffnen\n", inputpath ); return -1;

} else { // hier geht es zur Hauptschleife: do { // Eingabedaten lesen ... // Transition berechnen ... // switch( Zustand ) { ... } // Aktion in Ausgabe schreiben ... } while( 1 ); } close_digin( inputdevice ); // ////////////////////////////////////////////////////////// 4.2 /////////////////////////////////////////////////////////// // zu main: // ...

struct stockwerk st[4]; int i; // ...

// hier geht es zur Hauptschleife: do {

for( i=0 ; i<4 ; ++i ) {

if( stockwerk_eingabe( inputdevice, st, i ) < 0 ) fprintf( stdout, "*** kann %s nicht lesen\n", inputpath );

} // Transition berechnen ... // switch( Zustand ) { ... } // Aktion in Ausgabe schreiben ...

} // ... ///////////////////////////////////////////////////////////

Musterlö

sung



// nachfolgende Funktionsdefinition: ////////////////////// // int stockwerk_eingabe( int interface, struct stockwerk * st, int st_nr ) {

UDWORD input; if( read_digin( interface, & input ) != READ_OK )

return -1; else { st -> anford = input & ( 1 << ( 0 + st_nr *8 )) ; st -> ankunft = input & ( 1 << ( 1 + st_nr *8 )) ; st -> sperre = input & ( 1 << ( 2 + st_nr *8 )) ; st -> nothalt = input & ( 1 << ( 3 + st_nr *8 )) ; st -> ziel_1 = input & ( 1 << ( 4 + st_nr *8 )) ; st -> ziel_2 = input & ( 1 << ( 5 + st_nr *8 )) ; st -> ziel_3 = input & ( 1 << ( 6 + st_nr *8 )) ; st -> ziel_4 = input & ( 1 << ( 7 + st_nr *8 )) ; return 0; } } ///////////////////////////////////////////////////////// Aufgabe 5 5.1 Muss das laufende Programm evtl. seine Zykluszeit kontrollieren? Wenn ja bzw. unter welchen Bedingungen

mit welcher Zyklusdauer? Ja, wenn das Programm auf einem Zielsystem mit Multitaskbetrieb abläuft.

Erfassung der Vorbeifahrt am Sensor während t = s/v = 20mm / 1000mm *s = 0,02s = 20ms ergibt eine Zyklusdauer von t/2 = 10ms

5.2 Ergänzen Sie das Struktogramm um den Code für isochrone Zykluszeitkontrolle.

// ... #include <sys/ipc_timer.h> // ... if( (mychannel = open_ipc( this_process ) ) == IPC_SUCCESS )

if( mytimer = open_pulsetimer( mychannel ) ) == TIMER_SUCCESS ) { interval.sec = 0; interval_nsec = 10000000; // 10ms

if( pulsetimer_settime( mytimer, interval ) == 0 ) { do { ipc_receive( mychannel, NULL ); // erwarte Timer // // hier E-V-A wie oben ... // } while( 1 ); }

}

Musterlö

sung

Documents

PDV und Feldbusse - · PDF filePDV und Feldbusse Klausur im Sommersemester 2017 Seite 1 von 2 Ostfalia Hochschule für angewandte Wissenschaften Fakultät Elektrotechnik