ESP32_Host_MIDI

English

The universal MIDI hub for ESP32 — 9 transports, one API.

ESP32_Host_MIDI turns your ESP32 into a full-featured, multi-protocol MIDI hub. Connect a USB keyboard, receive notes from an iPhone via Bluetooth, bridge your DAW over WiFi with RTP-MIDI (Apple MIDI), control Max/MSP via OSC, reach 40-year-old synths through a DIN-5 serial cable, and link multiple ESP32 boards wirelessly with ESP-NOW — all simultaneously, all through the same clean event API.

#include <ESP32_Host_MIDI.h>

void setup() { midiHandler.begin(); }

void loop() {
    midiHandler.task();
    for (const auto& ev : midiHandler.getQueue()) {
        char noteBuf[8];
        Serial.printf("%-12s %-4s ch=%d  vel=%d\n",
            MIDIHandler::statusName(ev.statusCode),
            MIDIHandler::noteWithOctave(ev.noteNumber, noteBuf, sizeof(noteBuf)),
            ev.channel0 + 1, ev.velocity7);
    }
}

What can you build?

A partial list. Every combination of transports opens a new instrument, tool, or installation.

Wireless MIDI interfaces

USB keyboard → ESP32 → WiFi → macOS (Logic Pro / GarageBand) — no drivers, no cables to the Mac
iPhone / iPad BLE app → ESP32 → USB MIDI Device → DAW port — iOS apps become studio controllers
ESP32 presents itself as a USB MIDI Class Compliant interface — plug into any computer, it just works

Custom hardware instruments

Effects pedal board — ESP32 sends Program Change / CC messages to a Daisy Seed or hardware multi-effects unit; display shows preset name and bank
MIDI drum pad — piezo sensors on ADC inputs → velocity-sensitive MIDI notes → USB or BLE
Custom synthesizer — ESP32 receives MIDI and controls an external DAC + VCO/VCA analog circuit, or triggers a Daisy Seed running a synth engine
MIDI controller — encoders, faders, buttons, touchpads → USB MIDI Device → any DAW
MIDI to CV converter — ESP32 + external DAC (MCP4728, MCP4921) → 0–5 V CV / gate for Eurorack and analog synths
Wireless expression pedal — foot controller with ESP-NOW → central ESP32 hub → CC messages
Smart metronome / clock — generates MIDI Clock at precise BPM, sent simultaneously over USB, BLE, DIN-5, and WiFi
Theremin with MIDI output — ultrasonic sensors or capacitive touch → pitch + volume → MIDI notes
MIDI accordion or wind controller — pressure sensors + buttons → ESP32 → BLE → iPad instrument

Bridges and routers

DIN-5 vintage synth → ESP32 → USB Device → modern DAW — zero-driver adapter
Wireless stage rig: ESP-NOW mesh of performers → single USB output to FOH computer Creative software integration
Max/MSP / Pure Data / SuperCollider ↔ ESP32 over OSC — bidirectional, address-mapped
TouchOSC tablet → ESP32 → DIN-5 hardware synth — touchscreen for vintage gear
Algorithmic composition in Max → OSC → ESP32 → BLE → iOS instrument app

Monitoring and education

Live piano roll: keys lit as you play, scrollable view on a 1.9" display
Real-time chord detection: plays a chord, see its name instantly ("Cmaj7", "Dm7♭5")
MIDI event logger with timestamps, channel, velocity, and chord grouping

Transport Matrix

