Ziele gemäß Rahmenlehrplan

Cyber-physische Systeme ergänzen

Die Schülerinnen und Schüler verfügen über die Kompetenz, die physische Welt und IT-Systeme funktional zu einem cyber-physischen System zusammenzuführen.

  • Die Schülerinnen und Schüler analysieren ein cyber-physisches System bezüglich eines Kundenauftrags zur Ergänzung und Inbetriebnahme weiterer Komponenten.

  • Sie informieren sich über den Datenfluss an der Schnittstelle zwischen physischer Welt und IT-System sowie über die Kommunikation in einem bestehenden Netzwerk. Sie verschaffen sich einen Überblick über die Energie-, Stoff- und Informationsflüsse aller am System beteiligten Geräte und Betriebsmittel.

  • Die Schülerinnen und Schüler planen die Umsetzung des Kundenwunsches, indem sie Kri- terien für die Auswahl von Energieversorgung, Hardware und Software (Bibliotheken, Protokolle) aufstellen. Dazu nutzen sie Unterlagen der technischen Kommunikation und passen diese an.

  • Sie führen Komponenten mit dem cyber-physischen System funktional zusammen.

  • Sie prüfen systematisch die Funktion, messen physikalische Betriebswerte, validieren den Energiebedarf und protokollieren die Ergebnisse.

  • Die Schülerinnen und Schüler reflektieren den Arbeitsprozess hinsichtlich möglicher Optimierungen und diskutieren das Ergebnis in Bezug auf Betriebssicherheit und Datensicherheit.

Plan

Zeitplan

gantt
 title August - September (20UE LF7)
 dateFormat YYYY-MM-DD
 axisFormat %d.%m.
 section Do 28.08. 5
  Einführung, Grundlagen CPS, Schnittstellen, Einheiten  :2025-08-28, 5h
 section Fr 29.08. 6
  Widerstände, Logikgatter, Binäres Rechnen, DevOps  :2025-08-29, 4h
  SOL Git                     :crit, 2025-08-29, 2h
 section Do 04.09. 5
  Q&A, Wiederholung           :2025-09-04, 5h
  Nachhilfe                   :2025-09-04, 2h
 section Fr 05.09. 4
  Klassenarbeit               :crit, 2025-09-05, 2h
  GPIO, Mikrocontroller, Raspberry Pi, Simulator  :2025-09-05, 2h

gantt
 title Oktober (38UE IoT + 5UE LF7)
 dateFormat YYYY-MM-DD
 axisFormat %d.%m.
 section Mo 20.10. 8
  IoT Kurs                    :2025-10-20, 8h
 section Di 21.10. 8
  IoT Kurs                    :2025-10-21, 8h
 section Mi 22.10. 8
  IoT Kurs                    :2025-10-22, 8h
 section Do 23.10. 8
  IoT Kurs                    :2025-10-23, 8h
 section Fr 24.10. 6
  IoT Kurs                    :2025-10-24, 6h
 section Do 30.10. 5
  Standarts, Node-RED, REST, OpenAPI, HTTP  :2025-10-30, 5h

gantt
 title Dezember (15UE LF7)
 dateFormat YYYY-MM-DD
 axisFormat %d.%m.
 section Fr 05.12. 4
  HTTP, MQTT                  :2025-12-05, 4h
 section Mi 10.12. 5
  UART, I2C, SPI              :2025-12-10, 5h
 section Fr 12.12. 6
  Programmierübungen          :2025-12-12, 4h
  SOL Beenden Programmierübungen  :crit, 2025-12-12, 2h

gantt
 title Januar-Februar (30UE LF8b + 19UE PV)
 dateFormat YYYY-MM-DD
 axisFormat %d.%m.
 section Mo 12.01. 3
  PV                          :2026-01-12, 3h
 section Di 13.01. 3
  PV                          :2026-01-13, 3h
 section Mi 14.01. 5
  LF8b                        :2026-01-14, 5h
 section Do 15.01. 5
  LF8b                        :2026-01-15, 5h
 section Fr 16.01. 8
  LF8b                        :2026-01-16, 6h
  SOL PV                      :crit, 2026-01-16, 2h
 section Mo 02.02. 5
  LF8b                        :2026-02-02, 5h
 section Di 03.02. 3
  LF8b                        :2026-02-03, 3h
 section Mi 04.02. 4
  LF8b                        :2026-02-04, 4h
 section Do 05.02. 5
  LF8b                        :2026-02-05, 2h
  PV                          :2026-02-05, 3h
 section Fr 06.02. 8
  PV                          :2026-02-06, 6h
  SOL PV                      :crit, 2026-02-06, 2h

gantt
 title März (11UE LF7)
 dateFormat YYYY-MM-DD
 axisFormat %d.%m.
 section Do 26.03. 5
  Q&A, Wiederholung             :2026-03-26, 5h
 section Fr 27.03. 6
  Klassenarbeit                 :crit, 2026-03-27, 2h
  Von-Neumann-Zyklus            :2026-03-27, 2h
  SOL Projektplan               :crit, 2026-03-27, 2h

gantt
 title Mai-Juni (33UE LF7)
 dateFormat YYYY-MM-DD
 axisFormat %d.%m.
 section Do 21.05. 5
  Vorstellung Praxisprojekte    :crit, 2026-05-21, 2h
  Praxis                        :2026-05-21, 3h
 section Fr 22.05. 6
  Potenzielle Gefahren, Schutzbedarfsanalyse, FMEA  :2026-05-22, 2h
  Praxis                        :2026-05-22, 2h
  SOL Projektdokumentation, Schutzbedarfsanalyse    :crit, 2026-05-22, 2h
 section Di 09.06. 6
  Praxis                        :2026-06-09, 6h
 section Mi 10.06. 5
  Praxis (Benotung)             :crit, 2026-06-10, 5h
 section Do 18.06. 5
  Praxis                        :2026-06-18, 5h
 section Fr 19.06. 6
  Projektpräsentation           :2026-06-19, 4h
  SOL Projektdokumentation      :2026-06-19, 2h

Leistungskontrollen

  • Soll Notendichte: 7
  • Minimum Klassenarbeiten (>45min, doppelte Wertung): 2
  • Sonstige Noten: >=3

Programmier-Übungsaufgaben:

  • Mündliche Note 21.05.
    • Vorstellung Projektplan (SOL vom 27.03.)
    • Bisherige Mitarbeit
  • Bewertung Praxisprojekt am 10.06.
    • Note für fachliche Leistung
    • Note für Mitarbeit
  • Projektpräsentation 19.06. (nach Notenschluss)

Literatur

Lehrbuch

„IT-Berufe Fachstufe Technische IT-Berufe Lernfelder 6-9“

Westermann

  1. Auflage 2022

ISBN 978-3-14-220036-1

FI-Abschlussprüfungen der IHK (Teil 1+2, FISI+FIAE)

2021 - 2025

Prüfungskatalog FISI + FIAE

„Prüfungskatalog für die IHK Abschlussprüfungen — Fachinformatiker Fachinformatikerin Fachrichtung Systemintegration — Verordnung über die Berufsausbildung zum Fachinformatiker/ zur Fachinformatikerin“

Zentralstelle für Prüfungsaufgaben der Industrie- und Handelskammern (ZPA) Nord-West

  1. Auflage 2024 (Stand 10/2024)

Lernkarten für IHK-Abschlussprüfungen (Teil 1+2, FISI+FIAE)

u-form Verlag 2024

Prüfungsvorbereitung FISI

„Prüfungsvorbereitung Aktuell — Teil 2 der gestreckten Abschlussprüfung Fachinformatiker/-in Systemintegration (nach der neuen Ausbildungsverordnung ab August 2020)“

Europa-Fachbuchreihe

  1. Auflage 2022

ISBN 978-3-7585-3169-9

Grundlagen CPS

Was sind Cyber-physische Systeme?

=> Ein CPS ist eine Verbindung eines IT-Systems (Hard-&Software) mit physischen Bauteilen, die miteinander kommunizieren. Sprich ein CPS verbindet die virtuelle Welt mit der realen.

Was ist „Cyber“ und wo kommt das Wort her?

Kritik

Cybersicherheitsarchitektur

Cyberwehr

Anwendungsfelder

  • Industrie 4.0 = ist die Bezeichnung für Projekte zur umfassenden Digitalisierung der industriellen Produktion.
  • Smart Grids (deutsch: Intelligentes Stromnetz)
  • Logistik, Verkehrssteuerung
  • E-Health
  • Sicherheits- & Fahrerassistenzsysteme
  • Frühwarnsysteme für Katastrophenschutz (Bsp. Tsunami)

