ProjekinAja. Embedded Systems Stage 6 · Bring-Up & Deployment Lesson 6.1
● Stage 6 · Lesson 6.1

Board Bring-Up: Smoke Test to First Blink

Never power a new board fully. Power it in stages, measure at each one, and let the current tell you where it hurts.

⏱ ~24 min read 🔬 Bench method 🧭 Beacon Rev A

🎯 By the end you'll understand

Why the first minutes with a new board are a sequence of predictions, not a power switch. How to inspect, check continuity, and apply current-limited power so that every fault turns into a number you read rather than a smell you notice. What a current signature means at each stage, what a bench supply's readout cannot show you, and why the order of steps decides whether a fault is localised in one step or smeared across five. How Beacon Rev A was brought up — including the rotated LED footprint that the microscope found before power did, and the sleep current that came in 1.8 µA over plan.

KEY INSIGHTThe current tells you where it hurts

A bench supply with its current limit set to 20 mA cannot destroy anything on Beacon. That is not a safety feature. It is a measurement strategy: every fault becomes a number you read instead of a smell you notice.

Here is the scenario this lesson exists to prevent. Five boards arrive from the assembler. You plug a LiPo into the first one, because that is what the board is for. Two seconds later the regulator area is too hot to touch and there is a faint, sweet smell. The board is dead. Worse, you have no idea why: the battery delivered whatever the fault wanted, the fault took it, and the evidence is now a discoloured spot. A 1000 mAh LiPo has no current limit worth the name. It will happily push several amps into a solder bridge.

Bring-up is the discipline of never letting that happen. It treats the new board as a set of hypotheses — "the 3.3 V rail draws about 10 µA with the MCU held in reset," "the module draws about 25 mA running the bring-up image," "the charger sinks 500 mA from VBUS" — and tests them one at a time, in an order where each test can only fail in a way you can see, with an energy budget too small to cause damage. The bench supply's current limit is the instrument that makes this possible. Set it just above the predicted current, and a fault that would have been a fire is instead a supply folding back to zero volts and a readout you compare with your prediction.

🔑 Hold onto this

Bring-up is not "turn it on and see." It is predict → limit → apply → compare, repeated once per subsystem. The prediction comes from the design (Stages 1–5 gave you every number). The limit is set so that the worst case is harmless. The comparison is where you learn. Skip the prediction and the limit becomes a guess; skip the limit and the comparison becomes a post-mortem.

HOW IT WORKSThe bring-up ladder: eight rungs, each one cheap to fail

The sequence below is the one Beacon Rev A followed. It is written for boards that arrive fully assembled — which is what a contract assembler delivers, and which changes the classic advice. The old rule was "populate the power section, verify it, then populate the MCU." When everything is already soldered, you cannot stage the population, so you stage what is enabled and what is powered. The ESP32-C3-MINI-1's EN pin (the chip-enable, sometimes labelled CHIP_PU) is the tool: hold it low and the module is held in reset, drawing only microamps, and you get to examine the power section alone even though the MCU is sitting on the rail.

0

Inspect before power — the microscope is the cheapest instrument you own

Ten minutes with a 10× loupe or a USB microscope on every board. Check orientation of every polarised part against the schematic, not the silkscreen (the silkscreen can be wrong; that is exactly how a rotated footprint gets built). Look for bridges on the module's castellations and the USB-C pins, tombstoned 0402s, missing parts, and parts that look subtly wrong — a 0402 with no marking cannot be read, but a wrong-size package or a wrong colour on a diode can. Compare the assembled board against the placement (CPL) file you sent. Beacon's rotated LED was found here, on board 1, before any current flowed.

1

Unpowered resistance on every rail

Multimeter in resistance mode, black lead on GND, red lead on VBAT, VBUS, and 3V3 in turn. You are not looking for a specific value; you are looking for a plausible one. A rail with ICs on it reads hundreds of ohms to tens of kilohms, and the reading climbs for a few seconds as the meter charges the rail's capacitors. A rail at 0–2 Ω is a short, and you stop. Reverse the leads and look for the asymmetry of an IC's body diode (diode-test mode shows roughly 0.5–0.7 V one way, open the other) — the presence of that asymmetry tells you the chip is at least connected the right way round. Do this on all five boards and write the numbers down; five similar readings are a baseline, one outlier is a suspect.