Transport	Protocol	Physical	Latency	Requires
USB Host	USB MIDI 1.0	USB-OTG cable	< 1 ms	ESP32-S3 / S2 / P4
USB Host MIDI 2.0	USB MIDI 2.0 (UMP)	USB-OTG cable	< 1 ms	ESP32-S3 / S2 / P4
BLE MIDI	BLE MIDI 1.0	Bluetooth LE	3–15 ms	Any ESP32 with BT
USB Device	USB MIDI 1.0	USB-OTG cable	< 1 ms	ESP32-S3 / S2 / P4
ESP-NOW MIDI	ESP-NOW	2.4 GHz radio	1–5 ms	Any ESP32
RTP-MIDI (WiFi)	AppleMIDI / RFC 6295	WiFi UDP	5–20 ms	Any ESP32 with WiFi
Ethernet MIDI	AppleMIDI / RFC 6295	Wired (W5x00 / native)	2–10 ms	W5500 SPI or ESP32-P4
OSC	Open Sound Control	WiFi UDP	5–15 ms	Any ESP32 with WiFi
UART / DIN-5	Serial MIDI 1.0	DIN-5 connector	< 1 ms	Any ESP32

All transports share a single MIDIHandler event queue and the same send API. Mix and match at will.

Quick Start

#include <ESP32_Host_MIDI.h>
// Arduino IDE: Tools > USB Mode → "USB Host"

void setup() {
    Serial.begin(115200);
    midiHandler.begin();
}

void loop() {
    midiHandler.task();
    for (const auto& ev : midiHandler.getQueue()) {
        char noteBuf[8];
        Serial.println(MIDIHandler::noteWithOctave(ev.noteNumber, noteBuf, sizeof(noteBuf)));
    }
}

Access individual fields:

for (const auto& ev : midiHandler.getQueue()) {
    ev.statusCode;   // MIDI_NOTE_ON | MIDI_NOTE_OFF | MIDI_CONTROL_CHANGE | ...
    ev.channel0;     // 0–15 (MIDI spec)
    ev.noteNumber;   // MIDI note number (0–127)
    ev.velocity7;    // 0–127 (MIDI 1.0)
    ev.velocity16;   // 0–65535 (MIDI 2.0, scaled)
    ev.pitchBend14;  // 0–16383 (center = 8192)
    ev.pitchBend32;  // 0–0xFFFFFFFF (MIDI 2.0, center = 0x80000000)
    ev.chordIndex;   // groups simultaneous notes
    ev.timestamp;    // millis() at arrival

    // Static helpers (zero allocation):
    MIDIHandler::noteName(ev.noteNumber);       // "C", "C#", "D" ...
    MIDIHandler::noteOctave(ev.noteNumber);     // -1 to 9
    MIDIHandler::statusName(ev.statusCode);     // "NoteOn", "ControlChange" ...
}

Gallery

RTP-MIDI / Apple MIDI connecting to macOS · 25-key scrolling piano roll

25-key scrolling piano roll · Real-time chord name (Gingoduino) · Event queue debug

BLE Receiver (iPhone → ESP32) · BLE Sender · Piano debug view

Videos — each example folder contains an .mp4 demo inside examples/<name>/images/.

Architecture

╔══════════════════════════════════════════════════════════════════════╗
║  INPUTS                          MIDIHandler             OUTPUTS    ║
║                                                                      ║
║  USB keyboard ──[USBConnection]────►  ┌──────────────┐              ║
║  USB MIDI 2.0 ──[USBMIDI2Conn]────►  │              │              ║
║  iPhone BLE   ──[BLEConnection]────►  │              │              ║
║  macOS WiFi   ──[RTPMIDIConn.]─────►  │  Event Queue │──► getQueue()║
║  DAW USB out  ──[USBDeviceConn]────►  │  (ring buf,  │              ║
║  Max/MSP OSC  ──[OSCConnection]────►  │  thread-safe)│──► Active    ║
║  W5500 LAN    ──[EthernetMIDI]─────►  │              │    notes     ║
║  DIN-5 serial ──[UARTConnection]───►  │  Chord       │              ║
║  ESP32 radio  ──[ESPNowConn.]──────►  └──────┬───────┘──► Chord     ║
║                                              │            names     ║
║                                              │                      ║
║                                              ▼                      ║
║                                     sendMidiMessage()               ║
║                                  (broadcasts to ALL transports)     ║
╚══════════════════════════════════════════════════════════════════════╝

