some updates

src/analysis_3.typ

@@ -1,4 +1,5 @@
 #import "@preview/cetz:0.4.1"
+#import "@preview/zap:0.4.0"
 #set math.mat(align: left)
 
 == Differentialgleichungen
@@ -95,7 +96,7 @@ Da $x^2$ einen belibigen Wert haben kann kann es ausgeschlossen werden da logisc
 - $y^' eq frac("dy", "dx")$
 - $integral frac(1, y) dot "dy" eq ln(abs(y))$
 #table(columns: (0.5fr, 1fr),
-[$C_1$, $C_2$], [Entsthun beim Integrieren],
+[$C_1$, $C_2$], [Entsteht beim Integrieren],
 [$c$], [$c eq C_2 - C_1$],
 [$C$], [$C eq -c$],
 )
@@ -114,7 +115,7 @@ h^' (t) eq frac(Q_i, A) minus frac(A_a, A) dot root(, 2 dot g dot h)
 $
 
 $ cases(
-"OED: " h^' (t) &eq frac(Q_i, A) minus frac(A_a, A) dot root(, 2 dot g dot h),
+"ODE: " h^' (t) &eq frac(Q_i, A) minus frac(A_a, A) dot root(, 2 dot g dot h),
 "IC:    " h(t_0) &eq h_0
 ) $
 
@@ -135,3 +136,97 @@ Newton-Aktionsprinzip $m dot a eq F eq F_1 plus F_2 plus ... plus F_n$ \
 Fall 1: Geschwindigkeit $m dot v^' eq F_1(v) plus F_2(v) plus ... plus F_n (v)$ \
 Fall 2: Weg $m dot s^'' eq F_1(s) plus F_2(s) plus ... plus F_n (s)$ \
 Fall 3: Wrg und Geschwindigkeit $m dot s^'' eq F_1(s, s^') plus F_2(s, s^') plus ... plus F_n (s, s^')$ \
+
+==== Elektrische schaltkreise
+#table(columns: (1fr, 1fr, 1fr),
+[Bauelement], [Symbol], [Formel],
+[Widerstand], [
+#zap.circuit({
+    import zap: *
+    resistor("r1", (0, 0), (3, 0))
+})
+], [$U_R eq R dot I$],
+[Induktivität], [
+#zap.circuit({
+    import zap: *
+    capacitor("c1", (0, 0), (3, 0))
+})
+], [$U_L eq L dot I^'$],
+[Kapazität], [
+#zap.circuit({
+    import zap: *
+    inductor("i2", (0, 0), (3, 0), variant: "ieee")
+})
+], [$U_C eq frac(Q, C)$ mit $I eq Q^'$],
+)
+
+
+=== Lineare ODE 1. Grades
+==== Homogener Fall
+$ cases(
+"ODE: " y^' &eq m(x) dot y plus q(x),
+"IC:    " y(x_0) &eq y_0
+) $
+
+==== Homogener Fall
+$ y(x) eq C dot e^(M\(x\)) $
+
+==== Spezielle Lösung IVP mit homogener ODE
+$ y(x) eq y_0 dot e^(M(x) minus M(x)) $
+
+==== Inhomogener Fall
+$ y(x) eq (C plus C(x)) dot e^(M\(x\)) $
+$ y(x) eq (y_0 dot e^(minus M\(x_0\)) plus C_(\(x\))) dot e^(M\(x\)) $
+Mit $M(x) eq integral m(x) dot "dx"$ \ und $C(x) = integral q(x) dot e^(-M(x)) dot "dx"$
+
+
+=== Lineare ODE 2. Grades
+==== Eueler Ansatz
+$ y^"''" eq lambda^2 dot e^(lambda dot x) eq lambda^2 dot  y(x) $ daraus folgt
+$ p(lambda) :eq a dot lambda^2 plus b dot lambda plus c $
+
+*Determinante:*
+$ D eq b^2 minus 4 dot a dot c $
+
+// #grid(columns: (0.5fr, 1fr), gutter: 10pt,
+#table(columns: (0.3fr, 1fr),
+[Fall 1 $D > 0$], [
+  $ lambda_(1, 2) eq frac(minus b plus.minus root(, D), 2 dot a) $
+  $ underline(underline(y(x))) eq C_1 dot y_1(x) plus C_2 dot y_2(x) eq underline(underline(C_1 dot e^(lambda_1 dot x) plus C_2 dot e^(lambda_2 dot x))) $
+
+  IVP:
+  $ C_1 eq frac(lambda_2 dot y_0 - v_0, lambda_2 minus lambda_1) $
+  $ C_2 eq frac(v_0 minus lambda_1 dot y_0, lambda_2 minus lambda_1) $
+
+],
+[Fall 2 $D eq 0$], [
+  $ lambda eq frac(minus b, 2 dot a) $
+  $ underline(underline(y(x))) eq C_1 dot y_1(x) plus C_2 dot y_2(x) eq underline(underline((C_1 plus C_2 dot x) dot e^(lambda dot x))) $
+
+  IVP:
+  $ C_1 eq y_0 $
+  $ C_2 eq v_0 minus lambda dot y_0 $
+
+],
+[Fall 2 $D < 0$], [
+  $ underline(underline(lambda_(1, 2)))) eq
+  frac(minus b plus.minus root(, D), 2 dot a) eq
+  frac(minus b, 2 dot a) plus.minus i dot frac(root(, abs(D)), 2 dot abs(a)) eq
+  underline(underline(minus delta plus.minus i dot omega_d)) $
+  mit den Parametern:
+  $delta :eq frac(minus b, 2 dot a)$ und $omega_d :eq frac(root(, abs(D)), 2 dot abs(a))$
+  $ underline(underline(y(x))) eq C_1 dot y_1(x) plus C_2 dot y_2(x) $
+  #grid(columns: (0.4fr, 1fr), gutter: 10pt,
+  [Exponentialform], [$ underline(underline(e^(minus delta dot x) dot (C_1 dot e^(minus i dot omega_d dot x) plus C_2 dot e^(plus i dot omega_d dot x)))) $],
+  [Cosinus-Sinus-Form], [$ underline(underline(e^(minus delta dot x) dot (C dot cos(omega_d dot x) plus S dot sin(omega_d dot x)))) $],
+  [Sinus-Phasen-Form], [$ underline(underline(A dot e^(minus delta dot x) dot  sin(omega_d dot x plus phi_0)))) $],
+)
+
+  IVP:
+  $ C eq y_0 $
+  $ S eq frac(v_0 plus delta dot y_0, omega_d) $
+  $ A eq root(, C^2 plus S^2) $
+  $ phi_0 eq arg(S plus i dot C) $
+],
+)
+

