A mid-level course for future electrical engineers that connects circuit theory to the three big areas of the field. In electronics you will bias a transistor as a switch, design op-amp amplifier stages and work with logic gates, registers and microcontroller GPIO. In signals and systems you will compute and read a frequency spectrum, design an RC low-pass filter and tune a PID loop in simulation. In power systems you will trace power from the plant to the outlet, do per-unit and two-bus load-flow calculations, see how breakers, relays and inverters protect and connect the grid, and lay out a simple board in KiCad. Prerequisites: Electrical Circuits, Calculus & Linear Algebra for STEM, and Scientific Python. All hands-on work uses Python, a browser simulator or free design software: never mains. This course builds knowledge, not a licence: electrical engineering roles need an ABET-accredited bachelor's degree, and power and utility design sign-off needs the FE exam, experience and a PE licence (see NCEES, https://ncees.org). Real designs need review by licensed, experienced engineers.

Diodes, transistors and op-amps, digital logic and microcontrollers, spectra, filters and PID control, the power grid, per-unit and load flow, protection, inverters and PCB layout.

Power, Electronics & Signals

## Why it matters

Diodes and transistors are the building blocks of every power supply, amplifier and digital chip. The most common job you will give a discrete transistor is the simplest: letting a 3.3 V microcontroller pin switch a load (an LED string, a relay coil, a small motor) that needs more current than the pin can supply. Getting the bias right is the difference between a cool, reliable switch and a hot, half-on part.

## Diodes

A diode conducts easily in one direction (anode to cathode) and blocks the other. The **Shockley diode equation** describes the forward current:

```text
I = I_s * (exp(V / (n * V_T)) - 1)
V_T = k T / q = 25.85 mV at 300 K
```

`I_s` is a tiny saturation current (around `1e-14` A for a small silicon diode) and `n` is between 1 and 2. Because the current is exponential, a silicon diode's voltage stays near **0.6 to 0.7 V** over a wide range of currents. With `n = 1`, every extra 60 mV multiplies the current by about 10: `I_s = 1e-14 A` gives 0.12 mA at 0.60 V and 1.2 mA at 0.66 V.

Useful diode types:

- **Rectifier diodes** turn AC into pulsing DC in power supplies.
- **LEDs** drop more voltage (about 1.8 to 2.2 V for red, about 3 V for blue and white) and need a series resistor to set current.
- **Zener diodes** are used in reverse at a defined breakdown voltage as simple references.
- **Schottky diodes** have a lower forward drop (about 0.3 V) and switch fast.
- **Flyback diodes** go across relay coils and motors to absorb the voltage spike when the current is switched off. Leaving one out is a classic way to destroy a transistor.

## The bipolar transistor (NPN)

A small base current controls a much larger collector current. In the **active region**, `I_C = beta * I_B`, with `beta` (also called `h_FE`) somewhere from 50 to 300 and varying widely between parts. That is what amplifiers use.

For a **switch** we want the opposite: drive the transistor hard into **saturation**, where it acts like a closed contact with only `V_CE(sat)` (about 0.1 to 0.3 V) across it. Designers use a **forced beta** of about 10, meaning they supply ten times less than the load current as base current, far more than the minimum `I_C / beta`, so the switch stays saturated for any part from the bin.

## Worked example: an LED switched from a 3.3 V pin

A 5 V supply drives an LED (2.0 V drop) through a 150 Ω resistor and an NPN transistor (`V_CE(sat)` = 0.2 V). The base is driven from a 3.3 V GPIO pin through `R_B`, and `V_BE` is about 0.7 V.

```text
I_C = (5.0 - 2.0 - 0.2) / 150 = 18.7 mA
I_B (forced beta 10) = 18.7 mA / 10 = 1.87 mA
R_B = (3.3 - 0.7) / 1.87 mA = 1,393 Ω  ->  use 1.2 kΩ (next standard value down)
P_transistor = 0.2 V * 18.7 mA = 3.7 mW
```

Choosing the next value **down** gives a little more base current, which keeps the transistor saturated. Check that the pin can supply about 2.2 mA (most can; the datasheet gives the limit).

## MOSFETs

For larger currents, a **logic-level N-channel MOSFET** is often the better low-side switch. Its gate draws almost no steady current, and when fully on it behaves like a small resistance `R_DS(on)`, so it dissipates `P = I^2 * R_DS(on)`. Check that the datasheet specifies `R_DS(on)` at your gate voltage (for example 2.5 V or 4.5 V), because "threshold voltage" is only where it barely starts to conduct.

## Simulate it

