Build Guide 1: Bench Testing Electronics

Type: Build Guide

Before anything goes on the rover, every electronic component gets tested on the bench. This is the most important guide in the series — it's boring, it's methodical, and it will save you hours of frustration later.

What You Need

Parts:

Raspberry Pi 4 (4GB)
MicroSD card (32-64GB)
USB-C power supply (for bench testing the Pi)
PCA9685 PWM driver board
ADS1115 ADC module
u-blox NEO-6M GPS module
Raspberry Pi Camera Module 3
CSI ribbon cable
0-25V voltage divider module
Buzzer module (optional)

Tools:

Breadboard
Jumper wires (male-to-female and male-to-male)
Multimeter
USB battery pack (Anker or similar, for later Pi power test)
A monitor + micro-HDMI cable (or SSH — covered in Guide 2)

Step 1: Visual Inspection

Unbox everything and look for obvious problems before powering anything on:

Pi 4: Check GPIO pins are straight, no bent or missing pins. Check the CSI camera port flap isn't cracked.
PCA9685: All 16 channel headers present, no cold solder joints on the screw terminals.
ADS1115: 4 analog input pins visible, I2C header clean.
GPS module: Antenna connector secure, ceramic patch antenna intact (the square flat piece).
Camera Module 3: Ribbon cable connector intact, lens not scratched or dusty.
Voltage divider: Input and output terminals clearly labeled.

Set aside anything that looks wrong. Don't power it up.

Multimeter Basics (skip if you've used one before)

Before Step 2, you need to know how to drive your multimeter. Here's the bare-minimum tour for an Innova 3320 / Astro AI / any basic auto-ranging meter — they're all laid out the same way.

Plug in the leads:

Black probe → middle jack labeled COM. This is "common" / ground. Always goes here.
Red probe → right jack (labeled something like V Ω mA BAT). This is for voltage, resistance, and continuity. Always goes here for what you're doing.
Left yellow jack labeled DC10A or 10A is for measuring high current (>200mA). You won't use it in this guide. Leave it empty.

Set the dial:

For voltages → DCV (top right, usually red zone, marked with V and ⎓)
For resistance → Ω
For continuity (beeps when wires are connected) → the speaker icon )))

The meter is auto-ranging, so you don't need to pick a voltage range — it figures it out.

Sanity check on a known battery:

