Initial commit: Phase 1 skeleton

components/midi/midi_transport.cpp

@@ -0,0 +1,121 @@
+// midi/midi_transport.cpp
+#include "midi/midi_transport.h"
+#include "esp_log.h"
+#include "tusb.h"
+#include "class/midi/midi.h"
+
+static const char* TAG = "midi_transport";
+
+UsbMidiTransport::UsbMidiTransport() : event_queue(nullptr), initialized(false) {
+}
+
+UsbMidiTransport::~UsbMidiTransport() {
+    if (event_queue != NULL) {
+        vQueueDelete(event_queue);
+    }
+}
+
+bool UsbMidiTransport::begin() {
+    // Create event queue
+    event_queue = xQueueCreate(32, sizeof(MidiEvent));
+    if (event_queue == NULL) {
+        ESP_LOGE(TAG, "Failed to create event queue");
+        return false;
+    }
+    
+    // Initialize TinyUSB MIDI
+    tusb_init();
+    
+    // Configure USB device descriptors
+    tusb_device_set_string(1, "Loopy Foot Controller");
+    
+    // Register MIDI callback
+    tuh_midi_set_cb(usb_midi_callback);
+    
+    initialized = true;
+    ESP_LOGI(TAG, "USB MIDI transport initialized");
+    return true;
+}
+
+void UsbMidiTransport::task() {
+    if (!initialized) return;
+    
+    // Process USB MIDI events
+    while (tuh_uart_read_available()) {
+        uint8_t buffer[128];
+        uint32_t bytes_read = tuh_midi_read_packet(buffer, sizeof(buffer));
+        
+        if (bytes_read > 0) {
+            MidiEvent event;
+            parse_midi_packet(buffer, bytes_read, event);
+            
+            // Log incoming event
+            log_incoming("USB", event);
+            
+            // Send to event queue
+            if (xQueueSend(event_queue, &event, portMAX_DELAY) != pdPASS) {
+                ESP_LOGW(TAG, "Failed to queue MIDI event");
+            }
+        }
+    }
+}
+
+void usb_midi_callback(const uint8_t* event, uint32_t size) {
+    // This callback is called by TinyUSB when MIDI data is received
+    // For now, we'll implement a simple version
+    // In a full implementation, this would parse the MIDI packet
+    
+    MidiEvent midi_event;
+    // TODO: Implement actual MIDI parsing based on event type
+    // For Phase 1, we'll handle basic Note On/Off messages
+}
+
+void UsbMidiTransport::log_incoming(const char* source, const MidiEvent& event) {
+    const char* type_str;
+    switch (event.type) {
+        case MidiEvent::NOTE_ON: type_str = "NOTE_ON"; break;
+        case MidiEvent::NOTE_OFF: type_str = "NOTE_OFF"; break;
+        case MidiEvent::CONTROL_CHANGE: type_str = "CONTROL_CHANGE"; break;
+        default: type_str = "UNKNOWN"; break;
+    }
+    
+    ESP_LOGI(TAG, "MIDI IN: %s Channel: %d Type: %s Note: %d Velocity: %d",
+             source, event.channel, type_str, event.data1, event.data2);
+}
+
+void UsbMidiTransport::parse_midi_packet(const uint8_t* buffer, uint32_t size, MidiEvent& event) {
+    // Simple MIDI parser for basic messages
+    // This is a simplified version for Phase 1
+    
+    if (size < 2) return;
+    
+    uint8_t status = buffer[0];
+    uint8_t type = status & 0xF0;  // Message type
+    uint8_t channel = status & 0x0F;  // Channel (0-15, but MIDI uses 1-16)
+    
+    event.channel = channel + 1;  // Convert to 1-16 range
+    
+    switch (type) {
+        case 0x90:  // Note On
+            event.type = MidiEvent::NOTE_ON;
+            event.data1 = buffer[1];
+            event.data2 = buffer[2];
+            break;
+        
+        case 0x80:  // Note Off
+            event.type = MidiEvent::NOTE_OFF;
+            event.data1 = buffer[1];
+            event.data2 = buffer[2];
+            break;
+        
+        case 0xB0:  // Control Change
+            event.type = MidiEvent::CONTROL_CHANGE;
+            event.data1 = buffer[1];
+            event.data2 = buffer[2];
+            break;
+            
+        default:
+            // Unknown message type - ignore for now
+            return;
+    }
+}

components/midi/midi_transport.h

@@ -0,0 +1,46 @@
+// midi/midi_transport.h
+#pragma once
+
+#include <cstdint>
+#include <freertos/FreeRTOS.h>
+#include <freertos/queue.h>
+
+struct MidiEvent {
+    enum Type {
+        NOTE_ON,
+        NOTE_OFF,
+        CONTROL_CHANGE,
+        PROGRAM_CHANGE,
+        PITCH_BEND,
+        AFTERTOUCH_POLY,
+        AFTERTOUCH_CHAN,
+        SYSEX
+    } type;
+    
+    uint8_t channel;      // MIDI channel (1-16)
+    uint8_t data1;         // Note number or CC number
+    uint8_t data2;         // Velocity or CC value
+    uint32_t timestamp;   // Event timestamp
+};
+
+class UsbMidiTransport {
+public:
+    UsbMidiTransport();
+    ~UsbMidiTransport();
+    
+    bool begin();
+    void task();
+    
+    // Event queue for communication with controller task
+    QueueHandle_t get_event_queue() const { return event_queue; }
+    
+    // Diagnostic logging
+    void log_incoming(const char* source, const MidiEvent& event);
+    
+private:
+    QueueHandle_t event_queue;
+    bool initialized;
+};
+
+// Forward declaration for USB callback
+void usb_midi_callback(const uint8_t* event, uint32_t size);