Core 0 — USB Host task, BLE stack, radio / network drivers (FreeRTOS tasks) Core 1 — midiHandler.task() + your loop() code Thread safety — ring buffers + portMUX spinlocks on every transport

Every transport implements the same MIDITransport abstract interface. Adding a new transport is one line: midiHandler.addTransport(&myTransport).

Transports

USB Host (OTG)

Connects any class-compliant USB MIDI device — keyboards, pads, interfaces, drum machines, controllers — directly to the ESP32's USB-OTG port. No hub, no driver, no OS configuration.

Boards: ESP32-S3, ESP32-S2, ESP32-P4 · Arduino IDE: Tools > USB Mode → "USB Host"

#include <ESP32_Host_MIDI.h>
void setup() { midiHandler.begin(); }

Examples: T-Display-S3, T-Display-S3-Queue, T-Display-S3-Piano, T-Display-S3-Gingoduino

MIDI 2.0: Use USBMIDI2Connection for native USB MIDI 2.0 with UMP. See the MIDI 2.0 section below.

BLE MIDI

The ESP32 advertises as a BLE MIDI 1.0 peripheral. macOS (Audio MIDI Setup → Bluetooth), iOS (GarageBand, AUM, Loopy, Moog), and Android connect without any pairing ritual. Also supports Central (scanner) mode to connect to another BLE MIDI device.

Boards: Any ESP32 with Bluetooth · Range: ~30 m · Latency: 3–15 ms

#include <ESP32_Host_MIDI.h>
void setup() { midiHandler.begin(); }  // BLE advertises automatically

Examples: T-Display-S3-BLE-Sender, T-Display-S3-BLE-Receiver

USB Device

The ESP32-S3 presents itself as a class-compliant USB MIDI interface to the host computer. macOS, Windows, and Linux recognise it instantly — no driver. Acts as a transparent bridge: any MIDI from BLE, WiFi, UART, or ESP-NOW is forwarded to the DAW via USB, and vice versa.

Boards: ESP32-S3, ESP32-S2, ESP32-P4 · Arduino IDE: Tools > USB Mode → "USB-OTG (TinyUSB)"

Cannot coexist with USB Host — both use the OTG port.

#include "src/USBDeviceConnection.h"

USBDeviceConnection usbMIDI("ESP32 MIDI");   // name shown in DAW MIDI port list

void setup() {
    midiHandler.addTransport(&usbMIDI);
    usbMIDI.begin();
    midiHandler.begin();
}

Examples: USB-Device-MIDI, T-Display-S3-USB-Device

ESP-NOW MIDI

Ultra-low-latency (~1–5 ms) wireless MIDI between ESP32 boards via Espressif's proprietary peer-to-peer radio. No WiFi router, no handshake, no pairing. Broadcast mode (all boards receive everyone's notes) or unicast.

Boards: Any ESP32 · Range: ~200 m open air · Infrastructure: none

#include "src/ESPNowConnection.h"

ESPNowConnection espNow;

void setup() {
    espNow.begin();
    midiHandler.addTransport(&espNow);
    midiHandler.begin();
}

Examples: ESP-NOW-MIDI, T-Display-S3-ESP-NOW-Jam

RTP-MIDI / Apple MIDI

Implements Apple MIDI (RTP-MIDI, RFC 6295) over WiFi UDP. macOS and iOS discover the ESP32 automatically via mDNS Bonjour — it appears in Audio MIDI Setup → Network with no manual configuration. Compatible with Logic Pro, GarageBand, Ableton, and any CoreMIDI app.

Requires: lathoub/Arduino-AppleMIDI-Library v3.x

#include <WiFi.h>
#include "src/RTPMIDIConnection.h"

RTPMIDIConnection rtpMIDI;

void setup() {
    WiFi.begin("YourSSID", "YourPassword");
    while (WiFi.status() != WL_CONNECTED) delay(500);
    midiHandler.addTransport(&rtpMIDI);
    rtpMIDI.begin();
    midiHandler.begin();
}

Examples: RTP-MIDI-WiFi

Ethernet MIDI