2

Power section alone: EN low, limit 10 mA

Ground EN through a clip on the Tag-Connect footprint. Bench supply at 3.7 V (a battery's nominal voltage), current limit 10 mA, applied at the JST-PH battery pads so the current flows through the real path: DW01A + FS8205 protection, the reverse-battery PMOS, then the TPS62840 buck. Predicted draw: about 10 µA — the buck's 60 nA quiescent current, the protection IC's few microamps, the divider's switch, and leakage. The bench supply's own readout resolves 1 mA at best and will show zero; put a multimeter in series on its µA range to see the real number. Then measure 3V3: it must read 3.3 V within a few percent. The TPS62840 is a fixed-output part whose voltage is selected by a resistor on its VSET pin, so a wrong resistor gives you the wrong fixed voltage (1.8 V, 3.0 V) rather than a runaway — a nice property to have designed in, and a reason to check the number instead of assuming it.

3

Release EN: the module boots, limit 100 mA

With no application flashed, the ROM bootloader finds no valid image and loops, printing invalid header on UART0 at 115200 baud. That is a good sign: the core is running, the flash is readable, the serial path works. Predicted current: on the order of 20–30 mA with the radio off (the datasheet's modem-sleep figure at 160 MHz is a reasonable anchor; treat it as typical, not a spec). Plug a USB cable in later, not now — VBUS brings the charger into play and you want one unknown at a time.

4

Flash the bring-up image; first log line

The bring-up image (below) prints the reset reason, the chip revision, scans the I2C bus, and blinks. Flash it through the TC2030 (UART plus GPIO9 held low at reset to enter download mode — the very strapping behaviour that will bite Beacon in the field, used here on purpose). The first log line is the moment the board stops being a document. Note the active current: it is your baseline for every step that follows.

5

Sensors: an I2C scan and a sane reading

The scan must report ACKs at 0x44 (SHT40) and 0x19 (LIS2DH12) and nothing else. Then read each one and check the value is sane — a temperature near the room's, an acceleration of about 1 g on one axis. A stuck bus has almost no current signature (a slave holding SDA low burns only 0.7 mA through a 4.7 kΩ pull-up), which is why this rung is a functional test, not a current reading.

6

LED rail, then radio — with limits that clear the peaks

Enable the high-side PMOS that feeds the WS2812B-2020, send one colour, watch the current step up by a few milliamps and the LED light. Then an advertising burst: the average current during the 45 ms window is about 40 mA (canon), but the transmit peaks are well above 100 mA. Set the limit for the peaks, not the average. A limit that clears the average but not the peaks lets the rail sag mid-packet, the brown-out detector resets the chip, and you spend an afternoon debugging an "RF firmware bug" that is really your supply setting.

7

USB and charging, on a second supply

VBUS from a second current-limited supply at 5 V, limit 600 mA. With a partly discharged cell on VBAT, the MCP73831 should sink close to 500 mA (its charge current is set by the PROG resistor: 2 kΩ gives roughly 500 mA). Check the STAT pin, check that the board still runs. Only now, with everything else known, plug in a real USB cable and confirm the native USB-JTAG enumerates on the host.

10 µA 100 µA 1 mA 10 mA 100 mA PWR, EN low MCU boots Sensors LED rail BLE burst ≈10 µA · limit 10 mA ≈25 mA · limit 100 mA +0.5 mA · limit 100 mA +8 mA · limit 100 mA peaks >100 mA · limit 200 mA predicted limit the limit sits one comfortable step above the prediction — never far above it
The ladder as a staircase. The solid line is the predicted current at each rung (log scale; Beacon canon numbers for sleep and the advertising average, illustrative for the rest). The dashed line is the supply limit, set to clear the rung's peak with margin and nothing more. The gap between the two lines is where a fault becomes visible without becoming expensive.
💡 Injecting 3.3 V directly is a legitimate shortcut — with one caveat

If the power section itself is the suspect, you can bypass it: feed 3.3 V from the bench supply straight into the 3V3 test pad with VBAT absent. Everything downstream of the buck then runs from a known-good rail and you have separated "the regulator is wrong" from "the load is wrong." The caveat is that back-feeding a buck converter from its output is tolerated by most parts but is not a documented operating mode; the high-side switch's body diode will lift the unpowered input pin to a diode drop below your injected voltage. Keep it brief, keep it current-limited, and prefer it for diagnosis over routine.

CORE CONCEPTReading a current signature

Every rung produces one number: the current the supply delivers. That number is only meaningful next to the prediction you wrote down first. Here is the interpretation table Beacon's bring-up used. The columns are the ratio of observed to predicted current and what it most often means; the diagnoses are starting hypotheses, not verdicts.

Observed vs predictedSupply behaviourMost likely causeNext move
At the limit, voltage folded to near 0 VCC mode, red LEDShort on the rail: solder bridge, reversed diode or TVS, cracked ceramic capacitorUnpower. Resistance check. Thermal camera or IR thermometer with the limit lowered to a few mA — a short at 5 mA still warms enough to find
Zero, or far below predictionCV mode, rail correctOpen: unpopulated part, cold joint on a supply pin, reverse-battery PMOS not turning on, EN not releasedProbe the rail at each IC's pin, not at the test pad
Within ±30 %CV modeNominal. The 30 % covers datasheet spread and your model's simplicityRecord it. This is the baseline for the next rung
2–10× prediction, stableCV mode, rail correctA part in the wrong state: a pull-up fighting a driven pin, a peripheral clock left on, a sensor not put to sleep, an LED half on, a reverse-powered part conducting through its ESD diodeSubtract subsystems (disable them in firmware) until the excess disappears
Prediction, but periodic dips or resetsBriefly CC on peaksYour limit is below the peak current, or decoupling is inadequate for the transient (Lesson 2.5)Raise the limit one step. If resets persist at a generous limit, the board's own supply path is sagging
Slowly rising over minutesCV modeSomething heating: a marginal short, a part near its limit, a wet or contaminated board leakingTouch test with a knuckle (a part above ~45–50 °C is uncomfortable within a second), then thermal camera

Two instrument realities from Lesson 1.7 matter here. First, the bench supply's current display is not a microammeter: most resolve 1 mA, some 10 mA. For the power-section rung, where the honest answer is around 10 µA, a multimeter in series on the µA range is mandatory, and its burden voltage is fine at that current (a typical µA-range shunt of a few hundred ohms drops only millivolts at 10 µA). Second, once the module is awake and pulling tens of milliamps with 100 mA peaks, that same µA range would drop volts and brown the board out — switch ranges or, better, move the meter out and trust the supply's readout at that level.

📖 Why "energy before you notice" is the number that matters

Damage is not caused by current; it is caused by energy deposited faster than it can leave. With the limit at 10 mA and a 3.7 V supply, the absolute worst case is 37 mW spread over whatever is faulty — you could leave it on for an hour while you probe. With no limit, a 1000 mAh LiPo into a 0.3 Ω bridge delivers several amps through a spot the size of a pinhead, and the trace or pad is gone in seconds. The limit does not prevent the fault. It buys you the time to find it while the evidence is still intact.

Heat is the second signature. An IR thermometer or a cheap thermal camera turns a short into a bright dot, but only if there is enough current flowing to warm it — a few milliamps into a bridge is enough. A fingertip works too, with the caution that calluses blunt the test — a part at 60 °C that feels only warm to a hardened fingertip is already well past the comfortable range, and a part at 90 °C leaves a mark; the knuckle is more sensitive than the fingertip and less likely to be burned, and in any case the thermal camera is the tool once you can afford one.

SEE ITSequence the bring-up — and see what a fault does at each rung

Build Beacon's bring-up order by adding rungs, set the supply's current limit for each, then pick a fault that is hiding on the board and run it. The sequencer models what you would observe at every step: the predicted current, the observed current, whether the supply folds, and whether the fault is localised (found at the step where its cause lives) or cascades (shows up later as a misleading symptom). There are two ways to get it wrong: a limit too high lets a fault do damage, and a limit too low creates a fault of your own that looks like something else.

⚙ Interactive · Bring-up sequencer

Add rungs in the order you would run them. Each rung has its own supply limit. Then choose which fault is on the board and run. Faults never "run" through a rung you did not include — they escape to the pilot.

Your sequence is empty. Add rungs above; each row gets a limit selector.

Three things to try deliberately. Put the LED rung before the MCU rung and watch it accomplish nothing — there is no firmware to drive the PMOS, so the rung is wasted time. Set the advertising rung's limit to 50 mA and watch a healthy board "develop an RF bug." And run the charger fault with the USB rung's limit at 50 mA: the observed current sits exactly at the limit, and you cannot tell a folding supply from a wrong resistor. The prediction — 500 mA — is what would have told you, and the sequencer only catches it because it always compares. At the bench, the comparison is your job.

The bring-up image is not the application. It is a small, boring program whose only virtue is that every line of its output answers a question you had before you powered the board. It prints the reset reason (so a brown-out reset during bring-up is not mistaken for a power-on), the chip revision and flash size (so a wrong module variant shows up immediately), scans the I2C bus, and blinks. It uses ESP-IDF 5.x's newer I2C master driver, whose i2c_master_probe() does exactly what a bring-up scan needs: address a device and report whether it acknowledged.

main/bringup.cESP-IDF 5.x · Beacon Rev A bring-up image
#include "esp_log.h"
#include "esp_system.h"
#include "esp_chip_info.h"
#include "driver/gpio.h"
#include "driver/i2c_master.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

#define PIN_SDA      6      // Rev A net names, see schematic sheet "sensors"
#define PIN_SCL      7
#define PIN_LED_PWR  10     // gate of the LED high-side PMOS, active-low (gate low = rail on)

static const char *TAG = "bringup";

void app_main(void)
{
    esp_chip_info_t ci; esp_chip_info(&ci);
    ESP_LOGI(TAG, "reset reason=%d  cores=%d  rev=%d",
             (int)esp_reset_reason(), ci.cores, ci.revision);

    /* --- rung 5: I2C scan. External 4.7k pull-ups exist on Rev A, so no internal ones. --- */
    i2c_master_bus_config_t bus_cfg = {
        .i2c_port = I2C_NUM_0, .sda_io_num = PIN_SDA, .scl_io_num = PIN_SCL,
        .clk_source = I2C_CLK_SRC_DEFAULT, .glitch_ignore_cnt = 7,
        .flags.enable_internal_pullup = 0,
    };
    i2c_master_bus_handle_t bus;
    ESP_ERROR_CHECK(i2c_new_master_bus(&bus_cfg, &bus));
    int found = 0;
    for (uint8_t a = 0x08; a < 0x78; a++) {
        if (i2c_master_probe(bus, a, 20) == ESP_OK) {   // 20 ms timeout per address
            ESP_LOGI(TAG, "ACK at 0x%02X", a); found++;
        }
    }
    ESP_LOGI(TAG, "I2C scan: %d device(s); expected 2 (0x19 LIS2DH12, 0x44 SHT40)", found);

    /* --- rung 6: LED rail. Current should step up when this goes high. --- */
    gpio_reset_pin(PIN_LED_PWR);
    gpio_set_direction(PIN_LED_PWR, GPIO_MODE_OUTPUT);
    for (;;) {
        gpio_set_level(PIN_LED_PWR, 1);  ESP_LOGI(TAG, "LED rail ON (gate driven low)");
        vTaskDelay(pdMS_TO_TICKS(2000));
        gpio_set_level(PIN_LED_PWR, 0);  ESP_LOGI(TAG, "LED rail OFF");
        vTaskDelay(pdMS_TO_TICKS(2000));
    }
}

Three details carry weight. The internal pull-ups are explicitly disabled, because Rev A has 4.7 kΩ external pull-ups (Lesson 2.1) and adding the chip's weak internal ones would change the bus you are trying to characterise. The scan prints what it expected alongside what it found — a log line that says "2 devices" without saying which two is a test that only checks the code ran, the trap Lesson 6.3 is about. And the LED rung switches the rail, not the LED data: the point of the rung is the current step, which tells you whether the PMOS and the LED are healthy before a single WS2812 timing bit is sent. Driving the LED itself comes after, with the led_strip component over RMT.

Pin numbers in this listing are Rev A's schematic assignments, kept here for concreteness; the general rule is that the bring-up image reads them from the same board header the application will use, so the two can never disagree.

BEACONBeacon Rev A comes alive: five boards, one rotated LED, and 1.8 µA that should not be there

Five assembled Rev A boards arrived from the assembler with the Stage 5 order. Here is what the ladder found, board by board, and what went into the log.

RungPredictedMeasured (5 boards)Status
0 · InspectionAll parts per CPL, pin 1 per datasheetWS2812B-2020 placed rotated on all 5 — the footprint's pin-1 mark is on the wrong corner (Lesson 5.3). Everything else clean; no bridges on the module castellationsDefect logged, LED-1
1 · Rail resistancekΩ-range, rising; no shorts3V3: ~1.1 kΩ rising on all 5; VBAT: > 100 kΩ (reverse PMOS off); VBUS: ~10 kΩ (CC pulldowns and TVS)OK
2 · Power section, EN low≈ 10 µA, 3V3 = 3.30 V9–11 µA on the DMM; 3.30–3.32 V; ripple a few mV p-p on the scopeOK
3 · Release EN≈ 25 mA, "invalid header" on UART22–24 mA; ROM loop visible on all 5OK
4 · Bring-up imageLog line, reset reason POWERONAll 5 boot; reset reason 1 (POWERON); chip revision as expectedOK
5 · I2C scanACK at 0x19 and 0x44 only5/5 boards: exactly two ACKs; temperature 24–26 °C; 1 g on ZOK
6a · LED rail+8 mA and light+15 mA, no light, on all 5 — consistent with the rotated part conducting through a protection diode. Reworked in Lesson 6.2, then +8 mA and light→ LED-1
6b · BLE burst≈ 40 mA average over 45 ms; peaks > 100 mAPhone (nRF Connect) sees the 14-byte payload from all 5; scope on a 1 Ω shunt shows peaks above 100 mA during TXOK
6c · Deep sleep≈ 8 µA (canon budget)9.6–10.0 µA on all 5 — about 1.8 µA over plan, identical on every boardLogged OPEN-3
7 · VBUS & charge≈ 500 mA into a half-charged cell480–500 mA; STAT low while charging; native USB enumerates on the hostOK

Two of the three defects Beacon's canon lists for Rev A surfaced on the first day, and it is worth noticing how. The rotated LED was found by inspection, then confirmed by current: a rotated WS2812B lands its supply on the wrong pads, its internal protection diode conducts, and the rail draws more than a lit LED would while staying dark. The extra sleep current was found by the DMM and by nothing else — 1.8 µA is invisible to every other instrument on the bench, and it is a 22 % error on the sleep budget. Being identical on all five boards, it is a design defect, not workmanship. It went into the log as OPEN-3 with a hypothesis ("the divider's switch is not fully off in deep sleep") and was not chased that day: the canon's six-fold derating margin covers it, and the pilot in Lesson 6.9 turns out to be where the root cause is finally pinned down.

🧪 The third defect, seen and accepted

The GPIO9 button behaviour is not a bring-up finding — it is a review finding from Lesson 5.9, where it was flagged and accepted for Rev A. Bring-up actually uses it: holding the button while releasing EN puts the ESP32-C3 into download mode, which is exactly how the first image was flashed through the TC2030. The trap and the tool are the same strapping pin. Whether it matters in the field depends on whether anyone holds the button while inserting a battery, and the honest answer at bring-up was "we don't know yet."

Board-to-board consistency is itself a result. Five boards within a few percent of each other on every rung means the assembler's process is stable and the design is deterministic; a single outlier would have been a workmanship suspect to set aside for the jig in Lesson 6.3. Five identical anomalies mean the anomaly is yours.

IN PRACTICEThe bring-up log is the first page of the post-mortem

Everything above was written down as it happened, in a plain text file committed next to the KiCad project. The format matters less than the discipline: every rung gets its prediction before the measurement, every anomaly gets an ID and a status, and nothing is edited after the fact — corrections are appended. By Lesson 6.9 this file is the evidence chain that turns "we think the divider leaks" into "OPEN-3, measured 9.8 µA on 5 of 5 boards on day 1, root cause found day 22."

hardware/rev-a/BRINGUP.mdexcerpt · one rung, one anomaly
## Rung 6c — deep sleep current (board S/N 003)
predict : 8.0 uA  (canon: module 5 + buck + sensors asleep + divider off)
setup   : VBAT 3.70 V bench, DMM uA range in series, EN released, app asleep > 60 s
measure : 9.8 uA   (S/N 001: 9.7, 002: 9.6, 004: 10.0, 005: 9.8)
delta   : +1.8 uA  (+22 % of sleep budget; ~+5 % of average current at 1 report/min)

## OPEN-3 — sleep current 1.8 uA over plan  [status: OPEN]
hypothesis : divider switch not fully off in deep sleep (2 x 1M at 3.7 V = 1.85 uA — suspicious match)
evidence   : identical on 5/5 boards -> design, not workmanship
risk       : covered by 6x derating margin on R1; ship pilot, investigate in parallel
next       : probe divider node during sleep; check gate state of the switch driver

Notice the arithmetic in the hypothesis line. Two 1 MΩ resistors in series across 3.7 V draw 1.85 µA — almost exactly the excess. That is not proof; it is the kind of coincidence that promotes a hypothesis to "test this first." A log that records the arithmetic alongside the number is what lets a colleague, or you in three weeks, pick the thread up without redoing the day.

WEAKNESSWhere this bites

✗ "The assembler tested it" — so you skip the ladder

Contract assemblers test for what they are paid to test: usually a visual or AOI check and, if you paid for it, a flying-probe continuity test against your netlist. That catches opens and shorts between nets. It does not catch a part placed rotated on pads that happen to match, a wrong resistor value in an unmarked 0402, a footprint whose pad geometry starves a joint, or any behaviour at all. Beacon's rotated LED passed the assembler's checks because the netlist was satisfied — the wrong pins were connected to the right nets. The ladder exists because "tested" has many meanings, and the one you need is yours.

✗ First power from the battery, because that is what the board is for

A LiPo cell has an internal resistance of tens of milliohms and no current limit until the protection IC's over-current threshold, which on a DW01A-class part is set for amps, not milliamps. Everything the bench supply gives you — the fold-back, the readout, the energy bound — the battery takes away. The rule is simple: the battery is the last thing to touch a new board, after every rung has passed on a limited supply, and the first time it does, you are watching the current with a shunt in series.

✗ Finding the first anomaly and declaring the board understood

Faults arrive in bundles. Beacon had three on Rev A, and the LED rotation was loud enough to absorb all the attention on day one — it would have been easy to fix it, feel productive, and never put the DMM on the sleep rung where the quiet 1.8 µA was waiting. The ladder is only as good as your willingness to climb every rung even after you have found something. A rung you skip because "we already know what's wrong" is a rung whose fault ships to the pilot.

KEY INSIGHTHow this connects

The habit this lesson installs — predict, limit, apply, compare — is the same habit that runs the test jig in Lesson 6.3, the pre-compliance sweep in 6.4, and the pilot's failure criteria in 6.9. Bring-up is just the first time you apply it to a board that has never been powered.

GLOSSARYKey terms introduced

Staged bring-up
Powering and enabling a new board one subsystem at a time, each with a predicted current and a supply limit set just above it, so faults are localised to the rung where their cause lives.
Current limit / fold-back
A bench supply setting that caps output current; when the load would draw more, the supply drops its voltage (enters constant-current mode) instead. It bounds the energy a fault can dissipate and turns the fault into a readable event.
Current signature
The observed supply current at a rung compared with its prediction. The ratio and its behaviour (folded, zero, stable excess, periodic dips, slow rise) point to a class of cause before any probing.
EN / CHIP_PU
The ESP32-C3 module's chip-enable input. Held low, the chip is in reset and draws only microamps, which lets an assembled board's power section be characterised with the MCU present but inert.
Download (boot) mode
The ROM bootloader state entered when GPIO9 is low at reset (with GPIO8 high) on the ESP32-C3. It waits for a host over serial and never runs the application — the tool used to flash Rev A and the trap Beacon's button shares.
Burden voltage
The voltage a current-measuring instrument drops across its own shunt. Negligible on a µA range at 10 µA; enough to brown a board out on the same range at 100 mA.
Bring-up log
An append-only record of predictions, setups, measurements, and numbered anomalies with status. It is the evidence chain the post-mortem in Lesson 6.9 is built from.

ACTIVE RECALLCheck your understanding

Answer in your own words first, then reveal.

1Your boards arrive fully assembled. You cannot populate the power section first. What replaces staged population, and why does it work?›

Staged enabling. Hold the module's EN pin low so the MCU sits in reset drawing microamps, apply current-limited power at the battery pads, and characterise the protection, buck, and rail voltage with the MCU electrically present but inert. Then release EN, then enable subsystems from firmware one at a time (sensors, LED rail, radio), then VBUS from a second limited supply. Each stage adds one predicted increment of current, so an anomaly is attributed to the thing you just enabled. The one exposure this cannot remove is a rail-voltage fault reaching the MCU — which is why Beacon's fixed-output TPS62840 (no feedback resistor to get wrong, maximum selectable output 3.3 V) is a bring-up feature as much as a power feature.

2At the advertising rung you set the limit to 50 mA because the canon says the burst averages 40 mA. The board resets every burst. What happened, and how would you have misdiagnosed it?›

The 40 mA is an average over the 45 ms window; the transmit peaks are well above 100 mA. Each peak drives the supply into constant-current mode, the rail sags, the ESP32-C3's brown-out detector fires, and the chip resets mid-packet. The misdiagnosis is almost automatic: the reset coincides with the first radio activity, so it looks like an RF-stack or firmware bug, and you start bisecting BLE code. The fix is to set limits for peaks (200 mA here), and the discipline is to write the peak into the prediction. If resets persist at a generous limit, then and only then is the board's own supply path — decoupling, buck transient response, battery IR — the suspect.

3All five Rev A boards drew 9.8 µA in deep sleep against a plan of 8 µA. Why is "identical on five boards" the most important word in that finding?›

Because it sorts the defect into the right bin. Workmanship defects — a flux residue leaking, a marginal joint, a damaged part — are per-unit and vary from board to board. A design defect is deterministic and appears on every unit built from the same files. Five boards within 0.4 µA of each other, all 1.8 µA high, means the excess is in the schematic or layout, not the assembly; a jig test in Lesson 6.3 cannot screen it out, and Rev B has to fix it. The arithmetic sharpens the hypothesis: two 1 MΩ resistors across 3.7 V draw 1.85 µA, which is the signature of the battery divider's switch not being fully off in sleep.

4Why does the bring-up image print "expected 2 (0x19, 0x44)" next to the count of I2C devices it found, rather than just the count?›

Because a log line that reports only what happened is a test that verifies the code ran, not that the hardware is right. "2 devices found" is satisfied by two wrong addresses, by one sensor plus a bridged address that ACKs twice, or by a bus that behaves differently from the one you designed. Printing the expectation alongside the observation makes every log line a comparison — the same predict-then-compare discipline as the current limit — and makes a mismatch visible to someone reading the log who does not have the schematic open. Lesson 6.3 builds the whole production test on this principle.

Next: solder is a metallurgical joint with a profile — and the LED gets fixed by hand →