Skip to the content
2 layers253 × 60 mmFrontpanel, the printed circuit board in 3D

WIO Terminal adaptation of Elektor Platino soldering station

Size
253 × 60 mm
Copper layers
2
Thickness
1 mm
Parts
14
Nets
12
Pads
68
Tracks, vias
69, 0
Pours
12
Routed
Yes
KiCad
KiCad 10.0 (file 20260206)
Created
3 Jul 2026
Updated
7 Nov 2026

Overview

Frontpanel is an open-source printed circuit board by tzijnge, from the tzijnge/SolderingStation repository on GitHub, published under the MIT licence. It is a 2-layer board of 253 × 60 mm with 14 parts on 12 nets, routed with 69 tracks and 0 vias.

README

README.md

SolderingStation

WIO Terminal adaptation of the Elektor Platino soldering station

Development environment

Tooling

Hardware target

  • Seeed WIO Terminal (SAMD51, Cortex-M4F)
  • atmelsam platform, board = seeed_wio_terminal, framework = arduino (see platformio.ini)

Libraries

Declared in platformio.ini under lib_deps, fetched automatically by PlatformIO on build:

  • LovyanGFX — drives the 2.4" ILI9341 LCD (#include <LovyanGFX.hpp>, class LGFX), using genuine DMA-based SPI for speed. Needs -D LGFX_AUTODETECT -D LGFX_WIO_TERMINAL in platformio.ini's build_flags, since PlatformIO's seeed_wio_terminal board definition doesn't define ARDUINO_WIO_TERMINAL, which LovyanGFX's autodetect normally keys off.
  • SparkFun_Qwiic_Twist_Arduino_Library — driver for the Qwiic Twist rotary encoder, connected via a Grove-to-Qwiic cable on the WIO Terminal's Grove I2C port
  • ETL (Embedded Template Library) — used throughout for containers/utilities in this interrupt-driven design
  • Arduino-PID-Library — drives the tip-temperature PID control loop
  • LotusRPC — remote control and telemetry over USB. Not a lib_deps entry: its server code is generated during the build, see Remote control (LotusRPC) below

Building and uploading

Build and upload using the PlatformIO sidebar in VS Code (project/build/upload icons in the PlatformIO toolbar), or the equivalent pio run / pio run -t upload commands from a PlatformIO Core CLI.

