121 lines
3.6 KiB
C++
121 lines
3.6 KiB
C++
// 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;
|
|
}
|
|
} |