Grab any battery you have (9V, AA, AAA, C, D — doesn't matter). Battery markings:

Smaller / round terminal = positive (+)
Larger / hex terminal (or the flat negative end on a cylindrical battery) = negative (−)

Touch:

Red probe tip → positive (+)
Black probe tip → negative (−)

What you should see:

9V battery: 9.0–9.6V healthy, 7.0–8.9V fading, <7V dead
AA / AAA / C / D: 1.5–1.6V healthy, <1.3V dying
Negative reading (e.g. -9.2) → probes reversed. Harmless. Swap them or just ignore the minus sign.
0.00 or random noise → probes not making contact, or dial isn't on DCV
Display reads way low on a fresh battery → the battery is actually dead. The meter is fine.

You can't damage anything by touching probes to a battery. The meter has very high internal resistance (10MΩ on this model — see the label on the front), so almost no current flows through it.

Step 2: Test the Voltage Divider

This is passive electronics — no power needed, just your multimeter, the divider, a battery, and two jumper wires.

Why this matters: the divider exists so the Pi's ADC can read your 2S LiPo voltage (up to 8.4V) without frying — the ADC tops out at 3.3V, so the divider scales the input down by a fixed ratio (typically ~5x for the 0-25V module). What you're verifying here: does the output actually scale down proportionally, and does it stay under 3.3V at the highest input voltage you'll feed it.

What you need

The voltage divider module (small green PCB with two visible large resistors)
2× male-to-male jumper wires (skinny rainbow wires with metal pins on both ends, from the parts kit)
A small flathead screwdriver
A known DC voltage source. Best options, in order:
1. A fresh 9V battery — gives a big, easy-to-read output (~1.8V on a 5x divider)
2. Your TRX-4 2S LiPo (~7.4–8.4V) — this is the actual real-world input
3. A AA / C / D cell (1.5V) — works as a "does the divider do anything?" check; output is small (~0.3V) but the ratio still confirms

Identify the module's two sides

The divider has:

A 2-screw terminal block on one side — this is the INPUT (where the battery connects). Holes labeled VCC and GND (or + and −).
A 3-pin header sticking up on the other side — this is the OUTPUT (what would normally connect to the ADC). Pins labeled +, −, S (or VCC, GND, S). The S pin (signal) is the divided voltage.

Wire the input

Loosen both screws on the input terminal block a few turns with your screwdriver — don't take them all the way out.
Push one jumper wire into the VCC (or +) hole and tighten the screw down on it.
Push the second jumper wire into the GND (or −) hole and tighten that screw.

You now have two wires dangling out of the divider's input side.

Connect the battery

For a cylindrical cell (AA, C, D): the flat raised nub end is positive (+), the flat bottom end is negative (−). For a 9V: the smaller round terminal is +, the larger hex terminal is −.

Lay the battery on the table.
Press the VCC wire firmly against the (+) terminal with your finger.
Press the GND wire firmly against the (−) terminal with another finger. (Awkward but doable. Pinning the wires under your fingers against the battery against the table works.) If you have alligator clips or helping hands, even easier.

You won't damage anything if you mix + and − up — you'll just read a negative voltage.

Measure the output

Set the multimeter dial to DCV, leads in COM (black) and V Ω (red).
With your other hand, take the meter probes:
- Red probe tip → the pin labeled S on the 3-pin output header
- Black probe tip → the pin labeled − (or GND) on the same header
Read the display.

What you should see

Battery	Expected output	Notes
1.5V (AA/C/D)	~0.3V (0.28–0.32)	Small but confirms divider works
9V (fresh)	~1.8V	Easiest to read precisely
8.4V (full LiPo)	~1.7V	Real-world value, well under 3.3V ✅

Sanity-check math: input ÷ output = ratio. So 1.5 ÷ 0.3 = 5x, 9.0 ÷ 1.8 = 5x. That's your divider ratio. As long as it stays consistent and the output stays under 3.3V at your highest expected input, you're good.

Pass / Fail

Pass: Output is proportional to input AND stays under 3.3V at the highest battery voltage you plan to feed it (8.4V for a fully charged 2S LiPo).

Fail:

0.00V reading → no contact somewhere. Press wires harder against the battery, or check the dial is on DCV.
Output equals input → you're probably probing the wrong pins (you measured the input side), or the wires fell out of the screw terminals. Re-check.
Output exceeds 3.3V at LiPo voltage → wrong divider for this application. Do not connect to the ADC.

Step 3: Flash the SD Card and Headless First Boot

This is where the build actually starts to feel real, and also where the surprises hide. The official "flash with Imager, set hostname/SSH/wifi/user, boot, ssh in" workflow looks like five clicks but has a few non-obvious gotchas on current Raspberry Pi OS Lite (Bookworm). We'll walk both the GUI path (Raspberry Pi Imager) and the CLI path (xz + dd) since either works, and call out the gotchas as we go.

Pick your OS

Raspberry Pi OS Lite (64-bit) — that's the one. No desktop environment, smaller image, less to maintain, plenty for what we need. The full desktop version is wasted overhead on a vehicle's brain.

Path A — Raspberry Pi Imager (GUI, recommended for first-timers)

Install Raspberry Pi Imager
Choose Device → Raspberry Pi 4
Choose OS → Raspberry Pi OS (other) → Raspberry Pi OS Lite (64-bit)
Choose Storage → your SD card (verify the size matches — picking the wrong drive nukes whatever's on it)
Click Next, then Edit Settings when it asks about OS customisation
General tab:
- Hostname: tickslayer
- Username: todd (or whatever)
- Password: pick something memorable for now (you'll change it after first login)
- Configure wireless LAN: SSID + password + country US
- Locale: your timezone, us keyboard
Services tab: Enable SSH → password authentication
Save → Yes → Yes → wait for write + verify (~5–10 min)
Eject the card from your Mac

Path B — CLI flash (faster if you're scripting it)

# 1. Download (latest 64-bit Lite, ~500 MB compressed)
mkdir -p ~/tickslayer-pi-flash && cd ~/tickslayer-pi-flash
curl -L -o raspios-lite-arm64.img.xz \
  "https://downloads.raspberrypi.com/raspios_lite_arm64_latest"

# 2. Decompress (~2.8 GB)
xz -dk -T 0 raspios-lite-arm64.img.xz

# 3. Find your SD card. macOS example — adjust for Linux.
diskutil list physical
# Look for the "Built In SDXC Reader" entry, note its disk number (e.g. disk14).
# DOUBLE CHECK — picking the wrong disk destroys data.

# 4. Unmount and flash. Use the *raw* device (`rdisk`) on macOS, much faster.
diskutil unmountDisk /dev/disk14
sudo dd if=raspios-lite-arm64.img of=/dev/rdisk14 bs=4m
# (No progress bar by default. Hit Ctrl+T during the run to peek at status.)
# ~90 seconds at ~30 MB/s for a decent SD card.

If you went the CLI route, you now have a flashed but unconfigured card. You need to add the headless config files manually. This is where it gets non-obvious — see the next section.

The headless config gotchas

Several things that "should work" don't, on current Pi OS Lite:

custom.toml doesn't work on its own. That's a Raspberry Pi Imager-specific mechanism. If you write custom.toml by hand to the boot partition without Imager's matching firstrun.sh and cmdline.txt modifications, nothing happens. Skip it.
Cloud-init is NOT enabled by default on Raspberry Pi OS Lite Bookworm, even though meta-data, user-data, and network-config template files are present on the boot partition. Editing them does nothing. (Don't trust online tutorials that tell you to use them — they're for Ubuntu Server on Pi, not Pi OS.)
Pi WiFi is RFKILL soft-blocked until a country code is set. This is regulatory compliance. If no country code is set, the radio never turns on and wlan0 shows as unavailable. Imager handles this for you when you set the WiFi country during setup. If you flash by hand without setting it, you have to set it after first boot (covered below).

The headless config that actually works (CLI path)

After flashing, the FAT32 boot partition mounts automatically (on macOS, at /Volumes/bootfs). Drop these files on it:

bootfs/userconf.txt — creates your user via the legacy raspi-config first-run service. This is the file that actually does the work on current Pi OS:

# Generate password hash on your Mac
openssl passwd -6 'tickslayer-temp'
# Copy the $6$... output

# Write the file (use YOUR username and YOUR hash)
echo 'todd:$6$Tmyaw3JWdNXNg4V2$.Ohrm0...rest-of-hash' > /Volumes/bootfs/userconf.txt

bootfs/ssh — empty file enables SSH on first boot:

touch /Volumes/bootfs/ssh

That's it for the headless config that's actually load-bearing. Notice we're not writing any WiFi config. The reliable way to do WiFi on this image is to first boot via ethernet, then configure WiFi from inside via nmcli (covered in the next step).

Eject the card:

diskutil eject /dev/disk14

Agent Assist·Flash and prep the card

**Tell the agent:** "I have a fresh microSD card mounted on my Mac. Walk me through flashing Raspberry Pi OS Lite 64-bit using `dd`, identify the right disk safely, then write `userconf.txt` and `ssh` files to the boot partition. My username is `todd`, my hostname will be `tickslayer`, my temporary password is `tickslayer-temp`."

You'll need:

A microSD card (32 GB or bigger)
An SD card reader for your computer
~3 GB of disk space for the decompressed image

Heads up: the agent will need you to type your Mac password when it runs sudo dd. The Claude Code harness can't do that for you — it'll prompt and you'll run the actual dd command yourself via the ! prefix in your prompt.

Step 3a: First boot via ethernet

This is the part the official guides skim over. For first-time setup, plug ethernet into the Pi. Yes, even if your end goal is fully wireless. Reasons:

WiFi requires a country code that you can only set from inside a running Pi (or via Imager during flash). On a CLI flash, you can't set it ahead of time, which means WiFi will be radio-blocked on first boot.
If anything goes wrong with the WiFi config, you have zero visibility into what's happening — no console, no logs, no IP. Ethernet gives you a guaranteed first SSH so you can actually see what's going on.
Once you're SSHed in over ethernet, configuring WiFi takes about 30 seconds (nmcli device wifi connect), and from then on the Pi is fully wireless.

Plug order matters less than you'd think, but the safe order is:

SD card into the Pi (it's a push-push slot — push it in until it clicks, not just until it stops)
Ethernet cable from Pi → a LAN port on your router (not the modem — devices on the modem port land on a separate ISP-managed network and can't be reached from your home LAN)
USB-C power last — the Pi has no power button, so plugging power in IS turning it on. Doing power last means everything else is settled when it boots.

Now wait ~60–90 seconds for first boot. The very first boot is a little slow because the rootfs partition automatically expands to fill the card. LED check:

Red PWR LED: solid on (if it's off or flickering, power issue — try a different USB-C cable, ones that ship with phones are sometimes charge-only)
Green ACT LED: flickering during boot, then idle/dark when the system is ready

Step 3b: First SSH

From your computer (on the same LAN — wired or wireless to the same router):

ssh todd@tickslayer.local

(Replace todd with whatever username you set, and tickslayer with whatever hostname.) Type the password you set. You should land at the Pi's shell prompt — todd@tickslayer:~ $.

If tickslayer.local doesn't resolve: mDNS isn't reaching you. Two ways to find the Pi instead:

Check your router's admin page — look for connected devices, find one named tickslayer or raspberrypi and grab its IP. Then ssh todd@<that-ip>.
Or scan the LAN: arp -a and look for any MAC starting with b8:27:eb, dc:a6:32, e4:5f:01, d8:3a:dd, or 2c:cf:67 (Raspberry Pi Foundation prefixes).

Step 3c: Set WiFi country and connect to WiFi

Inside the SSH session:

# Set WiFi country (required to unblock the radio)
sudo raspi-config nonint do_wifi_country US
sudo rfkill unblock wifi

# Verify the radio is alive
nmcli device status
# wlan0 should now show "disconnected" instead of "unavailable"

# Scan and connect (use your real SSID and password)
sudo nmcli device wifi connect "Your SSID" password "yourpassword"

nmcli device wifi connect saves a persistent NetworkManager profile under /etc/NetworkManager/system-connections/ with autoconnect enabled, so the Pi will rejoin this network automatically on every reboot from here on out. SSIDs with spaces and special characters (like Jurassic Park.Which one?) work fine inside double quotes.

Verify:

nmcli device status
# wlan0 should now show "connected"
ip -4 addr show wlan0
# Should have a real LAN IP
ping -c 2 1.1.1.1
# Should respond — internet via WiFi works

Step 3d: Cut the cord

Now the satisfying part. Unplug the ethernet cable from the Pi while the SSH session is still running. Your current SSH session may freeze briefly as it shifts to the WiFi route — that's OK, it'll either recover or you can just open a new SSH session:

# In a new terminal on your computer
ssh todd@tickslayer.local

If you get back in, you're truly headless. Power-cycle the Pi (unplug USB-C, wait 5 sec, plug back in) and SSH in again to confirm it auto-rejoins WiFi on its own. Once that works, you can put the Pi anywhere in WiFi range and never need to plug it into anything but power.

Agent Assist·Walk through first boot and WiFi setup

**Tell the agent:** "My Pi is plugged into ethernet (LAN port on the router, not the modem) and powered on. Try `ssh todd@tickslayer.local` and walk me through verifying it's reachable, setting the WiFi country to US, unblocking the radio, and connecting to my WiFi via `nmcli`. My SSID is `` and password is ``. After WiFi is up, have me unplug ethernet and confirm the Pi is still reachable over WiFi only."

Tip: before that, ask the agent to set up an SSH config alias (Host tickslayer block in ~/.ssh/config) and an ed25519 keypair so you can ssh tickslayer with no password going forward.

Pass: You can ssh tickslayer (or ssh todd@tickslayer.local) over WiFi only, with no ethernet cable attached, and the Pi survives a power cycle.

Fail and how to debug:

Permission denied (publickey,password) but SSH connects: user wasn't created. Did you write userconf.txt? Is the password hash format correct ($6$...)?
Could not resolve hostname tickslayer.local with no IP either: the Pi never joined the network. With ethernet plugged in, this almost never happens — check that the ethernet cable is in a LAN port on the router (not the modem), and that the Pi's RJ45 jack lights are on.
wlan0 unavailable after SSHing in over ethernet: WiFi country code not set. Run the do_wifi_country US + rfkill unblock wifi commands above.
Could not find suitable connection profile when running nmcli connect: SSID typo. Run nmcli device wifi list and verify the exact SSID string.

Step 4: Test the Camera Module

With the Pi powered off:

Lift the CSI port flap on the Pi (gently — it's fragile)
Insert the ribbon cable — blue/contacts side facing the USB ports
Close the flap to lock it
Boot the Pi

Test with:

# Quick capture test
rpicam-still -o test.jpg

# If that works, try a preview (requires monitor)
rpicam-hello -t 5000

Pass: test.jpg exists and contains a recognizable image. Fail: "No camera detected" — reseat the ribbon cable. Make sure the contacts face the right direction. Check that the cable isn't creased or torn.

Step 5: Test the GPS Module

The GPS kit comes in two pieces: the board (with the u-blox chip, micro USB, and pin header) and the ceramic patch antenna (a small square unit with a short coaxial wire ending in a tiny gold connector).

Attach the antenna

The antenna connects to the board via an IPEX/u.FL connector — a tiny white square with a gold ring in the center, located near the chip. The gold connector on the end of the antenna cable presses straight down onto it.

To seat it: hold the gold connector flat over the socket, lined up with the ring, and press straight down with your fingertip until you feel a small click. Give the cable a gentle tug afterward to confirm it locked. Keep it perpendicular — pressing at an angle bends the center pin and ruins the socket.

Without the antenna, the module will not get a fix, even outdoors.

Wire the board to the Pi

Wire the GPS to the Pi on a breadboard:

GPS Pin	Pi Pin	Notes
VCC	3.3V (Pin 1)	GOOUUU GT-U7 boards accept 3.3V–5V; if the power LED won't light on 3.3V, move to Pin 2/4 (5V)
GND	GND (Pin 6)
TX	GPIO 15 / RXD (Pin 10)	GPS TX → Pi RX
RX	GPIO 14 / TXD (Pin 8)	GPS RX → Pi TX

Before reading data, disable the Pi's serial console so it doesn't interfere:

sudo raspi-config
# Interface Options → Serial Port
# "Login shell over serial?" → No
# "Serial port hardware enabled?" → Yes
sudo reboot

Confirm the board is powered

Power on the Pi and check the GPS board:

Solid red power LED — module is powered and searching for satellites.
No LED at all — VCC isn't getting power. Reseat the VCC jumper, or try 5V instead of 3.3V.
Blinking LED — fix acquired (this won't happen until later in the test).

Position the antenna

Place the antenna ceramic-side up — the flat white/cream square faces the sky, label side down. Flipping it over (label up) blocks reception and is the most common reason you'll see only 1–2 satellites outdoors.

Other things that hurt reception:

Antenna under an awning, tree, or close to a wall (needs ~30°+ of clear sky)
Antenna sitting directly on top of the Pi (the Pi's WiFi + power supply emit RF noise — move the antenna a foot or so away if possible)
Loose IPEX connector (re-seat if you only see 1–2 satellites despite open sky)

Read raw NMEA data

stty -F /dev/serial0 9600 raw -echo
cat /dev/serial0

You should see lines starting with $GPGGA, $GPRMC, $GPGSV streaming in. Press Ctrl+C to stop.

Interpret what you're seeing

The NMEA stream tells you exactly what stage the module is in:

$GPGGA,,,,,,0,00,... — no fix yet (fix quality 0, 00 satellites used). Normal during cold start.
$GPGSV,1,1,03,15,,,39,18,,,41,20,,,33 — 03 satellites visible. This number climbs as the module locks onto more.
$GPRMC,,V,... — V = void (no valid fix yet). Becomes A = active once a fix is acquired.
$GPGGA,210631.00,4216.17453,N,07416.34072,W,1,05,3.36,658.2,M,... — fix acquired. Fix quality 1, 05 satellites used, position in degrees-minutes (42°16.17453' N, 74°16.34072' W), altitude 658.2m. This is what success looks like.

Be patient on first power-on. A cold start (no almanac in memory) typically takes 30 seconds to 2 minutes outdoors with a clear sky view, occasionally longer. The module needs to see at least 4 satellites and download ephemeris data from each before it can compute a fix. You'll often see "satellites visible" climb to 5–8 well before the "satellites used" number leaves 0 — that's the ephemeris download in progress.

Pass: NMEA sentences streaming, fix quality flips to 1 in $GPGGA, non-zero lat/lon, RMC status A. Fail:

No data at all — check VCC has power (LED on?), TX/RX not swapped, baud rate is 9600 (stty -F /dev/serial0 9600).
Data but stuck at 0–2 satellites outdoors — flip the antenna ceramic-up, reseat the IPEX connector, move away from buildings/overhead obstructions.
Several satellites visible but never gets a fix — wait longer (cold-start ephemeris download can take a few minutes), or try a more open location.

Step 6: Test the USB Battery Pack

The PCA9685 and ADS1115 are bench-tested in Guide 3: Pi ↔ Hardware Integration — they need Python + the rover venv set up first (Guide 2), so we cover them there instead of here.

This is your Pi's power source on the rover:

Unplug the USB-C wall power from the Pi
Connect the Anker battery pack via USB-C (or USB-A to USB-C cable)
Pi should stay running or boot back up

Key things to verify:

The Pi runs stable for at least 5 minutes on battery power
The battery doesn't go into "low current sleep" mode (some packs shut off when current draw is too low — the Pi should draw enough, but verify)
No random reboots or undervoltage warnings (a yellow lightning bolt on the desktop, or vcgencmd get_throttled returns non-zero)

vcgencmd get_throttled
# 0x0 = all good
# Anything else = power issues

Pass: Stable operation for 5+ minutes, no throttling. Fail: Reboots or throttling — try a different USB cable (short, thick cables are better), or a different battery pack.

Helpful Resources

Adafruit 16-Channel Servo Driver with Raspberry Pi — Adafruit's own guide for the PCA9685. Covers I2C wiring, Python setup, and servo control in detail.
Adafruit ADS1115 ADC Python & CircuitPython Guide — Official walkthrough for the ADS1115: wiring, gain settings, single-ended vs differential reads.

Checklist

Before moving on, confirm:

Voltage divider outputs safe voltage (under 3.3V)
Pi boots and you can SSH in
Camera captures an image
GPS streams NMEA data (fix confirmed outdoors)
Pi runs stable on USB battery pack

Everything passing? On to Guide 2: Raspberry Pi Setup to build out the software environment.