Relevante Technologien

  • Eingebettete Systeme => sind Computer Systeme die Verbaut sind für ein bestimmten Anwendungsfall (z.B. Kassensysteme)

  • Sensornetze => sind ein Verbund aus Sensoren in einem bestimmten Bereich

  • Internet-Infrastruktur => Geräte werden mit Internet ausgestattet und verbunden

  • Echtzeitverarbeitung => Daten werden in Echtzeit verarbeitet

Begriffe

Bullshit-Bingo

flowchart TB
  cps(CPS)
  cps --> iot(IoT)
  iot --> smarthome(Smart Home)
  smarthome --> smarthealth(Smart Health)
  smarthome --> VR
  smarthome --> AR
  smarthome --> sprache(Spracherkennung & -steuerung)
  iot --> smartgrid(Smart Grid)
  iot --> smartcities(Smart Cities)
  iot --> iiot(IIoT)
  cps -.-> cppc(CPPC) -.-> iiot
  iiot --> industrie40(Industrie 4.0)
  industrie40 --> smartfactory(Smart Factory)

Begriffserklärungen

IoT

Internet of Things

=> Sammelbegriff für CPS-Geräte, die über das Internet kommunizieren können

VR

Virtuelle Realität

=> computergenerierte, interaktive, virtuelle Umgebung

AR

Augmented Reality

=> erweiterte Realität

CPPC

Cyber Physical Production Control

„Industrie 4.0“

„Industrie 4.0 ist die Bezeichnung für Projekte zur umfassenden Digitalisierung der industriellen Produktion.

Das Projekt geht zurück auf die Forschungsunion der deutschen Bundesregierung und ein gleichnamiges Projekt in der Hightech-Strategie der Bundesregierung.“ [1]

  1. industrielle Revolution bestand in der Mechanisierung mittels Wasser- und Dampfkraft (ab ~1790)
  2. industrielle Revolution geprägt durch Massenfertigung mit Hilfe von Fließbändern und elektrischer Energie (ab ~1870)
  3. industrielle Revolution oder digitale Revolution Automatisierung durch Einsatz von Elektronik und IT (v. a. die speicherprogrammierbare Steuerung und die CNC-Maschine) (ab ~1970)
  4. industrielle Revolution: Netzwerke, CPS, Industrial Internet of Things, Smart Factory, Cyber Physical Production Control (ab ~2017)

Schnittstellen

Wie kommunizieren Mensch, „Cyber“ und Physik miteinander?

„Aus CPS-Sicht“

HCI vs M2M vs CPS

flowchart LR
  Mensch <--HCI--> Cyber
  subgraph CPS[Cyber-physisches System]
    subgraph Cyber[Cyber System]
      Computer1 <--M2M--> Computer2
    end
    subgraph PS[Physisches System]
      subgraph Schnittstelle
        Aktuator
        Sensor
      end
      subgraph I[Geräte / Anlagen]
        Maschine1
        Maschine2
      end
    end
    PS --messen--> Cyber
    Cyber --ansteuern--> PS
  end
  Mensch <-..-> PS

HCI

(Human–computer interaction / Human-computer Interface)

-> Mensch-Maschine-Interaktion / Benutzerschnittstelle

M2M

(Machine-to-Machine)

CPS

(Cyber-physical system)

„Aus Sicht eines Prozessors“

(Rechnerarchitektur / Prozessorarchitektur)

IHK-Zwischenprüfung Herbst 2018: Aufgabe 2.2

stark vereinfacht

flowchart LR
subgraph Computersystem
  Arbeitsspeicher
  subgraph Devices
    subgraph Peripherie
      Speichermedien
      Netzwerkkarten
      HID[Human Interface Device]
    end
    Controller
    Koprozessoren
  end
  subgraph Prozessor
    Bus <--> Register
    Bus <--> Rechenwerk <--> Register
    Bus <--> Steuerwerk <--> Register
    Steuerwerk <--> Rechenwerk
  end
end
Arbeitsspeicher <--> Bus
Devices <--> Bus

cpu

detailierter

flowchart TB
  subgraph Motherboard[Motherboard / SoC]
    Arbeitsspeicher <--MMU--> Northbridge
    subgraph CPU-Chip
      Northbridge <--FSB--> Bus
      subgraph Prozessor-Kern
        Bus <--> Register
        Bus <--> Rechenwerk <--> Register
        Bus <--> Steuerwerk <--> Register
        Steuerwerk <--> Rechenwerk
      end
    end
    Northbridge <--DMI-->  Southbridge
  end
  subgraph Welt[Rest der Welt]
    subgraph Devices
      Device1
      Device2
      Device3
    end
  end
  Southbridge <--MMIO-->Device1 
  Southbridge <--PMIO--> Device2
  Register <--GPIO--> Device3
SoC

(System-on-a-Chip)

FSB

(Front Side Bus)

DMI

(Direct Media Interface)

MMU

(Memory Management Unit)

MMIO

(Memory-mapped I/O)

PMIO

(Port-mapped I/O)

GPIO

(General Purpose Input/Output)

lstopo -.txt

Beispiel Skylake Microarchitectures

Elektrische Einheiten

FormelzeichenEinheit
UVelektrische Spannung
IAelektrischer Strom
R = U / IΩ = V/Aelektrischer Widerstand
P = U * IW = VAelektrische Leistung
E (W) = P * tWhelektrische Energie (Arbeit)

Widerstände

Schaltzeichen:

=> Farbkodierung

Berechnung

R = U / I

Einheit: Ω = V / A

Messung

=> mittels Ohmmeter

Vorwiderstände

=> zur Strombegrenzung

UV = U - UR

RV = UV / I

gegeben:

U => Spannungsversorgung

UR => Spannung, die über zu schützendem Bauteil (z.B. LED) abfallen soll

I => Strom, der maximal durch das zu schützende Bauteil fließen soll

gesucht:

RV => benötigter Vorwiederstand

Welchen Wiederstand wählen wir aus, wenn ein Wiederstand benötigter größe nicht vorhanden ist?

Pull-up und Pull-down

=> zieht Signalleitung standartmäßig auf gewünschten Pegel

Praxis

=> Grundschaltungen ausprobieren

  • Schaltkreis mit LED + Vorwiderstand
    • Taster einbauen
  • AND und OR mit 2 Tastern
  • NOT mit Taster und Pull-up-Wiederstand
    • 2 verschiedenfarbige LEDs am Ein-/Ausgang
  • XOR mit 2 „Umschaltern“ bzw. Jumper wires
  • AND, OR, NOT mit Transistoren

Zusatzaufgaben:

Benötigstes Material pro Gruppe

  • Spannungsversorgung
    • 5V von Raspberry-Pi + USB-Netzteil => Pinout
    • je ein Jumper Wire female->male (rot+schwarz)
  • Breadboard + Jumper Wires male->male (verschiedenfarbig)
  • 2 LEDS (verschiedenfarbig) + 2 Vorwiederstände (330Ω)
  • 2 Taster
  • 1 Pull-Up- bzw. Pull-Down-Widerstand (470Ω-1kΩ)
  • 2 Transistoren mit 10kΩ Basis-Widerstand

Breadboard

Prozessoren

SOL „Funktionsweise von Prozessoren“

Erkundigen Sie sich selbstständig darüber, wie es möglich ist, mittels Maschinen zu rechnen. Als Einstieg wird folgendes Video empfohlen: A Computer Built With Dominos.

Beantworten Sie die folgenden Fragen:

  1. Wie funktioniert das Binärsystem?
  2. Schreiben Sie die Zahlen 0-7 als Binärzahl auf.
  3. Benennen Sie 4 verschiedene zweistellige logische Verknüpfungen (Logikgatter).
  4. Was ist ein Halbaddierer?
  5. Wieviele Eingänge und wieviele Ausgänge hat ein Halbaddierer?
  6. Zeichnen oder beschreiben Sie eine Schaltung, wie ein Halbaddierer aus einfachen Logikgattern aufgebaut werden kann.
  7. Finden Sie Möglichkeiten, wie Logikgatter mittels Murmeln, Wasser oder in Minecraft aufgebaut werden können?

Transistoren

npn

npn

Aufbau von Gattern und Addierer mit BJT-Transistioren

Von-Neumann-Zyklus