Build the LED switch in Falstad (https://www.falstad.com/circuit/) or LTspice: sweep the base resistor and watch `V_CE` rise when the transistor leaves saturation. Simulators make it safe to see what too little base drive or a missing flyback diode does. Every hands-on task in this course uses paper, Python or a free simulator (Falstad, LTspice or ngspice). Never build or probe circuits connected to mains (wall outlets, appliances, panels) or utility equipment.

## Common mistakes

- **Designing a switch with the typical beta** instead of a forced beta, so some parts never saturate.
- **No base resistor,** which overloads both the pin and the base-emitter junction.
- **No flyback diode** on inductive loads.
- **Picking a MOSFET by its threshold voltage** rather than `R_DS(on)` at the actual gate drive.
- **Forgetting power:** at 1 A, a `V_CE(sat)` of 0.3 V means 0.3 W to get rid of.

## Recap

- Diode current is exponential in voltage; silicon sits near 0.6 to 0.7 V.
- As a switch, saturate the BJT with forced beta about 10: `R_B = (V_drive - V_BE) / (I_C / 10)`.
- Use flyback diodes on coils; consider logic-level MOSFETs for higher currents.

## Try it

Open the **Do** tab to code the diode equation and the transistor-switch design calculation.


Use the diode equation and bias an NPN transistor as a saturated switch for a load driven from a microcontroller pin.

Diodes and transistors

Diodes Explained - The basics how diodes work working principle pn junction

Electronic Basics #22: Transistor (BJT) as a Switch

## Why it matters

Operational amplifiers (op-amps) are the most reused analog part there is. They scale sensor signals to fit an ADC, buffer high-impedance sources, build active filters, sum and subtract signals, and close control loops. Two resistors and an op-amp give you a gain you can set to within 1%, as long as you respect the part's limits.

## The ideal op-amp and its two rules

An op-amp has two inputs (`+` non-inverting and `-` inverting) and one output, with a huge open-loop gain (often `10^5` or more). With **negative feedback** (output connected back to the `-` input), two rules let you analyse almost any circuit:

1. **No current flows into the inputs.**
2. **The output adjusts so the two input voltages are equal** (the "virtual short").

## The inverting amplifier

Input through `R_in` into the `-` input, feedback resistor `R_f` from output to `-`, and `+` to ground. The `-` input sits at 0 V (a virtual ground), so the input current `V_in / R_in` must all flow through `R_f`:

```text
V_out = -(R_f / R_in) * V_in
input impedance = R_in
```

**Worked example.** A sensor gives up to 0.5 V and you want about -2.35 V. Choose `R_in = 10 kΩ` (input impedance) and `R_f = 47 kΩ` (a standard E12 value): gain = -4.7, so 0.5 V becomes -2.35 V.

## The non-inverting amplifier

Signal into `+`; `R_f` from output to `-` and `R_g` from `-` to ground:

```text
V_out = (1 + R_f / R_g) * V_in
input impedance: very high
```

With `R_f = 100 kΩ` and `R_g = 10 kΩ`, the gain is 11. With `R_f = 0` and no `R_g`, the gain is 1: the **voltage follower**, used to buffer a source that can't drive a load.

A **summing amplifier** adds several inputs, each through its own resistor into the virtual ground: `V_out = -R_f (V1/R1 + V2/R2 + ...)`.

## Real limits

- **Output swing.** The output can't go beyond the supply rails, and many op-amps stop a volt or two short. With ±12 V supplies and a gain of -4.7, an input of 3 V asks for -14.1 V; the output **clips** at about -12 V (or less). "Rail-to-rail output" parts get within tens of millivolts.
- **Gain-bandwidth product (GBW).** Open-loop gain falls with frequency. For a typical voltage-feedback op-amp, the closed-loop bandwidth is about `GBW / noise gain`, where the **noise gain** is `1 + R_f / R_g` for both configurations. For a 1 MHz part, a non-inverting gain of 11 gives about 91 kHz. The inverting gain of -4.7 has a noise gain of 5.7, so about 175 kHz.
- **Slew rate.** The output can only change so fast. For a sine of peak `V_p`, the full-power bandwidth is `SR / (2 pi V_p)`: a classic 741 at 0.5 V/µs manages only about 8 kHz at 10 V peak.
- **Input offset and bias currents** add DC errors; precision parts specify them in microvolts and picoamps.
- **Supply and common-mode range:** check that the input voltages stay inside the allowed range for your supply.

## Simulate it

Falstad (https://www.falstad.com/circuit/) has an op-amp model; LTspice includes models of real parts. Drive an inverting stage with a sine, increase the amplitude until it clips, and raise the frequency until the gain falls. Seeing the limits in a simulator is safer and faster than finding them on a bench.

## Common mistakes

- **Positive feedback by accident** (feedback to the `+` input), which makes a comparator or oscillator instead of an amplifier.
- **Ignoring the rails** and expecting gains that the supply can't deliver.
- **Using the signal gain instead of the noise gain** for bandwidth.
- **Very large resistors** (MΩ) that add noise and offset; very small ones that load the output. 1 kΩ to 100 kΩ is a comfortable range.
- **No decoupling capacitor** near the supply pins (100 nF is typical), which can make the stage oscillate.

## Recap

- With negative feedback: no input current, equal input voltages.
- Inverting: `-R_f / R_in`. Non-inverting: `1 + R_f / R_g`. Follower: 1.
- Check output swing, bandwidth (`GBW / noise gain`) and slew rate before trusting a design.

## Try it

Open the **Do** tab to write an op-amp design helper that computes gains, clips to the rails and estimates bandwidth.


Design inverting and non-inverting op-amp stages, and check output swing and bandwidth limits.

Op-amps

Operational Amplifiers - Inverting & Non Inverting Op-Amps

Electrical Engineering: Ch 5: Operational Amp (2 of 28) Inverting Amplifier-Basic Operation

## Why it matters

Almost every electrical product now has a microcontroller in it: chargers, inverters, motor drives, protective relays, meters, sensors. Electrical engineers write firmware, read logic analyser traces and design the interface between digital pins and real loads. Underneath all of it are a few gates and the idea of a register: a row of bits, each one wired to something.

## Logic levels and gates

Digital circuits treat a voltage as **1 (high)** or **0 (low)**. A 3.3 V CMOS input typically reads anything above about 2 V as 1 and below about 0.8 V as 0; the band in between is undefined. Mixing 5 V and 3.3 V parts needs care: a 5 V output can damage a 3.3 V input that isn't "5 V tolerant", so you use a level shifter or a divider.

The basic gates and their truth tables:

```text
A B | AND OR XOR NAND
0 0 |  0   0   0    1
0 1 |  0   1   1    1
1 0 |  0   1   1    1
1 1 |  1   1   0    0
NOT: 0 -> 1, 1 -> 0
```

NAND (and NOR) is **universal**: any logic function can be built from NAND gates alone. Inside a chip, each gate is a few CMOS transistors used as the switches from the previous lessons.

## Combinational logic: adding numbers

A **half adder** adds two bits: `sum = A XOR B`, `carry = A AND B`. A **full adder** also takes a carry in:

```text
sum  = A XOR B XOR Cin
Cout = (A AND B) OR (Cin AND (A XOR B))
```

Chain four full adders, passing each carry to the next, and you have a 4-bit **ripple-carry adder**. `0101 (5) + 0011 (3)` gives `1000 (8)`. The output depends only on the present inputs, which is what "combinational" means.

## Sequential logic: memory

A **flip-flop** stores one bit. A D flip-flop copies its D input to its Q output on each rising clock edge and holds it until the next edge. A **register** is a row of flip-flops sharing a clock, for example 8 or 32 bits. Counters, shift registers and the state machines in every controller are built from registers plus combinational logic. The **clock** sets the pace: the logic between registers must settle within one clock period.

## Inside a microcontroller

A microcontroller (MCU) puts a CPU, flash memory for the program, RAM, and **peripherals** on one chip: GPIO, timers, PWM, ADCs, UART, SPI and I2C. Peripherals are controlled through **memory-mapped registers**: writing a number to a particular address changes the hardware.

GPIO (general-purpose input/output) pins are usually configured with registers like:

- a **direction** register (bit = 1 for output),
- an **output** register (bit = 1 drives the pin high),
- an **input** register (read the pin's level).

You change one pin without disturbing the others with **bit masks**:

```c
REG |=  (1 << 5);        // set bit 5   (pin 5 high)
REG &= ~(1 << 5);        // clear bit 5 (pin 5 low)
int on = (REG >> 5) & 1; // read bit 5
REG ^=  (1 << 5);        // toggle bit 5
```

Arduino's `digitalWrite(pin, HIGH)` does exactly this behind the scenes.

**Worked example.** A port register holds `0b00010010` (pins 1 and 4 high). Setting bit 0 gives `0b00010011` (19); then clearing bit 4 gives `0b00000011` (3). Reading bit 1 gives 1.

## Pins meet the real world

- **Current limits:** a GPIO pin can source or sink only a few to about 20 mA, and the whole port has a total limit. Use a transistor (previous lesson) for anything bigger.
- **Pull-up and pull-down resistors** keep an input from floating when a button is open. Many MCUs have internal pull-ups you enable in a register.
- **Debouncing:** mechanical switches bounce for a few milliseconds, so firmware waits or samples repeatedly before accepting a change.
- **Interrupts** let the CPU react to an edge immediately instead of polling.

## Simulate it

Wokwi (https://wokwi.com) simulates Arduino and other boards in the browser, with LEDs, buttons and a logic analyser. Logic simulators such as Logisim Evolution let you build adders from gates. No hardware is needed.

## Common mistakes

- **Writing the whole register** (`REG = 1 << 5`) and accidentally turning every other pin off.
- **Forgetting the NOT** when clearing: `REG &= (1 << 5)` clears everything except bit 5.
- **Floating inputs** with no pull-up, giving random readings.
- **Driving loads straight from a pin** beyond its current rating.
- **Connecting 5 V signals to 3.3 V-only inputs.**

## Recap

- Gates implement Boolean logic; NAND is universal; full adders chain into multi-bit adders.
- Flip-flops and registers store state on clock edges.
- MCUs control peripherals through registers; use `|=`, `&= ~` and shifts to change single bits.

## Try it

Open the **Do** tab to build a full adder, a 4-bit adder and GPIO bit helpers in JavaScript.


Explain logic gates, adders, flip-flops and registers, and set, clear and read GPIO bits with bit masks.

Digital logic and microcontrollers

Boolean Logic & Logic Gates: Crash Course Computer Science #3

Arduino Basics 101: Hardware Overview, Fundamental Code Commands

Diodes and transistor switches, op-amp amplifier stages, and the digital logic and GPIO registers inside microcontrollers.

Electronics

## Why it matters

Engineers constantly ask "what frequencies are in this signal?" Is that noise on a sensor line 60 Hz hum from the mains wiring, or switching noise from a converter at 100 kHz? How much harmonic distortion does a motor drive put back on the grid? What bandwidth does an audio link need? The **frequency domain** answers those questions, and the **fast Fourier transform (FFT)** is how you get there from sampled data.

## Time domain and frequency domain

A **signal** is a quantity that changes over time, such as a voltage. In the time domain you see it as a waveform. A pure sinusoid is described by

```text
x(t) = A * sin(2 pi f t + phi)
```

with amplitude `A`, frequency `f` in hertz (period `T = 1/f`) and phase `phi`. Fourier's insight is that almost any signal is a sum of sinusoids. A square wave of frequency `f`, for example, is the sum of odd harmonics `f, 3f, 5f, ...` with amplitudes falling as `1, 1/3, 1/5, ...`. The **spectrum** lists how much of each frequency is present.

## Sampling

A computer stores a signal as samples taken every `1/fs` seconds, where `fs` is the **sampling rate**. Two rules matter:

- **Nyquist:** you can represent frequencies only up to `fs / 2`. Anything above that **aliases** to a false lower frequency: `f_alias = |f - fs * round(f / fs)|`. A 900 Hz tone sampled at 1 kHz looks like 100 Hz. Filter before sampling.
- **Resolution:** with `N` samples, the FFT gives frequency bins spaced `fs / N` apart. One second of data gives 1 Hz resolution, whatever the sample rate.

## The DFT and the FFT

The discrete Fourier transform turns `N` samples into `N` complex numbers, one per frequency bin; each one's magnitude says how much of that frequency is present and its angle gives the phase. The FFT is just a fast algorithm for it (`N log N` operations instead of `N^2`). For real-valued signals, NumPy's `np.fft.rfft` returns the `N/2 + 1` non-negative frequency bins, and `np.fft.rfftfreq(N, d=1/fs)` gives their frequencies.

To read amplitudes in volts, scale the magnitudes: divide by `N`, then double every bin except DC (bin 0) and, for even `N`, the Nyquist bin, because the energy of each real sinusoid is split between a positive and a negative frequency.

## Worked example: hum and a harmonic

A signal has a 0.5 V DC offset, 3 V of 50 Hz and 1 V of 120 Hz. Sample at `fs = 1000` Hz for one second (`N = 1000`).

```python
import numpy as np

fs, n = 1000, 1000
t = np.arange(n) / fs
x = 0.5 + 3 * np.sin(2 * np.pi * 50 * t) + 1 * np.sin(2 * np.pi * 120 * t)

X = np.fft.rfft(x)
freqs = np.fft.rfftfreq(n, d=1 / fs)
amps = 2 * np.abs(X) / n
amps[0] /= 2            # DC is not doubled
amps[-1] /= 2           # nor is the Nyquist bin (n is even)

for f in (0, 50, 120):
    print(f, round(amps[freqs == f][0], 3))   # 0.5, 3.0, 1.0
```

The peaks are exactly 3.0 and 1.0 because each tone completes a whole number of cycles in the one-second window.

## Leakage and windows

If a tone does **not** fit a whole number of cycles in the record, for example 50.5 Hz in one second, its energy smears into neighbouring bins (**spectral leakage**) and the peak looks lower. Multiplying the data by a **window** such as Hann (`np.hanning(N)`) before the FFT reduces leakage at the cost of slightly wider peaks. For plotting spectra in real work you might use `matplotlib` (`plt.semilogy(freqs, amps)`), and `scipy.signal.welch` averages many windowed FFTs to give a smoother power spectral density for noisy signals.

## Common mistakes

- **Sampling too slowly** and analysing aliases.
- **Forgetting to scale** the FFT, then reporting amplitudes that grow with `N`.
- **Doubling the DC bin.**
- **Expecting fine resolution from short records:** 0.1 s of data gives 10 Hz bins.
- **Reading leakage as extra signals,** where a window would have shown one clean peak.

## Recap

- Any periodic signal is a sum of sinusoids; the spectrum shows their amplitudes.
- Sample above `2 f_max`; bin spacing is `fs / N`.
- `np.fft.rfft` plus correct scaling gives amplitudes in signal units; windows reduce leakage.

## Try it

Open the **Do** tab to write a spectrum function, find the dominant frequency and predict aliases.


Describe signals in the time and frequency domains, sample them correctly and compute an amplitude spectrum with the FFT.

Signals and frequency

But what is the Fourier Transform?  A visual introduction.

Denoising Data with FFT [Python]

## Why it matters

Filters are everywhere in electrical engineering: anti-aliasing filters before ADCs, EMI filters on power supplies, tone controls, sensor smoothing, and the LC filters that clean up an inverter's output before it reaches the grid. The single-pole **RC low-pass** is the simplest and the one you will design most often, and it teaches the language (cutoff, decibels, roll-off, phase) used for every other filter.

## The RC low-pass

A resistor `R` in series with the signal, then a capacitor `C` to ground; the output is taken across the capacitor. At low frequencies the capacitor's impedance `1 / (j omega C)` is huge, so the output follows the input. At high frequencies the capacitor acts like a short, so the output falls.

```text
H(f) = 1 / (1 + j f / fc)
fc   = 1 / (2 pi R C)            (cutoff, or -3 dB, frequency)
|H|  = 1 / sqrt(1 + (f / fc)^2)
phase = -atan(f / fc)
```

- At `f = fc`: `|H| = 0.707` (-3.01 dB) and the phase is -45°.
- Well above `fc`: the gain falls by **20 dB per decade** (a factor of 10 per factor of 10 in frequency). At `10 fc` it is about -20 dB, so a tenth of the amplitude.
- Decibels for voltage gain: `dB = 20 log10(|H|)`.

The **time constant** `tau = R C` describes the time response: after a step input the output reaches 63.2% of the final value at `t = tau`, and about 99% after `5 tau`.

## Worked example: designing for 1 kHz

You want to remove noise above roughly 1 kHz from a sensor signal, and the source can drive about 1.6 kΩ.

```text
C = 1 / (2 pi R fc) = 1 / (2 pi * 1,600 * 1,000) = 99.5 nF  ->  use 100 nF
fc (actual) = 1 / (2 pi * 1,600 * 100e-9) = 995 Hz
tau = 1,600 * 100e-9 = 160 µs
```

At 10 kHz the gain is about -20 dB; at 100 Hz it is -0.04 dB, essentially untouched. Remember the source and load impedances add to the network: a load resistance comparable to `R` lowers the gain and shifts `fc`, so buffer with an op-amp follower if needed.

## Higher-order and other filters

- **High-pass:** swap `R` and `C` (output across `R`) to block DC and low frequencies, `fc` unchanged.
- **Steeper roll-off:** cascade stages or use active designs. A second-order filter falls at 40 dB per decade. Sallen-Key and multiple-feedback op-amp circuits implement Butterworth (flattest passband), Bessel (best step response) and Chebyshev (sharpest cutoff, with ripple) responses.
- **Design tools:** in real work you would use `scipy.signal.butter` and `scipy.signal.freqs` to compute responses, or a vendor filter wizard, then check in LTspice.

## Digital version

A discrete-time first-order low-pass (an exponential moving average) is the same idea in firmware:

```text
alpha = dt / (R C + dt)
y[k] = y[k-1] + alpha * (x[k] - y[k-1])
```

With a small time step `dt`, this closely matches the analog RC. It is how many microcontrollers smooth sensor readings.

## Simulate it

In Falstad or LTspice, build 1.6 kΩ and 100 nF, drive with a sine and sweep the frequency (LTspice `.ac dec 100 10 100k` gives a Bode plot). Then drive it with a square wave and watch the edges round off with the `RC` time constant.

## Common mistakes

- **Using `1 / (R C)` as the cutoff in hertz.** That is the angular frequency in rad/s; divide by `2 pi`.
- **Mixing up power and voltage decibels** (`10 log10` vs `20 log10`).
- **Ignoring source and load impedance** when the filter connects to real circuits.
- **Expecting a sharp cutoff** from one RC stage: at `2 fc` the signal is still 45% of its amplitude.
- **Choosing tiny capacitors** (a few pF) where stray capacitance dominates.

## Recap

- `fc = 1 / (2 pi R C)`; at `fc`, gain is -3 dB and phase -45°.
- One pole rolls off at 20 dB per decade; the step response reaches 63.2% at `tau = R C`.
- `y += alpha (x - y)` with `alpha = dt / (RC + dt)` is the digital equivalent.

## Try it

Open the **Do** tab to code RC filter design functions and simulate a step response.


Design an RC low-pass filter for a target cutoff, predict its gain and phase, and simulate its step response.

Filters

Low Pass Filters and High Pass Filters - RC and RL Circuits

Passive RC low pass filter tutorial!

## Why it matters

Feedback control keeps motors at speed, holds an inverter's output voltage steady, regulates temperatures, steers drones and balances generation with load on the grid. Most industrial loops are PID controllers. Electrical engineers design them for power converters and drives, and tune them in simulation before going near hardware.

## Open loop vs closed loop

An **open-loop** controller sends a fixed command and hopes. A **closed-loop** controller measures the output `y`, compares it with the setpoint `r`, and acts on the **error** `e = r - y`. Feedback corrects for disturbances (a load change, a cold draught) and for a plant that isn't exactly what you modelled.

## The plant

The thing being controlled is the **plant**. Many systems (a heater, a DC motor's speed, an RC circuit) behave roughly like a **first-order system**:

```text
tau * dy/dt = -y + K * u
```

`K` is the steady-state gain (output per unit input) and `tau` is the time constant. Stepped forward in time with step `dt` (Euler's method, fine when `dt` is much smaller than `tau`):

```text
y += dt / tau * (-y + K * u)
```

## The PID law

```text
u = Kp * e + Ki * integral(e dt) + Kd * de/dt
```

- **Proportional (P):** pushes harder the further you are from the setpoint. Alone, it leaves a **steady-state error**: for the first-order plant the output settles at `K Kp / (1 + K Kp)` of the setpoint.
- **Integral (I):** accumulates past error, so any persistent error keeps growing the command until it disappears. It removes steady-state error but can cause overshoot and, if the actuator saturates, **integrator windup**.
- **Derivative (D):** reacts to how fast the error is changing, adding damping in many plants. It amplifies measurement noise, so real controllers filter it or take the derivative of the measurement instead of the error.

In discrete time, each step:

```python
integral += e * dt
derivative = (e - prev_e) / dt
u = kp * e + ki * integral + kd * derivative
prev_e = e
```

## Worked example: a first-order plant

Plant: `K = 2`, `tau = 1 s`, setpoint 1, `dt = 0.01 s`, 10 s of simulation.

```text
P only, Kp = 2:        settles at 2*2 / (1 + 2*2) = 0.80   (20% error)
PI, Kp = 1, Ki = 5:    reaches 1.0 but overshoots to about 1.24
PI, Kp = 4, Ki = 4:    within 2% of 1.0 in under 0.5 s, no overshoot
```

The third tuning works well because the closed-loop poles are real and fast. That is the tuning game: fast enough, little overshoot, no oscillation, and robust when the plant changes a little.

## Tuning in practice

- **Manual:** raise `Kp` until the response is quick but starts to oscillate, back off; add `Ki` to remove the offset; add `Kd` only if needed for damping.
- **Ziegler-Nichols and relay auto-tune:** classic recipes from the gain at which the loop oscillates. They give a starting point, usually aggressive.
- **Model-based:** with a plant model, choose gains to place the closed-loop poles; MATLAB, Python's `python-control` package or Simulink do this in industry.
- **Limits:** real actuators saturate (a heater can't go below 0 W), so production code clamps `u` and uses anti-windup (stop integrating while saturated).

## Safety in real systems

Closed-loop control of motors, heaters and power converters can fail in dangerous ways (runaway speed, overheating, overvoltage). Real controllers include independent hardware limits and interlocks, and their tuning on live equipment is done by trained staff following site procedures. Practise in simulation only.

## Common mistakes

- **Expecting P alone to reach the setpoint** on a plant without its own integrator.
- **Huge integral gain,** giving overshoot and slow oscillation.
- **Derivative kick:** a setpoint step makes `de/dt` spike; take the derivative of the measurement instead.
- **A time step too large** compared with the plant's time constant, so the simulation itself goes unstable.
- **No output limits or anti-windup** in code that will meet real actuators.

## Recap

- Feedback acts on the error `e = r - y`.
- P reacts to present error (leaves offset), I to accumulated error (removes offset), D to the rate of change (damping).
- Simulate the plant, tune for speed and low overshoot, and add saturation and anti-windup before going near hardware.

## Try it

Open the **Do** tab to write the PID update, simulate the plant and measure steady-state error and overshoot.


Explain proportional, integral and derivative action and tune a PID loop on a simulated first-order plant.

Feedback control

PID Control - A brief introduction

What Is PID Control? | Understanding PID Control, Part 1

Frequency spectra with the FFT, RC low-pass filter design and PID feedback control, all simulated in Python.

Signals and Systems

## Why it matters

The grid is the largest machine ever built, and electrical engineers design, plan, protect and operate it. Even if you work on electronics, the grid is where your power supply's input comes from and where solar inverters and EV chargers connect. Knowing the path from plant to outlet, and why each step exists, is basic professional literacy.

## The big picture

1. **Generation:** power plants (gas, coal, nuclear, hydro) spin synchronous generators, typically at 13.8 to 25 kV. Wind turbines and solar farms connect through power electronics (inverters).
2. **Step-up substation:** a transformer next to the plant raises the voltage to **transmission** level.
3. **Transmission:** high-voltage lines (in North America typically 115 to 765 kV) carry bulk power long distances.
4. **Transmission substations** step down to **sub-transmission** (often 34.5 to 138 kV) for regional delivery.
5. **Distribution substations** step down again to primary **distribution** voltages, commonly 4 to 35 kV, on feeders running along streets.
6. **Service transformers** (on poles or pads) make the final step to customer voltage: in North America, homes get 120/240 V split-phase; commercial buildings often get 208Y/120 V or 480Y/277 V three-phase.
7. **Inside the building:** the service entrance, meter, main panel, branch circuits and finally the outlet, all governed by the National Electrical Code (NFPA 70).

The grid runs at **60 Hz** in North America (50 Hz in most of the world), and the system is almost entirely **three-phase AC**.

## Why high voltage?

Line losses are `I^2 R`. For the same power, raising the voltage lowers the current, and losses fall with the square. For 100 MW at unity power factor on a three-phase line:

```text
I = P / (sqrt(3) * V_LL)
at 138 kV:  I = 100e6 / (1.732 * 138e3)  = 418 A
at 13.8 kV: I = 100e6 / (1.732 * 13.8e3) = 4,184 A
```

Ten times the voltage means a tenth of the current and **one hundredth** of the `I^2 R` loss on the same conductor. Transformers make AC easy to step up and down, which is why AC won for most of the grid. High-voltage DC (HVDC) links are used for very long distances, undersea cables and connecting grids that are not synchronized.

## Balancing supply and demand

Electricity is mostly used the instant it is generated (batteries and pumped hydro store only a small share). When load exceeds generation, the generators slow and the **frequency drops**; when generation exceeds load, it rises. Operators keep frequency very close to 60 Hz with governors, automatic generation control and reserves. In North America, the grid is divided into large synchronous interconnections (Eastern, Western, and ERCOT in Texas, plus Québec), run day to day by balancing authorities and grid operators (ISOs and RTOs), under reliability standards from NERC.

## Who does what

- **Generation companies** run plants.
- **Transmission owners and operators** run the high-voltage network and markets.
- **Distribution utilities** run feeders and connect customers.
- **Electricians** work on the customer side under the NEC; utility line workers work on the utility side under OSHA 1910.269 and utility safety rules.

## Safety and licensing

Transmission and distribution equipment carries lethal voltages and can kill without contact through arc flash and arcing across air. Never approach downed or overhead lines or open utility equipment. Work on energized electrical equipment is governed by NFPA 70E, Standard for Electrical Safety in the Workplace (https://www.nfpa.org/codes-and-standards/nfpa-70e-standard-development/70e), and requires employer training, qualification and supervision. Power and utility design is signed off by licensed professional engineers (PE; see NCEES, https://ncees.org). Checked on 2026-10-23.

## Recap

- Plant (13.8 to 25 kV), step-up, transmission (115 to 765 kV), substations, distribution (4 to 35 kV), service transformer, 120/240 V or three-phase service.
- High voltage means low current and much lower `I^2 R` loss.
- Frequency reflects the balance of generation and load and is held near 60 Hz.


Trace electric power from the generating plant through transmission and distribution to a building's outlet.

The power grid

How Does the Power Grid Work?

How Electricity Gets to You

## Why it matters

Power system studies (load flow, short circuit, stability) are how engineers check that a network can carry its loads, keep voltages in range and survive faults. Every one of them is done in the **per-unit system**, because it turns a network with several voltage levels and transformers into one simple circuit. You will meet it in every power systems course, in the FE and PE Power exams, and in commercial tools such as PSS/E, PowerWorld and ETAP.

## The per-unit idea

Pick a **base** for each quantity and express values as fractions of it:

```text
per-unit value = actual value / base value
```

Choose one system-wide **power base** `S_base` (often 100 MVA) and a **voltage base** `V_base` for each voltage zone, matched to the transformer ratios. The other bases follow (three-phase, line-to-line kV, MVA):

```text
Z_base = kV_base^2 / MVA_base          (ohms)
I_base = MVA_base / (sqrt(3) * kV_base) (kA)
```

Because the voltage bases follow the transformer ratios, an ideal transformer disappears from the per-unit circuit: it becomes just its leakage impedance. Equipment of similar type also has similar per-unit values whatever its size, which makes errors easy to spot.

## Worked example 1: bases and conversion

At 138 kV on a 100 MVA base:

```text
Z_base = 138^2 / 100 = 190.44 Ω
I_base = 100 / (1.732 * 138) = 0.418 kA = 418 A
```

A line with 19.044 Ω of reactance is `19.044 / 190.44 = 0.10 pu`.

## Changing base

Nameplates give impedance on the equipment's own rating. Convert to the system base:

```text
Z_new = Z_old * (kV_old / kV_new)^2 * (MVA_new / MVA_old)
```

A 50 MVA transformer with 10% (0.10 pu) reactance on its own base, on a 100 MVA system base with the same kV: `0.10 * (100 / 50) = 0.20 pu`.

## Worked example 2: a simplified fault estimate

Assume a stiff source at 1.0 pu behind the transformer (0.20 pu) and the line (0.10 pu), and a bolted three-phase fault at the far end of the line, ignoring resistance and load:

```text
I_fault = V / Z_total = 1.0 / 0.30 = 3.33 pu
in amps at 138 kV: 3.33 * 418 A = 1,395 A  (about 1.39 kA)
```

Real short-circuit studies include the source impedance, generator and motor contributions, and the X/R ratio, following standards such as IEEE C37 and IEC 60909. This sketch shows the method, not a design value.

## Load flow

A **load flow** (power flow) finds the voltage magnitude and angle at every bus for given generation and loads. Buses are typed: the **slack** bus holds a fixed voltage and angle and supplies whatever balance is needed; **PV** (generator) buses fix real power and voltage magnitude; **PQ** (load) buses fix real and reactive power. The equations are nonlinear, so they are solved iteratively with Gauss-Seidel or Newton-Raphson.

For the smallest case, a slack bus `V1` feeding a load `S = P + jQ` at bus 2 through series impedance `Z`, the load current is `I = conj(S / V2)` and Gauss-Seidel repeats:

```python
v2 = 1 + 0j
for _ in range(50):
    v2 = v1 - z * (s_load / v2).conjugate()
```

## Worked example 3: two buses

`V1 = 1.0∠0° pu`, `Z = 0.02 + j0.08 pu`, load 80 MW and 40 Mvar on 100 MVA (`S = 0.8 + j0.4 pu`). The iteration converges in a few steps to

```text
V2 = 0.9459 - j0.0560 pu  =  0.948 pu at -3.39°
I  = 0.944 pu,  line loss = |I|^2 * R = 0.0178 pu = 1.78 MW
sending end: 81.8 MW and 47.1 Mvar
```

The voltage at the load is 5.2% low, which most planning criteria (often ±5%) would flag. Remedies include capacitor banks to supply reactive power locally, a tap-changing transformer, or a stronger line. Notice how much the reactive load matters: with `X` four times `R`, `Q` drives most of the voltage drop.

## Common mistakes

- **Mixing voltage zones,** using 138 kV bases on the 13.8 kV side.
- **Forgetting to change base** for nameplate impedances.
- **Using phase voltage with three-phase MVA** (or the reverse) in `Z_base`.
- **Dropping the conjugate** in `I = conj(S / V)`.
- **Treating a hand estimate as a design study.** Real studies use validated models and software and are reviewed and sealed by licensed engineers.

## Recap

- `Z_base = kV^2 / MVA`, `I_base = MVA / (sqrt(3) kV)`; per-unit = actual / base.
- Change base with `(kV_old / kV_new)^2 * (MVA_new / MVA_old)`.
- Load flow solves bus voltages iteratively; reactive power drives voltage drop on mostly reactive lines.

## Try it

Open the **Do** tab to code per-unit conversions, a fault estimate and a two-bus Gauss-Seidel load flow.


Convert impedances to per-unit, change bases, estimate a fault current and solve a two-bus load flow.

Per-unit and load flow

Per Unit Analysis - how does it work? (with examples) || Basics of Power Systems Analysis

Introduction to Per Unit Systems in Power Systems Part 1a

## Why it matters

Faults are certain: lightning strikes lines, trees fall, insulation ages, animals bridge conductors. **Protection** detects a fault and isolates the smallest possible part of the system in a fraction of a second, so equipment survives and the rest of the grid stays up. At the same time, more and more generation (solar, wind, batteries) connects through **inverters** rather than spinning machines, which changes how faults look and how the grid is controlled.

## Faults

- **Three-phase faults** are the most severe but least common.
- **Single line-to-ground faults** are by far the most common on overhead lines.
- **Line-to-line and double line-to-ground faults** fall in between.

Fault currents can be many times normal load current (the per-unit lesson estimated about 1.4 kA on a line that might carry a few hundred amps normally). They overheat conductors, create huge mechanical forces in equipment and drive **arc flash**: an explosive release of heat and light that can kill people nearby.

## The protection toolkit

- **Fuses** melt when current is too high for too long. Simple and cheap, but they must be replaced and operate one phase at a time.
- **Circuit breakers** interrupt current with contacts in air, vacuum or SF6 gas and can be reclosed. At transmission level, breakers don't decide when to trip: **relays** tell them to.
- **Instrument transformers:** current transformers (CTs) and voltage transformers (VTs) scale the high currents and voltages down (for example to 5 A and 120 V) for the relays.
- **Protective relays** (now mostly microprocessor-based) measure CT and VT signals and trip breakers. They are identified by ANSI/IEEE device numbers:
  - **50/51:** instantaneous and time overcurrent. Trip faster the higher the current (inverse-time curves).
  - **87:** differential. Compares current into and out of a zone (a transformer, a bus); any difference means an internal fault. Very fast and selective.
  - **21:** distance. Estimates the impedance to the fault from `V / I` on transmission lines and trips if it falls within set zones.
  - **52** is the circuit breaker itself; **79** is the reclosing relay.
- **Reclosers** on distribution feeders trip and automatically reclose, because most overhead faults (a branch brushing a line) are temporary.

## Coordination and selectivity

Devices are set so the one **closest to the fault** operates first and upstream devices act only as **backup** after a deliberate delay. Engineers plot time-current curves for fuses, relays and breakers to make sure they don't overlap. A poorly coordinated system trips a whole substation for a fault that one fuse should have cleared.

## Inverters and renewables

Solar panels and batteries produce DC; wind turbines produce variable-frequency AC. **Inverters** use fast semiconductor switches (IGBTs or MOSFETs) with pulse-width modulation (PWM) and output filters to build a clean 60 Hz sine wave synchronized with the grid.

- **MPPT (maximum power point tracking)** adjusts the panel operating voltage to extract the most power as sunlight changes.
- **Grid-following** inverters lock to the grid's voltage and inject current; **grid-forming** inverters set their own voltage and frequency and are increasingly used to stabilize grids with few spinning machines.
- **Anti-islanding and ride-through:** under IEEE 1547, distributed inverters must stop exporting if the grid goes down (so line crews are not shocked by a "dead" line) but ride through short disturbances instead of tripping en masse.
- **Fault behaviour:** inverters typically limit fault current to about 1.1 to 1.5 times rated, much less than a synchronous generator, so overcurrent protection designed for big machines may not see faults on inverter-dominated feeders. This is an active area of protection engineering.

## Safety, standards and licensing

Protection settings, arc flash studies and interconnection designs are engineering work that must be done by qualified engineers and, for utility and many commercial projects, reviewed and sealed by a licensed PE (NCEES, https://ncees.org). Working on or near energized equipment follows NFPA 70E (https://www.nfpa.org/codes-and-standards/nfpa-70e-standard-development/70e), with arc flash labelling, PPE and energized-work permits, and needs employer training and qualification. Interconnection follows IEEE 1547 and the local utility's rules. Checked on 2026-10-23.

## Recap

- Protection isolates faults quickly and selectively using fuses, breakers, CTs/VTs and relays (50/51 overcurrent, 87 differential, 21 distance).
- Coordination makes the nearest device operate first, with upstream backup.
- Inverters use PWM, MPPT and grid-following or grid-forming control; IEEE 1547 sets anti-islanding and ride-through rules; inverter fault current is limited.


Explain how fuses, breakers and relays isolate faults, and how inverters connect solar, wind and batteries to the grid.

Protection and renewables

Protective relay basics | Eaton PSEC

Power Inverters Explained - How do they work working principle IGBT

Create a new KiCad project and open the Schematic Editor. Place a 2-pin connector (Conn_01x02), a resistor (R) and an LED (LED), and wire J1 pin 1 to R1, R1 to the LED anode, the LED cathode back to J1 pin 2. Add a PWR_FLAG on each net.

Set values and annotate (R1 = 1k, D1 = Red, J1). Run the Electrical Rules Checker and fix every error.

Assign footprints: PinHeader_1x02_P2.54mm_Vertical, R_0805_2012Metric, and LED_0805_2012Metric (or LED_D5.0mm). Check the LED's cathode mark matches the footprint.

Open the PCB Editor and update the board from the schematic. Draw a board outline of about 20 mm x 15 mm on the Edge.Cuts layer.

Place J1 on the board edge, then R1 and D1 nearby. Route the traces on the top layer, 0.3 mm wide.

Add a ground (cathode-side net) copper zone on the bottom layer and two M3 mounting holes. Add silkscreen text for '+', '-' and your board name.

Run the Design Rules Checker with the default rules and fix every violation and unconnected item. Look at the board in the 3D viewer.

Generate Gerber and drill files (File > Fabrication Outputs) into a folder, then open them in KiCad's Gerber Viewer to check each layer.

Calculate the LED current and resistor power at 3 V and at 9 V and write them on your schematic as a note.

## Why it matters

Almost every electronic design ends up on a **printed circuit board (PCB)**. Electrical engineers draw the schematic, often lay out the board, and review layouts for current capacity, noise and safety. A circuit that works in simulation can fail on a board with traces that are too thin, a ground return that loops across the board, or a decoupling capacitor placed too far away. KiCad is a free, professional-grade, open-source tool used by hobbyists and companies alike (https://www.kicad.org).

## The workflow

1. **Schematic capture:** place symbols (resistors, LEDs, connectors, ICs) and wire them. Give every part a reference designator (R1, D1, J1) and a value.
2. **Electrical rules check (ERC):** catches unconnected pins, outputs driving outputs and missing power flags.
3. **Footprint assignment:** link each symbol to its physical land pattern, such as a 0805 surface-mount resistor, a 5 mm through-hole LED or a 2-pin 2.54 mm header. The footprint must match the part you will actually buy; check the datasheet's dimensions.
4. **Board layout:** draw the board outline, place parts, then route copper **traces** between pads. Unrouted connections show as thin "ratsnest" lines.
5. **Design rules check (DRC):** checks clearances, trace widths, drill sizes and unrouted nets against the manufacturer's capabilities.
6. **Fabrication outputs:** Gerber files (one per copper, mask and silkscreen layer), a drill file, and for assembly a bill of materials (BOM) and pick-and-place file.

## Layout basics

- **Layers:** a two-layer board has copper on top and bottom, connected by **vias** (plated holes). Four-layer boards add inner planes, typically ground and power.
- **Ground:** use a solid ground pour or plane where you can. Return current flows directly under its signal trace at high frequencies, so a continuous ground keeps loops small and noise low.
- **Decoupling:** put a 100 nF capacitor right next to each IC power pin with short connections to ground.
- **Trace width and current:** wider traces carry more current with less temperature rise. IPC-2152 gives charts; on common 1 oz copper (35 µm) an outer trace about 0.25 mm wide handles roughly half an amp for a modest temperature rise, and about 1 mm handles a couple of amps. Use a calculator such as the one built into KiCad, and get high-current designs reviewed.
- **Clearance:** higher voltages need larger spacing between conductors (creepage and clearance). Anything connected to mains must follow the applicable safety standards (such as IEC 62368-1) and be designed and reviewed by qualified engineers; it is out of scope for this course.
- **Placement first:** good placement (connectors on the edge, decoupling close, short high-current loops) makes routing easy.

## Worked example: an LED indicator board

Schematic: a 2-pin header J1 for 3 to 9 V from a battery, a 1 kΩ resistor R1, a red LED D1, and back to J1. At 9 V with a 2 V LED, `I = (9 - 2) / 1000 = 7 mA` and the resistor dissipates `P = I^2 R = (0.007 A)^2 * 1,000 Ω = 49 mW`, fine for an 0805 resistor rated 125 mW. Layout: a board about 20 mm by 15 mm, J1 on the edge, 0.3 mm traces, a ground pour on the bottom, mounting holes, and silkscreen labels for `+` and `-`. That small board teaches the whole workflow.

## Ordering boards

Many fabricators make small two-layer boards cheaply in a few days. You do not need to order one for this lesson. Any board you do build later should stay on battery power of 9 V or less, and anything beyond that needs proper training and supervision.

## Common mistakes

- **Footprint mismatch:** a SOT-23 pinout that doesn't match the transistor you bought, or a connector drawn mirror-image.
- **Skipping ERC and DRC,** or ignoring their warnings.
- **Thin traces for power,** or long, looping high-current paths.
- **Split or broken ground** under fast signals.
- **No silkscreen labels or polarity marks,** which makes assembly and testing error-prone.

## Recap

- Schematic, ERC, footprints, layout, DRC, Gerbers: the same steps in every tool.
- Solid grounds, close decoupling, adequate trace width and clearance.
- Keep your own boards low-voltage; anything touching mains needs certified design and review.

## Try it

Open the **Do** tab to lay out the LED indicator board in KiCad and generate its fabrication files.


Go from schematic to a manufacturable two-layer board in KiCad: footprints, layout, design rules and Gerber files.

PCB design basics

An Intro to KiCad – Part 1: How PCBs Are Made | DigiKey

KiCad 9.0 - Getting Started Part 1: Intro & Download | DigiKey

How the grid works, per-unit and load-flow calculations, protection and inverter-based renewables, and PCB design basics.

Power, Electronics & Signals

About this course

Course content

Electronics

Signals and Systems

Power Systems

Where this course leads

Next course on the path

Careers that use it