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.