TinyDyno

TinyDyno

An ESP32-S3 board that measures the speed and energy efficiency of one neural network inference.

What is it exactly? TinyDyno is a custom 72 by 72 mm, 2 layered PCB based on ESP32-S3.It is basically a test bench for machine learning on tiny devices (AKA edgeAI). It runs a neural network based on the data from sensors and measures every inference for time and energy. Time is how long the inference took and energy is how much ESP32-S3 has used during it.

To account for actual use cases it has an IMU(motion sensor) and a microphone which are for gesture recognition and keyword detector so the usual run look something like this:

1. Record the input from either sensors
2. Run the same model on the same input but with different libraries.(My kernels VS Espressif's ESP-DL VS TensorFlow Lite Micro)
3. Measure each run using the INA226 (power monitor) which reports current/voltage going into the ESP32-S3 which does the power over time math
4. Get the results and make conclusions

(A test pad (TP1) goes high during each inference, so the timing can be checked independently with an oscilloscope or logic analyzer.)

The WHY behind it all

Wanting to optimize the field I am currently curious about (AI) I brainstormed for a bit and came to the conclusion that you can't optimize something that you can't measure. After a bit of digging I found few issues it would solve on top of the qol it would provide for me:

1. Most benchmarks only report speed so a faster kernel that uses more power can still drain the battery sooner.
2. The USB power meters are quite slow. They update a few times per second, while one inference takes about 5–50 ms.

(Also it's not like you can find stuff like this easily to buy)

how does it work?

Power: two separate 3.3V rails

USB-C gives 5V and two separate 3.3V regulators split it into two rails:

1. Measured rail (3V3_MEAS): 5V goes through regulator U2, then solder jumper JP1, then the 75 mOhm shunt resistor R3 and then into the ESP32-S3. The ESP32 is the only thing on this rail.
2. Peripheral rail (3V3_PERIPH): 5V goes through regulator U1 to everything else (INA226, IMU, mic, LED, pull-ups).

So none of the sensor or LED current goes through the shunt and the measurement is only the ESP32.

Measuring power

Current going through the shunt makes a small voltage across it (V = I * R). For example at 100mA it's 0.1A * 0.075 Ohm = 7.5mV, which is tiny, so the INA226 (U3) does the job:

1. measures the voltage across the shunt to get the current
2. measures the 3.3V rail to get the voltage
3. multiplies them to get power
4. pulls its ALERT pin low when a new reading is ready so the ESP32 knows when to read it

The shunt is read through a separate pair of thin traces that go straight from the shunt's pads to the INA226 (Kelvin sensing), so the voltage drop on the thick power traces doesn't mess up the reading.

From power to energy and time

Energy = power * time, so during an inference the ESP32 reads the power about once a millisecond and keeps adding up power * time. Time comes from the ESP32's internal microsecond timer.

One measurement looks like this:

1. Load the recorded input
2. Set TP1 high, start the timer and the energy sum
3. Run the model
4. Set TP1 low, stop, and send time and energy to the PC over USB

Known problem

The ESP32 reads its own power monitor, so the reading itself costs a bit of energy too. The plan is to do the measuring on one core and the model on the other, and subtract the idle power.

Schematic and PCB

1. Schematic: hardware/kicad/TinyDyno.kicad_sch
2. PCB: hardware/kicad/TinyDyno.kicad_pcb
3. Gerbers, assembly BOM and placement file: hardware/kicad/production/

PCB design notes

1. 2 layers, 72 by 72mm, 1.6mm thick, made in KiCad
2. GND pour on both layers with stitching vias
3. No copper under the ESP32 antenna
4. Track widths: 0.5mm for power, 0.25mm default, 0.2mm on fine-pitch pins
5. Vias are 0.6mm with 0.3mm holes. The ESP32 module's thermal vias were 0.2mm, so I enlarged them to 0.3mm to fit JLCPCB's 2-layer minimum
6. JP1 is a solder jumper that's closed by default. Cutting it opens the measured rail, so I can put a multimeter or bench supply in there to calibrate the INA226

Pin map

I2C addresses: INA226 is 0x40, IMU is 0x6A.

What it can measure (INA226 + 75 mOhm shunt)

BOM (bill of materials)

Every part on the board. Everything is from LCSC and soldered by JLCPCB. Quantities are per board (2 boards get assembled).

Chips and main parts:

Resistors:

Capacitors:

Not actual parts (just copper on the PCB):

In total that's 32 parts per board, 16 different ones. The full exported list is in hardware/kicad/production/bom.csv, and the cost list synced from Half Life is in BOM.csv.

Cost (JLCPCB: 5 PCBs, 2 of them assembled)

Fabrication notes

1. Ordered from JLCPCB with Standard assembly, top side only. JLC adds 5mm edge rails on two sides, which you snap off along the V-cut.
2. U3 change: I planned to use the INA228 but it was out of stock at JLC, so I swapped it for the INA226. Same footprint and pin order, so the layout didn't change. The INA226 doesn't have a built-in energy counter, so the energy gets added up in firmware instead.
3. MK1 rotation: positions.csv says 180 degrees, but I rotated the mic by hand in JLC's placement preview. If you re-order, check it again.