cpu

  1. FETCH (Befehlsabruf):
    • Nächsten Befehl (entsprechend Adresse im Befehlszähler) aus Arbeitsspeicher in das Befehlsregister laden und Befehlszähler inkrementieren
  2. DECODE(Dekodierung):
    • Der Befehl wird durch das Steuerwerk in Schaltinstruktionen für das Rechenwerk aufgelöst
  3. FETCH OPERANDS(Operandenabruf):
    • Operanden werden aus dem Speicher laden
  4. EXECUTE (Befehlsausführung):
    • Arithmetische oder logische Operation wird vom Rechenwerk berechnet. (Bei Sprungbefehlen und erfüllter Sprungbedingung wird der Befehlszähler angepasst)
  5. WRITE BACK (Rückschreiben des Resultats): Ergebnis der Berechnung wird in den Speicher zurückgeschrieben (falls nötig)

Assembler

ARM instruction summary

Beispiel (blinky-rust):

git clone git@github.com:johannesloetzsch/blinky-rust-nix.git -b asm
cd blinky-rust-nix; nix develop
cargo rustc -- --emit asm
grep -m1 main_loop: -A43 target/thumbv7m-none-eabi/debug/deps/blinky_rust-*.s | bat --file-name example.s

.LBB26_1:
    .loc    11 0 5 is_stmt 0
    subs    r0, r7, #1
    .loc    11 15 9 is_stmt 1
    str r0, [sp]
    bl  _ZN136_$LT$stm32f1xx_hal..gpio..gpioc..PC13$LT$stm32f1xx_hal..gpio..Output$LT$MODE$GT$$GT$$u20$as$u20$embedded_hal..digital..v2..OutputPin$GT$8set_high17h41a8f7d2c1b1fab3E
    bl  _ZN4core6result19Result$LT$T$C$E$GT$2ok17hbba81ef68e509503E
    .loc    11 16 9
    ldr r0, [sp, #8]
    mov.w   r1, #1000
    str r1, [sp, #4]
    bl  _ZN97_$LT$stm32f1xx_hal..delay..Delay$u20$as$u20$embedded_hal..blocking..delay..DelayMs$LT$u16$GT$$GT$8delay_ms17h9fb44941d1d2b02bE
    ldr r0, [sp]
    .loc    11 18 9
    bl  _ZN136_$LT$stm32f1xx_hal..gpio..gpioc..PC13$LT$stm32f1xx_hal..gpio..Output$LT$MODE$GT$$GT$$u20$as$u20$embedded_hal..digital..v2..OutputPin$GT$7set_low17h5e48a13c9b6d1e70E
    bl  _ZN4core6result19Result$LT$T$C$E$GT$2ok17hbba81ef68e509503E
    ldr r1, [sp, #4]
    .loc    11 19 9
    ldr r0, [sp, #8]
    bl  _ZN97_$LT$stm32f1xx_hal..delay..Delay$u20$as$u20$embedded_hal..blocking..delay..DelayMs$LT$u16$GT$$GT$8delay_ms17h9fb44941d1d2b02bE
    b   .LBB26_1

Binary

## laut disassembly startet <main_loop> bei 0800_016c, das ist im ELF-binary an 1_016c
hexdump -s $((16#1016c)) target/thumbv7m-none-eabi/debug/deps/blinky_rust-* |head -n4

001016c b580 466f b084 9002 e7ff 1e78 9000 f000
001017c f92f f000 f886 9802 f44f 717a 9101 f000
001018c fc30 9800 f000 f917 f000 f87b 9901 9802
001019c f000 fc27 e7e9 b580 466f f000 f800 b580

## …und an adresse 717a befindet sich #0x3e8, also #1000
hexdump -s $((16#20717a)) target/thumbv7m-none-eabi/debug/deps/blinky_rust-* |head -n 1

020717a 4202 070d 0000 0018 0000 03e8 0000 0000

Disassemble

cargo objdump -- -S target/thumbv7m-none-eabi/debug/deps/blinky_rust-* | grep -m1 '<main_loop>' -A 26

0800016c <main_loop>:
; fn main_loop(mut led: PC13<Output<PushPull>>, mut delay: Delay) -> ! {
 800016c: b580         	push	{r7, lr}
 800016e: 466f         	mov	r7, sp
 8000170: b084         	sub	sp, #0x10
 8000172: 9002         	str	r0, [sp, #0x8]
;     loop {
 8000174: e7ff         	b	0x8000176 <main_loop+0xa> @ imm = #-0x2
 8000176: 1e78         	subs	r0, r7, #0x1
;         led.set_high().ok();
 8000178: 9000         	str	r0, [sp]
 800017a: f000 f92f    	bl	0x80003dc <_ZN136_$LT$stm32f1xx_hal..gpio..gpioc..PC13$LT$stm32f1xx_hal..gpio..Output$LT$MODE$GT$$GT$$u20$as$u20$embedded_hal..digital..v2..OutputPin$GT$8set_high17h41a8f7d2c1b1fab3E> @ imm = #0x25e
 800017e: f000 f886    	bl	0x800028e <_ZN4core6result19Result$LT$T$C$E$GT$2ok17hbba81ef68e509503E> @ imm = #0x10c
;         delay.delay_ms(1000_u16);
 8000182: 9802         	ldr	r0, [sp, #0x8]
 8000184: f44f 717a    	mov.w	r1, #0x3e8
 8000188: 9101         	str	r1, [sp, #0x4]
 800018a: f000 fc30    	bl	0x80009ee <<stm32f1xx_hal::delay::Delay as embedded_hal::blocking::delay::DelayMs<u16>>::delay_ms::h9fb44941d1d2b02b> @ imm = #0x860
 800018e: 9800         	ldr	r0, [sp]
;         led.set_low().ok();
 8000190: f000 f917    	bl	0x80003c2 <_ZN136_$LT$stm32f1xx_hal..gpio..gpioc..PC13$LT$stm32f1xx_hal..gpio..Output$LT$MODE$GT$$GT$$u20$as$u20$embedded_hal..digital..v2..OutputPin$GT$7set_low17h5e48a13c9b6d1e70E> @ imm = #0x22e
 8000194: f000 f87b    	bl	0x800028e <_ZN4core6result19Result$LT$T$C$E$GT$2ok17hbba81ef68e509503E> @ imm = #0xf6
 8000198: 9901         	ldr	r1, [sp, #0x4]
;         delay.delay_ms(1000_u16);
 800019a: 9802         	ldr	r0, [sp, #0x8]
 800019c: f000 fc27    	bl	0x80009ee <<stm32f1xx_hal::delay::Delay as embedded_hal::blocking::delay::DelayMs<u16>>::delay_ms::h9fb44941d1d2b02b> @ imm = #0x84e
 80001a0: e7e9         	b	0x8000176 <main_loop+0xa> @ imm = #-0x2e

bare-metal-programming

Logikgatter

Aufgabe 6 von Seite 78 aus „Prüfungsvorbereitung Aktuell Teil 1“ (Europa Verlag)

NOT

Y = NOT X = ¬ X = X̅

XNOT X
01
10


AND

Y = X1 AND X2 = X1 & X2 = X1 ∧ X2 = X1 • X2 = X1 X2

X1X2X1 AND X2
000
010
100
111


OR

Y = X1 OR X2 = X1 ∨ X2 = X1 + X2

X1X2X1 OR X2
000
011
101
111


XOR

Y = X1 XOR X2 = X1 ⊕ X2

X1X2X1 XOR X2
000
011
101
110


Halbaddierer

X1X2Übertrag cSumme s
0000
0101
1001
1110

Volladdierer

X1X2CinCouts
00000
00101
01001
01110
10001
10110
11010
11111

Praxis

Schaltungen für Aufbau von Gattern und Addierer mit npn-BJT-Transistioren

Binärzahlen

Computer kennen nur 1 und 0 und arbeiten mit Binärzahlen (im Dualsystem).

Wieviele Zustände können mit einer gegebenen Anzahl von Bits dargestellt werden?

Umrechnung

Addition

Integer overflow

Integration (ergänzen / zusammenführen)

Was soll/kann woran ergänzt oder zusammengeführt werden?

Wie sollte eine Systemarchitektur aussehen, damit sie:

  • Möglichst gut ergänzt oder mit anderen Systemen zusammengeführt werden kann?
  • Effektiv entwickelt, gewartet und ergänzt werden kann?
  • „Sicher“ ist?

Best Practice

  • Modularisierung
  • Schnittstellen
    • gut designen
      • wo?
      • welche?
    • dokumentieren
  • bestehende, verbreitete, offene Standards nutzen
    • Schnittstellen
      • Protokolle
        • Bibliotheken
  • Versionieren
    • git

DevOps

Development + Operations

Ziele:

  • Kontinuierliche Bereitstellung von Prototypen und aktuellen Produkten
    (Release-Zyklen verringern)
    • Zeit zwischen Korrekturen und Verbesserungen verkürzen
  • Fehlerrate in Releases reduzieren
  • „schnellere Markteinführung des Endproduktes“

Konzept / Ansatz / Prinzipien

  • „sicher“ und reproduzierbar (wiederholbar) implementieren
  • Lösungen im Rahmen der Entwicklung kontinuierlich in produktionsähnlichen Umgebungen testen
  • operative Qualität (Betrieb) überwachen und validieren
  • Feedbackschleifen

DevOps-Kultur / CALMS

  • Culture
  • Automation
  • Lean
  • Measurement
  • Sharing

7 DevOps-Phasen

(„Stages“ / „Lifecycle“)

  • Plan
  • Code
  • Build
  • Test
  • Release
  • Deploy
  • Operate

DevOps-Praktiken

=> Einsatz von Git

Standards / Normen

Wofür werden Standards benötigt?

Welche Standards und Standardisierungsgremien kennt ihr?

graph TB
  Standards[Technische Standards] --> Industriestandard[Industriestandard / De-facto-Standard]
  Standards --> Normen[Internationale Normen / De-jure-Standards]
  Normen -..-> DIN
  Normen -..-> WSC
  WSC -..-> ISO
  WSC -..-> ITU
  WSC -..-> IEC
  Normen -..-> IEEE
  Normen -..-> W3C
  Normen -..-> IETF -..-> RFC

Normen können auch Spaß machen…

OSI Modell

(Open Systems Interconnection model)

Was ist ein Modell? Wofür sind Modelle wichtig?

7 OSI Layer

OSI-SchichtEinordnungTCP/IP-ReferenzmodellProtokollbeispieleEinheitenKopplungselemente
7Anwendung (Application)
6Darstellung (Presentation)
5Sitzung (Session)AnwendungsorientiertAnwendung
HTTP, MQTT, DHCP, DNSDaten
4TransportTransportorientiertTransportTCP, UDP(TCP) Segmente, (UDP) Datagrame
3Vermittlung (Network)Ende-zu-EndeInternetIPv4, IPv6, ICMPPaketeRouter, Layer-3-Switch
2Sicherung (Data Link)Punkt-zu-PunktNetzzugriffARP, MAC, IEEE 802.11 (WLAN)Rahmen (Frames)Bridge, Layer-2-Switch, Wireless Access Point
1Bitübertragung (Physical)RS-232 (Serielle Schnittstelle), 1000BASE-T (Twisted-Pair GbE), 100GBASE-LR4 (Glasfaser)Bits, SymboleLeitungen, Stecker, Hubs, Repeater

Rechnernetze

Topologien

Welche Topologien kennt ihr? Wo finden sie Anwendung?

Welche Vor- und Nachteile haben verschiedene Topologien?

topologien

Bussysteme

Für welche Einsatzzwecke sind Bussysteme attraktiv? Warum?

chipset

graph TB
  Bussysteme --> On-Chip[On-Chip Bus]
  Bussysteme --> Inter-Chip[Inter-Chip Bus]
  Inter-Chip -..-> FSB[Front Side Bus]
  Inter-Chip -..-> DMI[Direct Media Interface]
  Bussysteme --> Peripheriebus
  Peripheriebus -..-> intern
  intern -..-> PCI
  intern -..-> sata[Serial ATA]
  intern -..-> I2C
  intern -..-> SPI
  Peripheriebus -..-> extern
  extern -..-> seriell[Serielle Schnittstelle]
  extern -..-> parallel[Parallele Schnittstelle]
  extern -..-> USB
  Bussysteme --> Feldbus -..-> CAN[z.B. CAN]

SPI

(Serial Peripheral Interface)

SPI

  • 4 Signalleitungen
    • SCLK = Serial Clock
    • MOSI / PICO = Master Out / Slave In bzw. Peripheral In / Controller Out
    • MISO / POCI = Master In / Slave Out bzw. Peripheral Out / Controller In
    • SS / CS = Slave Select bzw. Chip Select

I²C

I²C

  • Master-Slave-Bus

  • zwei Signalleitungen

    • SCL = Serial Clock
    • SDA = Serial Data

  • 7-bit Adressraum

Beispiel: I2C-LCD-Display

Anwendungsfälle

Protokolle

Was sind Protokolle?

Protokolle definieren Regeln und Standards, die die Kommunikation und den Datenaustausch zwischen Geräten oder Systemen regeln.

Fragen zu Protokollen

  1. Welche Arten von Protokollen gibt es?

    • Es gibt verschiedene Protokollarten wie Netzwerkprotokolle (z. B. TCP/IP), Sicherheitsprotokolle (z. B. SSL/TLS) und Übertragungsprotokolle (z. B. HTTP, FTP).

  2. Warum sind Protokolle in Netzwerken wichtig?

    • Protokolle gewährleisten zuverlässige und effiziente Datenübertragung und definieren, wie Informationen über ein Netzwerk transportiert werden.

  3. Welche Sicherheitsaspekte sind bei Protokollen relevant?

    • Authentifizierung, Verschlüsselung und Integrität der Daten sind entscheidend, um vertrauliche Informationen zu schützen.

  4. Wie unterscheiden sich verbindungsorientierte und verbindungslose Protokolle?

    • Verbindungsorientierte Protokolle (wie TCP) garantieren die Datenlieferung, während verbindungslose Protokolle (wie UDP) die Daten ohne Bestätigung senden.

  5. Welche Rolle spielt die Latenz bei der Protokollauswahl?

    • Protokolle mit niedriger Latenz sind wichtig für Echtzeitanwendungen, während andere Anwendungen mehr Fehlerkorrektur benötigen.

  6. Was bedeutet Protokoll-Interoperabilität?

    • Verschiedene Systeme sollten mithilfe standardisierter Protokolle miteinander kommunizieren können, um Kompatibilität zu gewährleisten.

  7. Wie kann man die Effizienz eines Protokolls messen?

    • Wichtige Kennzahlen sind Bandbreite, Latenz, Fehlerrate und die Komplexität des Overheads.

  8. Welche Rolle spielen Protokollschichten in einem Netzwerk?

    • Verschiedene Schichten (z. B. OSI-Modell) trennen Funktionen wie Transport, Datenverbindung und Anwendung, was die Komplexität reduziert und Flexibilität ermöglicht.

Protokolle sind das Rückgrat moderner Netzwerke, daher ist die Auswahl eines geeigneten Protokolls entscheidend für die Leistungsfähigkeit und Sicherheit der Systeme.

Bitübertragung == Physical Layer

Serielle Schnittstelle

UART

(Universal Asynchronous Receiver Transmitter)

rs-232 oscilloscope

Beim Anschließen beachten:

  • Spannungspegel
  • Baudrate
  • Parity-Bit
  • Stopp-Bit

NodeMCU

PI GPIO

RS-232

DE9 Stift (männlich) und Buchse (weiblich)

Ethernet Bitübertragung

Kupferkabel

z.B. 1 Gbit/s 1000BASE-T == IEEE 802.3 Clause 40 (früher IEEE 802.3ab)

Lichtwellenleiter

z.B. 1 Gbit/s 1000BASE-LX == IEEE 802.3 Clause 38 (früher IEEE 802.3z)

z.B. 100 Gbit/s 100GBASE-LR4

Totalreflexion

Anwendungsorientiert

HTTP

  • Server + Clients
  • Übertragung von Daten/Dateien
  • Für jede Übertragung wird eine neue TCP-Verbindung auf- und abgebaut

Layer

5-7

  • baut auf TCP/IP (Layer 4/3) auf
  • wenn SSL/TLS genutzt wird, ist es wie ein zusätzlicher Layer zwischen 4 und 5

Ports

  • 80 Standardport HTTP://
  • 443 HTTPS://

Methoden (Verben)

  • GET
  • POST
  • PUT
  • DELETE
  • …

Statuscodes

  • 200 OK
  • 301 Redirect
  • 404 Not Found
  • 503 Service Unavailable
  • 418 I'm a Teapot

HTTP-Response

HTTP 1.1 200 OK ## Protokoll-Version + Statuscode

Content-Type: text/html

… ## Weitere Header (key+value)

                  ## Leerzeile

<html> ## Content

…

</html>

REST

Beispiel APIs

Nominatim

API-Dokumentation

„Free-form query“ mit q=

„Structured query“ mit city= und optional countrycodes=

Mit format=xml

Ohne format=

Swagger Petstore

Dokumentation

Benötigte Informationen über API-Endpunkte:

  • URL (Protokoll, Host, Port, Pfad)
  • HTTP-Methode
  • Query Parameter
  • Request Body
  • Request Header (z.B. Authorization)
  • Responese Body
    • MimeType (z.B. application/json)
    • Encoding (z.B. UTF-8)
    • Schema (z.B. JSON-Schema, DTD)

Empfehlung: OpenAPI Specification / Swagger zur automatischen Dokumentation verwenden

Beispiel Code

Sicherheit

OWASP Top 10 Web Application Security Risks

Relevante IT-Grundschutz-Bausteine:

  • CON.2 Datenschutz
  • CON.8 Software-Entwicklung
  • CON.10 Entwicklung von Webanwendungen
  • APP.3.1 Webanwendungen und Webservices
  • APP.3.2 Webserver

Beispiel

APP.3.1.A21 Sichere HTTP-Konfiguration bei Webanwendungen

Zum Schutz vor Clickjacking, Cross-Site-Scripting und anderen Angriffen SOLLTE der IT-Betrieb geeignete HTTPResponse-Header setzen. Dazu SOLLTEN mindestens die folgenden HTTP-Header verwendet werden:

Weitere Infos bei OWASP

Python REST example

Der Beispielcode rest.py nutzt die Bibliothek FastAPI um eine REST-API mit Swagger UI bereitzustellen.

Usage

git clone https://github.com/johannesloetzsch/LF7.git
cd src/examples/rest/python

python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

python rest.py

http://localhost:8000/index.html

Development

To run a devserver with automatic reloading when code changed, use:

uvicorn rest:app --reload

MQTT

„Message Queuing Telemetry Transport“

  • Publish/Subscribe

  • Clients können ein „Topic“ abonnieren

    • TCP-Verbindung wird offen gehalten
    • Server kann Clients über bestehende Verbindung über Updates informieren
mosquitto  ## start the broker
mosquitto_sub -h 127.0.0.1 -p 1883 -u fi -P geheim -t fi/buttonGPIO2
mosquitto_pub -h 127.0.0.1 -p 1883 -u fi -P geheim -t fi/buttonGPIO2 -m '1'

Praxis

💡 Überlegungen zum Praxiseinstieg

Ressourcen

Beispielprojekte

Ergebnisse von Schülerprojekten aus dem Vorjahr:

Praxiseinstieg

Relevanz für Ausbildung und Berufsleben

❓💬 Vergleichen Sie, welche der Lernfelder von LF7-LF9 besonders relevant für
Anwendungsentwickler bzw. Systemintegratoren sind.

LF 7: Cyber-physische Systeme ergänzen
LF 8: Daten systemübergreifend bereitstellen
LF 9: Netzwerke und Dienste bereitstellen

=> DevOps

🙏 Überprüfen Sie im IoT-Kurs, welche Inhalte derzeitiger Lernfelder für die Projekte relevant sind.

Komponenten von CPS

❓ Beurteilen Sie, welche Komponente von CPS ist für uns besonders relevant ist.

flowchart LR
  Mensch <--HCI--> Cyber
  subgraph CPS[Cyber-physisches System]
    subgraph Cyber[Cyber System]
      Computer1 <--M2M--> Computer2
    end
    subgraph PS[Physisches System]
      subgraph Schnittstelle
        Aktuator
        Sensor
      end
      subgraph I[Geräte / Anlagen]
      end
    end
    PS --messen--> Cyber
    Cyber --ansteuern--> PS
  end

❓💡 Benennen Sie Bauteile, die als Kernkomponenten in CPS / IoT-Geräten verbaut werden.

heutige Lernziele

  • Mikrocontroller kennen lernen und von Einplatinencomputer unterscheiden
    • Geeignete Hardware für CPS/IoT-Projekte auswählen
  • Verstehen was ein Pinout ist und was die damit verbundenen Herausforderungen in der Praxis sein können (=> HAL)
  • Plattformen und Frameworks für IoT-Anwendungen kennen lernen
    • Programmiersprache für Projekte auswählen

mittelfristige Ziele

  • selbstständige Praxisfähigkeiten (weiter-)entwickeln
  • technischen Dokumentation lesen, verstehen, schreiben
  • Komplexität begreifen und kontrollieren
  • effizient Debuggen
  • Sicherheit einschätzen und im erforderlichen Maß umsetzen

=> Systeme designen, entwickeln, ergänzen, integrieren, …

Git

Praxis

Beispiel

Die aus meiner Sicht für Anfänger wichtigsten Operation:

## Eine Kopie eines existierenden Repositories klonen und in das Verzeichnis wechseln
git clone https://github.com/johannesloetzsch/LF10b.git
cd LF10b/

## Eine Datei editieren, die Änderungen betrachten und rückgängig machen
nano src/versionierung.md 
git status
git diff
git restore src/versionierung.md

## Eine Datei editieren, die Änderungen betrachten…
nano src/versionierung.md  ## man könnte auch vim benutzen
git status
git diff
## Die geänderte Datei für den nächsten Commit einplanen
git add src/versionierung.md 
git status 
## Einen neuen Commit erstellen
git commit

## Die Commit-Historie anschauen
git log

## Ein neues Git-Repository anlegen und in das Verzeichnis wechseln
git init myproject
cd myproject/

SOL

Erarbeiten Sie sich die Grundlagen zu Git.

Von folgenden Subcommands sollten Sie wissen, was sie tun:


git init

git clone

git status

git add

git diff

git commit

git restore




Empfehlung: Wenn Git für sie komplett neu ist, probieren sie zum lernen gerne die ersten Level von https://ohmygit.org/




Abgabe: Als Ergebnis wird erwartet, dass Sie zwischen folgenden beiden Aufgaben auswählen:




Variante 1:

a) erstellen Sie per "git init" ein neues git Repository

b) legen Sie die Dateien aus ihrem Arduine-Projekt in dem Repository ab

c) wählen Sie die Daten zum commit aus ("git add") und erstellen Sie einen commit

d) ändern Sie Dateien oder fügen Sie neue Dateien (z.B. eine README.md) hinzu

e) erstellen Sie einen zweiten commit mit den Änderungen

f) versuchen Sie Ihr git Repository auf einen Git-Server (z.B. https://github.com oder https://gitlab.com) hochzuladen. Wenn Sie erfolgreich sind, reicht als Abgabe ein Link

g) falls Sie mit f) nicht erfolgreich waren, erzeugen Sie ein zip-Archiv des Repositories und laden Sie dieses als Abgabe hoch

 

Variante 2:

a) erstellen Sie einen Github-Account (wenn Sie noch keinen haben)

b) forken Sie mein repository https://github.com/johannesloetzsch/LF7

c) clonen Sie ihren Fork auf ihren Computer

d) editieren Sie mindestens eine Datei (beheben Sie z.B. einen Tipp-/Rechtschreibfehler oder fügen sie zu einem Thema ergänzende Informationen wie einen nützlichen Link oder den Vorschlag einer Definition eines Begriffes hinzu)

e) commiten und pushen Sie die Änderungen

f) stellen Sie mir einen Pull-Request (das reicht als Abgabe)

Zusatzaufgabe für Schüler, die sich bereits mit Git auskennen:

Frischen Sie ihr Wissen zu DevOps auf.

Zusammenfassung Git

Was ist Git?

Git ist ein Programm, das dir hilft, den Überblick über Dateien in einem Projekt zu behalten. Es speichert Änderungen, die du an deinen Projekten machst, und ermöglicht es dir, ältere Versionen wiederherzustellen. So kannst du jederzeit zu einer früheren, festgehaltenen Version zurückkehren. Git bietet viele Vorteile: Es erleichtert die Teamarbeit, da mehrere Personen gleichzeitig an einem Projekt arbeiten können. Außerdem sorgt es für mehr Organisation, da du genau sehen kannst, wer welche Änderungen vorgenommen hat und wann diese passiert sind.

Mit Git kannst du Änderungen festhalten, indem du deine Arbeit speicherst, was als "committen" bezeichnet wird. Du kannst auch verschiedene Versionen miteinander vergleichen, um genau zu erkennen, was sich geändert hat. Darüber hinaus unterstützt Git in Verbindung mit einem Server die Zusammenarbeit, indem es dir ermöglicht, Dateien mit anderen zu teilen und Änderungen miteinander zu kombinieren.

Git wurde 2005 von Linus Torvalds, dem Schöpfer des Linux-Kernels, entwickelt, um die Versionsverwaltung für große Softwareprojekte zu verbessern. Es entstand als Antwort auf die Notwendigkeit eines schnellen, verlässlichen und verteilten Systems zur Zusammenarbeit in Entwicklerteams.

Grundlegende Konzepte

Git basiert auf einigen grundlegenden Konzepten, die wichtig sind, um es effektiv zu nutzen. Das Herzstück eines Git-Projekts ist das Repository. Ein Repository ist wie ein Ordner, der nicht nur deine Dateien enthält, sondern auch alle Änderungen, die du daran vornimmst. Du kannst ein neues Repository erstellen, indem du den Befehl git init in deinem Projektordner ausführst. Dadurch wird Git in diesem Ordner aktiviert und bereitgestellt, um Änderungen zu verfolgen.

Sobald du eine Änderung an deinen Dateien vorgenommen hast, kannst du diese mit dem Befehl git add zur sogenannten Staging-Area hinzufügen. Hier sammelst du Änderungen, die du in einem Schritt speichern möchtest. Mit git commit werden diese Änderungen dann endgültig festgehalten und in die Historie aufgenommen. Ein Commit speichert also einen "Stand" deines Projekts, der später wiederhergestellt werden kann.

Möchtest du wissen wie der aktuelle Stand der erstellten Daten ist, kannst du git status verwenden.

Um Änderungen nachzuvollziehen, bietet Git verschiedene Befehle. Mit git show kannst du dir die Details eines bestimmten Commits ansehen, z. B. welche Dateien geändert wurden. Der Befehl git diff zeigt dir die Unterschiede zwischen zwei Versionen deiner Dateien. Um den gesamten Verlauf deiner Änderungen zu sehen, kannst du git log verwenden, das dir alle Commits in einer chronologischen Liste anzeigt.

Branches

Ein Branch (zu Deutsch: Zweig) ist wie ein separater Arbeitsbereich innerhalb eines Projekts. Stell dir vor, du arbeitest an einem neuen Feature oder möchtest etwas ausprobieren, ohne die Hauptversion deines Projekts zu verändern. Mit einem Branch kannst du diese Änderungen vornehmen, ohne die Hauptversion (oft "main" oder "master" genannt) zu beeinflussen. Sobald du zufrieden bist, kannst du die Änderungen wieder mit der Hauptversion zusammenführen.

Branches ermöglichen es, parallel zu arbeiten - sei es allein oder im Team. So kannst du sicher experimentieren, Fehler beheben oder neue Features entwickeln, ohne das Risiko einzugehen, den Hauptcode zu beschädigen.

Du kannst einen neuen Branch erstellen und direkt in diesen wechseln, indem du den folgenden Befehl benutzt: git checkout -b <name>.

Wenn du mit deinem Branch fertig bist und die Änderungen in die Hauptversion (oder einen anderen Branch) übernehmen möchtest, kannst du die Branches zusammenführen - das nennt man "Mergen". Dafür wechselst du zunächst in den Zielbranch (z. B. main) mit: git checkout main

Danach führst du die Änderungen aus deinem Arbeitsbranch mit dem Befehl git merge <name> zusammen.

Git kombiniert die Änderungen beider Branches. Falls es keine Konflikte gibt, wird der Merge automatisch abgeschlossen.

Mergekonflikte

Warum treten Konflikte auf?

Konflikte in Git entstehen, wenn Git nicht automatisch entscheiden kann, wie Änderungen von verschiedenen Branches kombiniert werden sollen. Das passiert typischerweise, wenn:

  • Zwei Branches dieselbe Stelle in einer Datei verändert haben.
  • Eine Änderung in einem Branch eine Datei löscht, die im anderen Branch geändert wurde.
  • Änderungen aus unterschiedlichen Branches logisch nicht zusammenpassen. Git markiert diese Konflikte und fordert dich auf, sie manuell zu lösen. Danach kannst du die Änderungen zusammenführen.

Konflikte manuell lösen

Wenn ein Konflikt auftritt, zeigt Git betroffene Dateien im Statusbericht an. Die Datei enthält Markierungen, die die widersprüchlichen Änderungen anzeigen. Du löst den Konflikt, indem du die Markierungen entfernst und die Datei so bearbeitest, dass sie die gewünschte Version enthält. Das sieht z.B. so aus:

<<<<<<< HEAD
Text aus dem main-Branch
=======
Text aus dem feature-branch
>>>>>>> feature-branch

Remote Repositories zur Zusammenarbeit

Für die Zusammenarbeit von mehreren Personen benötigt man einen Git Server. Prinzipiell kann jede Installation von Git als Server fungieren, solange alle Nutzer diese erreichen können. Häufig werden Platformen wie GitHub, GitLab oder Gitea verwenden, die weitere Funktionen wie Issue-Tracking und automatisierungen (z. B. continuous integration) bieten.

Um nun das lokale Repository mit dem entfernten Repository zu syncronisieren werden verschiedene Befehle benötigt.

Zunächst wird das entfernte Repository mit git remote add origin <URL> unter dem Namen origin hinzugefügt.

Mit dem Befehl git push kannst du deine lokalen Commits an das entfernte Repository senden. Mit git pull holst du dir die neuesten Änderungen vom entfernten Repository in dein lokales Repository. Diese beiden Befehle reichen aus, damit zwei Personen gemeinsam an einem Repository arbeiten können.

Falls ihr aber gleichzeitig arbeitet oder vergisst, vor neuen Commits ein git pull zu machen, fehlen euch die neuesten Änderungen aus dem entfernten Repository in eurer lokalen Version. Wenn dein lokales Repository schon neuere Commits enthält und du es trotzdem mit dem Stand des entfernten Repositorys abgleichen willst, kannst du mit git fetch die Änderungen holen und dann mit git rebase origin/branch-name in deine lokale History einfügen.

Stash

Mit Stashing kannst du Änderungen, die du noch nicht committen möchtest, vorübergehend speichern. So kannst du problemlos an einer anderen Aufgabe weiterarbeiten, ohne deine aktuellen Änderungen zu verlieren. Wenn du den Befehl git stash ausführst, werden alle nicht-committeten Änderungen im sogenannten Stash gespeichert. Um dir einen Überblick über die gespeicherten Stashes zu verschaffen, kannst du git stash list verwenden. Die zuletzt gespeicherten Änderungen kannst du mit git stash pop wiederherstellen. Dabei werden die Änderungen zurückgebracht und gleichzeitig aus dem Stash entfernt. Falls du einen bestimmten Stash-Eintrag löschen möchtest, hilft dir der Befehl git stash drop.

Weitere Informationen

Viele Entwicklungsumgebungen bieten eine Unterstützung von Git. Die dafür entwickelten Benutzeroberflächen können den Umgang mit Git vereinfachen. Außerdem gibt es dedizierte Werkzeuge wie GitHub Desktop, welches sich nicht nur mit Repositories auf GitHub nutzen lässt.

Wenn du dein Wissen über Git vertiefen möchtest, lohnt sich ein Blick in das Buch Pro Git von Scott Chacon und Ben Straub. Es ist kostenlos online verfügbar, auch in deutscher Übersetzung, unter: https://git-scm.com/book/en/v2.

Raspberry Pi

=> Einplatinencomputer

Pinout

❗ Das Pinout ist abhängig von der Raspberry-Pi-Version

💻 Befehl um sich das Pinout eines Rapsberry-Pi auf der Kommandozeile des Pi anzeigen zu lassen:

 pinout

 +------------------| |--| |------+
 | ooooooooooooo P1 |C|  |A|      |
 | 1oooooooooooo    +-+  +-+      |
 |    1ooo                        |
 | P5 oooo        +---+          +====
 |                |SoC|          | USB
 |   |D| Pi Model +---+          +====
 |   |S| B  V2.0                  |
 |   |I|                  |C|+======
 |                        |S||   Net
 |                        |I|+======
 =pwr             |HDMI|          |
 +----------------|    |----------+
 
 P1:
    3V3  (1) (2)  5V    
  GPIO2  (3) (4)  5V    
  GPIO3  (5) (6)  GND   
  GPIO4  (7) (8)  GPIO14
    GND  (9) (10) GPIO15
 GPIO17 (11) (12) GPIO18
 GPIO27 (13) (14) GND   
 GPIO22 (15) (16) GPIO23
    3V3 (17) (18) GPIO24
 GPIO10 (19) (20) GND   
  GPIO9 (21) (22) GPIO25
 GPIO11 (23) (24) GPIO8 
    GND (25) (26) GPIO7

GPIO Output

Die Zuordnung der externen Pin-Nummern zu den internen Nummen des Chips steht in: /sys/kernel/debug/gpio

sys-Dateisystem

Als root oder Mitglied der Gruppe gpio:

grep GPIO3 /sys/kernel/debug/gpio
PIN=574

echo $PIN > /sys/class/gpio/export
echo out > /sys/class/gpio/gpio$PIN/direction

echo 1 > /sys/class/gpio/gpio$PIN/value
echo 0 > /sys/class/gpio/gpio$PIN/value

blink.sh

PIN=574

echo $PIN > /sys/class/gpio/export
echo out > /sys/class/gpio/gpio$PIN/direction

while true; do
  echo 1 > /sys/class/gpio/gpio$PIN/value
  sleep 1
  echo 0 > /sys/class/gpio/gpio$PIN/value
  sleep 1
done

sh blink.sh

Python

python  ## öffnet eine interaktive Python-Shell

import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
PIN = 3

GPIO.setup(PIN, GPIO.OUT)

GPIO.output(PIN, True)
GPIO.output(PIN, False)

GPIO.cleanup()

blink.py

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

LED1=3
GPIO.setup(LED1, GPIO.OUT)

try:
    while(True):
        GPIO.output(LED1, True)
        time.sleep(1)
        GPIO.output(LED1, False)
        time.sleep(1)
finally:
    GPIO.cleanup()

python blink.py

Aufgaben

  1. Bauen Sie eine Schaltung und schreiben Sie das dazugehörige Programm, um abwechselnd 2 LEDs blinken zu lassen.
  2. Programmieren Sie eine Ampelschaltung, die in der richtigen Reihenfolge zwischen 3 LEDs umschaltet.

Zusatzaufgaben

  1. Programmieren Sie eine Schaltung mit 3 LEDs, welche 3 Bits darstellen, mit denen von 0 bis 7 gezählt wird.
  2. Schreiben Sie ein Programm, um eine 7-Segment-Anzeige anzusteuern.

GPIO Input

sys-Dateisystem

PIN=574
echo $PIN > /sys/class/gpio/export
echo in > /sys/class/gpio/gpio$PIN/direction
cat /sys/class/gpio/gpio$PIN/value

read.sh

while true; do
  cat /sys/class/gpio/gpio$PIN/value
  sleep 1
done

sh read.sh

Die für I²C verwendeten GPIO-PINs (BCM GPIO2 und BCM GPIO3) haben einen fest verbauten Pull-Up-Widerstand.

Python

read.py

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

BUTTON1=3
GPIO.setup(BUTTON1, GPIO.IN)

try:
    while(True):
        print(GPIO.input(BUTTON1))
        time.sleep(1)
finally:
    GPIO.cleanup()

read2.py

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

BUTTON1=3
GEDRUECKT=0
GPIO.setup(BUTTON1, GPIO.IN)

try:
    while(True):
        if( GPIO.input(BUTTON1) == GEDRUECKT):
            print("Button wurde gedrückt")
        else:
            print("Button wurde nicht gedrückt")
        time.sleep(1)
finally:
    GPIO.cleanup()

read3.py

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

BUTTON1=3
GEDRUECKT=0
GPIO.setup(BUTTON1, GPIO.IN)

try:
    print("Bitte Button drücken um fortzufahren…")
    while( GPIO.input(BUTTON1) != GEDRUECKT ):
        pass

    print("Bitte Button loslassen um fortzufahren…")
    while( GPIO.input(BUTTON1) == GEDRUECKT ):
        pass
finally:
    GPIO.cleanup()
    print("Das Programm ist beendet")

Beispiel: Ansteuerung mittels Webserver

Aufgaben

Eränzen Sie die Programme aus dem ersten Teil (GPIO Output), so dass jeweils beim Drücken eines Knopfes auf den nächsten Zustand umgeschaltet wird:

  1. Bauen Sie eine Schaltung und schreiben Sie das dazugehörige Programm, um abwechselnd 2 LEDs blinken zu lassen.
  2. Programmieren Sie eine Ampelschaltung, die in der richtigen Reihenfolge zwischen 3 LEDs umschaltet.

Zusatzaufgaben

  1. Programmieren Sie eine Schaltung mit 3 LEDs, welche 3 Bits darstellen, mit denen von 0 bis 7 gezählt wird.
  2. Schreiben Sie ein Programm, um auf einer 7-Segment-Anzeige zu zählen.
  3. Schreiben Sie ein Programm, das die Zeit zählt, wie lange ein Knopf gedrückt wurde.
  4. Entwerfen Sie eine Schaltung, um mit dem Programm von 5. zu messen wie lange es dauert, einen Kondensator über einen Photoresistor zu (ent)laden.

Weitere einfache Sensoren

Helligkeit mit Photoresistor+Kondonsator (oder Boden-Feuchtigkeitssensor)

MotionSensor

HC-SR04 - Ultrasonic Sensor (Entfernungsmesser)

Weitere Aktuatoren/Anzeigen

Multi-character 7-segment display

Parallele Protokolle

16x2 LCD-Display

Serielle Protokolle

UART

minicom -D /dev/ttyUSB0

man minicom

  -D, --device
       Specify the device, overriding the value given in the configuration file.

  -b, --baudrate
       Specify the baud rate, overriding the value given in the configuration file.

I²C

  • Displays
  • GPIO-Expander
  • AD/DA-Wandler
  • Microcontroller

SPI

  • Programmer z.B. für Arduino (ATtiny, ESP8266, ESP32)

„1-Wire“ -> „Bit-Banging“

DHT11 / DHT22 / AM2302 (Luftfeuchtigkeit+Temperatur)

Sonstiges

PiCamera

SoundBoard

Internet connection status indicator

Reaction Game

Home Assistant

Raspap

Mikrocontroller

(µController, µC, MCU, „Einchipmikrorechner“)

Beispiele bekannter Mikrocontroller

Mikrocontroller vs SoC vs Einplatinencomputer

💡 Videoerklärung zu Mikrocontroller und SoC

Mikrocontroller

Vorteile:

  1. Kostengünstig: Microcontroller werden in kostensensitiven Projekte eingesetzt.
  2. Energieeffizient: Sie verbrauchen wenig Strom, was sie perfekt für batteriebetriebene Anwendungen macht.
  3. Einfache Integration: Microcontroller sind oft leicht in bestehende Systeme zu integrieren und benötigen nur minimale externe Komponenten.

Nachteile:

  1. Begrenzte Rechenleistung: Sie haben weniger Rechenleistung und Speicher im Vergleich zu Einplatinencomputern.
  2. Eingeschränkte Funktionalität: Microcontroller sind für spezifische Aufgaben ausgelegt und bieten weniger Flexibilität für komplexe Anwendungen.
  3. Weniger Peripherieoptionen: Sie haben oft weniger Schnittstellen und Peripheriegeräte im Vergleich zu Einplatinencomputern.

SoC

System-on-a-Chip

Vorteile:

  1. Hohe Integration: CPU, GPU, Speicher, und Peripheriegeräte auf einem Chip (kompakte Bauweise).
  2. Energieeffizienz: Optimierter Stromverbrauch durch Integration und geringere Kommunikationsverluste.
  3. Leistungsfähigkeit: Häufig leistungsstärker als Mikrocontroller, geeignet für komplexe Anwendungen (z. B. Multimedia, AI).

Nachteile:

  1. Komplexität: Höhere Anforderungen an Design und Programmierung als bei Mikrocontrollern.
  2. Kosten: Teurer als Mikrocontroller, insbesondere bei kleinen Projekten oder niedrigen Stückzahlen.
  3. Reparatur/Austausch: Fehlfunktion einzelner Komponenten kann den Austausch des gesamten Chips erfordern.

Einplatinencomputer

Vorteile:

  1. Hohe Rechenleistung: Einplatinencomputer wie der Raspberry Pi bieten deutlich mehr Rechenleistung und Speicher.
  2. Vielseitigkeit: Sie können eine Vielzahl von Betriebssystemen ausführen und sind für komplexe Anwendungen geeignet.
  3. Erweiterbarkeit: Einplatinencomputer bieten zahlreiche Schnittstellen und Peripheriegeräte, was sie sehr flexibel macht.

Nachteile:

  1. Höherer Stromverbrauch: Sie verbrauchen mehr Strom als Microcontroller, was sie weniger geeignet für batteriebetriebene Anwendungen macht.
  2. Kosten: Einplatinencomputer sind in der Regel teurer als Microcontroller.
  3. Komplexität: Die Einrichtung und Programmierung kann komplexer sein, was eine steilere Lernkurve bedeutet.

Für Mikrocontroller häufig verwendete Programmiersprachen

❓❗💬 Erklären Sie, welche Eigenschaften, Vor-/Nachteile und Einsatzzwecke die verschiedenen Programmiersprachen haben.

Arduino

Programmer und IDEs für Arduino

pio device list

git clone https://github.com/platformio/platform-espressif8266  ## oder platform-espressif32
cd platform-*/examples/arduino-wifiscan
pio run --target upload -e nodemcuv2  ## für esp8266mod-12-F
pio run --target upload -e esp-wrover-kit  ## für esp-WROOM-32

pio device monitor -b 115200

platformio.ini für die ESPs der Schule

💡 Simulator

µC Beispiel Setups

BoardArduino-IDEPIOMicroPythonRust
arduino.ccplatformio.org
platformio.ini		micropython.org
@Wokwi		rust-embedded.org
@Wokwi
xiao-esp32c3 @Wokwi @ESPHome Wokwi Templateenv:lolin_c3_mini
GPIO: blink		Installation, GPIO, WiFi, WebREPL, NeoPixelGPIO: blink
TockOS
esp-WROOM-32
@ESPHome		env:esp-wrover-kit
GPIO: blink
WiFi: scan		GPIO: blink
esp8266mod-12-F @ESPHomeenv:nodemcuv2
GPIO: blink
WiFi: scan

Hello World

print("Hallo Welt")

from machine import Pin
from time import sleep_ms

led_green = Pin(13, Pin.OUT)

while True:
    led_green.value(1)
    sleep_ms(500)
    led_green.value(0)
    sleep_ms(500)

Hello NeoPixel

from machine import Pin
from neopixel import NeoPixel

pixels_count = 32
pixels = NeoPixel(Pin(15), pixels_count)

pixels[0] = (255, 0, 0)
pixels.write()

Aufgaben

  1. Verstehen Sie das Beispiel um eine LED in MicroPython blinken zu lassen.
  • Bauen und programmieren Sie eine kleine Ampel-Schaltung.
  1. Versuchen Sie dieses Beispiel zum Ansteuern von NeoPixel-LEDs mit MicroPython zu verstehen.
  • Wenn für das Verständnis des Programmes nötig, vereinfachen Sie den Code.
  • Spielen Sie mit dem Beispiel-Code herum und versuchen Sie neue schöne Effekte anzuzeigen.

Künstliche Intelligenz

KI-Lehrmaterialien von N.Sultova

Vortrag von Klaus Knopper: „Chancen + Risiken generativer KI in Unterricht + Prüfungen“

Einführung

„Nur jeder vierte Deutsche überprüft KI-Ergebnisse“

Wofür/Wie kann ich KI einsetzen?

Wo sind derzeit die Grenzen? Was sollte man beachten?

  • Code Generierung (z.B. Copilot)
  • Datenschutz, Bias, Manipulation (z.B. DeepSeek)

Beispiel IHK-AP1 2025 „KI zur Rechtsberatung“???

Technische Grundlagen

Begriffe die man kennen sollte:

Was ist „KI“

  • Weak artificial intelligence (weak AI) = Artificial Narrow Intelligence
  • strong AI:
    • Artificial super intelligence (ASI)
    • Artificial general intelligence (AGI)

Unterschied zwischen „Programmieren“ und „Machine Learning“

Training und Inferenz

Netz(architektur/struktur) vs. Modell

  • Daten
  • Gewichte

Wie funktioniert maschinelles Lernen?

MultiLayerNeuralNetwork

Sprachmodelle

SOL Sprachmodelle

SOL:
https://media.ccc.de/v/ds23-194-chatgpt-dialoge

Fragen:

  • Wie funktionieren Sprachmodelle (ganz grob)
  • Was können Sprachmodelle aktuell?
  • Was können Sprachmodelle (aktuell noch) nicht?

Zusatzaufgabe:

  • Führt einen Dialog mit einem Sprachmodell, in dem ihr zeigt, wo die Grenzen der KI sind.
  • Welche Fragen zum Thema KI habt ihr?

Retrieval-augmented generation (RAG)

Vortrag + Material von Michael Christen: „Open Data/Freie Daten in KI Chatbots nutzen“ https://github.com/Orbiter/llm-rag-cheat-sheet

Rechtliches

Ausblick / Zukunft (?)

Turing-Test

Spiegeltest

Node-RED

Low-code programming for event-driven applications

Setup

via Docker

docker volume create --name node_red_data
docker run -it -p 1880:1880 -v node_red_data:/data --name mynodered nodered/node-red --dns 8.8.8.8

Documentation

Swagger

Setup

Menü -> User Settings -> Palette -> Install

Beispiel flow.json

Benutzung Client

  • openApi-red Node statt http request Node benutzen

Benutzung Documentation Generator

  1. http in Node nutzen und optional Docs Property editieren

  2. http://localhost:1880/http-api/swagger.json

  3. Swagger UI (Live Demo) starten

  • http://localhost:1880/http-api/swagger.json eintragen
  • mit Explore laden

SQL

Grundlagen

NoSQL (Not only SQL)

ACID

  • Atomicity
  • Consistency
  • Isolation
  • Durability

CAP theorem

  • Consistency
  • Availability
  • Partition tolerance

Normalisierung

Ziel: Konsistenzerhöhung durch Redundanzvermeidung

Erste Normalform (1NF)

Jedes Attribut der Relation muss einen atomaren Wertebereich haben, und die Relation muss frei von Wiederholungsgruppen sein

Lösung: atomare Attributwertebereiche

  • Felder (Spalten) mit zusammengesetzten Typen aufspalten -> atomaren Wertebereich
  • -> Aus Datenbankeinträgen mit Listen (Wiederholungsgruppen) können mehrere Einträge werden

Zweite Normalform (2NF)

Nichtschlüsselattribute müssen von allen Schlüsseln vollständig abhängen

Lösung: Tabellen aufteilen

Dritte Normalform (3NF)

Keine funktionalen Abhängigkeiten der Nichtschlüssel-Attribute untereinander (transitive Abhängigkeiten)

Lösung: Tabellen weiter aufteilen

Quick Reference

CREATE TABLE

CREATE TABLE table_name
(
column_name1 data_type,
column_name2 data_type,
column_name3 data_type,
)

INDEX

GRANT / REVOKE

GRANT
    privileges
    ON object
    TO role_specification
  • privilegeds: SELECT | INSERT | UPDATE | … | ALL PRIVILEGES
  • objects: db_name | table_name | …
  • role_specification: user | group | …

INSERT INTO

INSERT INTO table_name
(column1, column2, column3,...)
VALUES (value1, value2, value3,....)

UPDATE

UPDATE table_name
SET column1=value, column2=value,...
WHERE some_column=some_value

SELECT + WHERE

SELECT column_names
FROM table_name
WHERE column_name operator value

SQL Operators

Logical Operators

  • AND, OR, NOT
  • ANY, SOME, IN, ALL

Comparison Operators

  • =, >, <, >=, <=, <>

Arithmetic Operators

  • +, -, *, /, %

Date/Time-Functions

z.B. NOW()

SELECT + WHERE + LIKE

SELECT column_names
FROM table_name
WHERE column_name LIKE pattern

Wildcards

WildcardBedeutung
%Ein oder mehrere beliebige Zeichen
_Ein einzelnes Zeichen
weitere

SELECT + DISTINCT + LIMIT

SELECT (DISTINCT) column_names
FROM table_name
WHERE conditions
(LIMIT n)

SELECT + ORDER BY

SELECT column_names
FROM table_name
WHERE column_name operator value
ORDER BY column1, column2, ... ASC|DESC;

SELECT + GROUP BY (+ HAVING)

SELECT column_names, aggregate_function(column_name)
FROM table_name
WHERE column_name operator value
GROUP BY column_name
(HAVING condition)

Aggregate Functions

MIN(), MAX(), COUNT(), SUM(), AVG()

JOIN

SELECT column_name(s)
FROM table_name1
INNER JOIN table_name2
ON table_name1.column_name=table_name2.column_name

Natural Join

SQL Injections