path: root/sheet.typ

#import "@preview/fletcher:0.5.1" as fletcher: diagram, node, edge, shapes
#import "@preview/bob-draw:0.1.0": *

#show link: it => [#text(blue)[#underline[#it]]]

#set page(
  header: box(width: 1fr, stroke: (bottom: 1pt), outset: (bottom: 3pt), [
  #link("https://source.orangerot.dev/university/itat-etit-cheatsheet")\
  #smallcaps[Informations- und Automatisierungstechnik, ETIT]
  #h(1fr)
  _Gero Beckmann_ \
  ]),
  footer: [
  ]
)
// #set heading(numbering: "1.1")

= Informationstechnik

#grid(columns: 2 * (1fr,),
[
== Qualitätskriterien für Software

- Correctness
- Availability
- Reliability
- Safety
- Security
- Robustness
],
[
==== Interne Qualitätsfaktoren von Software

- Effizienz
- Erweiterbarkeit
- Kompatibilität
- Portierbarkeit
- Wartbarkeit
- Wiederverwendbarkeit
]
)

#grid(columns: 2 * (1fr,), 
[
== Programmierparadigmen 

#table(columns: 2, 
  [Imperativ], [Assembly],
  [Prozedural], [C],
  [Funktional], [Haskell], 
  [Logikbasiert], [Prolog], 
  [Objektorientiert], [Java]
)
],[
== Fließkommazahlen
$ X = V_Z dot 1,m dot 2^(c - 127) $
float32 $~ 2 dot 2^127$
#table(
  columns: 3,
  [Sign[1]], [Characterstik[8]], [Mantisse[23]]
)
double64 $~ 2 dot 2^1023$
#table(
  columns: 3,
  [Sign[1]], [Characterstik[11]], [Mantisse[52]]
)
]
)

*Projekt:* 
Einmaligkeit, Zielvorgabe, Abgrenzung zu andren Vorhaben, Begrenzungen, Organisationsform

#grid(columns: 2*(1fr,), [
== Programmablaufplan
#diagram(node-stroke: 1pt, node((0,0), [Start], shape: shapes.pill))
#diagram(node-stroke: 1pt, node((0,0), [Verarbeitung], shape: shapes.rect))
#diagram(node-stroke: 1pt, node((0,0), [Ein-/Ausgabe], shape: shapes.trapezium.with(angle: -10)))
#diagram(node-stroke: 1pt, node((0,0), [Verzweigung], shape: shapes.diamond))
],[

=== Nassi-Schnreidermann
#image(height: 4cm, "assets/nassi.png")
])

#v(-.3cm)
#grid(columns: 2*(1fr,), column-gutter: .2cm, [
== Hashfunktionen

$
"prob"(i) &= (m - (i - 1)) / m = (7 - (4 - 1)) / 7 = 0,57 \ 
          & "Beispiel für 4. Element von 7"
$

=== Umgang mit Kollisionen beim Hashing
==== Verkettete Liste
Sofortiges Kopieren / Verzögertes Kopieren

- neue Tabelle tab' mit dopperter Größe m' sobald Füllstand von tab überschritten
- Bei Zugriff: übertrage Elemente mit kleinstem Index min von tab zu tab' und aktualisieren min
- Falls $h(k) = k mod m <= min$ greife auf tab' mit $h'(k) = k mod m'$ sonst
  greife auf tab mit $h(k) = k mod m$
- ersetze tab' mit tab sobald tab leer ist.

],[
==== Sondieren 

- lineares Sondieren $h_i(x) = (h(x) + i) mod m$
- quadratisches Sondieren $h_i(x) = (h(x) + i^2) mod m$

==== Doppeltes Hashen

- $h(k,i) = (h_1(k) + i dot h_2(k)) mod m$
- $h_1(k) = k mod m$
- $h_2(k) = 1 + (k mod m')$

Universale Hashfunktion

$
(abs({h in H mid(|) h(x) = h(y)})) / abs(H) <= 1/m
$

])

== Automatisierungstechnik

==== SPS Speicherprogrammierbare Steuerung
#render(```
        /_    "PAE (Prozessabbild der Eingänge), PAA (Prozessabbild der Ausgänge)"
         /  
+-----+-v-----------+-----+----------+-----+-------------+-|---+
| PHE | Applikation | PAA | Watchdog | PAE | Applikation | PAA |
|-----+-:-----------+-----+----------|-----+-------------+-:---+
+<------:----Zykluszeit------------->+                     :
        +<-----------------Latenzzeit--------------------->+
```)

==== AT-Pyramide

#table(columns: 2, 
[ERP - Enterprise Resource Planung], [Level 4: Unternehmensebene],
[MES - Management Execution System], [Level 3: Betriebsebene],
[SCADA - Supervisory, Control and Data Aquisiton], [Level 2: (Prozess-)Leitebene],
[SPS - Industrial Controller, SPS, Embedded System], [Level 1: Steuerungsebene],
[Ein-/Ausgangssignale - Sensoren, Aktoren, Kommunikationssysteme], [Level 1: Feldebene],
[Fertigung / Produktionsprozess], [Level 0: Prozessebene]
)

*Kontinuierliche Prozesse*: Ständiger Zu- und Abfluss von Material/Energie \
*Diskontinuierliche Prozesse*: Stückprozesse, Chargenprozesse (Wasser in Flaschen)

=== Petri-Netze / Ablaufsprache

// #render(```
//                 ,-.                           ,-.                                                              
//             ,->(   )-.                ,->|-->(   )->|-.                                                         
//   ,-.      /    `-'   V.        ,-.  /        `-'      V.                                                        
//  ((_)) ->|+            |->     ((_))                    |->                                                     
//   `-'      \    ,-.   ^'        `-'  \        ,-.      ^'                                                         
//             '->(   )_/                '->|-->(   )->|_/                                                           
//                 `-'                           `-'   '                                                          
// ```)

