diff --git a/src/midichunker.cpp b/src/midichunker.cpp
new file mode 100644
index 0000000..b069aae
--- /dev/null
+++ b/src/midichunker.cpp
@@ -0,0 +1,48 @@
+//
+// midichunker.cpp
+//
+// MiniDexed - Dexed FM synthesizer for bare metal Raspberry Pi
+// Copyright (C) 2022-25 The MiniDexed Team
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see .
+//
+
+#include "midichunker.h"
+#include
+
+MIDISysExChunker::MIDISysExChunker(const uint8_t* data, size_t length, size_t chunkSize)
+ : m_data(data), m_length(length), m_chunkSize(chunkSize), m_offset(0) {}
+
+bool MIDISysExChunker::hasNext() const {
+ return m_offset < m_length;
+}
+
+std::vector MIDISysExChunker::next() {
+ if (!hasNext()) return {};
+ size_t remaining = m_length - m_offset;
+ size_t chunkLen = std::min(m_chunkSize, remaining);
+ // Only the last chunk should contain the final 0xF7
+ if (m_offset + chunkLen >= m_length && m_data[m_length-1] == 0xF7) {
+ chunkLen = m_length - m_offset;
+ } else if (m_offset + chunkLen > 0 && m_data[m_offset + chunkLen - 1] == 0xF7) {
+ chunkLen--;
+ }
+ std::vector chunk(m_data + m_offset, m_data + m_offset + chunkLen);
+ m_offset += chunkLen;
+ return chunk;
+}
+
+void MIDISysExChunker::reset() {
+ m_offset = 0;
+}
diff --git a/src/midichunker.h b/src/midichunker.h
new file mode 100644
index 0000000..06f49ac
--- /dev/null
+++ b/src/midichunker.h
@@ -0,0 +1,37 @@
+//
+// midichunker.h
+//
+// MiniDexed - Dexed FM synthesizer for bare metal Raspberry Pi
+// Copyright (C) 2022-25 The MiniDexed Team
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see .
+//
+
+#pragma once
+#include
+#include
+#include
+
+class MIDISysExChunker {
+public:
+ MIDISysExChunker(const uint8_t* data, size_t length, size_t chunkSize = 256);
+ bool hasNext() const;
+ std::vector next();
+ void reset();
+private:
+ const uint8_t* m_data;
+ size_t m_length;
+ size_t m_chunkSize;
+ size_t m_offset;
+};
diff --git a/src/mididevice.cpp b/src/mididevice.cpp
index f20cefc..633ea69 100644
--- a/src/mididevice.cpp
+++ b/src/mididevice.cpp
@@ -30,7 +30,7 @@
#include "midi.h"
#include "userinterface.h"
-LOGMODULE ("mididevice");
+LOGMODULE("midikeyboard");
// MIDI "System" level (i.e. all TG) custom CC maps
// Note: Even if number of TGs is not 8, there are only 8
@@ -249,8 +249,7 @@ void CMIDIDevice::MIDIMessageHandler (const u8 *pMessage, size_t nLength, unsign
m_pSynthesizer->setMasterVolume(fMasterVolume);
}
else
- {
- // Perform any MiniDexed level MIDI handling before specific Tone Generators
+ { // Perform any MiniDexed level MIDI handling before specific Tone Generators
unsigned nPerfCh = m_pSynthesizer->GetPerformanceSelectChannel();
switch (ucType)
{
@@ -621,7 +620,7 @@ void CMIDIDevice::HandleSystemExclusive(const uint8_t* pMessage, const size_t nL
else if (nLength == 5 && pMessage[3] == 0x09)
{
LOGDBG("SysEx bank dump request: device %d", nTG);
- LOGDBG("Still to be implemented");
+ SendSystemExclusiveBank(nTG, m_DeviceName, nCable, nTG);
return;
}
@@ -747,12 +746,6 @@ void CMIDIDevice::HandleSystemExclusive(const uint8_t* pMessage, const size_t nL
break;
}
}
- else if(sysex_return >= 500 && sysex_return < 600)
- {
- LOGDBG("SysEx send voice %u request",sysex_return-500);
- SendSystemExclusiveVoice(sysex_return-500, m_DeviceName, nCable, nTG);
- }
- break;
}
}
@@ -769,3 +762,17 @@ void CMIDIDevice::SendSystemExclusiveVoice(uint8_t nVoice, const std::string& de
LOGWARN("No device found in s_DeviceMap for name: %s", deviceName.c_str());
}
}
+
+void CMIDIDevice::SendSystemExclusiveBank(uint8_t nVoice, const std::string& deviceName, unsigned nCable, uint8_t nTG)
+{
+ // Example: F0 43 20 09 F7
+ static uint8_t voicedump[4104]; // Use static buffer, correct size for DX7 bank dump
+ m_pSynthesizer->getSysExBankDump(voicedump, nTG);
+ TDeviceMap::const_iterator Iterator = s_DeviceMap.find(deviceName);
+ if (Iterator != s_DeviceMap.end()) {
+ Iterator->second->Send(voicedump, 4104, nCable);
+ LOGDBG("Send SYSEX bank dump %u to \"%s\"", nVoice, deviceName.c_str());
+ } else {
+ LOGWARN("No device found in s_DeviceMap for name: %s", deviceName.c_str());
+ }
+}
diff --git a/src/mididevice.h b/src/mididevice.h
index 7da8717..104275a 100644
--- a/src/mididevice.h
+++ b/src/mididevice.h
@@ -56,6 +56,7 @@ public:
virtual void Send (const u8 *pMessage, size_t nLength, unsigned nCable = 0) {}
// Change signature to specify device name
void SendSystemExclusiveVoice(uint8_t nVoice, const std::string& deviceName, unsigned nCable, uint8_t nTG);
+ void SendSystemExclusiveBank(uint8_t nVoice, const std::string& deviceName, unsigned nCable, uint8_t nTG);
const std::string& GetDeviceName() const { return m_DeviceName; }
protected:
diff --git a/src/midikeyboard.cpp b/src/midikeyboard.cpp
index db71168..6d1f410 100644
--- a/src/midikeyboard.cpp
+++ b/src/midikeyboard.cpp
@@ -21,15 +21,24 @@
// along with this program. If not, see .
//
#include "midikeyboard.h"
+#include "midichunker.h"
#include
+#include
+#include
+#include
#include
#include
+#include
+#include
+
+LOGMODULE("midikeyboard");
CMIDIKeyboard::CMIDIKeyboard (CMiniDexed *pSynthesizer, CConfig *pConfig, CUserInterface *pUI, unsigned nInstance)
: CMIDIDevice (pSynthesizer, pConfig, pUI),
m_nSysExIdx (0),
m_nInstance (nInstance),
- m_pMIDIDevice (0)
+ m_pMIDIDevice (0),
+ m_HasQueuedSysEx(false)
{
m_DeviceName.Format ("umidi%u", nInstance+1);
@@ -42,6 +51,33 @@ CMIDIKeyboard::~CMIDIKeyboard (void)
void CMIDIKeyboard::Process (boolean bPlugAndPlayUpdated)
{
+ // Send any queued SysEx response in a safe context
+ if (m_HasQueuedSysEx && m_pMIDIDevice) {
+ // Pad to multiple of 4 bytes for USB MIDI event packets
+ size_t sysexLen = m_QueuedSysEx.size();
+ size_t paddedLen = (sysexLen + 3) & ~3; // round up to next multiple of 4
+ if (paddedLen > sysexLen) {
+ m_QueuedSysEx.resize(paddedLen, 0x00);
+ }
+ // Send in safe chunks to avoid USB lockup
+ static constexpr size_t kUSBMIDIMaxChunk = 256; // or 512 if your stack allows
+ size_t offset = 0;
+ // Only send one chunk per Process() call to avoid blocking or watchdog reset
+ if (offset < m_QueuedSysEx.size()) {
+ size_t chunk = std::min(kUSBMIDIMaxChunk, m_QueuedSysEx.size() - offset);
+ m_pMIDIDevice->SendEventPackets(m_QueuedSysEx.data() + offset, chunk);
+ offset += chunk;
+ // Save progress for next Process() call
+ if (offset < m_QueuedSysEx.size()) {
+ // Not done yet, keep queued SysEx and return
+ m_QueuedSysEx.erase(m_QueuedSysEx.begin(), m_QueuedSysEx.begin() + chunk);
+ return;
+ }
+ }
+ m_QueuedSysEx.clear();
+ m_HasQueuedSysEx = false;
+ }
+
while (!m_SendQueue.empty ())
{
TSendQueueEntry Entry = m_SendQueue.front ();
@@ -73,16 +109,80 @@ void CMIDIKeyboard::Process (boolean bPlugAndPlayUpdated)
}
}
-void CMIDIKeyboard::Send (const u8 *pMessage, size_t nLength, unsigned nCable)
+// Helper: Convert SysEx to USB MIDI event packets
+std::vector> SysExToUSBMIDIPackets(const uint8_t* data, size_t length, unsigned cable)
{
- TSendQueueEntry Entry;
- Entry.pMessage = new u8[nLength];
- Entry.nLength = nLength;
- Entry.nCable = nCable;
+ LOGNOTE("SysExToUSBMIDIPackets: length=%u, cable=%u", (unsigned)length, cable);
+ std::vector> packets;
+ size_t idx = 0;
+ while (idx < length) {
+ size_t remaining = length - idx;
+ uint8_t cin;
+ uint8_t packet[4] = {0};
+ packet[0] = (uint8_t)(cable << 4); // Upper nibble: cable number, lower: CIN
+ if (remaining >= 3) {
+ if (idx == 0) {
+ cin = 0x4; // SysEx Start or continue
+ } else {
+ cin = 0x4; // SysEx continue
+ }
+ packet[0] |= cin;
+ packet[1] = data[idx];
+ packet[2] = data[idx+1];
+ packet[3] = data[idx+2];
+ LOGNOTE(" Packet: [%02X %02X %02X %02X] (idx=%u)", packet[0], packet[1], packet[2], packet[3], (unsigned)idx);
+ idx += 3;
+ } else if (remaining == 2) {
+ cin = 0x6; // SysEx ends with 2 bytes
+ packet[0] |= cin;
+ packet[1] = data[idx];
+ packet[2] = data[idx+1];
+ packet[3] = 0;
+ LOGNOTE(" Packet: [%02X %02X %02X %02X] (last 2 bytes)", packet[0], packet[1], packet[2], packet[3]);
+ idx += 2;
+ } else if (remaining == 1) {
+ cin = 0x5; // SysEx ends with 1 byte
+ packet[0] |= cin;
+ packet[1] = data[idx];
+ packet[2] = 0;
+ packet[3] = 0;
+ LOGNOTE(" Packet: [%02X %02X %02X %02X] (last 1 byte)", packet[0], packet[1], packet[2], packet[3]);
+ idx += 1;
+ }
+ packets.push_back({packet[0], packet[1], packet[2], packet[3]});
+ }
+ LOGNOTE("SysExToUSBMIDIPackets: total packets=%u", (unsigned)packets.size());
+ return packets;
+}
- memcpy (Entry.pMessage, pMessage, nLength);
+void CMIDIKeyboard::Send(const u8 *pMessage, size_t nLength, unsigned nCable)
+{
+ // NOTE: For USB MIDI, we do NOT use MIDISysExChunker for SysEx sending.
+ // The chunker splits SysEx into arbitrary chunks for traditional MIDI (e.g., serial/DIN),
+ // but USB MIDI requires SysEx to be split into 4-byte USB MIDI event packets with specific CIN headers.
+ // Therefore, for USB MIDI, we packetize SysEx according to the USB MIDI spec and send with SendEventPackets().
+ // See: https://www.usb.org/sites/default/files/midi10.pdf (USB MIDI 1.0 spec)
+ // This is why the chunker is bypassed for USB MIDI SysEx sending.
- m_SendQueue.push (Entry);
+ // Check for valid SysEx
+ if (nLength >= 2 && pMessage[0] == 0xF0 && pMessage[nLength-1] == 0xF7 && m_pMIDIDevice) {
+ // Convert to USB MIDI event packets and send directly
+ auto packets = SysExToUSBMIDIPackets(pMessage, nLength, nCable);
+ std::vector flat;
+ for (const auto& pkt : packets) {
+ flat.insert(flat.end(), pkt.begin(), pkt.end());
+ }
+ m_QueuedSysEx = flat;
+ m_HasQueuedSysEx = true;
+ return;
+ }
+ // Not a SysEx, send as-is
+ TSendQueueEntry Entry;
+ Entry.pMessage = new u8[nLength];
+ Entry.nLength = nLength;
+ Entry.nCable = nCable;
+ memcpy(Entry.pMessage, pMessage, nLength);
+ m_SendQueue.push(Entry);
}
// Most packets will be passed straight onto the main MIDI message handler
diff --git a/src/midikeyboard.h b/src/midikeyboard.h
index bf62689..642c726 100644
--- a/src/midikeyboard.h
+++ b/src/midikeyboard.h
@@ -30,6 +30,7 @@
#include
#include
#include
+#include
#define USB_SYSEX_BUFFER_SIZE (MAX_DX7_SYSEX_LENGTH+128) // Allow a bit spare to handle unexpected SysEx messages
@@ -45,6 +46,14 @@ public:
void Send (const u8 *pMessage, size_t nLength, unsigned nCable = 0) override;
+ void QueueSysExResponse(const uint8_t* data, size_t len) {
+ m_QueuedSysEx.assign(data, data + len);
+ m_HasQueuedSysEx = true;
+ }
+ bool HasQueuedSysExResponse() const { return m_HasQueuedSysEx; }
+ void ClearQueuedSysExResponse() { m_QueuedSysEx.clear(); m_HasQueuedSysEx = false; }
+ const std::vector& GetQueuedSysExResponse() const { return m_QueuedSysEx; }
+
private:
static void MIDIPacketHandler (unsigned nCable, u8 *pPacket, unsigned nLength, unsigned nDevice, void *pParam);
static void DeviceRemovedHandler (CDevice *pDevice, void *pContext);
@@ -68,6 +77,11 @@ private:
CUSBMIDIDevice * volatile m_pMIDIDevice;
std::queue m_SendQueue;
+
+ std::vector m_QueuedSysEx;
+ bool m_HasQueuedSysEx = false;
};
+std::vector> SysExToUSBMIDIPackets(const uint8_t* data, size_t length, unsigned cable);
+
#endif
diff --git a/src/minidexed.cpp b/src/minidexed.cpp
index f7c341d..9843174 100644
--- a/src/minidexed.cpp
+++ b/src/minidexed.cpp
@@ -1868,6 +1868,49 @@ void CMiniDexed::getSysExVoiceDump(uint8_t* dest, uint8_t nTG)
dest[162] = 0xF7; // SysEx end
}
+void CMiniDexed::getSysExBankDump(uint8_t* dest, uint8_t nTG)
+{
+ // DX7 Bulk Dump: 32 voices
+ // Header: F0 43 00 09 20 00
+ // Data: 4096 bytes (32 voices x 128 bytes packed)
+ // Checksum: 1 byte (2's complement of sum of 4096 data bytes, masked to 7 bits)
+ // Footer: F7
+ // Total: 4104 bytes
+
+ constexpr size_t kVoices = 32;
+ constexpr size_t kPackedVoiceSize = 128;
+ constexpr size_t kBulkDataSize = kVoices * kPackedVoiceSize; // 4096
+ constexpr size_t kHeaderSize = 6;
+ constexpr size_t kTotalSize = kHeaderSize + kBulkDataSize + 2; // +checksum +F7 = 4104
+
+ // Header (Yamaha DX7 standard)
+ dest[0] = 0xF0; // SysEx start
+ dest[1] = 0x43; // Yamaha ID
+ dest[2] = 0x00; // Sub-status (0), device/channel (0)
+ dest[3] = 0x09; // Format number (9 = 32 voices)
+ dest[4] = 0x20; // Byte count MSB (4096 = 0x1000, MSB=0x20)
+ dest[5] = 0x00; // Byte count LSB
+
+ // Fill packed voice data
+ uint8_t* pData = dest + kHeaderSize;
+ uint8_t checksum = 0;
+ for (size_t v = 0; v < kVoices; ++v) {
+ uint8_t packedVoice[kPackedVoiceSize];
+ m_SysExFileLoader.GetVoice(m_nVoiceBankID[nTG], v, packedVoice);
+ for (size_t b = 0; b < kPackedVoiceSize; ++b) {
+ pData[v * kPackedVoiceSize + b] = packedVoice[b];
+ checksum += packedVoice[b];
+ }
+ }
+
+ // Checksum: 2's complement, masked to 7 bits
+ checksum = (~checksum + 1) & 0x7F;
+ dest[kHeaderSize + kBulkDataSize] = checksum;
+
+ // Footer
+ dest[kHeaderSize + kBulkDataSize + 1] = 0xF7;
+}
+
void CMiniDexed::setOPMask(uint8_t uchOPMask, uint8_t nTG)
{
m_uchOPMask[nTG] = uchOPMask;
diff --git a/src/minidexed.h b/src/minidexed.h
index 1658482..3e877a2 100644
--- a/src/minidexed.h
+++ b/src/minidexed.h
@@ -124,6 +124,7 @@ public:
void loadVoiceParameters(const uint8_t* data, uint8_t nTG);
void setVoiceDataElement(uint8_t data, uint8_t number, uint8_t nTG);
void getSysExVoiceDump(uint8_t* dest, uint8_t nTG);
+ void getSysExBankDump(uint8_t* dest, uint8_t nTG);
void setOPMask(uint8_t uchOPMask, uint8_t nTG);
void setModController (unsigned controller, unsigned parameter, uint8_t value, uint8_t nTG);
diff --git a/syslogserver.py b/syslogserver.py
index feffaa6..16f86f1 100644
--- a/syslogserver.py
+++ b/syslogserver.py
@@ -34,6 +34,9 @@ class SyslogServer:
def handle_message(self, data):
message = data[2:].decode('utf-8').strip()
+ if "Time exceeded (0)" in message:
+ return
+
if self.start_time is None:
self.start_time = time.time()
relative_time = "0:00:00.000"