ich nutze auf meinem ESP32-S3 zum senden von Midi Daten über USB die Bibliothek USBMIDI. Leider ist das Board da etwas schwierig, daher scheiden viele Wege aus. Nun kann ich ohne Probleme etwas senden, jedoch gelingt mir der Empfang von Midi Daten nicht. Das Board wird als Eingabe und Ausgabe am System erkannt, jedoch kann ich am Board keine Daten auslesen.
Hat von euch schon jemand mit USBMIDI etwas am Arduino ausgelesen und wenn ja, wie habt ihr es umgesetzt? Die Dokumentation ist irgendwie nicht hilfreich, da sie sich wohl auf verschiedene USBMIDI Bibliotheken beziehen? Immer wieder (auch in Beispielen) angegebenen Funktionen wie read(), pool() oder setHandlerXXX() gibt es nicht. Ich habe einmal ein Beispiel angehängt welches zumindest sendet. Es ist minimal.
So, manchmal sieht man das offensichtliche nicht. usbmidi.h ist nicht USBMIDI.H ich nutze die ganze Zeit das USBMIDI vom esp32 und mit diesem Wissen macht es doch wieder Sinn. Die Lösung ist:
#if ARDUINO_USB_MODE
#warning This sketch should be used when USB is in OTG mode
void setup() {}
void loop() {}
#else
#include "USB.h"
#include "USBMIDI.h"
USBMIDI MIDI;
void setup() {
Serial.begin(115200);
MIDI.begin();
USB.begin();
}
void loop() {
midiEventPacket_t midi_packet_in = {0, 0, 0, 0};
if (MIDI.readPacket(&midi_packet_in)) {
printDetails(midi_packet_in);
}
}
void printDetails(midiEventPacket_t &midi_packet_in) {
// See Chapter 4: USB-MIDI Event Packets (page 16) of the spec.
uint8_t cable_num = MIDI_EP_HEADER_CN_GET(midi_packet_in.header);
midi_code_index_number_t code_index_num = MIDI_EP_HEADER_CIN_GET(midi_packet_in.header);
Serial.println("Received a USB MIDI packet:");
Serial.println(".----.-----.--------.--------.--------.");
Serial.println("| CN | CIN | STATUS | DATA 0 | DATA 1 |");
Serial.println("+----+-----+--------+--------+--------+");
Serial.printf("| %d | %X | %X | %X | %X |\n", cable_num, code_index_num, midi_packet_in.byte1, midi_packet_in.byte2, midi_packet_in.byte3);
Serial.println("'----'-----'--------.--------'--------'\n");
Serial.print("Description: ");
switch (code_index_num) {
case MIDI_CIN_MISC: Serial.println("This a Miscellaneous event"); break;
case MIDI_CIN_CABLE_EVENT: Serial.println("This a Cable event"); break;
case MIDI_CIN_SYSCOM_2BYTE: // 2 byte system common message e.g MTC, SongSelect
case MIDI_CIN_SYSCOM_3BYTE: // 3 byte system common message e.g SPP
Serial.println("This a System Common (SysCom) event");
break;
case MIDI_CIN_SYSEX_START: // SysEx starts or continue
case MIDI_CIN_SYSEX_END_1BYTE: // SysEx ends with 1 data, or 1 byte system common message
case MIDI_CIN_SYSEX_END_2BYTE: // SysEx ends with 2 data
case MIDI_CIN_SYSEX_END_3BYTE: // SysEx ends with 3 data
Serial.println("This a system exclusive (SysEx) event");
break;
case MIDI_CIN_NOTE_ON: Serial.printf("This a Note-On event of Note %d with a Velocity of %d\n", midi_packet_in.byte2, midi_packet_in.byte3); break;
case MIDI_CIN_NOTE_OFF: Serial.printf("This a Note-Off event of Note %d with a Velocity of %d\n", midi_packet_in.byte2, midi_packet_in.byte3); break;
case MIDI_CIN_POLY_KEYPRESS: Serial.printf("This a Poly Aftertouch event for Note %d and Value %d\n", midi_packet_in.byte2, midi_packet_in.byte3); break;
case MIDI_CIN_CONTROL_CHANGE:
Serial.printf(
"This a Control Change/Continuous Controller (CC) event of Controller %d "
"with a Value of %d\n",
midi_packet_in.byte2, midi_packet_in.byte3
);
break;
case MIDI_CIN_PROGRAM_CHANGE: Serial.printf("This a Program Change event with a Value of %d\n", midi_packet_in.byte2); break;
case MIDI_CIN_CHANNEL_PRESSURE: Serial.printf("This a Channel Pressure event with a Value of %d\n", midi_packet_in.byte2); break;
case MIDI_CIN_PITCH_BEND_CHANGE:
Serial.printf("This a Pitch Bend Change event with a Value of %d\n", ((uint16_t)midi_packet_in.byte2) << 7 | midi_packet_in.byte3);
break;
case MIDI_CIN_1BYTE_DATA: Serial.printf("This an embedded Serial MIDI event byte with Value %X\n", midi_packet_in.byte1); break;
}
Serial.println();
}
#endif /* ARDUINO_USB_MODE */
Also eigentlich ganz einfach... Mit dem Arduino direkt bin ich es nicht gewohnt so viele unterschiedliche Dinge wie beim esp32 zu haben.
[quote="wwerner, post:2, topic:1360794, full:true"]
Darf man fragen, warum es unbedingt der
sein muß?
[/quote]
In meinem Fall ist das Set mit 7" Touch Display schon ein unschlagbares Argument für den esp32. Da ich auch eine gewisse Reaktionsgeschwindigkeit brauche und eine Lösung wollte die aus einer Hand kommt, ist es für mich die beste Wahl. lvgl und co sind ja schon ein großer Brocken, wenn ich dann auch noch die oft schlecht dokumentierten Bestandteile zusammenbringen soll, dann wäre ich wohl überfordert. Ich persönlich würde auch eher eine CircuitPython Lösung bevorzugen, ganz einfach weil ich in Python sehr viel erfahrener bin und gerne den Pi Pico nutze. Aber leider habe ich CircuitPython noch nicht zum laufen gebracht, obwohl die Hardware eigentlich unterstützt werden sollte. Es handelt sich um https://www.waveshare.com/wiki/ESP32-S3-Touch-LCD-7
Bisher war sie mit Due erfolgreich, aber sie möchte noch einen MIDI-Mischer bauen. Möglicherweise wäre da ein ESP32-S3 geeigneter. Ich würde euch gerne zusammenbringen, Du scheinst was darüber zu wissen.
Dadurch, daß ich sie erwähnt habe, bekommt sie eine Nachricht. Also nicht wundern, wenn sie sich bei Dir meldet, so sie Interesse hat.
Wenn ich kann, dann helfe ich gerne. Aber im Grundsatz bin ich kein Experte und pfusche mir mein Projekt so zusammen... Ich bin Orgelspieler und baue mir gerade eine Steuerung für die Orgel, mit der ich dann ohne Schalter un Knöpfe flexibel das Instrument steuern kann. Bis jetzt geht das in eine Richtung gut, aber die Anzeige soll ja auch Veränderungen übernehmen, beispiel ich rufe eine gespeicherte Kombination auf. Später sollen die Einträge für die Oberfläche von der Speicherkarte kommen um flexibel mehrere Instrumente abbilden zu können... Bis vor einer Woche wusste ich nicht einmal was lvgl ist Bisher habe ich mit dem Arduino DUE ein Pedal midifiziert und mit dem Pi Pico über eine Tastenmatrix die Schalter der alten Steuerung.
An dem MEGA bin ich lieber auf die alte 5POL DIN Lösung gegangen, dadurch bin ich viel flexibler. So manches bei mir nutzt 5POL DIN. An den Rechner gehe ich dann über ein Standard Interface die es unter 20€ gibt.
Zu meinem Projekt hab ich etwas in der Tube, kannst ja mal reinschauen.
Erst einmal Danke für deine Rückmeldung. Dein Projekt ist interessant. Ich habe das Problem ja inzwischen gelöst wie oben geschrieben sind beim ESP32 die Dinge etwas anders. Inzwischen habe ich auch ein Server/Client Prinzip, ein Server (Python) kommuniziert mit dem Display, da ich nach vielen Tage die Nase voll hatte diese vemurkste SD Karten Geschichte zum laufen zu bekommen. Entweder ging es nicht, oder das Display ging nicht und die Beschreibung des Expander ist totaler Mist. Zumindest mit der Arduino IDE ist das nicht nutzbar, da es sich nicht an Standards hält und im Gegensatz zum ESP-IDF führt ein Dummy Pin den es nicht gibt aber zwingend angegeben sein muss zur Panik… Naja und umstellen wollte ich es auch nicht mehr, zukünftig bleibe ich wohl beim Originalen Arduino…
ich nutze die ganze Zeit das USBMIDI vom esp32 und mit diesem Wissen macht es doch wieder Sinn. Die Lösung ist:
