306 lines
8.4 KiB
Typst
306 lines
8.4 KiB
Typst
#import "@preview/cetz:0.4.1"
|
||
|
||
== Elektronik 3
|
||
=== Speisungen
|
||
Speisungen (linear, boost, buck, inverter, charge pump)
|
||
|
||
78xx
|
||
|
||
|
||
|
||
=== Reale Bauelemente (Transistor und OP)
|
||
=== Operationsverstärker und Transimpedanzverstärker
|
||
|
||
Eingangsspannungs offset nullen
|
||
|
||
#image("../img/elektronik_3/Instrumentenverstärker.jpg")
|
||
|
||
CMRR??? -> comon mode redejte ration
|
||
|
||
|
||
=== Verstärkerschaltungen für Detektoren
|
||
=== Schaltungen für Gepulste Sender, Laser und Gleichlichtunterdrückung von Detektoren
|
||
=== Brückenschaltungen und ihre Steuerung
|
||
=== Wirkungsgrad und Verluste
|
||
=== 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, [
|
||
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
|
||
- Kein DC, weder im Signal, noch in der Auswertung
|
||
- Die Eingänge toleranter gegen Über- bzw. Unterspannungen machen.
|
||
- Eigenrauschen der «Signal Conditioning-Stufe» sehr rauscharm gestalten
|
||
- 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
|
||
- Hohe Dynamik bei ADC, damit digitale Filterung effektiv ist.
|
||
- Kleine Signale möglichst früh im Pfad rauscharm verstärken, wenn möglich bandlimitiert.
|
||
- Auf Leiterplatten:
|
||
- Sternförmige Signale (auch Erde, Versorgung)
|
||
- Abstände zwischen hochfrequenten Signalen
|
||
- Zusätzliche Erdungsebenen
|
||
- Kurze Signalleitungen
|
||
- Unterschiedliche Domänen (Bereiche, z.B. Hochstrom, digital, analog)
|
||
- Kondensatoren zur Entkopplung
|
||
|
||
=== Netzwerkgrundlagen
|
||
==== Topologien
|
||
#table(columns: (0.5fr, 1fr, 1fr),
|
||
[Punkt zu Punkt], [
|
||
#cetz.canvas({
|
||
import cetz.draw: *
|
||
// scale(0.5)
|
||
rect((0, 0), (2, 2), fill: blue)
|
||
rect((4, 0), (6, 2), fill: blue)
|
||
line((2, 1), (4, 1), mark: (symbol: ">"), fill: blue, stroke: blue)
|
||
})], [
|
||
*Vorteile*
|
||
- Volle Bandbreite
|
||
- Einfach
|
||
- Kein Routing
|
||
*Nachteile*
|
||
- Nur 2 Einheiten verbindbar
|
||
],
|
||
[Stern], [
|
||
#cetz.canvas({
|
||
import cetz.draw: *
|
||
scale(0.5)
|
||
rect((0, 0), (2, 2), fill: blue)
|
||
rect((4, -1), (6, 1), fill: blue)
|
||
rect((1, -3), (3, -1), fill: blue)
|
||
rect((-2, -4), (0, -2), fill: blue)
|
||
rect((-4, -1), (-2, 1), fill: blue)
|
||
rect((-4, 2), (-2, 4), fill: blue)
|
||
rect((-1, 3), (1, 5), fill: blue)
|
||
line((2, 1), (4, 0), mark: (symbol: ">"), fill: blue, stroke: blue)
|
||
line((1, 0), (2, -1), mark: (symbol: ">"), fill: blue, stroke: blue)
|
||
line((1, 0), (-1, -2), mark: (symbol: ">"), fill: blue, stroke: blue)
|
||
line((0, 1), (-2, 0), mark: (symbol: ">"), fill: blue, stroke: blue)
|
||
line((0, 1), (-2, 3), mark: (symbol: ">"), fill: blue, stroke: blue)
|
||
line((1, 2), (0, 3), mark: (symbol: ">"), fill: blue, stroke: blue)
|
||
})], [
|
||
*Vorteile*
|
||
- Ausfall von Endgeräten lokal begrenzt
|
||
- Hohe Datenraten
|
||
- Leicht erweiterbar
|
||
- Einfach
|
||
- Einfaches Routing
|
||
*Nachteile*
|
||
- Ausfall des Verteilers ist fatal
|
||
],
|
||
[Ring], [
|
||
#cetz.canvas({
|
||
import cetz.draw: *
|
||
scale(0.5)
|
||
circle((0, 0), radius: 4)
|
||
rect((2, 3), (4, 5), fill: blue)
|
||
rect((2, -3), (4, -1), fill: blue)
|
||
rect((2, -3), (4, -1), fill: blue)
|
||
rect((-2, -5), (0, -3), fill: blue)
|
||
rect((-5, -1), (-3, 1), fill: blue)
|
||
rect((-3, 3), (-1, 5), fill: blue)
|
||
})], [
|
||
*Vorteile*
|
||
- Deterministisch wie Punkt zu Punkt begrenzt
|
||
- Signalauffrischung
|
||
- Hohe Bandbreite zwischen den Rechnern
|
||
*Nachteile*
|
||
- Ausfall eines Gerätes kritisch
|
||
- Lange Wege, hohe Latenzen
|
||
- Energieeffizienz
|
||
],
|
||
[Bus], [
|
||
#cetz.canvas({
|
||
import cetz.draw: *
|
||
scale(0.38)
|
||
rect((0, 0), (2, 2), fill: blue)
|
||
rect((3, 0), (5, 2), fill: blue)
|
||
rect((6, 0), (8, 2), fill: blue)
|
||
rect((11, 0), (13, 2), fill: blue)
|
||
rect((14, 0), (16, 2), fill: blue)
|
||
line((0, 3), (16, 3), stroke: 4pt)
|
||
line((1, 3), (1, 2))
|
||
line((4, 3), (4, 2))
|
||
line((7, 3), (7, 2))
|
||
line((12, 3), (12, 2))
|
||
line((15, 3), (15, 2))
|
||
})], [
|
||
*Vorteile*
|
||
- Wenig Kabel
|
||
- Keine aktiven Netzwerkkomponente
|
||
*Nachteile*
|
||
- Leicht abhörbar
|
||
- Lange Wege, hohe Latenzen
|
||
],
|
||
[Baum], [
|
||
#cetz.canvas({
|
||
import cetz.draw: *
|
||
scale(0.5)
|
||
rect((0, 0), (2, 2), fill: blue)
|
||
rect((0, 4), (2, 6), fill: blue)
|
||
rect((-3, 7), (-1, 9), fill: blue)
|
||
rect((-3, 14), (-1, 16), fill: blue)
|
||
rect((0, 12), (2, 14), fill: blue)
|
||
rect((3, 9), (5, 11), fill: blue)
|
||
rect((3, 6), (5, 8), fill: blue)
|
||
rect((6, 14), (8, 16), fill: blue)
|
||
line((1, 4), (1, 2))
|
||
line((0.5, 3), (0.5, 2))
|
||
line((0.5, 3), (-2, 3))
|
||
line((-2, 7), (-2, 3))
|
||
line((-2, 9), (-2, 14))
|
||
line((-1, 8), (1, 8))
|
||
line((1, 12), (1, 8))
|
||
line((1.5, 6), (1.5, 10))
|
||
line((3, 10), (1.5, 10))
|
||
line((3, 7), (1.5, 7))
|
||
line((2, 5), (7, 5))
|
||
line((7, 14), (7, 5))
|
||
})], [
|
||
*Vorteile*
|
||
- Skaliert gut
|
||
- Ausfall eines Blattes unkritisch
|
||
- Grosse ‘Entfernungen’ realisierbar
|
||
- Gut durchsuchbar
|
||
*Nachteile*
|
||
- Zentrale Knoten sind kritisch
|
||
- An der Wurzel hohe Datenlast
|
||
],
|
||
[Vermaschtes Netz], [
|
||
#cetz.canvas({
|
||
import cetz.draw: *
|
||
scale(0.5)
|
||
rect((0, 0), (2, 2), fill: blue)
|
||
rect((1, 3), (3, 5), fill: blue)
|
||
rect((3, 7), (5, 9), fill: blue)
|
||
rect((0, 7), (2, 9), fill: blue)
|
||
rect((-3, 4), (-1, 6), fill: blue)
|
||
rect((5, 4), (7, 6), fill: blue)
|
||
rect((5, 1), (7, 3), fill: blue)
|
||
line((2, 3), (1, 2))
|
||
line((2, 1), (5, 2))
|
||
line((6, 4), (6, 3))
|
||
line((6, 6), (5, 8))
|
||
line((4, 7), (3, 4))
|
||
line((5, 5), (3, 4))
|
||
line((5, 5), (2, 8))
|
||
line((2, 5), (1, 7))
|
||
line((-1, 5), (1, 7))
|
||
line((-1, 5), (1, 4))
|
||
line((-1, 5), (0, 1))
|
||
line((-1, 5), (3, 8))
|
||
})], [
|
||
*Vorteile*
|
||
- Zuverlässig
|
||
- Leistungsfähig (viele Pfade)
|
||
*Nachteile*
|
||
- Hoher Infrastrukturaufwand (ausser drahtlos)
|
||
- Komplexes Routing
|
||
- Energieeffizienz
|
||
],
|
||
[Zelle], [
|
||
#cetz.canvas({
|
||
import cetz.draw: *
|
||
scale(0.38)
|
||
rect((0, 0), (2, 2), fill: blue)
|
||
rect((3, 0), (5, 2), fill: blue)
|
||
rect((6, 0), (8, 2), fill: blue)
|
||
rect((11, 0), (13, 2), fill: blue)
|
||
rect((14, 0), (16, 2), fill: blue)
|
||
line((0, 3), (16, 3), stroke: 4pt)
|
||
line((1, 3), (1, 2))
|
||
line((4, 3), (4, 2))
|
||
line((7, 3), (7, 2))
|
||
line((12, 3), (12, 2))
|
||
line((15, 3), (15, 2))
|
||
})], [
|
||
Wie Bus, aber drahtlos
|
||
],
|
||
[Hybrid], [ ], [
|
||
- Mischung aus vorgenannten Topologien
|
||
- Kann auf Kontext optimal angepasst werden
|
||
],
|
||
)
|
||
|
||
==== Schichtenmodell
|
||
|
||
#cetz.canvas({
|
||
import cetz.draw: *
|
||
|
||
let layers = (
|
||
(color: red, name: "Physical", data: " "),
|
||
(color: yellow, name: "Data link", data: "D"),
|
||
(color: green, name: "Network", data: "N"),
|
||
(color: aqua, name: "Transport", data: "T"),
|
||
(color: purple, name: "Session", data: "S"),
|
||
(color: eastern, name: "Presentation", data: "P"),
|
||
(color: orange, name: "Application", data: "A"),
|
||
)
|
||
|
||
for (i, layer) in layers.enumerate() {
|
||
rect(
|
||
(0, i * 1.5),
|
||
(1, i * 1.5 + 1),
|
||
fill: layer.color
|
||
)
|
||
content((0.5, i * 1.5 + 0.5), [#(i + 1)])
|
||
|
||
rect(
|
||
(1.5, i * 1.5),
|
||
(4.5, i * 1.5 + 1),
|
||
fill: layer.color
|
||
)
|
||
content((3, i * 1.5 + 0.5), [#layer.name])
|
||
}
|
||
|
||
for (i, layer) in layers.enumerate(){
|
||
if i > 0 {
|
||
for j in range(i){
|
||
rect(((i - 1) * 1 + 5, j * 1.5 + 1.5), ((i - 1) * 1 + 6, j * 1.5 + 2.5), fill: layer.color)
|
||
content(((i - 1) * 1 + 5.5, j * 1.5 + 2.3), [#layer.data])
|
||
content(((i - 1) * 1 + 5.5, j * 1.5 + 1.7), [H])
|
||
}
|
||
}
|
||
}
|
||
|
||
for i in range(1, 7){
|
||
rect((11, i * 1.5), (13, i * 1.5 + 1), fill: gray)
|
||
content((12, i * 1.5 + 0.5), [Data])
|
||
}
|
||
|
||
rect((13, 1.5), (14, 2.5), fill: yellow)
|
||
content((13.5, 2.3), [D])
|
||
content((13.5, 1.7), [T])
|
||
rect((5, 0), (14, 1), fill: red)
|
||
content((9.5, 0.5), [Bits])
|
||
|
||
line((14.5, 0), (14.5, 1), stroke: 5pt)
|
||
line((14.5, 1.5), (14.5, 2.5), stroke: 5pt)
|
||
line((14.5, 3), (14.5, 4), stroke: 5pt)
|
||
line((14.5, 4.5), (14.5, 5.5), stroke: 5pt)
|
||
line((14.5, 6), (14.5, 10), stroke: 5pt)
|
||
content((15, 0.5), [Bits], anchor: "west")
|
||
content((15, 2), [Frames], anchor: "west")
|
||
content((15, 3.5), [Packets], anchor: "west")
|
||
content((15, 5), [Segments], anchor: "west")
|
||
content((15, 8), [Data], anchor: "west")
|
||
})
|
||
|
||
==== TCP/IP
|
||
|
||
==== Sockets
|
||
==== HTTP/HTML, JS/Web-Programmierung
|
||
==== MQTT
|
||
==== Sicherheit
|
||
|