src/elektronik_2.typ

@@ -39,3 +39,31 @@
 === OP-Schaltungen 1, nicht-invertierend, invertierend, Stromquelle
 === OP-Schaltungen 2, Filter
 === Signalintegrität
+
+
+
+
+=== Nichtinvertierender Verstärker
+#grid(columns: (1fr, 1fr), gutter: 10pt, [
+$V$ = Verstärkung \
+$U_+ eq U_e$ ($U_e$ = eingang) \
+Der Op probiert $U_+ eq U_-$ \
+
+$U_- eq U_a dot frac(R_1, R_1 plus R_2)$ ($U_a$ = ausgang) daraus folgt:
+$ U_a eq U_e dot (1 plus frac(R_2, R_1)) $
+$ V eq frac(U_a, U_e) eq 1 plus frac(R_2, R_1) $
+], [#image("../img/elektronik_2/Noninverting_Amplifier.svg.png")]
+)
+
+=== Invertierender Verstärker
+#grid(columns: (1fr, 1fr), gutter: 10pt, [
+$ I = frac(U_e, R_1) $
+$ U_a eq minus I dot R_2 $
+$ U_a eq minus U_e dot frac(R_2, R_1) $
+$ V eq frac(U_a, U_e) eq minus frac(R_2, R_1) $
+], [#image("../img/elektronik_2/Inverting_Amplifier.svg.png")]
+)
+
+
+
+

src/elektronik_3.typ

@@ -2,56 +2,146 @@
 
 == Elektronik 3
 === Speisungen
-Speisungen (linear, boost, buck, inverter, charge pump)
+// Speisungen (linear, boost, buck, inverter, charge pump)
+// 78xx
 
-78xx
+==== Buck-Konverter (Abwärtswandler)
+#image("../img/elektronik_3/Buck_converter.svg.png", width: 70%)
 
+==== Boost-Konverter (Aufwärtswandler)
+#grid(columns: (2fr, 1fr), gutter: 10pt, [
+#image("../img/elektronik_3/Boost_conventions.svg.png")
+], [
+#image("../img/elektronik_3/Boost_operating.svg.png")
+])
 
+==== Invertierender Schaltregler (Buck-Boost)
+#image("../img/elektronik_3/inverter_boost.png", width: 60%)
 
-=== Reale Bauelemente (Transistor und OP)
+// === Reale Bauelemente (Transistor und OP)
 === Operationsverstärker und Transimpedanzverstärker
 