Same RTP-MIDI / AppleMIDI protocol over a wired W5x00 SPI Ethernet module or ESP32-P4 native Ethernet MAC. Lower and more consistent latency than WiFi. Ideal for studio racks and live venues with managed networks.

Requires: lathoub/Arduino-AppleMIDI-Library v3.x + Arduino Ethernet library

#include <SPI.h>
#include "src/EthernetMIDIConnection.h"

EthernetMIDIConnection ethMIDI;
static const uint8_t MAC[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

void setup() {
    midiHandler.addTransport(&ethMIDI);
    ethMIDI.begin(MAC);   // DHCP — pass a static IPAddress as second arg for fixed IP
    midiHandler.begin();
}

Examples: Ethernet-MIDI

OSC

Bidirectional OSC ↔ MIDI bridge over WiFi UDP. Receives OSC messages from Max/MSP, Pure Data, SuperCollider, and TouchOSC and converts them to MIDI events — and sends every MIDI event out as an OSC message.

Address map: /midi/noteon, /midi/noteoff, /midi/cc, /midi/pc, /midi/pitchbend, /midi/aftertouch

Requires: CNMAT/OSC library

#include <WiFi.h>
#include "src/OSCConnection.h"

OSCConnection oscMIDI;

void setup() {
    WiFi.begin("YourSSID", "YourPassword");
    while (WiFi.status() != WL_CONNECTED) delay(500);
    midiHandler.addTransport(&oscMIDI);
    oscMIDI.begin(8000, IPAddress(192, 168, 1, 100), 9000);
    midiHandler.begin();
}

Examples: OSC-MIDI-WiFi, T-Display-S3-OSC

UART / DIN-5

Standard MIDI serial (31250 baud, 8N1) for connecting vintage hardware — synthesizers, drum machines, mixers, sequencers, anything with a DIN-5 connector. Supports running status, real-time messages (Clock, Start, Stop), and multiple simultaneous UART ports (ESP32-P4 has five hardware UARTs).

Hardware: TX → DIN-5 pin 5 via 220 Ω; PC-900V / 6N138 optocoupler on RX → DIN-5 pin 4

#include "src/UARTConnection.h"

UARTConnection uartMIDI;

void setup() {
    uartMIDI.begin(Serial1, /*RX=*/16, /*TX=*/17);
    midiHandler.addTransport(&uartMIDI);
    midiHandler.begin();
}

Examples: UART-MIDI-Basic, P4-Dual-UART-MIDI

USB Host MIDI 2.0

Native USB MIDI 2.0/UMP support with automatic protocol negotiation. USBMIDI2Connection extends USBConnection — scans the device's configuration descriptor for both Alt 0 (MIDI 1.0) and Alt 1 (MIDI 2.0), preferring MIDI 2.0 when available. Falls back to MIDI 1.0 transparently.

After selecting MIDI 2.0, performs the mandatory UMP Endpoint Discovery and Protocol Negotiation sequence. Raw UMP words (32-bit) are delivered via callback — no conversion to MIDI 1.0.

#include "src/USBMIDI2Connection.h"

USBMIDI2Connection usb;

void onUMP(void*, const uint32_t* words, uint8_t count) {
    // Raw UMP words — MIDI 2.0 native resolution
}

void setup() {
    usb.setUMPCallback(onUMP, nullptr);
    usb.setMidiCallback(onMidi, nullptr);  // MIDI 1.0 fallback
    midiHandler.addTransport(&usb);
    midiHandler.begin();
}

Query device capabilities after negotiation:

if (usb.isMIDI2() && usb.isNegotiated()) {
    auto& ep = usb.getEndpointInfo();
    Serial.printf("UMP v%d.%d, %d function blocks\n",
        ep.umpVersionMajor, ep.umpVersionMinor, ep.numFunctionBlocks);
}

Boards: ESP32-S3, ESP32-S2, ESP32-P4 · Examples: T-Display-S3-AMoled-MIDI2-UMP

Bridge Use Cases

Any MIDI arriving on any transport is automatically forwarded to all others — no extra code.

Bridge	Diagram
Wireless keyboard → DAW	iPhone BLE → ESP32 → USB Device → Logic Pro
USB keyboard → WiFi	USB keyboard → ESP32 → RTP-MIDI → macOS
Legacy to modern	DIN-5 synth → ESP32 → USB Device → any DAW
Modern to legacy	macOS → RTP-MIDI → ESP32 → DIN-5 → 1980s drum machine
Wireless stage mesh	ESP-NOW nodes → ESP32 hub → USB → FOH computer
Creative software	Max/MSP OSC → ESP32 → BLE → iPad instrument app

Full hub — receive everything, send everywhere:

USB keyboard ─┐
iPhone BLE   ─┤
macOS RTP   ──┼──► MIDIHandler ──► USB Device (DAW)
DIN-5 synth ─┤               ──► BLE (iOS app)
TouchOSC    ─┤               ──► DIN-5 (drum machine)
ESP-NOW     ─┘               ──► ESP-NOW (stage nodes)

Hardware Ecosystem

ESP32_Host_MIDI acts as the MIDI brain and protocol hub. It connects and communicates with a broad ecosystem of boards and devices.

Boards you can connect to the ESP32

Board	Connection	Use case
Daisy Seed (Electro-Smith)	UART / DIN-5 or USB	DSP audio synthesis engine; ESP32 sends MIDI, Daisy plays notes
Teensy 4.x (PJRC)	UART serial or USB Host	Complex MIDI routing or synthesis; excellent USB MIDI native support
Arduino UNO / MEGA / Nano	UART serial (DIN-5)	Classic MIDI projects; ESP32 is the wireless gateway
Raspberry Pi	RTP-MIDI, OSC, or USB	DAW host, audio processing, generative composition
Eurorack / modular synths	MIDI DIN-5 → CV/gate interface	Pitch CV, gate, velocity → analogue voltage via converter module
Hardware synthesizers	DIN-5	Any keyboard, rack synth, or effects unit with MIDI In/Out/Thru
iPad / iPhone	BLE MIDI	GarageBand, AUM, Moog apps, NLog, Animoog — all CoreMIDI-compatible
Computer DAW	USB Device or RTP-MIDI	Logic Pro, Ableton, Bitwig, FL Studio, Reaper, Pro Tools

Daisy Seed + ESP32 is a particularly powerful combination: the ESP32 handles all MIDI connectivity (USB, BLE, WiFi, DIN-5) and the Daisy Seed processes audio in real time at 48 kHz / 24-bit with its ARM Cortex-M7 DSP. They talk over a single UART/DIN-5 cable.

Teensy 4.1 can run complex MIDI logic, arpeggiators, chord voicers, or sequencers, while ESP32 handles wireless transport — each board doing what it does best.

Hardware projects you can build

┌─────────────────────────────────────────────────────────────────────┐
│  PROJECT               │  COMPONENTS                                 │
├─────────────────────────────────────────────────────────────────────┤
│  Wireless MIDI pedal   │  ESP32 + buttons + enclosure → ESP-NOW     │
│  board                 │  → central hub → DIN-5 / USB to amp rack   │
├─────────────────────────────────────────────────────────────────────┤
│  MIDI drum pad         │  ESP32 + piezo sensors + ADC → velocity-   │
│                        │  sensitive MIDI notes over USB or BLE       │
├─────────────────────────────────────────────────────────────────────┤
│  Synthesizer           │  ESP32 + Daisy Seed: ESP32 bridges all     │
│                        │  MIDI protocols, Daisy generates audio      │
├─────────────────────────────────────────────────────────────────────┤
│  MIDI to CV converter  │  ESP32 + MCP4728 DAC → 0–5 V pitch CV +   │
│                        │  gate for Eurorack / analogue synths        │
├─────────────────────────────────────────────────────────────────────┤
│  Custom MIDI           │  ESP32-S3 + encoders + faders + OLED →     │
│  controller            │  USB MIDI Device recognized by any DAW      │
├─────────────────────────────────────────────────────────────────────┤
│  Piano learning aid    │  ESP32 + RGB LEDs on piano keys + display  │
│                        │  → lights the correct key for each note     │
├─────────────────────────────────────────────────────────────────────┤
│  Wireless expression   │  ESP32 + FSR / potentiometer in foot       │
│  pedal                 │  enclosure → CC messages via ESP-NOW        │
├─────────────────────────────────────────────────────────────────────┤
│  MIDI arpeggiator /    │  ESP32 receives chords, generates          │
│  sequencer             │  arpeggiated patterns, sends to DIN-5       │
├─────────────────────────────────────────────────────────────────────┤
│  Theremin / air synth  │  Ultrasonic sensors → pitch + volume →     │
│                        │  MIDI notes via BLE or USB                  │
├─────────────────────────────────────────────────────────────────────┤
│  Interactive art       │  Motion / proximity / touch sensors →      │
│  installation          │  MIDI → generative music / light control    │
└─────────────────────────────────────────────────────────────────────┘

Display Examples (T-Display-S3)

The LilyGO T-Display-S3 has a 1.9" 170×320 ST7789 display + ESP32-S3. These examples show a live MIDI dashboard in landscape mode (320×170 after setRotation(2)).

Example	Transport	What the display shows
`T-Display-S3`	USB Host	Active notes + event log
`T-Display-S3-Queue`	USB Host	Full event queue debug view
`T-Display-S3-Piano`	USB Host	25-key scrollable piano roll
`T-Display-S3-Piano-Debug`	USB Host	Piano roll + extended debug info
`T-Display-S3-Gingoduino`	USB Host + BLE	Chord names (music theory engine)
`T-Display-S3-BLE-Sender`	BLE	Send mode status + event log
`T-Display-S3-BLE-Receiver`	BLE	Receive mode + note log
`T-Display-S3-ESP-NOW-Jam`	ESP-NOW	Peer status + jam events
`T-Display-S3-OSC`	OSC + WiFi	WiFi status + OSC bridge log
`T-Display-S3-USB-Device`	BLE + USB Device	Dual status + bridge log

Gingoduino — Music Theory on Embedded Systems

Gingoduino is a music theory library for embedded systems — the same engine that powers the T-Display-S3-Gingoduino example. When integrated via GingoAdapter.h, it listens to the same MIDI event stream and continuously analyses the active notes to produce:

Chord name — "Cmaj7", "Dm7♭5", "G7", "Am" with extensions and alterations
Root note — identified root pitch of the chord
Active note set — structured list of currently pressed notes
Interval analysis — intervals between notes (M3, m7, P5, etc.)
Scale matching — identifies likely scale (major, minor, modes)

Everything runs on-device at interrupt speed — no cloud, no network, no latency.

#include "src/GingoAdapter.h"  // requires Gingoduino ≥ v0.2.2

void loop() {
    midiHandler.task();

    // Chord name updates automatically as notes arrive and are released:
    std::string chord = gingoAdapter.getChordName();  // "Cmaj7", "Dm", "G7sus4" …
    std::string root  = gingoAdapter.getRootNote();    // "C", "D", "G" …

    display.setChord(chord.c_str());
}

T-Display-S3-Gingoduino: chord name, root note, and active keys updated in real time

→ github.com/sauloverissimo/gingoduino

Gingo — Music Theory for Python and Desktop

Gingo is the desktop and Python counterpart of Gingoduino — the same music theory concepts ported to Python for use in scripts, DAW integrations, MIDI processors, composition tools, and web apps.

Use it to:

Analyse MIDI files and extract chord progressions
Build Python MIDI processors that recognise chords on the fly
Create web applications with real-time music theory annotation
Prototype music theory algorithms before porting them to Gingoduino
Generate chord charts, lead sheets, and educational exercises

from gingo import Gingo

g = Gingo()
chord = g.identify([60, 64, 67, 71])   # C E G B
print(chord.name)   # "Cmaj7"
print(chord.root)   # "C"

→ github.com/sauloverissimo/gingo → sauloverissimo.github.io/gingo

ESP32 + Gingo workflow: prototype music theory algorithms in Python with Gingo → port the logic to Gingoduino on ESP32 → display chord names live on T-Display-S3.

Hardware Compatibility

Chip → available transports

Chip	USB Host	BLE	USB Device	WiFi	Ethernet (native)	UART	ESP-NOW
ESP32-S3	✅	✅	✅	✅	❌ (W5500 SPI)	✅	✅
ESP32-S2	✅	❌	✅	✅	❌ (W5500 SPI)	✅	❌
ESP32-P4	✅	❌	✅	❌	✅	✅ ×5	❌
ESP32 (classic)	❌	✅	❌	✅	❌ (W5500 SPI)	✅	✅
ESP32-C3 / C6 / H2	❌	✅	❌	✅	❌	✅	✅

W5500 SPI Ethernet works on any ESP32 via EthernetMIDIConnection.

Recommended boards

Use case	Board
Best all-round (USB Host + BLE + WiFi + display)	LilyGO T-Display-S3
Full USB Host + USB Device + BLE	Any ESP32-S3 DevKit
Ultra-low-latency wireless stage mesh	ESP32 DevKit (ESP-NOW)
Wired studio rack	ESP32-P4 native Ethernet or any ESP32 + W5500
DIN-5 MIDI gateway	Any ESP32 + UART optocoupler

Installation

Arduino IDE: Sketch → Include Library → Manage Libraries → search ESP32_Host_MIDI

PlatformIO:

[env:esp32-s3-devkitc-1]
platform = espressif32
board    = esp32-s3-devkitc-1
framework = arduino

lib_deps =
    sauloverissimo/ESP32_Host_MIDI
    # lathoub/Arduino-AppleMIDI-Library  ; RTP-MIDI + Ethernet MIDI
    # arduino-libraries/Ethernet          ; Ethernet MIDI
    # CNMAT/OSC                           ; OSC
    # sauloverissimo/gingoduino           ; Chord names

Board package: Tools > Boards Manager → "esp32" by Espressif → ≥ 3.0.0 USB Host and USB Device require arduino-esp32 ≥ 3.0 (TinyUSB MIDI).

Transport	Required library
RTP-MIDI / Ethernet MIDI	`lathoub/Arduino-AppleMIDI-Library`
Ethernet MIDI	`arduino-libraries/Ethernet`
OSC	`CNMAT/OSC`
Chord names	`sauloverissimo/gingoduino`
USB Host / Device / BLE / ESP-NOW	Built into arduino-esp32

API Reference

// Setup
midiHandler.begin();               // start built-in transports (USB, BLE, ESP-NOW)
midiHandler.begin(cfg);            // with custom config
midiHandler.addTransport(&t);      // register external transport

// Receive
const auto& q = midiHandler.getQueue();                        // event ring buffer
std::vector<std::string> n = midiHandler.getActiveNotesVector(); // ["C4","E4","G4"]
std::string chord = midiHandler.getChordName();                 // "Cmaj7"

// Send (broadcasts to ALL transports simultaneously)
midiHandler.sendNoteOn(ch, note, vel);
midiHandler.sendNoteOff(ch, note, vel);
midiHandler.sendControlChange(ch, ctrl, val);
midiHandler.sendProgramChange(ch, prog);
midiHandler.sendPitchBend(ch, val);          // 0–16383, center = 8192

MIDIHandlerConfig:

MIDIHandlerConfig cfg;
cfg.maxEvents      = 20;    // queue capacity
cfg.enableHistory  = true;  // keep full history
cfg.chordDetection = true;  // group simultaneous notes

Custom transport interface:

class MyTransport : public MIDITransport {
public:
    void task() override;
    bool isConnected() const override;
    bool sendMidiMessage(const uint8_t* data, size_t len) override;
protected:
    void dispatchMidiData(const uint8_t* data, size_t len); // inject received MIDI
    void dispatchConnected();
    void dispatchDisconnected();
};
midiHandler.addTransport(&myTransport);

File Structure

ESP32_Host_MIDI/
├── src/
│   ├── ESP32_Host_MIDI.h             ← main include (USB + BLE + ESP-NOW built-in)
│   ├── MIDIHandler.h / .cpp          ← event queue, chord detection, active notes
│   ├── MIDITransport.h               ← abstract transport interface
│   ├── MIDIHandlerConfig.h           ← config struct
│   ├── USBConnection.h / .cpp        ← USB Host OTG
│   ├── USBMIDI2Connection.h / .cpp   ← USB Host MIDI 2.0 (UMP negotiation)
│   ├── MIDI2Support.h                ← UMP types, scaler, builder, parser
│   ├── BLEConnection.h / .cpp        ← BLE MIDI
│   ├── ESPNowConnection.h / .cpp     ← ESP-NOW MIDI
│   ├── UARTConnection.h / .cpp       ← UART / DIN-5
│   ├── USBDeviceConnection.h         ← USB MIDI Device (header-only)
│   ├── RTPMIDIConnection.h / .cpp    ← RTP-MIDI over WiFi (header-only)
│   ├── EthernetMIDIConnection.h      ← AppleMIDI over Ethernet (header-only)
│   ├── OSCConnection.h               ← OSC ↔ MIDI bridge (header-only)
│   └── GingoAdapter.h                ← Gingoduino chord integration
├── extras/
│   └── tests/
│       ├── test_native.cpp           ← MIDI2Support + MIDITransport tests (32)
│       ├── test_handler.cpp          ← MIDIHandler tests (99)
│       └── test_midi2_scan.cpp       ← USB MIDI 2.0 descriptor tests (120)
└── examples/
    ├── T-Display-S3/                 T-Display-S3-Queue/
    ├── T-Display-S3-Piano/           T-Display-S3-Piano-Debug/
    ├── T-Display-S3-Gingoduino/      T-Display-S3-BLE-Sender/
    ├── T-Display-S3-BLE-Receiver/    T-Display-S3-ESP-NOW-Jam/
    ├── T-Display-S3-OSC/             T-Display-S3-USB-Device/
    ├── ESP-NOW-MIDI/                 UART-MIDI-Basic/
    ├── P4-Dual-UART-MIDI/           RTP-MIDI-WiFi/
    ├── Ethernet-MIDI/               OSC-MIDI-WiFi/
    └── USB-Device-MIDI/

License

MIT — see LICENSE

Built with ❤️ for musicians, makers, and researchers.
Issues and contributions welcome: github.com/sauloverissimo/ESP32_Host_MIDI

Name		Name	Last commit message	Last commit date
Latest commit History 122 Commits
.github/workflows		.github/workflows
docs		docs
examples		examples
extras/tests		extras/tests
src		src
.gitignore		.gitignore
LICENSE		LICENSE
README-PT-BR.md		README-PT-BR.md
README.md		README.md
keywords.txt		keywords.txt
library.properties		library.properties
mkdocs.yml		mkdocs.yml

Folders and files

Latest commit

History

Repository files navigation

ESP32_Host_MIDI

English

What can you build?

Transport Matrix

Quick Start

Gallery

Architecture

Transports

USB Host (OTG)

BLE MIDI

USB Device

ESP-NOW MIDI

RTP-MIDI / Apple MIDI

Ethernet MIDI

OSC

UART / DIN-5

USB Host MIDI 2.0

Bridge Use Cases

Hardware Ecosystem

Boards you can connect to the ESP32

Hardware projects you can build

Display Examples (T-Display-S3)

Gingoduino — Music Theory on Embedded Systems

Gingo — Music Theory for Python and Desktop

Hardware Compatibility

Chip → available transports

Recommended boards

Installation

API Reference

File Structure

License

About

Topics

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases 11

Packages 0

Uh oh!

Contributors 1

Languages

Packages