#grid(columns: 2, column-gutter: 1cm,
    diagram(
      node-stroke: 1pt,
      edge-stroke: 1pt,
      node((0,0), none, radius: 0.4cm, extrude: (0, 4), fill: black),
      node((1,0), height: 1cm, stroke: 3pt),
      node((2,0.5), none, radius: .5cm),
      node((2,-0.5), none, radius: .5cm),
      node((3,0), height: 1cm, stroke: 3pt),
      node((4,0), none, radius: .5cm),
      edge((0,0), (1,0), marks: (none, "straight")),
      edge((1,0), (2,0.5), marks: (none, "straight")),
      edge((1,0), (2,-0.5), marks: (none, "straight")),
      edge((2,0.5), (3,0), marks: (none, "straight")),
      edge((2,-0.5), (3,0), marks: (none, "straight")),
      edge((3,0), (4,0), marks: (none, "straight"))
      ),
    diagram(
      node-stroke: 1pt,
      edge-stroke: 1pt,
      node((0,0), [Init], inset: 10pt, extrude: (0, -4)),
      node((1,0.5), height: 1cm, stroke: 3pt),
      node((1,-0.5), height: 1cm, stroke: 3pt),
      node((2,0.5), [Schritt0]),
      node((2,-0.5), [Schritt1]),
      node((3,0.5), height: 1cm, stroke: 3pt),
      node((3,-0.5), height: 1cm, stroke: 3pt),
      node((4,0), [Schritt2]),
      edge((0,0), (1,0.5)),
      edge((0,0), (1,-0.5)),
      edge((1,0.5), (2,0.5)),
      edge((1,-0.5), (2,-0.5)),
      edge((2,0.5), (3,0.5)),
      edge((2,-0.5), (3,-0.5)),
      edge((3,0.5), (4, 0)),
      edge((3,-0.5), (4, 0)),
      )
    )

=== IEC 61131-3: Kontaktplan

#render(```
--| |-- Kontakt

--|/|-- negierter Kontakt vgl. Öffner
   
--( )-- Spule vgl. Relais
```)

SPS-Programmiersprachen: FBS, KOP, ST, AS, CFC

IEC 61131 Objektorientierung

#pagebreak()

== Automatisierungsarchitekturen

#table(
  columns: (3cm, 4cm, auto),
  table.header([], [*Zentrale Automatisierung*], [*Dezentrale Automatisierung*]),
  [Implementierung], [
    wenige Componenten zB SPS für gesamte Anlage.
  ], [
    Verteilte Steuerung (SPS) für dedizierte
    Anlagenteile. Übergeordnete Orchestrierung notwendig order direkte
    Kommunikation der Modulsteuerungen untereinander. 
  ],
  [Einsatzgebiet], [
    Zugeschnitten. Statischer Aufbau mit Single-Use
  ], [
    Aufteilung von Aufgaben/Funktionen. Reduktion der Komplexität der
    Steuerungskonfiguration. Zusätzlicher Aufwand zur Kommunikation. Hohe
    Zuverlässigkeit. Schnelle Wartung. Lastverteilung.  
  ]
)

*Zuverlässigkeit*: Wahrscheinlichkeit dass System Funktion erfüllt \
*Ausfall*: Übergang von funktionsfähig zu fehlerhaft \
*Fehler*: Zustand bei nichterfüllung mindestens einer Anforderung


*MooN*: M von N Komponenten müssen funktionieren, um Sicherheit zu gewährleisten. 

== Hardware-Redundanz - Doppelstrukturen

- Zwei Rechner müssen dass selbe Ergebnis berechnen damit fehlerfrei (2oo2)
- Zwei Rechner mit Watchdog. Wenn Rechner 1 fehlerhaft, schalte zu Rechner 2,
  falls auch fehlerhaft: Alarm! (1oo2)
- Zwei Rechner mit Watchdog und Lastverteilung. Rechner 2 berechnet normal
  weniger wichtige Dinge. (1oo2)

== Fehleridentifikation

- Sensoren zur Fehlererkennung
- Unlogische Zustände
- Keine Antwort von Sensor (Timeout)

== IEC 62061 Zuverlässigkeit (Werte von 1 bis 5)

- Schwere der Verletzung ($S in [1 hat(=) "Erste Hilfe",4 hat(=) "Tod"]$)
- Häufigkeit und Dauer der Gefährdungsposition ($F in [1 hat(=) "< 1 pro Jahr",
  5 hat(=) >= "1 pro h"]$)
- Wahrscheinlichkeit des Auftretens eines gefahrbringenden Ereignisses ($W in [1
  hat(=) "vernachlässigbar", 5 hat(=) "sehr hoch"]$)
- Möglichkeit zur Vermeidung oder Begrenzung des Schadens ($P in [1 hat(=)
  "wahrscheinlich", 5 hat(=) "unmöglich"]$)

  #image(height: 5.5cm, "assets/sil.png")