1999 lines
55 KiB
Typst
1999 lines
55 KiB
Typst
#import "@preview/mannot:0.3.1"
|
||
#import "@preview/zap:0.5.0"
|
||
#import "@preview/cetz:0.4.2": *
|
||
#import "@preview/cetz-plot:0.1.3"
|
||
#import "@preview/unify:0.7.1": num, qty, unit
|
||
#import "@preview/cetz-plot:0.1.3"
|
||
#import "@preview/grayness:0.5.0": image-grayscale, image-crop
|
||
|
||
#import "../lib/schaltungstheorie/opampTable.typ": *
|
||
#import "../lib/schaltungstheorie/tumCustomSymbols.typ" as tumSymbols
|
||
|
||
#import "../lib/circuit.typ": *
|
||
#import "../lib/common_rewrite.typ": *
|
||
#import "../lib/circuit.typ": *
|
||
|
||
|
||
#set math.mat(delim: "[")
|
||
#show math.equation.where(block: true): it => math.inline(it)
|
||
#set math.mat(delim: "[")
|
||
#show math.integral: it => math.limits(math.integral)
|
||
#show math.sum: it => math.limits(math.sum)
|
||
#let jVec(x) = $bold(underline(#x))$
|
||
#let jMat(x) = $bold(#x)$
|
||
|
||
#set page(
|
||
paper: "a4",
|
||
margin: (
|
||
bottom: 10mm,
|
||
top: 5mm,
|
||
left: 5mm,
|
||
right: 5mm,
|
||
),
|
||
flipped: true,
|
||
footer: context [
|
||
#grid(
|
||
align: center,
|
||
columns: (1fr, 1fr, 1fr),
|
||
[#align(left, datetime.today().display("[day].[month].[year]"))],
|
||
[#align(center, counter(page).display("– 1 –"))],
|
||
[#align(right, image("../images/cc0.png", height: 5mm))],
|
||
)
|
||
],
|
||
)
|
||
|
||
#let colorAllgemein = color.hsl(105.13deg, 92.13%, 75.1%)
|
||
#let colorEigenschaften = color.hsl(145.13deg, 92.13%, 75.1%)
|
||
#let colorEineTore = color.hsl(202.05deg, 92.13%, 75.1%)
|
||
#let colorZweiTore = color.hsl(235.9deg, 92.13%, 75.1%)
|
||
#let colorAnalyseVerfahren = color.hsl(280deg, 92.13%, 75.1%)
|
||
#let colorComplexAC = color.hsl(356.92deg, 92.13%, 75.1%)
|
||
#let colorMathe = color.hsl(34.87deg, 92.13%, 75.1%)
|
||
|
||
#place(top + center, scope: "parent", float: true, heading(
|
||
[Schaltungstheorie],
|
||
))
|
||
|
||
#set text(8.5pt)
|
||
|
||
#columns(4, gutter: 2mm)[
|
||
// Allgemein
|
||
#bgBlock(fill: colorAllgemein)[
|
||
#subHeading(fill: colorAllgemein)[Allgemeine]
|
||
*Konzentriertheitshypotese*\
|
||
$lambda >> d quad quad lambda = c/f quad quad c approx 3.10dot 10^8 m/s$
|
||
|
||
d: größe Bauteil Dimension
|
||
|
||
f: Maximal Frequenze
|
||
|
||
*Kirchhoff*
|
||
|
||
#grid(
|
||
columns: (1fr, 1fr),
|
||
row-gutter: 5mm,
|
||
[
|
||
KCL: $sum_(k=1)^n i_k =0$ (Knotenregel)
|
||
],
|
||
/*[
|
||
#cetz.canvas(length: 8mm, {
|
||
import cetz.draw: *
|
||
|
||
circle((0, 0), radius: 1)
|
||
|
||
line((angle: 0deg, radius: 0.2), (angle: 0deg, radius: 1.5), stroke: red)
|
||
line((angle: 120deg, radius: 1.5), (angle: 120deg, radius: 0.2), stroke: red)
|
||
line((angle: 240deg, radius: 1.5), (angle: 240deg, radius: 0.2), stroke: red)
|
||
|
||
set-style(mark: (end: "straight"))
|
||
line((angle: 0deg, radius: 0.2), (angle: 0deg, radius: 0.8), stroke: red)
|
||
line((angle: 120deg, radius: 1.2), (angle: 120deg, radius: 0.4), stroke: red)
|
||
line((angle: 240deg, radius: 1.2), (angle: 240deg, radius: 0.4), stroke: red)
|
||
})
|
||
],*/
|
||
|
||
[
|
||
KVL: $sum_(k=1)^n u_k =0$ (Maschenregel)
|
||
],
|
||
/*[
|
||
#zap.circuit({
|
||
import zap: wire
|
||
import cetz.draw: *
|
||
|
||
registerAllCustom()
|
||
|
||
einTor("F1", (0, -1), (0, 1))
|
||
einTor("F2", (1.5, 0), (1.5, 1), flip: true)
|
||
einTor("F3", (1.5, 0), (1.5, -1), flip: true)
|
||
wire((0, -1), (1.5, -1))
|
||
wire((0, 1), (1.5, 1))
|
||
|
||
translate((0.75, 0))
|
||
circle((0, 0), radius: 4mm, stroke: blue)
|
||
translate((0, 1mm))
|
||
mark((angle: 180deg, radius: 4mm), 90deg, symbol: "straight", stroke: blue, scale: 0.75)
|
||
translate((0, -2mm))
|
||
mark((angle: 0deg, radius: 4mm), 270deg, symbol: "straight", stroke: blue, scale: 0.75)
|
||
})
|
||
],*/
|
||
)
|
||
|
||
$u dot i > 0$: Nimmt Energie auf\
|
||
$u dot i = 0$: Verlustlos\
|
||
$u dot i < 0$: Gibt Energie ab\
|
||
]
|
||
|
||
// Verschaltung
|
||
#bgBlock(fill: colorAllgemein)[
|
||
#subHeading(fill: colorAllgemein)[Verschaltung]
|
||
|
||
$1/x_"ges" = 1/x_1 + 1/x_2 + 1/x_3 + ...$
|
||
|
||
$x_1 parallel x_2 = 1/(1/x_1 + 1/x_2) = (x_1 x_2)/(x_1 + x_2)$
|
||
|
||
$x_1 parallel x_2 parallel x_3 = (x_1 x_2 x_3)/(x_1 x_2 + x_2 x_3 + x_1 x_3)$
|
||
|
||
#table(
|
||
columns: (1fr, 1fr),
|
||
fill: (x, y) => if calc.rem(x, 2) == 1 { tableFillLow } else { tableFillHigh },
|
||
|
||
[*Serie*], [*Reihe/Parrallel*],
|
||
|
||
align(
|
||
horizon + center,
|
||
scale(100%, zap.circuit({
|
||
import zap: *
|
||
|
||
resistor("R1", (0, 0.375), (1.5, 0.375), fill: none, width: 1, height: 0.4)
|
||
resistor("R2", (1.5, 0.375), (3, 0.375), fill: none, width: 1, height: 0.4)
|
||
})),
|
||
),
|
||
align(
|
||
horizon + center,
|
||
scale(
|
||
100%,
|
||
zap.circuit({
|
||
import zap: *
|
||
|
||
resistor("R1", (0, 0), (2, 0), fill: none, width: 1, height: 0.4)
|
||
resistor("R2", (0, 0.75), (2, 0.75), fill: none, width: 1, height: 0.4)
|
||
wire("R1.in", "R2.in")
|
||
wire("R1.out", "R2.out")
|
||
|
||
node("N2", (0, 0.375))
|
||
node("N3", (2, 0.375))
|
||
|
||
wire("N2", (rel: (-0.3, 0)))
|
||
wire("N3", (rel: (0.3, 0)))
|
||
}),
|
||
),
|
||
),
|
||
|
||
$R_"ges" = R_1+R_2$, $R_"ges" = R_1 parallel R_2$,
|
||
$G_"ges" = G_1 parallel G_2$, $G_"ges" = G_1 + G_2$,
|
||
$L_"ges" = L_1 + L_2$, $L_"ges" = L_1 parallel L_2$,
|
||
$C_"ges" = C_1 parallel C_2$, $C_"ges" = C_1 + C_2$,
|
||
|
||
$U_"ges" = U_1 + U_2$, $U_"ges" = U_1 = U_2$,
|
||
$I_"ges" = I_1 = I_2$, $I_"ges" = I_1 + I_2$,
|
||
[In $U$-Richtung Addieren], [In $I$-Richtung Addieren],
|
||
)
|
||
]
|
||
|
||
|
||
// Quell Wandlung
|
||
#bgBlock(fill: colorEineTore)[
|
||
#subHeading(fill: colorEineTore)[Ein-Tor]
|
||
|
||
#grid(
|
||
columns: (auto, auto),
|
||
column-gutter: 3mm,
|
||
zap.circuit({
|
||
import zap: *
|
||
registerAllCustom()
|
||
einTor(
|
||
"F1",
|
||
(0, 0),
|
||
(2, 0),
|
||
i: (content: $i_(cal(F),1)$, anchor: "south-east", label-distance: -10pt),
|
||
u: $u_1$,
|
||
)
|
||
einTor("F1", (0, 0), (2, 0), i: (content: $i_(cal(F),2)$, anchor: "west", label-distance: -10pt, invert: true))
|
||
}),
|
||
[
|
||
Tor-Bedinung:\
|
||
$i_(cal(F),2) = i_(cal(F),1)$
|
||
],
|
||
)
|
||
]
|
||
|
||
|
||
// Lineare Quelle
|
||
#bgBlock(fill: colorEineTore)[
|
||
#subHeading(fill: colorEineTore)[Lineare Quelle]
|
||
|
||
#align(
|
||
center + horizon,
|
||
cetz.canvas({
|
||
import cetz.draw: *
|
||
import cetz-plot: *
|
||
plot.plot(
|
||
size: (3, 3),
|
||
name: "plot",
|
||
axis-style: "school-book",
|
||
x-label: "u",
|
||
y-label: "i",
|
||
x-tick-step: none,
|
||
y-tick-step: none,
|
||
axes: ("u", "i"),
|
||
x-min: -1,
|
||
x-max: 2,
|
||
x-grid: "both",
|
||
y-min: -2,
|
||
y-max: 1,
|
||
y-grid: "both",
|
||
{
|
||
plot.add(((-2, -3), (3, 2)))
|
||
plot.add-anchor("u0", (1, 0))
|
||
plot.add-anchor("i0", (0, -1))
|
||
},
|
||
)
|
||
|
||
content("plot.u0", $U_0$, anchor: "south", padding: .2)
|
||
content("plot.i0", $-I_0$, anchor: "east", padding: .2)
|
||
|
||
mark("plot.u0", 0deg, symbol: "+", fill: black)
|
||
mark("plot.i0", 0deg, symbol: "+", fill: black)
|
||
|
||
line(
|
||
"plot.i0",
|
||
(horizontal: "plot.u0", vertical: "plot.i0"),
|
||
"plot.u0",
|
||
stroke: (dash: "dashed", paint: rgb("#005c00")),
|
||
)
|
||
|
||
content(
|
||
(horizontal: "plot.u0", vertical: "plot.i0"),
|
||
anchor: "south-west",
|
||
text(rgb("#005c00"))[$R$],
|
||
padding: 0.1,
|
||
)
|
||
}),
|
||
)
|
||
|
||
$U_0$: LL-Spannung ($i = 0 => u = U_0$) \
|
||
$I_0$: KS-Strom ($u = 0 => i = -I_0$)
|
||
|
||
$R_i$: Innenwiderstand $R_i = U_0/I_0$
|
||
|
||
#table(
|
||
columns: (1fr, 1fr),
|
||
fill: (x, y) => if calc.rem(x, 2) == 1 { tableFillLow } else { tableFillHigh },
|
||
inset: 3mm,
|
||
align(center, [*$u$-gesteuert*]), align(center, [*$i$-gesteuert*]),
|
||
|
||
align(
|
||
horizon + center,
|
||
zap.circuit({
|
||
import zap: *
|
||
import cetz.draw
|
||
|
||
zap.resistor("R1", (1, 0), (1, -1.5), fill: none, width: 0.8, height: 0.3)
|
||
zap.isource("I0", (0, 0), (0, -1.5), fill: none, scale: 0.6, i: (
|
||
content: $-I_0$,
|
||
distance: 6pt,
|
||
label-distance: -11pt,
|
||
anchor: "west",
|
||
invert: true,
|
||
))
|
||
node("N0", "R1.in")
|
||
node("N0", "R1.out")
|
||
|
||
wire("I0.out", "R1.out", (rel: (0.5, 0)))
|
||
wire("I0.in", "R1.in")
|
||
wire("R1.in", (rel: (0.5, 0)), i: (content: $i$, invert: true))
|
||
|
||
cetz.draw.content((0.62, -0.75), [$G_i$])
|
||
cetz.draw.set-style(mark: (end: ">", fill: black, scale: 0.6))
|
||
cetz.draw.content((1.7, -0.75), [$u$])
|
||
cetz.draw.line((1.5, -0.1), (1.5, -1.4), stroke: 0.5pt)
|
||
}),
|
||
),
|
||
align(
|
||
horizon + center,
|
||
zap.circuit({
|
||
import zap: *
|
||
import cetz.draw
|
||
|
||
zap.vsource("U0", (0, 0), (0, -1.5), fill: none, scale: 0.6, u: (
|
||
content: $U_0$,
|
||
distance: -4pt,
|
||
label-distance: -8pt,
|
||
anchor: "south-west",
|
||
invert: true,
|
||
))
|
||
zap.resistor("R1", (0, 0), (1.75, 0), fill: none, width: 0.8, height: 0.3, i: (
|
||
content: $i$,
|
||
invert: true,
|
||
distance: 0.3,
|
||
))
|
||
wire((0, -1.5), (1.75, -1.5))
|
||
|
||
cetz.draw.content((0.62, -0.75), [$R_i$])
|
||
cetz.draw.set-style(mark: (end: ">", fill: black, scale: 0.6))
|
||
cetz.draw.content((1.95, -0.75), [$u$])
|
||
cetz.draw.line((1.75, -0.1), (1.75, -1.4), stroke: 0.5pt)
|
||
}),
|
||
),
|
||
|
||
[
|
||
$u = R_i i + U_0$ \
|
||
|
||
],
|
||
[
|
||
$i = G_i u - I_0$
|
||
],
|
||
|
||
align(center, text(size: 7mm, $-->$)), [$G_i = 1/R_i \ I_0 = U_0 G_i$],
|
||
|
||
[$R_i = 1/G_i \ U_0 = I_0 R_i$], align(center, text(size: 7mm, $<--$)),
|
||
)
|
||
]
|
||
|
||
/*// Quell Wandlung
|
||
#bgBlock(fill: colorEineTore)[
|
||
#subHeading(fill: colorEineTore)[Quelle Wandlung]
|
||
|
||
#grid(
|
||
columns: (1fr, 1fr),
|
||
align: center,
|
||
scale(x: 65%, y: 65%,
|
||
zap.circuit({
|
||
import zap : *
|
||
import cetz.draw : line, content
|
||
|
||
vsource("U0", (0, 1.5), (0, -1.5), fill: none)
|
||
|
||
node("n2", (3.5,1.5), fill: false)
|
||
node("n3", (3.5,-1.5), fill: false)
|
||
|
||
resistor("R0", "U0.in", "n2", fill: none, label: (content: $R_i$, anchor: "south", distance: 0.1))
|
||
wire("U0.out", "n3")
|
||
|
||
wire((2.49,1.5), "n2", i: (content: $i$, anchor: "south", invert: true))
|
||
|
||
set-style(mark: (end: ">", fill: black))
|
||
line((3.5, 1.2), (3.5, -1.2), stroke: 0.5pt)
|
||
content((3.9, 0), $u$)
|
||
|
||
line((0.7, 0.5), (0.7, -0.5), stroke: 0.5pt)
|
||
content((1.7, 0), $U_0 = I_0 / G_i$)
|
||
})),
|
||
scale(x: 65%, y: 65%,
|
||
zap.circuit({
|
||
import zap : *
|
||
import cetz.draw : line, content
|
||
|
||
isource("I0", (0, 1.5), (0, -1.5), fill: none)
|
||
node("n0", (2,1.5))
|
||
node("n1", (2,-1.5))
|
||
|
||
node("n2", (3.5,1.5), fill: false)
|
||
node("n3", (3.5,-1.5), fill: false)
|
||
|
||
resistor("g0", "n1", "n0", fill: none, label: (content: $G_i$, anchor: "south", distance: 0.2))
|
||
wire("I0.in", "n0", "n2")
|
||
wire("I0.out", "n1", "n3")
|
||
wire("n0", "n2", i: (content: $i$, anchor: "south", invert: true))
|
||
wire((0,0.6), "I0.in", i: (content: $I_0 = U_0 / R_i$, anchor: "east", invert: false, distance: 0.2))
|
||
|
||
set-style(mark: (end: ">", fill: black))
|
||
line((3.5, 1.2), (3.5, -1.2), stroke: 0.5pt)
|
||
content((3.9, 0), $u$)
|
||
})),
|
||
[
|
||
$U_0 = I_0 R_i$
|
||
|
||
$R_i=1/G_i$
|
||
|
||
$u = r(i) = R_i i + U_0$
|
||
],
|
||
[
|
||
$I_0 = U_0 G_i$
|
||
|
||
$G_i=1/R_i$
|
||
|
||
$i = g(u) = G_i u + I_0$
|
||
]
|
||
);
|
||
]
|
||
*/
|
||
|
||
|
||
// Linearsierung
|
||
#bgBlock(fill: colorEineTore)[
|
||
#subHeading(fill: colorEineTore)[Linearisierung (Ein-Tore)]
|
||
|
||
1. Arbeitspunkt bestimmen \ $"AP" =(u_"AP", i_"AP")$
|
||
|
||
2. Ableitung $g_cal(F)(u)$/$r_cal(F)(i)$ bilden \ $g'_cal(F)(u)$/$r'_cal(F)(i)$
|
||
|
||
#colbreak()
|
||
|
||
#line(length: 100%)
|
||
|
||
*Stromgesteuert* $quad r(i) = u$
|
||
|
||
*Groß-Signal* \
|
||
#grid(columns: (1fr, 1fr),
|
||
column-gutter: 4mm,
|
||
$I_0 = i_"AP" - g'_cal(F)(u_"AP")u_"AP"$,
|
||
$g_0 = g'_cal(F)(u_"AP")u$
|
||
)
|
||
|
||
#linebreak()
|
||
|
||
$i_"lin" = g_"lin" (u) = g'_cal(F)(u_"AP")(u-u_"AP") + i_"AP"\
|
||
i_"lin" = g_"lin" (u) = g_0 u + I_0$
|
||
|
||
#block(
|
||
height: 20mm,
|
||
scale(x: 75%, y: 75%, zap.circuit({
|
||
import zap: *
|
||
import cetz.draw: content, line
|
||
|
||
isource("I0", (0, 1.5), (0, -1.5), fill: none)
|
||
node("n0", (2, 1.5))
|
||
node("n1", (2, -1.5))
|
||
|
||
node("n2", (3.5, 1.5), fill: false)
|
||
node("n3", (3.5, -1.5), fill: false)
|
||
|
||
resistor("g0", "n1", "n0", fill: none, label: (content: $g_0$, anchor: "south", distance: 0.2))
|
||
wire("I0.in", "n0", "n2")
|
||
wire("I0.out", "n1", "n3")
|
||
wire("n0", "n2", i: (content: $i_"lin"$, anchor: "south", invert: true))
|
||
wire((0, 0.6), "I0.in", i: (content: $I_0$, anchor: "east", invert: true))
|
||
|
||
set-style(mark: (end: ">", fill: black))
|
||
line((3.5, 1.2), (3.5, -1.2), stroke: 0.5pt)
|
||
content((3.9, 0), $u$)
|
||
})),
|
||
);
|
||
|
||
#linebreak()
|
||
|
||
*Klein-Signal* $quad i_"lin" = g_"lin" (u) = g'(u_"AP")u$
|
||
|
||
#line(length: 100%)
|
||
|
||
|
||
*Spannungsgesteuert* $quad g(u) = i$
|
||
|
||
*Groß-Signal* \
|
||
#grid(columns: (1fr, 1fr),
|
||
column-gutter: 4mm,
|
||
$U_0 = u_"AP" - r'(i_"AP") i_"AP"$,
|
||
$r_0 = r'(i_"AP")$
|
||
)
|
||
#linebreak()
|
||
$u_"lin" = r_"lin" (i) = r'(i_"AP")(i-i_"AP") + u_"AP"\
|
||
u_"lin" = r_"lin" (i) = r_0 i + U_0$
|
||
#block(
|
||
height: 25mm,
|
||
scale(x: 75%, y: 75%, zap.circuit({
|
||
import zap: *
|
||
import cetz.draw: content, line
|
||
|
||
vsource("U0", (0, 1.5), (0, -1.5), fill: none)
|
||
|
||
node("n2", (3.5, 1.5), fill: false)
|
||
node("n3", (3.5, -1.5), fill: false)
|
||
|
||
resistor("R0", "U0.in", "n2", fill: none, label: (content: $r_0$, anchor: "south", distance: 0.1))
|
||
wire("U0.out", "n3")
|
||
|
||
wire((2.49, 1.5), "n2", i: (content: $i$, anchor: "south", invert: true))
|
||
|
||
set-style(mark: (end: ">", fill: black))
|
||
line((3.5, 1.2), (3.5, -1.2), stroke: 0.5pt)
|
||
content((3.9, 0), $u_"lin"$)
|
||
|
||
line((0.7, 0.5), (0.7, -0.5), stroke: 0.5pt)
|
||
content((1.2, 0), $U_0$)
|
||
})),
|
||
);
|
||
#linebreak()
|
||
*Klein-Signal* $quad u_"lin" = r_"lin" (i) = r'(i_"AP")i$
|
||
]
|
||
|
||
|
||
#colbreak()
|
||
// Graphen und Matrizen
|
||
#bgBlock(fill: colorAnalyseVerfahren)[
|
||
#subHeading(fill: colorAnalyseVerfahren)[Graphen und Matrizen]
|
||
|
||
$bold(i_b)$ (oder $bold(i)$): Zweigstrom-Vektor \
|
||
$bold(u_b)$ (oder $bold(u)$): Zweigspannungs-Vektor \
|
||
$bold(i_m)$ : Maschenstrom-Vektor \
|
||
#text(rgb(20%, 20%, 20%))[(Strom in einer viruellen Masche)] \
|
||
$bold(u_k)$ : Kontenspannungs-Vektor \
|
||
#text(rgb(20%, 20%, 20%))[(Spannung zwischen Referenzknoten und Knoten k)] \
|
||
|
||
#line(length: 100%, stroke: (thickness: 0.2mm))
|
||
|
||
Knotenzidenzmatrix $bold(A)$
|
||
|
||
$bold(A) : bold(i_k) -> text("Knotenstrombilanz") = 0$ \
|
||
$bold(A^T) : bold(u_b)-> bold(u_k)$
|
||
$
|
||
bold(A) = quad space space mannot.mark(
|
||
mat(
|
||
a_11, a_12, ..., a_(1m);
|
||
a_21, a_22, ..., a_(2m);
|
||
dots.v, dots.v, dots.down, dots.v;
|
||
a_(n 1), a_(n 2), ..., a_(n m)
|
||
), tag: #<1>
|
||
)
|
||
#mannot.annot(<1>, pos: left, text(rgb("#404296"))[#rotate(-90deg)[$<-$ Knoten \ ($n-1$)]], dx: 2mm)
|
||
#mannot.annot(<1>, pos: bottom, text(rgb("#404296"))[Zweige ($b$) $->$], dy: -0.5mm)
|
||
a in {-1, 0, 1}
|
||
$
|
||
#linebreak()
|
||
$-1 &: "In Knoten rein" \
|
||
1 &: "Aus Knoten raus"$
|
||
|
||
#line(length: 100%, stroke: (thickness: 0.2mm))
|
||
|
||
Mascheninsidenz Matrix $bold(B)$\
|
||
|
||
|
||
$bold(B) : bold(u_b) -> text("Zweigspannungsbilanz") = 0$ \
|
||
$bold(B^T) : bold(i_m) -> i_b$
|
||
|
||
$
|
||
bold(B) = quad space space mannot.mark(mat(
|
||
b_11, b_12, ..., b_(1m);
|
||
b_21, b_22, ..., b_(2m);
|
||
dots.v, dots.v, dots.down, dots.v;
|
||
b_(n 1), b_(n 2), ..., b_(n m)
|
||
), tag: #<1>)
|
||
|
||
#mannot.annot(<1>, pos:left, text(rgb("#404296"))[#rotate(-90deg)[$<-$ Maschen \ $b-(n-1)$]], dx: 4mm)
|
||
#mannot.annot(<1>, pos:bottom, text(rgb("#404296"))[Zweige ($b$) $->$], dy: -0.5mm)
|
||
|
||
b in {-1, 0, 1}
|
||
$
|
||
|
||
#linebreak()
|
||
$-1 &: "Gegen Maschenrichtung" \
|
||
1 &: "In Maschenrichtung"$
|
||
|
||
#line(length: 100%, stroke: (thickness: 0.2mm))
|
||
|
||
*KCL und KVL* \
|
||
|
||
KCL in Nullraum: $bold(A) bold(i_b) = bold(0)$ \
|
||
KVL in Bildraum: $bold(A^T) bold(u_k) = bold(u_b)$
|
||
|
||
KVL in Nullraum: $bold(B) bold(u_b) = bold(0)$ \
|
||
KCL in Bildraum: $bold(B^T) bold(i_m) = bold(i_b)$ \
|
||
|
||
#line(length: 100%, stroke: (thickness: 0.2mm))
|
||
|
||
|
||
*Tellegen'sche Satz* \
|
||
$bold(A B^T) = bold(B^T A) = 0$ \
|
||
$bold(u_b^T i_b) = 0$
|
||
]
|
||
|
||
// Baumkonzept
|
||
#bgBlock(fill: colorAnalyseVerfahren)[
|
||
#subHeading(fill: colorAnalyseVerfahren)[Baumkonzept]
|
||
KCLs: $n-1$\
|
||
KVLs: $b-(n-1)$
|
||
|
||
Baum einzeichnen (Keine Schleifen!)
|
||
]
|
||
|
||
// Tablauematrix
|
||
#bgBlock(fill: colorAnalyseVerfahren)[
|
||
#subHeading(fill: colorAnalyseVerfahren)[Tablauematrix]
|
||
]
|
||
// Machenstrom-/Knotenpotenzial-Analyse
|
||
#bgBlock(fill: colorAnalyseVerfahren)[
|
||
#subHeading(fill: colorAnalyseVerfahren)[Machenstrom-/Knotenpotenzial-Analyse]
|
||
]
|
||
|
||
// Reduziert Knotenpotenzial
|
||
#bgBlock(fill: colorAnalyseVerfahren)[
|
||
#subHeading(fill: colorAnalyseVerfahren)[Reduzierte Knotenpotenzial-Analyse]
|
||
]
|
||
|
||
// ZweiTor Beschreibungen
|
||
#bgBlock(fill: colorZweiTore)[
|
||
#subHeading(fill: colorZweiTore)[Zwei-Tor Beschreibungen]
|
||
|
||
*Parametrisch/Bildraum*\
|
||
Parameter: $c in RR^n$
|
||
|
||
*Streng Linear:* $vec(jVec(u), jVec(i)) = mat(jMat(U); jMat(I))jVec(c)$\
|
||
|
||
*Linear:* $vec(jVec(u), jVec(i)) = mat(jMat(U); jMat(I))jVec(c) + vec(jVec(u), jVec(i))$
|
||
|
||
|
||
*Implizite/Kern/Nullraum*
|
||
|
||
$mat(jMat(M), jMat(N)) vec(jVec(u), jVec(i)) = 0$
|
||
|
||
*Explizit*
|
||
|
||
siehe Tabelle
|
||
|
||
*Umrechnung*
|
||
|
||
#grid(
|
||
columns: (auto, 1fr),
|
||
column-gutter: 2mm,
|
||
row-gutter: 2mm,
|
||
$"Nullraum" "Explizit"$,
|
||
[
|
||
$G = I U^(-1)\ R = U I^(-1)$\
|
||
],
|
||
|
||
$"Explizit" -> "Nullraum"$,
|
||
[
|
||
Zwei Messungen einsetzen
|
||
],
|
||
|
||
$"Kernraum" -> "Nullraum"$,
|
||
)
|
||
|
||
]
|
||
|
||
// ZweiTor Verschaltung
|
||
#bgBlock(fill: colorZweiTore)[
|
||
#subHeading(fill: colorZweiTore)[Zweitor Verschaltung]
|
||
#grid(
|
||
columns: (auto, auto),
|
||
gutter: 5mm,
|
||
[
|
||
Parallel-Parallel \
|
||
$jMat(G)_"ges" = jMat(G_1) + jMat(G_2)$
|
||
],
|
||
[
|
||
#zap.circuit({
|
||
import zap: *
|
||
|
||
registerAllCustom()
|
||
zweiTor("G1", (0, -6mm), $jMat(G_1)$)
|
||
zweiTor("G2", (0, 6mm), $jMat(G_2)$)
|
||
|
||
zwire("G1.in1", (-8mm, -3.5mm), (-8mm, 8.5mm), "G2.in1")
|
||
zwire("G1.in0", (-10mm, -8.5mm), (-10mm, 3.5mm), "G2.in0")
|
||
node("n0", (13mm, 8.5mm), fill: false)
|
||
node("n1", (13mm, -8.5mm), fill: false)
|
||
node("n00", (10mm, 8.5mm))
|
||
node("n11", (8mm, -8.5mm))
|
||
wire("n0", "n00")
|
||
wire("n1", "n11")
|
||
|
||
zwire("G1.out1", (10mm, -3.5mm), (10mm, 8.5mm), "G2.out1")
|
||
zwire("G1.out0", (8mm, -8.5mm), (8mm, 3.5mm), "G2.out0")
|
||
node("n2", (-13mm, 8.5mm), fill: false)
|
||
node("n3", (-13mm, -8.5mm), fill: false)
|
||
node("n22", (-8mm, 8.5mm))
|
||
node("n33", (-10mm, -8.5mm))
|
||
wire("n2", "n22")
|
||
wire("n3", "n33")
|
||
})
|
||
],
|
||
|
||
[
|
||
Seriel-Seriel \
|
||
$jMat(G)_"ges" = jMat(G_1) + jMat(G_2)$
|
||
],
|
||
[
|
||
#zap.circuit({
|
||
import zap: *
|
||
|
||
registerAllCustom()
|
||
zweiTor("G1", (0, -6mm), $jMat(R_1)$)
|
||
zweiTor("G2", (0, 6mm), $jMat(R_2)$)
|
||
|
||
node("n0", (13mm, 8.5mm), fill: false)
|
||
node("n1", (13mm, -8.5mm), fill: false)
|
||
|
||
node("n2", (-13mm, 8.5mm), fill: false)
|
||
node("n3", (-13mm, -8.5mm), fill: false)
|
||
|
||
zwire("G1.in1", (-8mm, -3.5mm), (-8mm, 3.5mm), "G2.in0")
|
||
zwire("G1.out1", (8mm, -3.5mm), (8mm, 3.5mm), "G2.out0")
|
||
|
||
zwire("G1.in0", "n3")
|
||
zwire("G1.out0", "n1")
|
||
zwire("G2.out1", "n0")
|
||
zwire("G2.in1", "n2")
|
||
})
|
||
],
|
||
|
||
[
|
||
Seriel-Parallel \
|
||
$jMat(H)_"ges" = jMat(H_1) + jMat(H_2)$
|
||
],
|
||
[
|
||
#zap.circuit({
|
||
import zap: *
|
||
|
||
registerAllCustom()
|
||
zweiTor("G1", (0, -6mm), $jMat(H_1)$)
|
||
zweiTor("G2", (0, 6mm), $jMat(H_2)$)
|
||
|
||
node("n0", (13mm, 8.5mm), fill: false)
|
||
node("n1", (13mm, -8.5mm), fill: false)
|
||
|
||
node("n2", (-13mm, 8.5mm), fill: false)
|
||
node("n3", (-13mm, -8.5mm), fill: false)
|
||
|
||
zwire("G1.in1", (-8mm, -3.5mm), (-8mm, 3.5mm), "G2.in0")
|
||
|
||
zwire("G1.in0", "n3")
|
||
zwire("G2.in1", "n2")
|
||
|
||
zwire("G1.out1", (10mm, -3.5mm), (10mm, 8.5mm), "G2.out1")
|
||
zwire("G1.out0", (8mm, -8.5mm), (8mm, 3.5mm), "G2.out0")
|
||
node("n00", (10mm, 8.5mm))
|
||
node("n11", (8mm, -8.5mm))
|
||
wire("n0", "n00")
|
||
wire("n1", "n11")
|
||
})
|
||
],
|
||
|
||
[
|
||
Parallel-Seriel \
|
||
$jMat(H')_"ges" = jMat(H'_1) + jMat(H'_2)$
|
||
],
|
||
[
|
||
#zap.circuit({
|
||
import zap: *
|
||
|
||
registerAllCustom()
|
||
zweiTor("G1", (0, -6mm), $jMat(H'_1)$)
|
||
zweiTor("G2", (0, 6mm), $jMat(H'_2)$)
|
||
|
||
node("n0", (13mm, 8.5mm), fill: false)
|
||
node("n1", (13mm, -8.5mm), fill: false)
|
||
|
||
node("n2", (-13mm, 8.5mm), fill: false)
|
||
node("n3", (-13mm, -8.5mm), fill: false)
|
||
|
||
zwire("G1.out1", (8mm, -3.5mm), (8mm, 3.5mm), "G2.out0")
|
||
|
||
zwire("G1.out0", "n1")
|
||
zwire("G2.out1", "n0")
|
||
|
||
zwire("G1.in1", (-8mm, -3.5mm), (-8mm, 8.5mm), "G2.in1")
|
||
zwire("G1.in0", (-10mm, -8.5mm), (-10mm, 3.5mm), "G2.in0")
|
||
node("n22", (-8mm, 8.5mm))
|
||
node("n33", (-10mm, -8.5mm))
|
||
wire("n2", "n22")
|
||
wire("n3", "n33")
|
||
})
|
||
],
|
||
|
||
[
|
||
Kette normal \
|
||
$jMat(A)_"ges" = jMat(A_1) dot jMat(A_2)$
|
||
],
|
||
[
|
||
#zap.circuit({
|
||
import zap: *
|
||
|
||
registerAllCustom()
|
||
zweiTor("A2", (6mm, 0), $jMat(A_2)$, height: 8mm, width: 8mm)
|
||
zweiTor("A1", (-6mm, 0), $jMat(A_1)$, height: 8mm, width: 8mm)
|
||
|
||
node("n0", (-13mm, 2mm), fill: false)
|
||
node("n1", (-13mm, -2mm), fill: false)
|
||
node("n2", (13mm, 2mm), fill: false)
|
||
node("n3", (13mm, -2mm), fill: false)
|
||
|
||
wire((-13mm, 2mm), "A1.in1")
|
||
wire((-13mm, -2mm), "A1.in0")
|
||
wire((13mm, 2mm), "A2.out1")
|
||
wire((13mm, -2mm), "A2.out0")
|
||
wire("A2.in1", "A1.out1")
|
||
wire("A2.in0", "A1.out0")
|
||
})
|
||
],
|
||
|
||
[
|
||
Kette invers \
|
||
$jMat(A')_"ges" = jMat(A'_2) dot jMat(A'_1)$
|
||
],
|
||
[
|
||
#zap.circuit({
|
||
import zap: *
|
||
|
||
registerAllCustom()
|
||
zweiTor("A2", (6mm, 0), $jMat(A'_2)$, height: 8mm, width: 8mm)
|
||
zweiTor("A1", (-6mm, 0), $jMat(A'_1)$, height: 8mm, width: 8mm)
|
||
|
||
node("n0", (-13mm, 2mm), fill: false)
|
||
node("n1", (-13mm, -2mm), fill: false)
|
||
node("n2", (13mm, 2mm), fill: false)
|
||
node("n3", (13mm, -2mm), fill: false)
|
||
|
||
wire((-13mm, 2mm), "A1.in1")
|
||
wire((-13mm, -2mm), "A1.in0")
|
||
wire((13mm, 2mm), "A2.out1")
|
||
wire((13mm, -2mm), "A2.out0")
|
||
wire("A2.in1", "A1.out1")
|
||
wire("A2.in0", "A1.out0")
|
||
})
|
||
],
|
||
)
|
||
],
|
||
|
||
// Linearsierung (N-Tore)
|
||
#bgBlock(fill: colorZweiTore)[
|
||
#subHeading(fill: colorZweiTore)[Linearisierung (N-Tore)]
|
||
|
||
1. Arbeitspunk bestimmen $vec(jVec(u)_"AP", jVec(i)_"AP") hat(=) vec(jVec(x)_"AP", jVec(y)_"AP")$
|
||
|
||
$f_1(x_1, x_2, ... x_n) &= y_1\
|
||
f_2(x_1, x_2, ... x_n) &= y_2\
|
||
&dots.v \
|
||
f_n (x_1, x_2, ... x_n) &= y_n$
|
||
|
||
$bold(f)(jVec(x))=jVec(y)$
|
||
|
||
2. Ableitung: Jacobi-Matrix
|
||
|
||
$jMat(J) = mat(
|
||
#mannot.mark($delta y_1$, color: red)/(#mannot.mark($delta x_1$, color: red)), #mannot.mark($delta y_1$, color: red)/(#mannot.mark($delta x_2$, color: purple)), ..., #mannot.mark($delta y_1$, color: red)/(#mannot.mark($delta x_n$, color: blue));
|
||
#mannot.mark($delta y_2$, color: purple)/(#mannot.mark($delta x_1$, color: red)), #mannot.mark($delta y_2$, color: purple)/(#mannot.mark($delta x_2$, color: purple)), ..., #mannot.mark($delta y_2$, color: purple)/(#mannot.mark($delta x_n$, color: blue));
|
||
dots.v, dots.v, dots.down, dots.v;
|
||
#mannot.mark($delta y_n$, color: blue)/(#mannot.mark($delta x_1$, color: red)), #mannot.mark($delta y_n$, color: blue)/(#mannot.mark($delta x_2$, color: purple)), ..., #mannot.mark($delta y_n$, color: blue)/(#mannot.mark($delta x_n$, color: blue));
|
||
)$
|
||
|
||
*Großsignal Beschreibung:* \
|
||
$jVec(y)_"lin" = jMat(J)|_(jVec(x)_"AP") (jVec(x)_"lin" - jVec(x)_"AP") + jVec(y)_"AP"$
|
||
|
||
*Kleinsingal Beschreibung:* \
|
||
$jVec(y)_"lin" = jMat(J)|_(jVec(x)_"AP") jVec(x)_"lin"$
|
||
]
|
||
|
||
// Newton-Raphson
|
||
#bgBlock(fill: colorEineTore)[
|
||
#subHeading(fill: colorEineTore)[Newton-Raphson (Eine-Tor)]
|
||
$x_(n+1) = x_n - f(x_n)/(f'(x_n))$
|
||
]
|
||
|
||
// Netwen-Raphson N-Tore
|
||
#bgBlock(fill: colorZweiTore)[
|
||
#subHeading(fill: colorZweiTore)[Newton-Raphson (N-Tore)]
|
||
Nicht lineare Beschreibung in Nullraum/Impliziter Darstellung:
|
||
$f(jVec(x)) = jVec(0)$\
|
||
|
||
$jVec(x)_(n+1) = jVec(x)_n - (jMat(J)|_(jVec(x)_"AP"))^(-1) f(jVec(x))$
|
||
]
|
||
|
||
// Reaktive Elemeten
|
||
#colbreak()
|
||
#bgBlock(fill: colorComplexAC)[
|
||
#subHeading(fill: colorComplexAC)[Reaktive Element]
|
||
|
||
*Zustandsgrößen*\
|
||
|
||
#grid(
|
||
columns: (1fr, 0pt, 1fr),
|
||
row-gutter: 10mm,
|
||
column-gutter: 2mm,
|
||
[
|
||
$[i(t)] = unit("A")$\
|
||
$[q(t)] = unit("A s") = unit("C")$\
|
||
],
|
||
grid.vline(stroke: 0.75pt),
|
||
[],
|
||
[
|
||
$[u(t)] = unit("V")$ \
|
||
$[Phi(t)] = unit("V s") = unit("W b")$ \
|
||
],
|
||
|
||
[
|
||
$q(t) = integral_(-infinity)^(t) i(tau) d tau = \
|
||
q(0) + integral_(0)^(t) i(tau) d tau$ \
|
||
|
||
$i(t) = (d q)/(d t) = dot(q(t))$
|
||
],
|
||
[],
|
||
[
|
||
$Phi(t) = integral_(-infinity)^(t) u(tau) d tau = \
|
||
Phi(0) + integral_(0)^(t) u(tau) d tau$ \
|
||
|
||
$u(t) = (d Phi)/(d t) dot(Phi(t))$
|
||
],
|
||
)
|
||
|
||
$W(t_1, t_2) = integral_(t_1)^(t_2) P(tau) d tau = integral_(t_1)^(t_2) u(tau) i(tau) d tau$
|
||
|
||
$W(t_1, t_2) > 0$: Nimmt Energie auf\
|
||
$W(t_1, t_2) = 0$: Verlustlos\
|
||
$W(t_1, t_2) < 0$: Gibt Energie ab\
|
||
]
|
||
|
||
#bgBlock(fill: colorComplexAC)[
|
||
#subHeading(fill: colorComplexAC)[Reaktive Bauelemente]
|
||
#grid(
|
||
columns: (1fr, 0pt, 1fr),
|
||
row-gutter: 4mm,
|
||
column-gutter: 2mm,
|
||
[*Kapazitiv*],
|
||
grid.vline(stroke: 0.75pt),
|
||
[],
|
||
[*Induktivität*],
|
||
[
|
||
$q = c(u) \ u = chi(q)$\
|
||
],
|
||
[],
|
||
[
|
||
$Phi = l(i) \ i = lambda(Phi)$
|
||
],
|
||
|
||
[$u,q$ stetig und beschränkt],
|
||
[],
|
||
[$i,Phi$ stetig und beschränkt],
|
||
|
||
grid.hline(stroke: 0.75pt),
|
||
[],
|
||
[],
|
||
[],
|
||
|
||
[*Restiv*],
|
||
[],
|
||
[*Memristiv*],
|
||
[
|
||
$i = g(u) \ u = r(i)$\
|
||
],
|
||
[],
|
||
[
|
||
$Phi = l(i) \ i = lambda(Phi)$
|
||
],
|
||
|
||
[$u,q$ stetig und beschränkt],
|
||
[],
|
||
[$i,Phi$ stetig und beschränkt],
|
||
[],
|
||
)
|
||
|
||
#line(length: 100%, stroke: (thickness: 0.2mm))
|
||
|
||
#align(center, [*Lineare Bauelemente*])
|
||
#grid(
|
||
columns: (1fr, 0pt, 1fr),
|
||
row-gutter: 4mm,
|
||
column-gutter: 2mm,
|
||
[
|
||
*Kapazitiv*
|
||
],
|
||
grid.vline(stroke: 0.75pt),
|
||
[],
|
||
[
|
||
*Induktivität*
|
||
],
|
||
[
|
||
$q(t) = C dot u(t)$\
|
||
$i(t) = C dot (d u)/(d t)$\
|
||
$[C] = F = unit("A s")/unit("V")$
|
||
],
|
||
[],
|
||
[
|
||
$Phi(t) = L dot i(t)$\
|
||
$u(t) = L dot (d i)/(d t)$\
|
||
$[L] = H = unit("V s") / unit("A")$
|
||
],
|
||
[
|
||
$E_C = q^2 / 2C = C/2 u^2$
|
||
],
|
||
[],
|
||
[
|
||
$E_L = Phi^2/2L = (L i^2)/2$
|
||
],
|
||
[
|
||
$C$: Admittanz $hat(=) G$
|
||
],
|
||
[],
|
||
[
|
||
$L$: Impedanz $hat(=) R$
|
||
],
|
||
)
|
||
|
||
Admittanz: $Y = I/U$\
|
||
Impedanz: $Z = U/I$
|
||
|
||
]
|
||
|
||
// Reaktive Dual Wandlung
|
||
#bgBlock(fill: colorComplexAC)[
|
||
#subHeading(fill: colorComplexAC)[Reaktive Dualwandlung]
|
||
|
||
#grid(
|
||
columns: (1fr, 1fr),
|
||
row-gutter: 4mm,
|
||
$u --> R_d i^d$, $i --> u^d/R_d$,
|
||
$q --> Phi^d / R_d$, $Phi --> q^d R_d$,
|
||
)
|
||
]
|
||
|
||
// Complex AC
|
||
#bgBlock(fill: colorComplexAC)[
|
||
#subHeading(fill: colorComplexAC)[Komplex Wechselstrom Rechnnung]
|
||
Im Eingeschwungenem Zustand
|
||
|
||
$u(t) =U_m "Re"{e^(j omega t + phi)}$
|
||
|
||
$u(t) = U_m cos(omega t + alpha)$ \
|
||
$i(t) = I_m cos(omega t + beta)$
|
||
|
||
$(d u)/(d t) = A_m$
|
||
|
||
Kreisfrequenz: $omega = 2 pi f$ \
|
||
Amplitude: $A_m$ \
|
||
Phaseverschieben: $alpha$
|
||
|
||
*Ohm:* $u(t) = R I_m cos(omega t + beta) = omega A_m cos(omega)$)
|
||
|
||
*Serienschaltung*\
|
||
$u_1(t) = U_1 cos(omega t)$\
|
||
$u_2(t) = U_2 cos(omega t + phi)$
|
||
|
||
$u(t)_"ges" = u_1(t) + u_2(t) = \
|
||
U_"ges"^2 = U_1^2 + 2 U_1 U_2 + U_2^2 \
|
||
tan(phi) = (U_2 sin(phi))/(U_1 + U_2 cos(phi))$
|
||
]
|
||
|
||
|
||
#bgBlock(fill: colorComplexAC)[
|
||
#subHeading(fill: colorComplexAC)[Komplex Beziehungen]
|
||
#let size = 1.4
|
||
#let margin = 0.2
|
||
|
||
*Bauelement Beziehungen*
|
||
#align(center+horizon, [
|
||
#canvas({
|
||
import cetz.draw : content, set-style, line, scale
|
||
content((-size, size), $i$)
|
||
content((size, size), $u$)
|
||
content((-size, -size), $q$)
|
||
content((size, -size), $Phi$)
|
||
|
||
set-style(mark: (symbol: ">"))
|
||
line((-size + margin, size), (size - margin, size),
|
||
stroke: (thickness: 0.2mm, paint: rgb("#005500"))
|
||
)
|
||
line((-size + margin, -size), (size - margin, -size),
|
||
stroke: (thickness: 0.2mm, paint: rgb("#008b00"))
|
||
)
|
||
|
||
|
||
set-style(mark: (symbol: ">"))
|
||
line((-size+margin, -size+margin), (size -margin, size -margin),
|
||
stroke: (thickness: 0.2mm, paint: rgb("#2534ff"))
|
||
)
|
||
line((size -margin, -size+margin), (-size+margin, size -margin),
|
||
stroke: (thickness: 0.2mm, paint: rgb("#ff4625"))
|
||
)
|
||
|
||
scale(y: 75%, x: 75%)
|
||
content((0.0, -size - 0.8), text(rgb("#008b00"))[$"Memristiv" q = f(Phi)$], auto-scale: true)
|
||
|
||
content((0.0, size+0.8), text(rgb("#005500"))[$"Resitiv" u = r(i)$], auto-scale: true)
|
||
|
||
|
||
content((0.0, 0.2), text(rgb("#ff4625"))[$"Induktiv" quad i = lambda(Phi)$], angle: -45deg, auto-scale: true)
|
||
|
||
|
||
content((-0.2, 0.1), text(rgb("#2534ff"))[$"Kapazitiv" quad u = chi(Phi)$], angle: 45deg, auto-scale: true)
|
||
})
|
||
])
|
||
|
||
*Allgemeine Beziehungen (gilt immer)*
|
||
#align(center+horizon, [
|
||
#canvas({
|
||
import cetz.draw : content, set-style, line, bezier
|
||
content((-size, size), $i$)
|
||
content((size, size), $u$)
|
||
content((-size, -size), $q$)
|
||
content((size, -size), $Phi$)
|
||
|
||
set-style(mark: (end: ">"))
|
||
bezier((-size -margin*0.5, -size +margin), (-size -margin*0.5, size -margin), (-size - 0.5, 0), stroke: (thickness: 0.2mm, paint: rgb("#00318b")))
|
||
bezier((size -margin*0.5, -size +margin), (size -margin*0.5, size -margin), (size - 0.5, 0), stroke: (thickness: 0.2mm, paint: rgb("#00318b")))
|
||
|
||
|
||
bezier((-size +margin*0.5, size -margin), (-size +margin*0.5, -size +margin), (-size + 0.5, 0), stroke: (thickness: 0.2mm, paint: rgb("#8b2000")))
|
||
bezier((size +margin*0.5, size -margin), (size +margin*0.5, -size +margin), (size + 0.5, 0), stroke: (thickness: 0.2mm, paint: rgb("#8b2000")))
|
||
|
||
content((-size + 0.2, 0), scale(75%, text(rgb("#8b2000"), $integral i(tau) d tau$)), anchor: "west")
|
||
content((-size - 0.3, 0), scale(75%, text(rgb("#00318b"), $(d q)/(d t)$)), anchor: "east")
|
||
|
||
content((size + 0.2, 0), scale(75%, text(rgb("#8b2000"), $integral u(tau) d tau$)), anchor: "west")
|
||
content((size - 0.3, 0), scale(75%, text(rgb("#00318b"), $(d Phi)/(d t)$)), anchor: "east")
|
||
|
||
})
|
||
])
|
||
]
|
||
|
||
// AC Components
|
||
#bgBlock(fill: colorComplexAC)[
|
||
#subHeading(fill: colorComplexAC)[Komplexe Komponent]
|
||
#table(
|
||
columns: (1fr, 2fr, 2fr, 2fr),
|
||
inset: (bottom: 2mm, top: 2mm),
|
||
fill: (x, y) => if calc.rem(y, 2) == 1 { tableFillLow } else { tableFillHigh },
|
||
[], [*$Z = U/I$*], [*$Y = I/U$*], [*$phi$*],
|
||
[], [*$I -> U$*], [*$U -> I$*], [*$phi$*],
|
||
[], [*$Omega space (R)$*], [*$S space (G)$*], [*rad*],
|
||
zap.circuit({
|
||
import zap: *
|
||
resistor("R", (0, 0), (0.6, 0), width: 3mm, height: 2mm, fill: none)
|
||
}),
|
||
$R = 1/G$,
|
||
$G = 1/R$,
|
||
$0$,
|
||
|
||
zap.circuit({
|
||
import zap: *
|
||
capacitor("R", (0, 0), (0.6, 0), width: 4mm, height: 6mm, fill: none)
|
||
}),
|
||
$1/(j w C)$,
|
||
$j w C$,
|
||
$-pi/2$,
|
||
|
||
zap.circuit({
|
||
import zap: *
|
||
inductor("R", (0, 0), (0.6, 0), width: 4mm, height: 2mm, fill: none, variant: "ieee")
|
||
}),
|
||
$j w L$,
|
||
$1/(j w L)$,
|
||
$pi/2$,
|
||
)
|
||
]
|
||
|
||
#bgBlock(fill: colorComplexAC)[
|
||
#subHeading(fill: colorComplexAC)[*Levi's Lustig Leistung*]
|
||
$P=P_W + j P_B$\
|
||
|
||
#table(
|
||
columns: (auto, 1fr, auto),
|
||
fill: (x, y) => if calc.rem(y, 2) == 0 { tableFillLow } else { tableFillHigh },
|
||
[Scheinleitsung], [$S = abs(P)$], [$["VA"]$],
|
||
[Wirkleistung], [$P_W = "Re"{P}$], [$["W"]$],
|
||
[Blindleistung], [$P_B = "Im"{P}$], [$["var"]$],
|
||
)
|
||
|
||
$P = 1/2 U I^* = 1/2 abs(U)^2 Y^* = 1/2 abs(I)^2 Z^*$
|
||
|
||
//Bei Wiederstand: $R$
|
||
|
||
//$P_w = U_m^2 / 2R = (I_m^2 R)/2$
|
||
|
||
|
||
|
||
$U_"eff" = U_m/sqrt(2), I_"eff" = I_m / sqrt(2)$
|
||
]
|
||
|
||
// Komplexe Zahlen
|
||
#bgBlock(fill: colorAllgemein)[
|
||
#subHeading(fill: colorAllgemein)[Komplexe Zahlen]
|
||
|
||
#ComplexNumbersSection(i: $j$)
|
||
|
||
|
||
]
|
||
|
||
// SinTable
|
||
#bgBlock(fill: colorAllgemein, [
|
||
#subHeading(fill: colorAllgemein, [Sin-Table])
|
||
#sinTable
|
||
|
||
#SineCircle()
|
||
])
|
||
]
|
||
|
||
#pagebreak()
|
||
|
||
#let NodeRed = rgb("#ff5656")
|
||
#let NodeGreen = rgb("#5eff56")
|
||
#let NodeBlue = rgb("#6156ff")
|
||
#let NodeYellow = rgb("#ffa856")
|
||
|
||
#let nodeSymbol(s, center, color, ..style) = {
|
||
import cetz.draw: *
|
||
(
|
||
ctx => {
|
||
// Define a default style
|
||
let def-style = (n: 5, inner-radius: .5, radius: 1, stroke: auto, fill: auto)
|
||
|
||
// Resolve center to a vector
|
||
let (ctx, center) = cetz.coordinate.resolve(ctx, center)
|
||
|
||
// Resolve the current style ("star")
|
||
let style = cetz.styles.resolve(ctx.style, merge: style.named(), base: def-style, root: "star")
|
||
|
||
let paths = (
|
||
cetz.drawable.ellipse(center.at(0), center.at(1), 0, 0.25, 0.25, fill: color, stroke: black),
|
||
cetz.drawable.content((center.at(0),center.at(1) + 0.025), 1, 1, none, s),
|
||
)
|
||
(
|
||
ctx: ctx,
|
||
drawables: cetz.drawable.apply-transform(ctx.transform, paths)
|
||
)
|
||
},
|
||
)
|
||
}
|
||
|
||
|
||
#columns(2)[
|
||
#bgBlock(fill: colorAnalyseVerfahren)[
|
||
#subHeading(fill: colorAnalyseVerfahren)[Knotenpotenzial-Analyse Komponetent]
|
||
#import mannot: *
|
||
|
||
#let ImageHeight = 2.5cm
|
||
|
||
#table(
|
||
columns: (1fr, 1fr),
|
||
fill: (x, y) => if calc.rem(y, 2) == 0 { tableFillHigh } else { tableFillLow },
|
||
align(center, image("../images/schaltungstheorie/knotenpotenzial/schaltKontenPotenziell3-1.png", height: ImageHeight, fit: "contain")),
|
||
|
||
align(center, image("../images/schaltungstheorie/knotenpotenzial/schaltKontenPotenziell4.png", height: ImageHeight, fit: "contain")),
|
||
|
||
align(center, image("../images/schaltungstheorie/knotenpotenzial/schaltKontenPotenziell5.png", height: ImageHeight, fit: "contain")),
|
||
|
||
align(center, image("../images/schaltungstheorie/knotenpotenzial/schaltKontenPotenziell6.png", height: ImageHeight, fit: "contain")),
|
||
|
||
align(center, image("../images/schaltungstheorie/knotenpotenzial/schaltKontenPotenziell7.png", height: ImageHeight, fit: "contain")),
|
||
|
||
align(center, image("../images/schaltungstheorie/knotenpotenzial/schaltKontenPotenziell8.png", height: ImageHeight, fit: "contain")),
|
||
|
||
align(center, image("../images/schaltungstheorie/knotenpotenzial/schaltKontenPotenziell9.png", height: ImageHeight, fit: "contain")),
|
||
|
||
align(center, image("../images/schaltungstheorie/knotenpotenzial/schaltKontenPotenziell10.png", height: ImageHeight, fit: "contain")),
|
||
|
||
align(center, image("../images/schaltungstheorie/knotenpotenzial/schaltKontenPotenziell1.png", height: ImageHeight, fit: "contain")),
|
||
|
||
align(center, image("../images/schaltungstheorie/knotenpotenzial/schaltKontenPotenziell2.png", height: ImageHeight, fit: "contain")),
|
||
|
||
align(center, image("../images/schaltungstheorie/knotenpotenzial/nullator.jpg", height: ImageHeight, fit: "contain")),
|
||
|
||
align(center, image("../images/schaltungstheorie/knotenpotenzial/norator.jpg", height: ImageHeight, fit: "contain")),
|
||
|
||
)
|
||
]
|
||
|
||
#colbreak()
|
||
|
||
// Bauelemente
|
||
#bgBlock(fill: colorEineTore)[
|
||
#subHeading(fill: colorEineTore)[Bauelemente]
|
||
|
||
#table(
|
||
columns: (1fr, 1fr, 1fr),
|
||
stroke: none,
|
||
fill: (x, y) => if (calc.rem(y, 2) == 0) { tableFillLow } else { tableFillHigh },
|
||
align: center,
|
||
table.header([*Zeichen*], [*Gleichungen*], [*Abbildung*]),
|
||
table.hline(),
|
||
|
||
// Nullator
|
||
[
|
||
Nullator
|
||
#scale(x: 100%, y: 100%, zap.circuit({
|
||
import zap: *
|
||
import cetz.draw: content, line
|
||
joham.nullator("nullator1",(0,0), (-1.75,0))
|
||
}))
|
||
],
|
||
align(center+horizon,
|
||
$u = 0 \ i = 0$
|
||
),
|
||
[
|
||
#scale(x: 75%, y: 75%, cetz.canvas({
|
||
import cetz.draw: *
|
||
import cetz-plot: *
|
||
|
||
let opts = (x-tick-step: none, y-tick-step: none, size: (2, 1), x-label: [u], y-label: [i])
|
||
|
||
plot.plot(axis-style: "school-book", ..opts, name: "plot", {
|
||
|
||
plot.add(((0,0), (0,0)),
|
||
mark-style: (stroke: red, fill: red), mark: "o", )
|
||
})
|
||
}))
|
||
],
|
||
|
||
// Norator
|
||
[
|
||
Norator
|
||
#scale(x: 100%, y: 100%, zap.circuit({
|
||
import zap: *
|
||
import cetz.draw: content, line
|
||
joham.norator("norator1",(0,0), (-1.75,0))
|
||
}))
|
||
],
|
||
[
|
||
$u = "bel." \
|
||
i = "bel."$
|
||
],
|
||
[
|
||
#scale(x: 75%, y: 75%, cetz.canvas({
|
||
import cetz.draw: *
|
||
import cetz-plot: *
|
||
|
||
let opts = (x-tick-step: none, y-tick-step: none, size: (2, 1), x-label: [u], y-label: [i])
|
||
|
||
plot.plot(axis-style: "school-book", ..opts, name: "plot", {
|
||
plot.add-contour(x-domain: (-3, 3), y-domain: (-3, 3),
|
||
style: (fill: rgb("#f7000832"), stroke: none),
|
||
fill: true,
|
||
op: "<", // Find contours where data < z
|
||
z: (0,100000), // Z values to find contours for
|
||
(x, y) => calc.sqrt(x*x + y * y))
|
||
})
|
||
}))
|
||
],
|
||
|
||
table.hline(),
|
||
|
||
// Kurzschluss
|
||
[
|
||
Kurzschluss
|
||
#scale(x: 100%, y: 100%, zap.circuit({
|
||
import zap: *
|
||
import cetz.draw: content, line
|
||
|
||
node("n1", (0, 0))
|
||
node("n2", (1, 0))
|
||
wire((0,0), (1,0))
|
||
wire((-0.25,0), (0,0))
|
||
wire((1,0), (1.25,0))
|
||
|
||
}))
|
||
],
|
||
[
|
||
$u = 0$
|
||
|
||
i = bel.
|
||
],
|
||
[
|
||
#scale(x: 75%, y: 75%, cetz.canvas({
|
||
import cetz.draw: *
|
||
import cetz-plot: *
|
||
|
||
let opts = (x-tick-step: none, y-tick-step: none, size: (2, 1), x-label: [u], y-label: [i])
|
||
|
||
plot.plot(axis-style: "school-book", ..opts, name: "plot", {
|
||
|
||
plot.add(((0, -1), (0, 1)), style: (stroke: red))
|
||
})
|
||
}))
|
||
],
|
||
|
||
// Leerlauf
|
||
[
|
||
Leerlauf
|
||
#scale(x: 100%, y: 100%, zap.circuit({
|
||
import zap: *
|
||
import cetz.draw: content, line
|
||
node("n1", (0, 0))
|
||
node("n2", (1, 0))
|
||
|
||
wire((-0.25,0), (0,0))
|
||
wire((1,0), (1.25,0))
|
||
}))
|
||
],
|
||
[
|
||
$u = "bel." \
|
||
i = 0$
|
||
],
|
||
[
|
||
#scale(x: 75%, y: 75%, cetz.canvas({
|
||
import cetz.draw: *
|
||
import cetz-plot: *
|
||
|
||
let opts = (x-tick-step: none, y-tick-step: none, size: (2, 1), x-label: [u], y-label: [i])
|
||
|
||
plot.plot(axis-style: "school-book", ..opts, name: "plot", {
|
||
|
||
plot.add(((-1, 0), (1, 0)), style: (stroke: red))
|
||
})
|
||
}))
|
||
],
|
||
|
||
table.hline(),
|
||
// Quellen: //
|
||
// Spannungs-quelle
|
||
[
|
||
Spannungs-quelle
|
||
#scale(x: 100%, y: 100%, zap.circuit({
|
||
import zap: *
|
||
import cetz.draw: content, line
|
||
vsource(
|
||
"b1",
|
||
(0, 0),
|
||
(1.75, 0),
|
||
)
|
||
}))
|
||
],
|
||
[
|
||
$u = U_0$
|
||
|
||
i = bel.
|
||
],
|
||
[
|
||
#scale(x: 75%, y: 75%, cetz.canvas({
|
||
import cetz.draw: *
|
||
import cetz-plot: *
|
||
|
||
let opts = (x-tick-step: none, y-tick-step: none, size: (2, 1), x-label: [u], y-label: [i])
|
||
|
||
plot.plot(axis-style: "school-book", ..opts, name: "plot", {
|
||
|
||
plot.add(((1, -1), (1, 1)), style: (stroke: red))
|
||
plot.add-anchor("pt",(1,0))
|
||
})
|
||
content("plot.pt", [$U_0$], anchor: "north-west", padding: .1)
|
||
}))
|
||
],
|
||
|
||
// Strom-quelle
|
||
[
|
||
Strom-quelle
|
||
#scale(x: 100%, y: 100%, zap.circuit({
|
||
import zap: *
|
||
import cetz.draw: content, line
|
||
isource(
|
||
"b1",
|
||
(0, 0),
|
||
(1.75, 0),
|
||
)
|
||
}))
|
||
],
|
||
[
|
||
u = bel.
|
||
|
||
$i = I_0$
|
||
],
|
||
[
|
||
#scale(x: 75%, y: 75%, cetz.canvas({
|
||
import cetz.draw: *
|
||
import cetz-plot: *
|
||
|
||
let opts = (x-tick-step: none, y-tick-step: none, size: (2, 1), x-label: [u], y-label: [i])
|
||
|
||
plot.plot(axis-style: "school-book", ..opts, name: "plot", {
|
||
|
||
plot.add(((-1, 1), (1, 1)), style: (stroke: red))
|
||
plot.add-anchor("pt",(0,1))
|
||
})
|
||
content("plot.pt", [$I_0$], anchor: "south-east", padding: .1)
|
||
}))
|
||
],
|
||
|
||
table.hline(),
|
||
|
||
// Wiederstand
|
||
[
|
||
Wiederstand
|
||
#scale(x: 100%, y: 100%, zap.circuit({
|
||
import zap: *
|
||
import cetz.draw: content, line
|
||
resistor(
|
||
"b1",
|
||
(0, 0),
|
||
(2, 0),
|
||
)
|
||
}))
|
||
],
|
||
align(center+horizon,
|
||
$u = r dot i \
|
||
i = u/r$
|
||
),
|
||
[
|
||
#scale(x: 75%, y: 75%, cetz.canvas({
|
||
import cetz.draw: *
|
||
import cetz-plot: *
|
||
|
||
let opts = (x-tick-step: none, y-tick-step: none, size: (2, 1), x-label: [u], y-label: [i])
|
||
|
||
plot.plot(axis-style: "school-book", ..opts, name: "plot", {
|
||
|
||
plot.add(((-1, -1), (1, 1)), style: (stroke: red))
|
||
})
|
||
}))
|
||
],
|
||
|
||
// Induktivität
|
||
[
|
||
Induktivität
|
||
#scale(x: 100%, y: 100%, zap.circuit({
|
||
import zap: *
|
||
import cetz.draw: content, line
|
||
inductor(
|
||
"b1",
|
||
(0, 0),
|
||
(2, 0),
|
||
variant: "ieee",
|
||
)
|
||
}))
|
||
],
|
||
[
|
||
|
||
],
|
||
[
|
||
|
||
],
|
||
|
||
// Kapazität
|
||
[
|
||
Kapazität
|
||
#scale(x: 100%, y: 100%, zap.circuit({
|
||
import zap: *
|
||
import cetz.draw: content, line
|
||
capacitor(
|
||
"b1",
|
||
(0, 0),
|
||
(2, 0),
|
||
)
|
||
}))
|
||
],
|
||
[
|
||
|
||
],
|
||
[
|
||
|
||
],
|
||
|
||
table.hline(),
|
||
|
||
// Dioden ://
|
||
//
|
||
// ideale Diode
|
||
[
|
||
ideale Diode
|
||
#scale(x: 100%, y: 100%, zap.circuit({
|
||
import zap: *
|
||
import cetz.draw: content, line
|
||
diode("b1", (0, 0), (1., 0), stroke: black, fill: white)
|
||
}))
|
||
],
|
||
[
|
||
|
||
$i=0$ falls $u<0$\
|
||
$i>=0$. falls $u=0$
|
||
],
|
||
[
|
||
/*
|
||
#scale(x: 50%, y: 50%,
|
||
cetz.canvas({
|
||
import cetz.draw: *
|
||
line((-1.5, 0), (1.5, 0), mark: (end: "straight"))
|
||
line((0, -1.5), (0, 1.5), mark: (end: "straight"))
|
||
|
||
content( (1.55, 0), $u$, anchor: "west")
|
||
content( (0.15, 1.4), $i$, anchor: "west")
|
||
|
||
line((-1.5, 0), (0, 0), stroke: red) // u = 0
|
||
line((0, 0), (0, 1.35), stroke: red) // i = 0
|
||
|
||
}))
|
||
*/
|
||
#scale(x: 75%, y: 75%, cetz.canvas({
|
||
import cetz.draw: *
|
||
import cetz-plot: *
|
||
|
||
let opts = (x-tick-step: none, y-tick-step: none, size: (2, 1), x-label: [u], y-label: [i])
|
||
|
||
plot.plot(axis-style: "school-book", ..opts, name: "plot", {
|
||
plot.add(((-1, 0), (0, 0)), style: (stroke: red))
|
||
plot.add(((0, 0), (0, 1)), style: (stroke: red))
|
||
})
|
||
}))
|
||
],
|
||
//table.hline(start: 1, end: 2),
|
||
|
||
// reale/pn Diode
|
||
[
|
||
reale/pn Diode
|
||
#scale(x: 100%, y: 100%, zap.circuit({
|
||
import zap: *
|
||
import cetz.draw: content, line
|
||
diode("b1", (0, 0), (1., 0), stroke: black, fill: black)
|
||
}))
|
||
],
|
||
|
||
[
|
||
$u_D = u_T dot ln((i_D/I_S)+1) \
|
||
i_D = I_S dot (e^(u_D/U_T)-1)$
|
||
],
|
||
[
|
||
#scale(x: 75%, y: 75%, cetz.canvas({
|
||
import cetz.draw: *
|
||
import cetz-plot: *
|
||
|
||
let opts = (x-tick-step: none, y-tick-step: none, size: (2, 1), x-label: [u], y-label: [i])
|
||
let data = plot.add(x => calc.exp(x) - 1, domain: (-2, 2), style: (stroke: red))
|
||
|
||
plot.plot(axis-style: "school-book", ..opts, data, name: "plot")
|
||
}))
|
||
],
|
||
|
||
// Photodiode
|
||
[
|
||
Photodiode
|
||
#scale(x: 100%, y: 100%, zap.circuit({
|
||
import zap: *
|
||
import cetz.draw: content, line
|
||
photodiode("b1", (0, 0), (1., 0), stroke: black, fill: black)
|
||
}))
|
||
],
|
||
align(horizon+center,
|
||
$i = I_S*(e^(u_D/U_T)-1)- i_L$
|
||
),
|
||
[
|
||
#scale(x: 75%, y: 75%, cetz.canvas({
|
||
import cetz.draw: *
|
||
import cetz-plot: *
|
||
|
||
let opts = (x-tick-step: none, y-tick-step: none, size: (2, 1), x-label: [u], y-label: [i])
|
||
|
||
plot.plot(axis-style: "school-book", ..opts, name: "plot", {
|
||
plot.add(x => calc.exp(x) - 1, domain: (-2, 2), style: (stroke: red))
|
||
|
||
plot.add(x => calc.exp(x) - 2, domain: (-2, 2), style: (stroke: red))
|
||
|
||
plot.add(x => calc.exp(x) - 3, domain: (-2, 2), style: (stroke: red))
|
||
})
|
||
}))
|
||
],
|
||
|
||
// Zenerdiode
|
||
[
|
||
Zenerdiode
|
||
#scale(x: 100%, y: 100%, zap.circuit({
|
||
import zap: *
|
||
import cetz.draw: content, line
|
||
zener("b1", (0, 0), (1., 0), stroke: black, fill: black)
|
||
}))
|
||
],
|
||
[
|
||
Durchbruch bei $u=U_Z$ :
|
||
$u<=U_Z$ stark leitend
|
||
],
|
||
[
|
||
|
||
],
|
||
|
||
// Tunneldiode
|
||
[
|
||
Tunneldiode
|
||
#scale(x: 100%, y: 100%, zap.circuit({
|
||
import zap: *
|
||
import cetz.draw: content, line
|
||
tunnel("b1", (0, 0), (1., 0), stroke: black, fill: black)
|
||
}))
|
||
],
|
||
[
|
||
|
||
],
|
||
[
|
||
|
||
],
|
||
|
||
|
||
);
|
||
]
|
||
]
|
||
|
||
#bgBlock(fill: colorZweiTore, width: 100%)[
|
||
#subHeading(fill: colorZweiTore)[OpAmp Schaltungen]
|
||
|
||
#scale(opampTable, 100%)
|
||
]
|
||
|
||
// Zwei-Tor Tabelle
|
||
#bgBlock(fill: colorZweiTore, width: 100%)[
|
||
#subHeading(fill: colorZweiTore)[Zwei-Tor-Übersichts]
|
||
|
||
#table(
|
||
fill: (x, y) => if calc.rem(y, 2) == 0 { tableFillHigh } else { tableFillLow },
|
||
columns: (auto, auto, auto, 1fr, 1fr, 1fr),
|
||
[*Name*], [*Schaltbild*], [*Ersatz-Schaltbild*], [*Eigenschaften*], [*Beschreibung*], [*Knotenspannungs Analyse*],
|
||
|
||
[Nullor], [], [#scale(x: 50%, y: 50%, zap.circuit({
|
||
import zap: *
|
||
import cetz.draw: content, line
|
||
joham.nullor("nullor", (0,0))
|
||
}))], [], [$ A = mat(0, 0; 0, 0) $], [],
|
||
|
||
[OpAmp \ lin], [], [], [], [], [],
|
||
|
||
[OpAmp \ $U_"sat+"$\ (4-polig)], [#scale(x: 100%, y: 100%, zap.circuit({
|
||
import zap: *
|
||
import cetz.draw: content, line
|
||
zap.opamp("opamp", variant: "ieee",(0,0))
|
||
|
||
//-
|
||
zap.wire((0,0.45),(-1.3,0.45))
|
||
//+
|
||
zap.wire((0,-0.45),(-1.3,-0.45))
|
||
//out
|
||
zap.wire((0,0),(1.3,0))
|
||
// mass
|
||
zap.wire((0,0),(0,-1.1))
|
||
|
||
joham.norator("null-op",
|
||
(0.2,0),(0.2,0),
|
||
scale: .4)
|
||
|
||
}))], [], [], [], [],
|
||
|
||
[OpAmp \ $U_"sat-"$], [], [], [], [], [],
|
||
|
||
[VCVS], [#scale(x: 100%, y: 100%, zap.circuit({
|
||
import zap: *
|
||
import cetz.draw: content, line
|
||
//tor1
|
||
wire((-1,0), (-1.75,0))
|
||
node("n2_1", (-1.75, 0))
|
||
|
||
wire((-1.75,2.5),(-1,2.5), i: (content: $i_1$, anchor: "south"))
|
||
node("n2_1", (-1.75, 2.5), f:$f$)
|
||
|
||
|
||
//tor 2
|
||
zap.dvsource("dv1",
|
||
(0,2.5),(0,0), u:$alpha u_1$, i:$i_2$)
|
||
|
||
|
||
wire((0,0), (1.3,0))
|
||
node("n2_1", (1.3, 0))
|
||
wire((0,2.5), (1.3,2.5))
|
||
node("n2_2", (1.3,2.5), n:"o-o")
|
||
|
||
}))], [], [], [$ H' = mat(0, 0; mu, 0) quad A = mat(1/mu, 0; 0, 0) $], [],
|
||
|
||
[VCCS], [], [], [], [$ G = mat(0, 0; g, 0) quad A = mat(0, -1/g; 0, 0) $], [],
|
||
|
||
[CCVS], [], [], [], [$ R = mat(0, 0; r, 0) quad A = mat(0, 0; 1/r, 0) $], [],
|
||
|
||
[CCCS], [], [], [], [$ H = mat(0, 0; beta, 0) quad A = mat(0, 0; 0, -1/beta) $], [],
|
||
|
||
[Übertrager], [], [],
|
||
[],
|
||
[$ H = mat(0, ü; -ü, 0) quad
|
||
H' = mat(0, -1/ü; 1/ü, 0) \
|
||
A = mat(ü, 0; 0, 1/ü) quad A' = mat(1/ü, 0; 0, ü)
|
||
$],
|
||
[],
|
||
|
||
[Gyrator],
|
||
[],
|
||
[],
|
||
[
|
||
- Antireziprok, Antisymetrisch
|
||
- Auch Positiv-Immitanz-Inverter
|
||
],
|
||
[$ R = mat(0, -R_d; R_d, 0) quad G = mat(0, G_d; -G_d, 0) \ A = mat(0, R_d; 1/R_d, 0) quad A' = mat(0, -R_d; -1/R_d, 0)
|
||
quad
|
||
$],
|
||
[],
|
||
|
||
[NIK],
|
||
[],
|
||
[],
|
||
[
|
||
- Aktiv
|
||
- Antireziprok
|
||
- Symetrisch für $abs(k) = 1$
|
||
],
|
||
[$ H = mat(0, -k; -k, 0) quad H' = mat(0, -1/k; -1/k, 0) \ A = mat(-k, 0; 0, 1/k) quad A'= mat(-1/k, 0; 0, k) $],
|
||
[],
|
||
|
||
[T-Glied],
|
||
[],
|
||
[],
|
||
[],
|
||
[
|
||
|
||
],
|
||
[],
|
||
|
||
[$pi$-Glied],
|
||
[],
|
||
[],
|
||
[
|
||
|
||
],
|
||
)
|
||
]
|
||
|
||
// Knoten Spannungs Analyse
|
||
|
||
// Tor Eigenschaften
|
||
#bgBlock(fill: colorEigenschaften, width: 100%)[
|
||
#subHeading(fill: colorEigenschaften)[Tor Eigenschaften]
|
||
|
||
#table(
|
||
columns: (auto, auto, auto, auto),
|
||
inset: 2mm,
|
||
align: horizon,
|
||
fill: (x, y) => if calc.rem(y, 2) == 1 { rgb("#c5c5c5") } else { white },
|
||
|
||
table.header([], [*Ein-Tor*], [*Zwei-Tor*], [*Reaktive Elemente*]),
|
||
[*passiv*\ (nimmt Energie auf)\ $not$aktiv],
|
||
[$forall (u,i) in cal(F): u dot i >= 0$],
|
||
[
|
||
$jMat(U)^T jMat(I) + jMat(I)^T jMat(U)$\
|
||
$forall vec(jVec(u), jVec(v)) in cal(F) : jVec(u)^T jVec(i) >=0$
|
||
],
|
||
[],
|
||
|
||
[*verlustlos*],
|
||
[
|
||
$forall (u,i) in cal(F): u dot i = 0$\
|
||
|
||
Kennline nur $u\/i$-Achsen
|
||
],
|
||
[$forall vec(jVec(u), jVec(v)) in cal(F) : jVec(u)^T jVec(i) = 0$],
|
||
[
|
||
$u\/q$-Plot: Wenn keine Schleifen \
|
||
$i\/Phi$-Plot: Wenn keine Schleifen \
|
||
$u\/i$-Plot: Wenn Auf Achse \
|
||
$Phi\/q$-Plot: Wenn auf Achse \
|
||
],
|
||
|
||
[*linear*],
|
||
[Kennline ist Gerade],
|
||
[
|
||
Darstellbar: Matrix $+$ Aufpunkt\
|
||
$lambda_1 vec(jVec(u)_1, jVec(i)_1) + lambda_2 vec(jVec(u)_2, jVec(i)_2) in cal(F)$
|
||
],
|
||
[],
|
||
|
||
[*quellenfrei*],
|
||
[$(qty("0", "A"), qty("0", "V")) in cal(F)$],
|
||
[$(qty("0", "A"), qty("0", "V")) in cal(F)$],
|
||
[$(qty("0", "A"), qty("0", "V")) in cal(F)$],
|
||
|
||
[*streng linear*], [linear UND quellenfrei], [linear UND quellenfrei\ Darstellbar: Nur Matrix], [],
|
||
|
||
[*ungepolt* \ (Punkt sym.)],
|
||
[$(u,i) in cal(F) <=> (-u, -i) in cal(F)\
|
||
g(u) = i, r(i) = u$],
|
||
[
|
||
N/A
|
||
],
|
||
[],
|
||
|
||
[*symetrisch*\ $<=>$ Umkehrbar],
|
||
[N/A],
|
||
[
|
||
$jMat(A) = jMat(A')$\
|
||
$jMat(G) = jMat(P) jMat(G) jMat(P), space jMat(R) = jMat(P) jMat(R) jMat(P), quad jMat(P) = mat(0, 1; 1, 0) \
|
||
det(H) = 1,$
|
||
|
||
],
|
||
[],
|
||
|
||
[*Reziprok*],
|
||
[Immer Reziprok],
|
||
[
|
||
$cal(F)$ symetrisch $=> cal(F)$ reziprok
|
||
|
||
$jMat(U)^T jMat(I) - jMat(I)^T jMat(U) = 0 \
|
||
jMat(R)^T = jMat(R), quad jMat(G)^T = jMat(G) quad h_21 = -h_12 \ det(jMat(A)) = 1 quad det(jMat(A')) = 1 quad h'_21 = -h'_12$],
|
||
[],
|
||
|
||
[*$x$-gesteudert*], [Existiert $r(i) = u \/g(u) = i$], [Existiert die Matrix? siehe Tabelle], [],
|
||
|
||
[Alle Beschreibung], [Klar], [$det(M) != 0$, Alle Eintrag $!= 0$],
|
||
)
|
||
]
|
||
|
||
#bgBlock(fill: colorZweiTore)[
|
||
#set text(size: 10pt)
|
||
|
||
#subHeading(fill: colorZweiTore)[Umrechnung Zweitormatrizen]
|
||
#table(
|
||
columns: (12mm, 1fr, 1fr, 1fr, 1fr, 1fr, 1fr),
|
||
align: center,
|
||
inset: (bottom: 4mm, top: 4mm),
|
||
gutter: 0.1mm,
|
||
fill: (x, y) => if x != 0 and calc.rem(x, 2) == 0 { rgb("#c5c5c5") } else { white },
|
||
|
||
table.cell(
|
||
inset: 0mm,
|
||
[
|
||
#cetz.canvas(length: 12mm, {
|
||
import cetz.draw: *
|
||
line((1, 0), (0, 1))
|
||
content((0.309, 0.25), "Out")
|
||
content((0.75, 0.75), "In")
|
||
})
|
||
],
|
||
),
|
||
$bold(R) quad mat(Omega, Omega; Omega, Omega)$,
|
||
$bold(G) quad mat(S, S; S, S)$,
|
||
$bold(H) quad mat(Omega, 1; 1, S)$,
|
||
$bold(H') quad mat(S, 1; 1, Omega)$,
|
||
$bold(A) quad mat(S, 1; 1, Omega)$,
|
||
$bold(A') quad mat(S, 1; 1, Omega)$,
|
||
|
||
$bold(R)$,
|
||
$mat(r_11, r_12; r_21, r_22)$,
|
||
$jMat(G^(-1) =) 1/det(bold(G)) mat(g_22, -g_12; -g_21, g_11)$,
|
||
$1/h_22 mat(det(bold(H)), h_12; -h_21, 1)$,
|
||
$1/h'_11 mat(1, -h'_12; h'_21, det(bold(H')))$,
|
||
$1/a_21 mat(a_11, det(bold(A)); 1, a_22)$,
|
||
$1/a'_21 mat(a'_22, 1; det(bold(A')), a'_11)$,
|
||
|
||
$bold(G)$,
|
||
$jMat(R^(-1) =) 1/det(bold(R)) mat(r_22, -r_12; -r_21, r_11)$,
|
||
$mat(g_11, g_12; g_21, g_22)$,
|
||
$1/h_11 mat(1, -h_12; h_21, det(bold(H)))$,
|
||
$1/h'_22 mat(det(bold(H')), h'_12; -h'_21, 1)$,
|
||
$1/a_12 mat(a_22, -det(bold(A)); -1, a_11)$,
|
||
$1/a'_12 mat(a'_11, -1; -det(bold(A')), a'_22)$,
|
||
|
||
$bold(H)$,
|
||
$1/r_22 mat(det(bold(R)), r_12; -r_21, 1)$,
|
||
$1/g_11 mat(1, -g_12; g_21, det(bold(G)))$,
|
||
$mat(h_11, h_12; h_21, h_22)$,
|
||
$jMat(H')^(-1)= 1/det(bold(H')) mat(h'_22, -h'_12; -h'_21, h'_11)$,
|
||
$1/a_22 mat(a_12, det(bold(A)); -1, a_21)$,
|
||
$1/a'_11 mat(a'_12, 1; -det(bold(A')), a'_21)$,
|
||
|
||
$bold(H')$,
|
||
$1/r_11 mat(1, -r_12; r_21, det(bold(R)))$,
|
||
$1/g_22 mat(det(bold(G)), g_12; -g_21, 1)$,
|
||
$jMat(H^(-1))= 1/det(bold(H)) mat(h_22, -h_12; -h_21, h_11)$,
|
||
$mat(h'_11, h'_12; h'_21, h'_22)$,
|
||
$1/a_11 mat(a_21, -det(bold(A)); 1, a_12)$,
|
||
$1/a'_22 mat(a'_21, -1; det(bold(A')), a'_12)$,
|
||
|
||
$bold(A)$,
|
||
$1/r_21 mat(r_11, det(bold(R)); 1, r_22)$,
|
||
$1/g_21 mat(-g_22, -1; -det(bold(G)), -g_11)$,
|
||
$1/h_21 mat(-det(bold(H)), -h_11; -h_22, -1)$,
|
||
$1/h'_21 mat(1, h'_22; h'_11, det(bold(H')))$,
|
||
$mat(a_11, a_12; a_21, a_22)$,
|
||
$jMat(A'^(-1))= 1/det(bold(A')) mat(a'_22, a'_12; a'_21, a'_11)$,
|
||
|
||
$bold(A')$,
|
||
$1/r_12 mat(r_22, det(bold(R)); 1, r_11)$,
|
||
$1/g_12 mat(-g_11, -1; -det(bold(G)), -g_22)$,
|
||
$1/h_12 mat(1, h_11; h_22, det(bold(H)))$,
|
||
$1/h'_12 mat(-det(bold(H')), -h'_22; -h'_11, -1)$,
|
||
$jMat(A^(-1))= 1/det(bold(A)) mat(a_22, a_12; a_21, a_11)$,
|
||
$mat(a'_11, a'_12; a'_21, a'_22)$,
|
||
)
|
||
|
||
#table(
|
||
columns: (12mm, 1fr, 1fr, 1fr, 1fr, 1fr, 1fr),
|
||
align: center,
|
||
inset: (bottom: 4mm, top: 4mm),
|
||
gutter: 0.1mm,
|
||
fill: (x, y) => if x != 0 and calc.rem(x, 2) == 0 { rgb("#c5c5c5") } else { white },
|
||
|
||
[],
|
||
$bold(R) jVec(i) = jVec(u)$,
|
||
$bold(G) jVec(u) = jVec(i)$,
|
||
$bold(H) vec(i_1, u_2) = vec(u_1, i_2)$,
|
||
$bold(H') vec(u_1, i_2) = vec(i_1, u_2)$,
|
||
$bold(A) vec(u_2, -i_2) = vec(i_1, u_1)$,
|
||
$bold(A') vec(u_1, -i_1) = vec(i_2, u_2)$,
|
||
)
|
||
]
|