-Eingangsspannungs offset nullen
+// Eingangsspannungs offset nullen
+#image("../img/elektronik_3/Instrumentenverstärker.jpg", width: 60%)
 
-#image("../img/elektronik_3/Instrumentenverstärker.jpg")
+// CMRR??? -> comon mode redejte ration
-
-CMRR??? -> comon mode redejte ration
 
 
-=== Verstärkerschaltungen für Detektoren
+// === Verstärkerschaltungen für Detektoren
-=== Schaltungen für Gepulste Sender, Laser und Gleichlichtunterdrückung von Detektoren
+// === Schaltungen für Gepulste Sender, Laser und Gleichlichtunterdrückung von Detektoren
+
 === Brückenschaltungen und ihre Steuerung
-=== Wirkungsgrad und Verluste
+==== Induktivitä schalten
-=== Rauschen
-==== weisses Rauschen
-==== Rosa Rauschen
-==== Burst Rauschen
-==== Bandbegrenztes Rauschen
-==== SNR Signal to Noise Ration
-
-=== Signalintegrität (Massnahmen)
-==== Parasitäre Effekte
-==== Jitter
 #grid(columns: (1fr, 1fr), gutter: 10pt, [
+  #image("../img/elektronik_3/spule_peak_h_brücke.png")
+], [
+  #image("../img/elektronik_3/h_brücke_mit_freilauf.png")
+])
+
+==== H-Brücke
+#grid(columns: (1fr, 1fr), gutter: 10pt, [
+#image("../img/elektronik_3/H-Brücke.png")
+], [
+- Hohe Spannung an der Induktivität bedeutet, dass der Strom schnell ansteigt
+- Ein schnell steigender Strom bedeutet, dass die Energie schnell in der Spule ‘ankommt’
+- Für einen Motor bedeutet das, dass das Drehmoment schnell zur Verfügung steht.
+- Die dynamische Ansteuerung von Schrittmotoren und BLDC-Motoren erfordert schnelles Ein- und Ausschalten
+])
+
+==== Schrittmotor
+#grid(columns: (2fr, 1fr), gutter: 10pt, [
+  #image("../img/elektronik_3/schrittmotor_h_brücke.png")
+], [
+  #image("../img/elektronik_3/schrittmotor_img.png")
+])
+
+==== Bürstenloser DC-Motor (BLDC-Motoren)
+#grid(columns: (3fr, 1fr), gutter: 10pt, [
+  #image("../img/elektronik_3/bcd_motor.png")
+], [
+  #image("../img/elektronik_3/bcd_motor.jpg")
+])
+
+
+=== Verstärker
+==== AB-Verstärker
+#image("../img/elektronik_3/ab-verstärker.png", width: 60%)
+
+=== Wirkungsgrad und Verluste
+
+$ eta eq frac(P_"out", P_"in") $
+
+=== Rauschen
+#grid(columns: (1fr, 1fr), gutter: 10pt, [
+
+==== weisses Rauschen
+Konstant über alle Frequenzen.
+#image("../img/elektronik_3/weisses_rauschen.png")
+], [
+
+==== Rosa Rauschen
+Nimt mit der Frequenz ab.
+#image("../img/elektronik_3/rosa_rauschen.png")
+], [
+
+==== Burst Rauschen
+Burst-Rauschen, in der Fachwelt oft treffend als Popcorn-Rauschen bezeichnet, ist eine spezielle Art von niederfrequentem Rauschen in Halbleitern.
+#image("../img/elektronik_3/popcorn_rauschen.png")
+
+], [
+==== Bandbegrenztes Rauschen
+Nur in einem Frequenzbereich sonst ideal Null.
+#image("../img/elektronik_3/band_rauschen.png")
+])
+
+// ==== SNR Signal to Noise Ration
+
+=== Signalträger
+#table(columns: (1fr, 1fr),
+[Kabellos], [Kabel],
+[
+  - Licht
+  - Radiowellen
+], [
+  - COAX
+  - Twisted Pair
+  - LWL
+])
+#image("../img/elektronik_3/lwl.jpg")
+#table(columns: (1fr,)*4,
+fill: (x, y) => if y == 0 {gray.lighten(40%)},
+[Merkmal], [Multimode (Stufenindex)], [Multimode (Gradient)], [Monomode (Singlemode)],
+[Kerndurchmesser], [Groß (50 / 62,5 µm)], [Groß (50 / 62,5 µm)], [Sehr klein (ca. 9 µm)],
+[Lichtausbreitung], [Zick-Zack (hart)], [Wellenförmig (sanft)], [Direkt / Gerade],
+[Reichweite], [Gering (einige 100m)], [Mittel (bis ca. 2km)], [Sehr hoch (bis 100km+)],
+[Datenrate], [Niedrig], [Hoch], [Extrem hoch],
+[Lichtquelle], [LED], [LED oder VCSEL-Laser], [Laser],
+[Typische Anwendung], [Veraltet / Kurze Wege], [LAN / Rechenzentren], [Weitverkehrsnetze / FTTH],
+)
+
+// === Signalintegrität (Massnahmen)
+// ==== Parasitäre Effekte
+==== Jitter
+#grid(columns: (2fr, 1fr), gutter: 10pt, [
 Jitter bezeichnet eine nicht gerade Flanke, sondern eine, die wie in der Abbildung dargestellt leicht hin und her schwankt.
 ], [#image("../img/elektronik_3/Jitter_timing.svg.png")]
 )
 
