
Type d
google/mozc-devices
Circuit diagrams and firmware source code for Gboard DIY keyboards

WIO Terminal adaptation of Elektor Platino soldering station
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.
WIO Terminal adaptation of the Elektor Platino soldering station
.vscode/extensions.json)
pio CLI, etc.) on first use — no separate Arduino IDE or ARM toolchain install neededpip install -r tools/requirements.txt (optional) — for the PC tools: remote control with lrpcc and the telemetry script, see Remote control (LotusRPC) belowatmelsam platform, board = seeed_wio_terminal, framework = arduino (see platformio.ini)Declared in platformio.ini under lib_deps, fetched automatically by PlatformIO on build:
#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.lib_deps entry: its server code is generated during the build, see Remote control (LotusRPC) belowBuild 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.
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.tft.setRotation(1) (not 3) for correct upright landscape orientation.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.
| SVG | Generated header | Used in |
|---|---|---|
assets/warning_sign.svg | src/images/WarningSign.h | src/safety/FaultScreen.h |
To change an image:
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.
Install the script's dependencies (only needed once):
pip install -r tools/requirements.txtRegenerate the header. The last argument is the C++ namespace the image gets:
python tools/svg_to_bitmap.py assets/warning_sign.svg src/images/WarningSign.h WarningSignThe script prints the image's size in bytes and how much the colour reduction (see below) changed it.
Build and upload as usual, and commit both the SVG and the regenerated header.
Things to know:
--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.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.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.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.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.
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.Signal chain from the soldering tip's thermocouple to the ADC reading (see TipTemperature.h):
tip sensor (16uV/°C) -> PCB amplifier (gain 68000/150) -> ADC (12-bit, 3.3V ref, pin A3/BCM24/40-pin header pin 18)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:
These are tracked in issues #3, #4 and #7. Until they're implemented, do not leave the station heating unattended.
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:
<KiCad install dir>/bin/python generate_frontpanel.pyThe 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:
| Pin | Signal | WIO |
|---|---|---|
| 1 | TEMP (tip temperature, ADC) | A3/BCM24 |
| 2 | GND | |
| 3 | HEATER PWM | BCM23 |
| 4 | 5V (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:
variant.h wrongly shows pin 17 as GND; it's 3.3V.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.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:
| Service | Functions and streams |
|---|---|
input | press, 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. |
status | state, fault, setpoint, tip_temperature (measured and filtered), duty, and all for all of these in one call |
telemetry | stream 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:
definition_url: rpc/soldering_station.lrpc.yaml
transport_type: serial
transport_params:
port: COM5
timeout: 2Run lrpcc from the repo root (it resolves definition_url against the working directory):
lrpcc input press
lrpcc input rotate 5
lrpcc input rotate -- -5
lrpcc input button left
lrpcc status state
lrpcc status tip_temperature
lrpcc status allThe serial port can only be open in one program at a time: lrpcc can't be used while the telemetry script runs.
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.
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.
| Qty | Value | Footprint | References |
|---|---|---|---|
| 8 | MountingHole_3.2mm_M3 | MountingHole_3.2mm_M3 | H3, H4, H5, H6, H7, H8, H9, H10 |
| 2 | JST_PH_S4B-PH-SM4-TB_1x04-1MP_P2.00mm_Horizontal | JST_PH_S4B-PH-SM4-TB_1x04-1MP_P2.00mm_Horizontal | J3, J4 |
| 2 | MountingHole_2.2mm_M2 | MountingHole_2.2mm_M2 | H1, H2 |
| 1 | PinHeader_2x20_P2.54mm_Vertical | PinHeader_2x20_P2.54mm_Vertical | J1 |
| 1 | PinSocket_1x06_P2.54mm_Vertical_SMD_Pin1Left | PinSocket_1x06_P2.54mm_Vertical_SMD_Pin1Left | J2 |

google/mozc-devices
Circuit diagrams and firmware source code for Gboard DIY keyboards


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



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


It measures 253 × 60 mm and has 2 copper layers, 1 mm thick.
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.
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.
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).