Known build gotchas

  • Arduino.h (with the WIO Terminal's variant.h it pulls in) #defines names that break standard library and ETL headers parsed after it: the function-like macros min, max, abs and round, and pin names such as D1 and D2, which ETL uses as template parameter names. The fix is to include the affected headers before Arduino.h: their include guards then keep them from being parsed again once the macros exist. That's the include block at the very top of src/main.cpp. If a newly used <...> or etl/... header fails with odd errors pointing into Arduino.h or variant.h, add it to that block. main.cpp is the only source file; a second .cpp file would need the same block, or a forced include (-include) in platformio.ini.
  • LovyanGFX's rotation numbering for this board is offset by 180° from the old TFT_eSPI-based fork this project used to use — call tft.setRotation(1) (not 3) for correct upright landscape orientation.

Images

Images on the display, such as the warning sign on the fault screen, are drawn as SVG files in assets/. A script converts each one into a C++ header in src/images/, which the firmware draws by calling the header's draw() function. The generated headers are committed, so building the firmware doesn't need Python.

SVGGenerated headerUsed in
assets/warning_sign.svgsrc/images/WarningSign.hsrc/safety/FaultScreen.h

To change an image:

  1. Edit the SVG, in a text editor or a drawing program such as Inkscape. Draw at the size it should appear on screen: one SVG unit is one pixel. The display has 320 × 240 pixels.

  2. Install the script's dependencies (only needed once):

    text
    pip install -r tools/requirements.txt
  3. Regenerate the header. The last argument is the C++ namespace the image gets:

    text
    python tools/svg_to_bitmap.py assets/warning_sign.svg src/images/WarningSign.h WarningSign

    The script prints the image's size in bytes and how much the colour reduction (see below) changed it.

  4. Build and upload as usual, and commit both the SVG and the regenerated header.

Things to know:

  • Never edit the generated header by hand; the next regeneration overwrites it.
  • To save flash, images are stored with a limited colour table (a palette): by default 16 colours, so each pixel takes 4 bits instead of the 16 bits of full colour. The warning sign takes about 4.9 KB instead of 19.5 KB. 16 colours is plenty for icons made of a few flat colours plus the smoothed shades along their edges. If the script reports many changed pixels for a more colourful image, use --bits 8 (256 colours, 8 bits per pixel). For an image with only 2 or 4 flat colours and no smoothing, --bits 1 or --bits 2 makes it smaller still.
  • The script renders the image on a black background, the screen background, so its smoothed edges blend into black. Transparent parts of the SVG come out black.
  • The header contains the image's WIDTH, HEIGHT and a draw(tft, x, y) function, which draws it with its top-left corner at (x, y). All its data is stored in flash, not RAM.
  • If the image size changes, check the layout of the screen that uses it. FaultScreen.h centres the warning sign horizontally, but its vertical position (SIGN_Y) and the positions of the text above and the temperature below are fixed.
  • To add a new image, run the script with a new SVG, header name and namespace, add a row to the table above, and include the header where the image is drawn.

Hardware

Inputs

  • Three onboard buttons (WIO_KEY_A/B/C, pins 28/29/30). Physical left-to-right position does not match alphabetical pin naming — confirmed on-device: left = WIO_KEY_C, middle = WIO_KEY_B, right = WIO_KEY_A.
  • SparkFun Qwiic Twist rotary encoder, connected via Grove-to-Qwiic cable into the WIO Terminal's Grove I2C port (standard Wire, no special Qwiic-specific setup needed). Its INT pad is wired to BCM21 (40-pin header physical position 40) — confirmed working. Do not wire it to BCM2 (physical position 3): despite the Arduino pin table labeling it as a free, independent I2C bus, it shares a net at the PCB level with the Grove I2C bus and breaks the Twist's communication when wired, even before any new firmware is uploaded.
    • The Twist library never enables its own interrupt register (TWIST_ENABLE_INTS, 0x04) — setup() writes it directly over raw I2C (0x03, encoder + button interrupt bits) to get the INT line to assert at all.
    • twist.setIntTimeout(0) is set to avoid the default ~250ms coalescing delay on rotation events, for a responsive display.

Tip temperature sensing

Signal chain from the soldering tip's thermocouple to the ADC reading (see TipTemperature.h):

text
tip sensor (16uV/°C) -> PCB amplifier (gain 68000/150) -> ADC (12-bit, 3.3V ref, pin A3/BCM24/40-pin header pin 18)

Heater and power supply

  • The soldering iron's heating element measures ~2Ω and is rated 40W (implied design voltage ≈ 9–12V, not the 19V a laptop supply would suggest).
  • Power supply: 12V, 5A (not the originally-considered 19V/3A laptop brick, which was bench-tested and found both underpowered — couldn't supply the ~9.5A peak current the element draws at 19V without significant ripple — and would have driven the element to ~4.5x its rated power at full duty).
  • The reverse-polarity protection diode on the supply input is a Schottky diode (not silicon) — its lower forward voltage drop (~0.2–0.3V vs. ~0.7V) leaves more of the supply's voltage headroom for the heater.
  • PWM output pin: BCM23/A2.

⚠️ Safety note: the firmware cuts the heater when the tip goes above a fixed temperature limit (OVER_TEMPERATURE_LIMIT_C in src/safety/SafetyMonitor.h). The fault stays latched, shown on a separate fault screen, until the tip has cooled below the limit and the knob is pressed. It also faults when the heater runs at (near) full power without the tip heating up below 150C (ThermalRunaway, catches a shorted sensor within ~3s), or for 15s without a break at any temperature (HeaterSaturated). Every fault beeps twice. At the time of writing the firmware still has:

  • no sensor fault detection: a sensor that fails while the tip is hot is only caught by the 15s saturation check;
  • no power or duty cap;
  • no hardware watchdog.

These are tracked in issues #3, #4 and #7. Until they're implemented, do not leave the station heating unattended.

Front panel

A PCB used as the enclosure's front panel (black soldermask, white silkscreen), KiCad 10 project in hardware/frontpanel/. It carries the mains switch, the WIO Terminal (plugged into a 40-pin header on the front), the Qwiic Twist knob (on the back, plugged into a socket) and the XLR socket for the iron. All routing is on the back layer, so nothing shows through the soldermask on the front.

The board is generated by generate_frontpanel.py. To adapt it to your own enclosure and parts, edit the constants at the top of the script and run it with the Python interpreter that comes with KiCad 10:

text
<KiCad install dir>/bin/python generate_frontpanel.py

The main parameters (all in mm, from the top-left corner as seen from the front):

  • PANEL_W, PANEL_H, PANEL_THICKNESS, SLOT_DEPTH — panel size and how far it sits in the enclosure's slots.
  • SWITCH_X, WIO_X, KNOB_X, XLR_X — horizontal position of each part; everything is centred vertically. The connectors, tracks and silkscreen follow.
  • SWITCH_HOLE_D, ENCODER_HOLE_D, XLR_HOLE_D, XLR_SCREW_DX — cutouts for your particular parts.
  • BACK_CONN_POS, BACK_CONN_EXIT — where the connector to the iron PCB sits and which way its cable leaves.
  • CREDITS, REPO_URL — text and QR code on the back.

After regenerating, open the board in KiCad and run DRC. The script overwrites frontpanel.kicad_pcb, so either keep making changes in the script, or edit in KiCad and stop using the script.

The connector to the soldering iron PCB (J3, 4-pin JST-PH) — the iron PCB must use the same order:

PinSignalWIO
1TEMP (tip temperature, ADC)A3/BCM24
2GND
3HEATER PWMBCM23
45V (powers the WIO)

A second 4-pin JST-PH (J4) brings out three spare GPIOs (BCM7, BCM12, BCM16) and GND for debugging.

Things to watch out for:

  • The WIO's 40-pin header follows the Raspberry Pi pinout exactly. The pin table in the board's variant.h wrongly shows pin 17 as GND; it's 3.3V.
  • The Twist's encoder is on its bottom side, so seen from the front its pin row is mirrored relative to SparkFun's drawings.
  • The copper pours stay clear of the board edge and of the XLR and mains switch, so logic GND can't touch the earthed enclosure, the XLR chassis or mains.
  • The panel must fill the enclosure's slots (2.2 mm here). A 2.0 mm board costs about four times as much as a 1.0 or 1.6 mm one, so here two identical 1.0 mm boards are stacked (PANEL_THICKNESS = 1.0): the back one carries the parts, the front one only shows its front side, and the parts' screws clamp them together. The 40-pin header then goes through both boards — use one with pins long enough to solder on the back of the back board.
  • Have the fab leave its order number off the board (at JLCPCB: "Mark on PCB: Remove Mark", same price).

Remote control (LotusRPC)

The station is a LotusRPC server on its USB serial port. PC tools can simulate the knob and buttons, read the station's state, and receive the telemetry. The interface is defined in rpc/soldering_station.lrpc.yaml:

ServiceFunctions and streams
inputpress, rotate <steps>, button left|middle|right — the same events as the real knob and buttons, so they go through the same limits and fault handling. Like the knob, a press also acknowledges a fault and can switch the heater on.
statusstate, fault, setpoint, tip_temperature (measured and filtered), duty, and all for all of these in one call
telemetrystream samples: one sample every 100 ms while started (see below)

Code generation. The server code is generated during every PlatformIO build by tools/lrpc_generate.py (extra_scripts in platformio.ini), into the build directory; nothing generated is committed. The script installs the LotusRPC version pinned in tools/requirements.txt in a venv of its own (.pio/lrpc-venv, not PlatformIO's own Python, whose packages LotusRPC's pins could conflict with), and only regenerates when the definition or the pin changed. The generated soldering_station.hpp is included in the block before Arduino.h in main.cpp (see Known build gotchas).

lrpcc. lrpcc is LotusRPC's command-line client. It reads lrpcc.config.yaml, which is machine-specific and therefore git-ignored. Create it in the repo root, with the station's serial port:

yaml
definition_url: rpc/soldering_station.lrpc.yaml
transport_type: serial
transport_params:
  port: COM5
  timeout: 2

Run lrpcc from the repo root (it resolves definition_url against the working directory):

text
lrpcc input press
lrpcc input rotate 5
lrpcc input rotate -- -5
lrpcc input button left
lrpcc status state
lrpcc status tip_temperature
lrpcc status all

The serial port can only be open in one program at a time: lrpcc can't be used while the telemetry script runs.

Telemetry / PID tuning

tools/telemetry.py starts the telemetry service's samples stream and forwards each sample to Teleplot over UDP (port 47269, Teleplot's default) as name:value lines. Unlike over serial, there's no > in front: over UDP, Teleplot reads that as a log message.

text
python tools/telemetry.py [--port COM5]

Without --port it takes the port from lrpcc.config.yaml. Open Teleplot in VS Code (not connected to the serial port, which the script holds); it plots setpoint (0 while not On), measured, measuredFiltered, measuredAvg (2 s moving average, calculated by the script), duty, adcRaw and fault. Ctrl+C stops the stream. The station also stops it when the port is closed, so a killed script leaves nothing running.

tools/capture.py reads the same stream for a few seconds (--seconds, default 10) and prints a summary instead of plotting: min, max, mean and standard deviation of adc_raw and measured, the duty, the faults seen and the lowest raw values. With --csv <file> it also saves every sample (all telemetry fields) as it arrives, and Ctrl+C ends a capture early and still prints the summary. It's read-only, and meant for characterising the sensor input. It needs the serial port too, so close the telemetry script first.

TemperatureController's Kp/Ki/Kd gains are placeholders — this project has no characterized plant model (heater wattage, thermal mass, sensor lag), so they need on-device tuning: start with pure P, observe steady-state behavior, add Ki to remove steady-state error, and only add Kd afterward if overshoot still needs taming.

Parts

14
QtyValueFootprintReferences
8MountingHole_3.2mm_M3MountingHole_3.2mm_M3H3, H4, H5, H6, H7, H8, H9, H10
2JST_PH_S4B-PH-SM4-TB_1x04-1MP_P2.00mm_HorizontalJST_PH_S4B-PH-SM4-TB_1x04-1MP_P2.00mm_HorizontalJ3, J4
2MountingHole_2.2mm_M2MountingHole_2.2mm_M2H1, H2
1PinHeader_2x20_P2.54mm_VerticalPinHeader_2x20_P2.54mm_VerticalJ1
1PinSocket_1x06_P2.54mm_Vertical_SMD_Pin1LeftPinSocket_1x06_P2.54mm_Vertical_SMD_Pin1LeftJ2

Similar boards

  • 2 layers116.8 × 30 mmType d, the printed circuit board in 3D

    Type d

    google/mozc-devices

    Circuit diagrams and firmware source code for Gboard DIY keyboards

    14 parts3kApache-2.0
  • 2 layers32 × 22 mmDiff driver, the printed circuit board in 3D

    Diff driver

    rene-dev/stmbl

    AC Servo Driver for STM32F4

    14 parts990GPL-3.0
  • 2 layers34 × 45 mm2032Charger, the printed circuit board in 3D

    2032Charger

    hackclub/OnBoard

    💡 Join 1,000 teenagers and make your first PCB with a $100 grant!

    14 parts915
  • 2 layers34 × 109.9 mmTdisplay s3, the printed circuit board in 3D

    Tdisplay s3

    landonr/homeThing

    Wifi Smart Home Remotes that run on ESPHome

    14 parts551GPL-3.0
  • 2 layers45.3 × 42.7 mmMainPcb, the printed circuit board in 3D

    MainPcb

    adamb314/ServoProject

    Getting the most out of your hobby servo

    14 parts545
  • 2 layers42.5 × 28.8 mmC5VRX JACK DIY, the printed circuit board in 3D

    C5VRX JACK DIY

    Twotoz/C5VRX

    Ultra-minimal, zero-CPU 5.8 GHz analog FPV video receiver using ESP32-C5 Wi-Fi 6 PHY MODEM_DIAG, BitScrambler WBFM demodulation & resistor DAC CVBS

    14 parts515GPL-3.0
  • 2 layers62 × 24 mmMai button, the printed circuit board in 3D

    Mai button

    whowechina/mai_pico

    Pico controller for Maimai

    14 parts475

Questions

How big is the Frontpanel PCB?

It measures 253 × 60 mm and has 2 copper layers, 1 mm thick.

What parts does the Frontpanel use?

14 parts. The full list of its parts is on this page, with links to each part's symbol and footprint where PCBKit's library has them.

Where can I download the Frontpanel KiCad files?

From the tzijnge/SolderingStation repository on GitHub, at the commit this page was made from: the board is hardware/frontpanel/frontpanel.kicad_pcb. PCBKit opens the board in the browser, with nothing to install.

Can I use the Frontpanel design in my own project?

Its repository publishes it under the MIT licence: you may reuse it on that licence's terms (keep the author's notice, and for a copyleft licence share your changes alike).