-==== Massnahmen
+// ==== Massnahmen
-- Kein DC, weder im Signal, noch in der Auswertung
+// - Kein DC, weder im Signal, noch in der Auswertung
-- Die Eingänge toleranter gegen Über- bzw. Unterspannungen machen.
+// - Die Eingänge toleranter gegen Über- bzw. Unterspannungen machen.
-- Eigenrauschen der «Signal Conditioning-Stufe» sehr rauscharm gestalten
+// - Eigenrauschen der «Signal Conditioning-Stufe» sehr rauscharm gestalten
-- Alle Frequenzbereiche, die nicht zum Signal beitragen VOR dem Eingang filtern.
+// - Alle Frequenzbereiche, die nicht zum Signal beitragen VOR dem Eingang filtern.
-- Spezielle Messverfahren (z.B Lock-in), die Messungen in stark rauschenden Umgebungen ermöglichen
+// - Spezielle Messverfahren (z.B Lock-in), die Messungen in stark rauschenden Umgebungen ermöglichen
-- Hohe Dynamik bei ADC, damit digitale Filterung effektiv ist.
+// - Hohe Dynamik bei ADC, damit digitale Filterung effektiv ist.
-- Kleine Signale möglichst früh im Pfad rauscharm verstärken, wenn möglich bandlimitiert.
+// - Kleine Signale möglichst früh im Pfad rauscharm verstärken, wenn möglich bandlimitiert.
-- Auf Leiterplatten:
+// - Auf Leiterplatten:
-  - Sternförmige Signale (auch Erde, Versorgung)
+//   - Sternförmige Signale (auch Erde, Versorgung)
-  - Abstände zwischen hochfrequenten Signalen
+//   - Abstände zwischen hochfrequenten Signalen
-  - Zusätzliche Erdungsebenen
+//   - Zusätzliche Erdungsebenen
-  - Kurze Signalleitungen
+//   - Kurze Signalleitungen
-  - Unterschiedliche Domänen (Bereiche, z.B. Hochstrom, digital, analog)
+//   - Unterschiedliche Domänen (Bereiche, z.B. Hochstrom, digital, analog)
-  - Kondensatoren zur Entkopplung
+//   - Kondensatoren zur Entkopplung
 
 === Netzwerkgrundlagen
 ==== Topologien
@@ -145,7 +235,7 @@ Jitter bezeichnet eine nicht gerade Flanke, sondern eine, die wie in der Abbildu
 [Baum], [
   #cetz.canvas({
     import cetz.draw: *
-    scale(0.5)
+    scale(0.4)
     rect((0, 0), (2, 2), fill: blue)
     rect((0, 4), (2, 6), fill: blue)
     rect((-3, 7), (-1, 9), fill: blue)
@@ -297,10 +387,22 @@ Jitter bezeichnet eine nicht gerade Flanke, sondern eine, die wie in der Abbildu
 })
 
 ==== TCP/IP
+#image("../img/elektronik_3/tcp_udp.jpg")
+#table(columns: (0.6fr, 1fr, 1fr),
+fill: (x, y) => if y == 0 {gray.lighten(40%)},
+[Funktion], [TCP], [UDP],
+[Verbindung], [Verbindungsorientiert], [Verbindungslos],
+[Zuverlässigkeit], [Zuverlässig, garantiert Datenintegrität], [Unzuverlässig, garantiert keine Zustellung],
+[Header-Overhead], [Größere Header-Größe (20 Byte)], [Kleinere Header-Größe (8 Byte)],
+[Übertragungseffizienz], [Geringere Effizienz aufgrund des Verbindungsaufbaus], [Höhere Effizienz, kein Verbindungsaufbau],
+[Anwendungsfall], [Zuverlässige Übertragung (z. B. Dateiübertragung, E-Mail)], [Echtzeitanwendungen (z. B. Video-/Audiostreaming, DNS)],
+)
 
