2020-12-06 19:23:01 +01:00
\documentclass [german, a4paper, headheight=36pt, parskip=true] { scrartcl}
\usepackage { hs-el-text}
\modul { Echtzeitdatenverarbeitung}
\semester { Wintersemester 2020/21}
2020-12-18 10:09:38 +01:00
\thema { Dokumentation Bearbeiten}
2020-12-06 19:23:01 +01:00
\author { Charlotte Friedemann \und Johannes Theiner}
2020-12-18 10:09:38 +01:00
\gruppe { A5}
2020-12-06 19:23:01 +01:00
\begin { document}
\maketitle
\section { Tasks} \label { sec:tasks}
2020-12-18 10:09:38 +01:00
Um einen konsistenten Startpunkt zu erhalten werden bei allen Tasks zu Beginn sämtliche vom entsprechenden
Task verwendeten Aktoren auf Ausgangsposition zurückgesetzt.
\subsection { Drehteller} \label { subsec:task_ turntable}
Nach dem Zurücksetzen vom Drehteller und des Auswerfers am Eingang fährt der Drehteller zuerst fünf Runden,
bei denen der Auswerfer am Ausgang bedingungslos betätigt wird,
um Teile die sich vielleicht noch in der Anlage befinden aus dieser zu entfernen.
Um eine Synchronisierung zu erlangen wird der Drehteller erst aktiv, wenn Prüfer, Bohrer und Auswerfer
mit einer Nachricht auf die Status Mailbox signalisiert haben das sie mit ihren Aktionen fertig sind.
Liegt auf mindestens einem Sensor(Eingang, Tester oder Bohrer) ein Teil wird der Drehteller
aktiviert und erst wieder deaktiviert, wenn dieser wieder in Position ist.
Nun wird den anderen Tasks über Nachrichten signalisiert das diese aktiv werden können
und der Prozess beginnt erneut.
\subsection { Prüfer} \label { subsec:task_ tester}
Sobald der Prüfer aktiv werden darf(Nachricht auf Status Mailbox) wird überprüft ob
ein Teil auf dem Sensor liegt.
Liegt ein Teil auf dem Sensor, fährt der Prüfer aus und das Testergebnis wird dem
Bohrer über eine Nachricht mitgeteilt.
Nun wird der Prüfer eingefahren und der Drehteller kann wieder aktiv werden.
Der Prozess beginnt nun wieder von vorne.
\subsection { Bohrer} \label { subsec:task_ drill}
Wird ein Werkstück durch den Sensor erkannt wird abhängig von der Nachricht des Prüfers der Bohrer
angeschaltet, heruntergefahren und das Werkstück festgehalten.
Nach einer kurzen Wartezeit wird der Bohrer wieder nach oben gefahren, ausgeschaltet und das Werkstück losgelassen.
Nachdem der Auswerfer über ein zu erwartendes Teil benachrichtigt wurde, wird die Kontrolle wieder an
den Drehteller übergeben.
\subsection { Auswerfer} \label { subsec:output}
Da für den Auswerfer keine Sensoren existieren sendet der Bohrer den Status seines Sensors per Nachricht
an den Auswerfer, der auf Basis dieser auslöst.
\subsection { Diagramme} \label { subsec:diagrams}
2020-12-07 11:49:32 +01:00
\begin { figure} [H]
2020-12-06 19:23:01 +01:00
\centering
2020-12-07 11:49:32 +01:00
\begin { minipage} { .5\textwidth }
\centering
\begin { plantuml}
2020-12-06 19:23:01 +01:00
@startuml
scale 150 width
!include https://raw.githubusercontent.com/bharatrajagopalan/plantuml-styles/master/activity_ skin.pu
start
:Drehteller ausschalten;
2020-12-07 11:49:32 +01:00
:Auswefer Eingang ausschalten;
repeat
:Drehteller kurz anschalten;
:Auswerfer kurz betätigen;
repeat while(5 Durchläufe ?)
2020-12-06 19:23:01 +01:00
repeat
:Prüfer fertig?<
:Bohrer fertig?<
:Auswerfer fertig?<
:Teil im Prüfer?<
:Teil im Bohrer?<
if(Teil auf einem Sensor ?) then (true)
:Drehteller anschalten;
if(Sensor Drehteller in Position ?) then (true)
:Drehteller auschalten;
endif
endif
:Drehteller fertig>
repeatwhile()
kill
@enduml
2020-12-07 11:49:32 +01:00
\end { plantuml}
\captionof { figure} { SDL Diagramm Drehteller}
\label { fig:sdl-turntable}
\end { minipage} %
\begin { minipage} { .5\textwidth }
\centering
\begin { plantuml}
2020-12-06 19:23:01 +01:00
@startuml
!include https://raw.githubusercontent.com/bharatrajagopalan/plantuml-styles/master/activity_ skin.pu
2020-12-07 11:49:32 +01:00
start
2020-12-06 19:23:01 +01:00
:Prüfer einfahren;
2020-12-07 11:49:32 +01:00
:Prüfer fertig>
2020-12-06 19:23:01 +01:00
repeat
:Drehteller fertig?<
if(Werkstück vorhanden ?) then (ja)
:Prüfer ausfahren;
2020-12-07 11:49:32 +01:00
if(Werkstück in Normallage ?) then (ja)
2020-12-06 19:23:01 +01:00
:Sende Bohrer(an)>
else (nein)
:Sende Bohrer(aus)>
endif
:Prüfer einfahren;
else (nein)
endif
:Prüfer fertig>
repeatwhile()
kill
@enduml
2020-12-07 11:49:32 +01:00
\end { plantuml}
\captionof { figure} { SDL Diagramm Prüfer}
\label { fig:sdl-tester}
\end { minipage}
\end { figure}
2020-12-06 19:23:01 +01:00
2020-12-07 11:49:32 +01:00
\begin { figure} [H]
\centering
\begin { minipage} { .5\textwidth }
\centering
\begin { plantuml}
@startuml
scale 150 width
!include https://raw.githubusercontent.com/bharatrajagopalan/plantuml-styles/master/activity_ skin.pu
start
2020-12-06 19:23:01 +01:00
:Bohrer ausschalten;
2020-12-07 11:49:32 +01:00
:Bohrer hochfahren;
2020-12-06 19:23:01 +01:00
:Werkstück loslassen;
2020-12-07 11:49:32 +01:00
:Bohrer fertig>
repeat
:Drehteller fertig?<
if(Werkstück vorhanden?) then(ja)
:Empfange Lage des Werkstücks<
:Sende Auswerfer>
if(Teil in Normallage?) then(ja)
:Werkstück festhalten;
:Bohrer anschalten;
:Bohrer herunterfahren;
:Warte bis Bohrer unten;
:Bohrer hochfahren;
:Warte bis Bohrer oben;
:Bohrer ausschalten;
:Werkstück loslassen;
else(nein)
endif
else (nein)
endif
:Bohrer fertig>
repeatwhile()
kill
@enduml
\end { plantuml}
\captionof { figure} { SDL Diagramm Bohrer}
\label { fig:sdl-drill}
\end { minipage} %
\begin { minipage} { .5\textwidth }
\centering
\begin { plantuml}
2020-12-06 19:23:01 +01:00
scale 250 width
@startuml
!include https://raw.githubusercontent.com/bharatrajagopalan/plantuml-styles/master/activity_ skin.pu
2020-12-07 11:49:32 +01:00
start
2020-12-06 19:23:01 +01:00
:Auswerfer einfahren;
2020-12-07 11:49:32 +01:00
:Auswerfer fertig>
2020-12-06 19:23:01 +01:00
repeat
:Drehteller fertig?<
:Auswerfer<
2020-12-07 11:49:32 +01:00
if(Auswerfen ?) then (ja)
:Auswerfer betätigen;
endif
2020-12-06 19:23:01 +01:00
:Auswerfer fertig>
repeatwhile()
kill
@enduml
2020-12-07 11:49:32 +01:00
\end { plantuml}
\captionof { figure} { SDL Diagramm Auswerfer}
\label { fig:sdl-output}
\end { minipage}
\end { figure}
2020-12-06 19:23:01 +01:00
2021-01-02 14:07:36 +01:00
\section { Hilfsfunktionen} \label { sec:functions}
Zur Vereinfachung des Leseflusses und der besseren Nachvollziehbarkeit des Codes werden wiederkehrende Programmteile in Hilfsfunktionen ausgelagert.
Passiert während des Durchlaufens der einzelnen Funktionen ein Fehler,
so wird die erste hier beschriebene Hilfsfunktion aufgerufen.
\subsection { void end(bool fail)} \label { subsec:void end(bool fail)}
Bei Aufruf dieser Hilfsfunktion werden sämtliche Taks, Mailboxen, Modbus-Verbindungen und Semaphoren deinitialisiert und der Timer gestoppt.
Falls der Übergabeparameter \mintinline { c} { fail == true} ist, so wird eine entsprechende Nachricht auf der Konsole ausgegeben.
\subsection { int readAll(int type, int *result)} \label { subsec:int readAll(int type, int *result)}
Das Auslesen aller zur Verfügung stehenden Bits, abhängig vom Typ der Verbindung, erfolgt mithilfe der nicht Thread-sicheren Funktion readAll.
Dabei wird dieser Funktion sowohl der Verbindungs-Typ (\mintinline { c} { DIGITAL_ IN, DIGITAL_ OUT, ANALOG_ IN, ANALOG_ OUT} ),
als auch ein Pointer auf den Speicherplatz übergeben, an welchem das Ergebnis gespeichert wird.
Bei erfolgreichem Durchlaufen dieser Funktion wird eine 0 zurückgegeben, ansonsten eine 1.
\subsection { int readData(int part)} \label { subsec:int readData(int part)}
Im Gegensatz zur Hilfsfunktion \mintinline { c} { readAll()} liest die Funktion readData nur ein einzelnes Bit aus und gibt dieses zurück.
Damit die Richtigkeit der Daten während des Auslesens gewährleistet werden kann,
ist diese Funktion mithilfe einer Semaphore Thread-sicher gemacht worden.
Nach dem Auslesen aller Bits des Modbus wird der Wert der Funktion \mintinline { c} { readAll()} mit der in \mintinline { c} { part} übergebenen Bitmaske verundet und somit isoliert.
Dieses einzelne Bit wird nun in \mintinline { c} { result} gespeichert und die Semaphore wieder freigegeben.
Bei fehlerfreiem Aufruf der \mintinline { c} { readAll()} -Funktion wird das spezifizierte einzelne Bit zurückgeben, falls nicht,
so wird in die \mintinline { c} { end()} -Hilfsfunktion gesprungen und alle Tasks, Mailboxen, etc deinitialisiert und gestoppt.
\subsection { void disable(int actor)} \label { subsec:void disable(int actor)}
Diese Funktion deaktiviert den im Übergabeparameter spezifizierten Aktor.
Da auch in diesem Fall die Daten aus dem Modbus während des Lesezugriffs nicht verändert werden dürfen ist diese Funktion Thread-sicher.
Zur Kommunikation mit dem jeweiligen Aktor wird die gesamte Bitfolge über \emph { readAll()} ausgelesen.
Ist dies ohne Fehler geschehen, so wird die empfangene Bitfolge mit der negierten Bitmaske des anzusprechenden Aktors verundet.
Diese neue, sich nur in einem Bit unterscheidende Bitfolge wird auf den Modbus geschrieben und die Semaphore freigegeben.
\subsection { void sendMail(MBX * mailbox, int msg)} \label { subsec:void sendMail(MBX * mailbox, int msg)}
Das Senden einer blockierenden Nachricht (\mintinline { c} { msg} ) an eine über mailbox spezifierte Mailbox wird mithilfe dieser Funktion realisiert.
\subsection { void sendMailNonBlocking(MBX * mailbox, int msg)} \label { subsec:void sendMailNonBlocking(MBX * mailbox, int msg)}
Im Unterschied zur Funktion \mintinline { c} { sendMail()} wird hier eine nicht-blockierende Nachricht (msg) an die in mailbox spezifizierte Mailbox gesendet.
\subsection { int receiveMail(MBX * mailbox)} \label { subsec:int receiveMail(MBX * mailbox)}
Diese Hilfsfunktion fasst das Erhalten einer blockierenden Nachricht an der im Übergabeparameter spezifizierten Mailbox
zusammen und gibt den Nachrichteninhalt zurück.
\subsection { int receiveMailNonBlocking(MBX * mailbox)} \label { subsec:int receiveMailNonBlocking(MBX * mailbox)}
Analog zu \mintinline { c} { receiveMail()} wird auch hier einen Nachricht an der im Übergabeparamter spezifizierten Mailbox erhalten und deren Inhalt zurückgegeben,
jedoch ist diese nicht blockierend.
\subsection { void sleepMs(int ms)} \label { subsec:void sleepMs(int ms)}
Da bei der Kommunikation der Tasks untereinander oder der Abarbeitung an den einzelnen Stationen teilweise Pausen benötigt werden,
ist diese Funktion unerlässlich. Dabei wird mithilfe des Übergabeparameters festgelegt, für wie viele Millisekunden ein Tasks pausieren soll.
2020-12-06 19:23:01 +01:00
\end { document}
