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

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.