Project Overview

Inspired by drone swarms, this project aims to synchronize and control multiple Tesla coils through a master/slave architecture. The baseline hardware combines Pico 2, I2CEncoder, SPI OLED, SD, and SPI Ethernet (WIZnet). WIZnet was the natural choice; since the W6100 lacked MicroPython support, the prototype used W5500 + MicroPython, while the high-performance slave target was W6100 + C.

Key Features

WIZnet Ethernet: Provides low-latency and reliable UDP frame reception. Implemented in MicroPython (W5500) and C (W6100).

Flexible UI: Built on the MicroPython uMenu library (class-based, modular).

Scalable Slave System: Configuration stored in flash with group/offset addressing for individual or grouped slave control.

Hardware Setup

Pico 2 ↔ WIZnet(W5x00): SPI (SCK/MOSI/MISO), CS, RST. Follow board-specific power/ground guidelines.

Input/UI: I2CEncoders share interrupt lines; use mutex + asyncio to avoid race conditions.

Output: Hardware PWM is preferred. For noise, apply low-pass filter + resistor.

Software Implementation

Core Functionality (MicroPython, W5500 Example)

# MicroPython UDP Slave (W5500)
import machine, network, socket, struct

spi = machine.SPI(0, baudrate=20_000_000, polarity=0, phase=0)
cs  = machine.Pin(17, machine.Pin.OUT)
rst = machine.Pin(20, machine.Pin.OUT)
nic = network.WIZNET5K(spi, cs, rst)
nic.active(True)

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind(('0.0.0.0', 5005))

pwm = machine.PWM(machine.Pin(2))
pwm.duty_u16(0)

while True:
    data, addr = sock.recvfrom(12)
    ch, freq, duty = struct.unpack('>III', data)
    pwm.freq(freq if 1 <= freq <= 200000 else 1000)
    pwm.duty_u16(duty if 0 <= duty <= 65535 else 0)

MicroPython → C Migration

When moving to W6100, implement UDP listener + PWM updates in C with Pico SDK and WIZnet libraries for higher performance and flash persistence.

Network Architecture

Master: Generates control frames (interrupter, MIDI, etc.) and transmits via UDP.

Slaves: Receive UDP packets and update PWM outputs. Addressing supports both individual and group commands.

Performance Results

MIDI Handling: MicroPython on a single core struggled; dual-core execution required.

Output Quality: Hardware PWM proved most stable; spikes/pops reduced with low-pass filters and resistors.

Language Comparison: CircuitPython too slow, MicroPython (W5500) worked for prototypes, C (W6100) offered best scalability.

Demo: 8-channel controller successfully played “Footloose”, with RGB ring LEDs functioning as VU meters.

Lessons Learned

Multi-I2C devices require mutexes and lightweight interrupt callbacks (heavy work deferred to asyncio tasks).

Wired UDP + WIZnet delivered the required low latency and reliability for swarm control.

Future Improvements

Full transition to W6100-based slaves; possible MicroPython integration if support matures.

Standardized multicast/group control protocol, explore time synchronization (NTP/PTP), and add OTA firmware updates/logging.

Improve EMI/ESD hardening near high-voltage Tesla coils with shielding, grounding, and filtering.

Challenges & Solutions

I2CEncoder concurrency issues → solved with mutex + asynchronous design.

Performance/language trade-offs → W5500+MicroPython succeeded initially; C on W6100 required for higher performance.

Output spikes → mitigated with filter/resistors; further refinement planned in future updates.

DOCUMENTS

Code
Name: uMenu (MicroPython menu library)
Link: https://github.com/plugowski/umenu
Comment: Class-based UI library used for the project.

Others
Name: Project Article – Part 2
Link: https://teslauniverse.com/tesla-universe-news/tesla-swarm-controller-part-2-getting-net-work
Comment: Detailed description of networking, slaves, and language choices.

Others
Name: Tesla Swarm Controller – Gallery
Link: https://teslauniverse.com/tesla-news/galleries/tesla-swarm-controller
Comment: Photos of development and testing.