A failed processor should not force you to unwire an entire machine-control board. That idea helped shape JetFlight Adaptor V2: a replaceable ESP32-S3 core with built-in Ethernet, using the familiar Arduino Uno footprint.
We intend to use this common core across the JetFlight ecosystem, leaving machine-specific interfaces and field wiring on the carrier. It also has potential beyond motion control as a programmable Ethernet development board.
On November 17, 2026, JetFlight Adaptor V2 made its first cut on our shop plasma rig, with arc-voltage reading for AVTHC confirmed. The four-layer board has progressed from initial bring-up and its intended 1 kHz Ethernet bench test to real machine operation. Here is why we built it this way.
Figure 1. The first V2 board during November 16 bring-up. This is actual hardware, not a render.
Why the Arduino Uno footprint?
The Uno layout gives us more than a convenient board outline. Its header arrangement is familiar, it provides a foundation for our own carriers, and it connects the adaptor to an existing shield ecosystem.
Think of it as an ESP32-S3-based ESPDuino-style board with Ethernet integrated. Some existing shields can work directly when their pin assignments, power, logic levels and software requirements match. The footprint does not make every Uno shield compatible, particularly those expecting 5 V-tolerant I/O.
That combination—familiar connections, a capable processor and onboard wired networking—is useful whether the board runs our motion firmware or somebody’s custom application.
Replace the core, keep the wiring
The adaptor carries the processor, memory and communications. A machine-specific carrier provides the appropriate electrical interfaces and field connections.
For a failure confined to the adaptor, the intended repair is straightforward: power down, exchange the module, restore the correct firmware and machine configuration, and verify operation. The carrier’s field wiring stays connected. A failed MCU or memory device need not turn the whole wired assembly into a replacement job.
This is not a cure for every fault: the carrier, power supply and external interfaces must still be healthy. Corrupted firmware may only need reflashing. But separating the common core from the machine interface gives us a more practical unit to diagnose, stock and replace.
Low manufacturing cost at quantity is part of that goal. We want keeping a spare core to be practical, although final pricing is not established. The first machine cut validates operation; it is not a field-replacement test.
What runs where
JetFlight separates host-side motion planning from timing-critical work at the machine. The computer parses the program, plans trajectories and sends targets; board firmware generates step pulses and handles time-sensitive signals. The desktop operating system is not responsible for individual pulse edges.
In JetFlight, Ethernet carries the heartbeat. USB is for programming, diagnostics and recovery; those interface roles were established before this hardware was built.
The V2 board brings together:
- ESP32-S3-WROOM-1-N8R2: 8 MB flash and 2 MB PSRAM. The exact variant matters because its memory arrangement leaves the GPIO used by this design available.
- W5500 Ethernet: a 10/100 network interface connected to the ESP32 over SPI.
- USB-C through a CP2102N: a programming, serial diagnostic and recovery path independent of working Ethernet firmware.
The adaptor is not a complete breakout board, motor drive or safety system. Signal conditioning and machine-specific connections belong to the carrier; buffering, synchronization and failure handling remain responsibilities of the complete control system.
Figure 2. Functional boundaries, not a complete wiring diagram. The host-to-adaptor bench measurements and the later machine-cut validation are separate milestones.
The JetFlight architecture guide covers that host/controller split in more detail.
Built in our own eCAD
V1 was a hands-on KiCad design drawn and routed by Travis, with an agent reviewing the work. It later supported real plasma cutting.
For V2, we moved implementation into JetCad3’s eCAD workspace. We set the requirements, architecture and interfaces; an agent carried out schematic and PCB work under our direction and review, including placement, routing and silkscreen preparation. The earlier design provided a reference—it was not an unattended design from a single prompt.
That made the adaptor a practical test of our own tools. The saved JC3 project had to carry the design through to native Gerber, drill, BOM and placement output, not stop at an attractive layout.
Independent manufacturing-file checks caught a problem before fabrication. We corrected the exporter and regenerated the files from the saved project instead of hand-patching the output. The useful outcome was both a manufacturable board and an improved workflow for the next project.
Figure 3. A later inspection of the saved board snapshot associated with the order. It is evidence of the design, not a recording of the original design session.
Meeting the 1 kHz design target
We chose a 1 kHz heartbeat—a one-millisecond update period for JetFlight’s closed-loop control. The aim is efficient control with low following error, including on fast machines. This was the design target from the outset.
Initial bring-up established programming and reset behavior, the expected status indication, and a 1 MiB PSRAM write/read test with zero mismatches. We then connected the board to the real JetFlight runtime over Ethernet to check the intended heartbeat rate.
The board met the 1 kHz bench criterion: all 2,000 requests received replies, with a 99th-percentile round-trip time of 0.707 ms, below the one-millisecond update period. The paced stage was nominally two seconds, followed by a 100 ms receive grace period.
This was a transport check using zero-target heartbeat traffic, with no machine connected. It remains a transport measurement, not a measurement of loaded-machine following error.
First machine cut — November 17, 2026
Installed on a StrikeCommand breakout board, the V2 adaptor completed its first plasma cut on our shop rig. We confirmed machine operation and arc-voltage reading for AVTHC (arc-voltage torch-height control). The V2 hardware is now validated in this Ethernet-connected machine setup.
One operating combination remains to investigate: when powered through USB and the host breakout board simultaneously, the firmware reboots periodically. The cause has not been investigated, and a possible firmware workaround remains untested. Ethernet is the primary machine connection; USB is intended for initial bring-up, programming and diagnostics. This dual-power observation does not change the successful Ethernet-connected cutting result, but it remains an open item.
A development board beyond JetFlight
The adaptor can already be programmed with Arduino IDE or PlatformIO for custom firmware. We are considering offering it as a general-purpose development board, alongside a proposed open-source JetFlight Adaptor Library for convenient Ethernet access and consistent I/O names.
That would let builders use the hardware for their own applications without adopting our motion-control software. JetFlight’s motion-control firmware remains proprietary and closed-source. The helper library is not released yet, and this article is not a release of the board’s complete manufacturing files.
From board to machine
The first V2 cut completes the path from our own eCAD workspace, through manufactured hardware and bench checks, to a working plasma machine. It also puts the common-core architecture to work: a familiar, programmable Ethernet module paired with the machine’s existing interface board.
We will investigate the dual-power behavior and continue building experience with the hardware. The development-board offering and open-source helper library remain under consideration.
If you build CNC controls or embedded systems, what would you use a replaceable Uno-footprint Ethernet core for?