-==== Sockets
+Übersetzt mit DeepL.com (kostenlose Version)
+// ==== Sockets
 
 ==== HTTP/HTML
+#grid(columns: (1fr, 1fr), gutter: 10pt, [
 *Aufbau*
 HTTP besteht aus einem Header und einem Body
 Header:
@@ -312,8 +414,7 @@ Header:
 - Name: Inhalt
 Body:
 - vollständige Payload
-
+], [
-
 ```html
 <!DOCTYPE html>
 <html>
@@ -328,12 +429,34 @@ Body:
   </body>
 </html>
 ```
+])
 
 ==== JS/Web-Programmierung
+#image("../img/elektronik_3/web_browser.png")
 
-
+==== IoT / WoT
+#table(columns: (0.4fr, 1fr, 1fr),
+fill: (x, y) => if y == 0 {gray.lighten(40%)},
+[Merkmal], [Internet of Things (IoT)], [Web of Things (WoT)],
+[Hauptebene], [Netzwerk-Ebene (OSI Layer 3/4)], [Anwendungs-Ebene (OSI Layer 7)],
+[Kernziel], [Geräte vernetzen], [Geräte kompatibel & steuerbar machen],
+[Protokolle], [MQTT, CoAP, Zigbee, Bluetooth], [HTTP, WebSockets, JSON],
+[Komplexität], [Hoch (viele proprietäre Standards)], [Niedriger (einheitliche Web-Standards)],
+[Analogie], [Das Internet (die Leitungen/Datenpakete)], [Das World Wide Web (Webseiten/Browser)],
+)
 
 ==== MQTT
+#image("../img/elektronik_3/mqtt.png")
 
 ==== Sicherheit
+#table(columns: (0.5fr, 1fr, 1fr),
+fill: (x, y) => if y == 0 {gray.lighten(40%)},
+[Merkmal], [DoS (Denial of Service)], [DDoS (Distributed Denial of Service)],
+[Anzahl der Quellen], [Eine (1 Angreifer, 1 Computer)], [Viele (Hunderte bis Millionen Geräte)],
+[Vorgehensweise], [Direkter Angriff vom eigenen PC oder Server.], [Nutzung eines Botnetzes (infizierte Computer/IoT-Geräte).],
+[Geschwindigkeit], [Meist langsamer im Aufbau.], [Sehr schnell, da die Last verteilt ist.],
+[Erkennung], [Einfach (nur eine IP-Adresse muss gesperrt werden).], [Sehr schwierig (Angriff kommt von überall).],
+[Abwehr], [Relativ leicht durch Firewalls möglich.], [Sehr komplex; oft spezielle Schutzdienste nötig.],
+[Datenvolumen], [Begrenzt durch die Leitung des Angreifers.], [Enorm hoch, kann ganze Netzwerke lahmlegen.],
+)
 

src/python_wahlmodul.typ

@@ -170,7 +170,7 @@ Ein Dictionary ist wie ein Wörterbuch mit einem "Key" und einer dazugehörigen
 [Dictionary erstellen], [```py d1 = {"1": "1. Element", 2: [1, 2, 3]} ``` \ ```py d2 = {[1, 2]: 2} ```], [d2 ist ungültig weil Listen keine "Key's" sind.],
 [Auf Element zugreifen], [```py d1[2] ```], [Gibt `[1, 2, 3]` zurück],
 [Auf Element zugreifen], [```py d1["x"] ```], [Gibt einen Fehler da "x" nicht im Dictionary ist],
-[Auf Element zugreifen mit get()], [```py d1.get(2)  # [1, 2, 3] ``` \ ```py d1.get("x") ```], [Gibt keinen Fehler auch wenn "x" nicht im Dictionary ist],
+[Auf Element zugreifen mit get()], [```py d1.get(2)  # [1, 2, 3] ``` \ ```py d1.get("x") ``` \ ```py d1.get("y", 0) ``` \ ```py d1.get(key, default) ```], [Gibt keinen Fehler auch wenn "x" nicht im Dictionary ist. Beim y wird 0 zurückgegeben falls y nicht im dict ist anstelle von None.],
 [Element überschreiben], [```py d1[2] = 2 ```], [Die Liste wurde mit 2 überschrieben],
 [Element hinzufügen], [```py d1["neuer key"] = 12 ```], [Neuses Element mit dem der "value" 12.],
 )