MIDI senden: GO hängt sich auf

Ja klar. Ich verwende für zwei Zustände i.d.R. auch Note-On/Off-Befehle.

Zitat von J. Brassmann

Code

Ich stelle mir nun die Frage, was muss ich tun, um die dreistellige Anzeige aus GO via Arduino auf ein Display zu transportieren. Denn genau dafür kann die Anzeige doch Sysex senden.

Das wird man nur mir der entsprechenden Anleitung zum Display herausfinden können.

0x20 ist ein ASCII-Leerzeichen (Space)

0x30 ist ASCII "0"

0x31 ist ASCII "1"

0x32 ist ASCII "2"

0x33 ist ASCII "3"

Somit steht hinter dem mir nichts sagenden 0x7d, 0x01, 0x00, 0x01, 0x00

der Text

"001"

"002"

"003"

"013"

"023"

"123"

"223"

Alles anzeigen

Kommen bei deinem Arduino Daten an? Bedenke auch dass Midi je nach Implementierung anders nummeriert ist. Je nach Bibliothek führt die Angabe von Kanal 1 zu Kanal 0 und 2 zu 1 und so weiter

Wenn ich dir einen guten Ratschlag geben darf:

Lasse es! Also die Kommunikation zwischen GO und Arduino. Das ist eine so komplexe Sache (wie du selber siehst) dass es selbst mich an die Grenzen der Verzweiflung gebracht hat. Spätestens wenn du mit Setzer arbeitest die nicht fix sind, sondern frei Programmiert werden können (also aktuelle Registrierung mit Set auf Platz 1 speichern) fängt der Spaß an. GO sagt dir per Midi das am Rechner der Button gewählt wurde. Nun weißt du aber erst einmal nicht was dort hinterlegt ist und so weiter.

Ich würde dir den Ratschlag geben nur über deinen Spieltisch zu arbeiten. Bedeutet dein Arduino kümmert sich um alles und sendet nur noch was für Register gewählt werden sollen. Dann musst du zwar eine Logik schreiben welche die Daten speichert, aber das ist kein Problem. Beispiel du hast 30 Register und 10 Setzer. Dann erstellst du für jeden ein Array mit 30 Felder. Dort speicherst du einfach für jedes Register 0=Aus oder 1=An. Wenn du nun Taste 1 drückst, dann sendet dein Programm in einer Schleife einfach für jedes Register NoteON/OFF. Da deine Steuerung weiß was los ist kann sie auch selbstständig LED's schalten und ein Display ansteuern. GO müsste nur einmalig ein Signal senden wenn es gestartet wurde, damit dein Arduino den aktuellen Stand beim Start senden kann.

Speichern ließen sich die Daten z.B im Flash (würde ich nicht machen weil Lebensdauer), oder auf einem SDKarten Modul für ein paar Cent. Diese Zweiwege Kommunikation und Synchronisation ist wirklich die absolute Königsdisziplin und für dich als Einsteiger wohl nicht machbar. Da verzweifeln echte Nerds. Ich habe dann auch aufgegeben weil es mir das nicht wert war. Ich will ja auch nicht während ich spiele an einem Monitor zusätzlich etwas machen.

BTW Schau mal bei Google nach Arduino Sysex, da findest du viele Fragen, Probleme und Lösungen.

Zitat

0x20 ist ein ASCII-Leerzeichen (Space)

0x30 ist ASCII "0"

0x31 ist ASCII "1"

0x32 ist ASCII "2"

0x33 ist ASCII "3"

Somit steht hinter dem mir nichts sagenden 0x7d, 0x01, 0x00, 0x01, 0x00

der Text

Alles anzeigen

GO benutzt hier das Sysex-Nachrichtenformat von Hauptwerk. Das erste Byte 0x7d ist die feste Herstellerkennung, das darauffolgende Byte 0x01 ist der Code für eine LCD-Nachricht. Dann folgen zwei Bytes für die ID des anzusteuernden Panels (hier 0x01), und schließlich noch ein Byte für die Farbcodierung (hier 0x00). Danach kommt dann der Text als 32 Byte 7-bit ASCII. Nachzulesen ist das alles in der Bedienungsanleitung von Hauptwerk. Wenn man nur ein Panel selbst ansteuern will, kann man die ersten 5 Bytes der Nachricht auch ignorieren und nur die benötigten Bytes aus dem Text extrahieren. Diese lassen sich dann auch ganz einfach ausgeben, es handelt sich ja bereits um Text.

Zitat von J. Brassmann

Ich stelle mir nun die Frage, was muss ich tun, um die dreistellige Anzeige aus GO via Arduino auf ein Display zu transportieren. Denn genau dafür kann die Anzeige doch Sysex senden.

Benutzt du weiterhin die Arduino Midi Library auf dem Controller? Falls ja, kannst du die Sysex-Nachrichten ganz einfach über einen Callback abfangen, und dann dein Display direkt mit dem empfangenen Text ansteuern.

#include "LedControl.h"
LedControl leds = LedControl(data_pin, clk_pin, load_pin, 1);

MIDI.setHandleSystemExclusive(clbkHandleSystemExclusive);

void clbkHandleSystemExclusive(byte* data, unsigned int dataSize) {
  if(dataSize < 9 || data[2] != 1)
    return; // Not an LCD message

  if(data[4] != 1)
    return; // Not the right LCD panel id

  leds.setChar(0, 2, data[6], false); // Hunderter
  leds.setChar(0, 1, data[7], false); // Zehner
  leds.setChar(0, 0, data[8], false); // Einer
}

Dieses Beispiel schreibt die empfangene Setzer-Nummer auf drei 7-Segment-Anzeigen. Wenn du stattdessen ein LCD-Panel ansteuern willst, kannst du einfach dafür eine passende Library nehmen. Bei der Ansteuerung ist noch darauf zu achten, dass data hier am Anfang auch das Startbyte 0xF0 und am Ende das Abschlussbyte 0xF7 enthält. Hairless-Midi zeigt dir in den Debug-Nachrichten nur die Sysex-Nachricht zwischen Start- und Endbyte an, daher ist im Code der Index um eins höher als man vielleicht erwartet.

Falls dir ein ausführlicheres Codebeispiel für den Arduino bei der Programmierung hilft, kannst du mal hier schauen. In MIDIControl.cpp findest du unter anderem den Code, den ich benutze um aus GO heraus die Setzer-Nummer mit einem Arduino auf einem 7-Segment-Panel anzuzeigen (allerdings versende ich in GO 16 Byte String Werte statt 32 Byte LCD Werte, das Prinzip ist aber das gleiche).

Zitat von Haralder

Ich würde dir den Ratschlag geben nur über deinen Spieltisch zu arbeiten. Bedeutet dein Arduino kümmert sich um alles und sendet nur noch was für Register gewählt werden sollen. Dann musst du zwar eine Logik schreiben welche die Daten speichert, aber das ist kein Problem. Beispiel du hast 30 Register und 10 Setzer. Dann erstellst du für jeden ein Array mit 30 Felder. Dort speicherst du einfach für jedes Register 0=Aus oder 1=An. Wenn du nun Taste 1 drückst, dann sendet dein Programm in einer Schleife einfach für jedes Register NoteON/OFF. Da deine Steuerung weiß was los ist kann sie auch selbstständig LED's schalten und ein Display ansteuern. GO müsste nur einmalig ein Signal senden wenn es gestartet wurde, damit dein Arduino den aktuellen Stand beim Start senden kann.

Ja, das kann man natürlich auch machen. Mir stellt sich allerdings die Frage, wieso es gerade für Programmiereinsteiger einfacher sein sollte gleich die ganze Setzerlogik selbst zu implementieren, anstatt einfach den internen Setzer von GO zu benutzen Der lässt sich über MIDI ja prinzipiell genauso ansteuern wie etwa die Registerschalter.

Deine Aussagen sind etwas ungenau, das macht es etwas schwierig. Hex ist ja auch ascii, du meinst wahrscheinlich Hex-Darstellung (Ascii) in Dezimal-Darstellung (Ascii). Die Daten liegen wahrscheinlich in einem Byte-Array, wo du das 0x überspringen kannst.

Zitat von techlit

Mir stellt sich allerdings die Frage, wieso es gerade für Programmiereinsteiger einfacher sein sollte gleich die ganze Setzerlogik selbst zu implementieren, anstatt einfach den internen Setzer von GO zu benutzen

Ganz einfach, weil du bei der Zweiwege Lösung neben einer Setzer Logik im Arduino zusätzlich den Abgleich mit GO über ein komplexes Protokoll wie Midi abwickeln musst. Beide Teile müssen ja die identischen Informationen haben. Bei einem Spieltisch der einfach nur Taster hat ist das noch ganz simpel. Midisignal für den zugewiesenen Setzer schicken und fertig. Aber wenn der Spieltisch dann auch signalisieren soll welche Register nun aktiv sind (was erst einmal nur GO weiß), dann muss deine Steuerung irgendwie an die bei GO hinterlegten Daten kommen und abgleichen.

Midi ist eigentlich ein sehr simples Protokoll, aber trotzdem nicht einfach zu handhaben. Vor allem muss es ja auch zuverlässig funktionieren und da ist die Master (Arduino) Slave (GO) am einfachsten.

Da ich schon viele Jahre nicht mehr in C programmiert habe, war es mir ein Vergnügen, so ein kleines Converter-Programm ohne Bibliotheks-Funktionen zu schreiben. Falls du so was noch brauchst (Hex zu Dezimal), kann ich den Code gerne weitergeben.

Zitat von J. Brassmann

zudem Sysex ein MIDI-Standard ist und zudem auch von verschiedenen Arduino-Librarys unterstützt wird

Kannst du vieleicht auf deinem Arduino mal das folgende Programm ausführen und schauen ob und was dieser dann bei Signale von GO auswirft?

/*
 * MIDIUSB_test.ino
 *
 * Created: 4/6/2015 10:47:08 AM
 * Author: gurbrinder grewal
 * Modified by Arduino LLC (2015)
 */ 

#include "MIDIUSB.h"

// First parameter is the event type (0x09 = note on, 0x08 = note off).
// Second parameter is note-on/note-off, combined with the channel.
// Channel can be anything between 0-15. Typically reported to the user as 1-16.
// Third parameter is the note number (48 = middle C).
// Fourth parameter is the velocity (64 = normal, 127 = fastest).

void noteOn(byte channel, byte pitch, byte velocity) {
  midiEventPacket_t noteOn = {0x09, 0x90 | channel, pitch, velocity};
  MidiUSB.sendMIDI(noteOn);
}

void noteOff(byte channel, byte pitch, byte velocity) {
  midiEventPacket_t noteOff = {0x08, 0x80 | channel, pitch, velocity};
  MidiUSB.sendMIDI(noteOff);
}

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

// First parameter is the event type (0x0B = control change).
// Second parameter is the event type, combined with the channel.
// Third parameter is the control number number (0-119).
// Fourth parameter is the control value (0-127).

void controlChange(byte channel, byte control, byte value) {
  midiEventPacket_t event = {0x0B, 0xB0 | channel, control, value};
  MidiUSB.sendMIDI(event);
}

void loop() {
  midiEventPacket_t rx;
  do {
    rx = MidiUSB.read();
    if (rx.header != 0) {
      Serial.print("Received: ");
      Serial.print(rx.header, HEX);
      Serial.print("-");
      Serial.print(rx.byte1, HEX);
      Serial.print("-");
      Serial.print(rx.byte2, HEX);
      Serial.print("-");
      Serial.println(rx.byte3, HEX);
    }
  } while (rx.header != 0);
}

Selber senden kann man ja ganz gut mit

#include "MIDIUSB.h"

byte message[] = {0xF0,0x00, 0x00, 0x66, 0x05, 0x00, 0x10, 0x00, 0x6D, 0x61, 0x72, 0x65, 0xF7};

void setup() {
  while(!Serial) {};
}

void loop() {
  MidiUSB_sendSysEx(message,sizeof(message));
  MidiUSB.flush(); 
  delay(1000);
}

void MidiUSB_sendSysEx(const uint8_t *data, size_t size)
{
    if (data == NULL || size == 0) return;

    size_t midiDataSize = (size+2)/3*4;
    uint8_t midiData[midiDataSize];
    const uint8_t *d = data;
    uint8_t *p = midiData;
    size_t bytesRemaining = size;

    while (bytesRemaining > 0) {
        switch (bytesRemaining) {
        case 1:
            *p++ = 5;   // SysEx ends with following single byte
            *p++ = *d;
            *p++ = 0;
            *p = 0;
            bytesRemaining = 0;
            break;
        case 2:
            *p++ = 6;   // SysEx ends with following two bytes
            *p++ = *d++;
            *p++ = *d;
            *p = 0;
            bytesRemaining = 0;
            break;
        case 3:
            *p++ = 7;   // SysEx ends with following three bytes
            *p++ = *d++;
            *p++ = *d++;
            *p = *d;
            bytesRemaining = 0;
            break;
        default:
            *p++ = 4;   // SysEx starts or continues
            *p++ = *d++;
            *p++ = *d++;
            *p++ = *d++;
            bytesRemaining -= 3;
            break;
        }
    }
    MidiUSB.write(midiData, midiDataSize);
}

Zum convertieren müsste es doch auch fertige Lösungen geben. Ich persönlich würde aber eher bei Midi in Reinform bleiben.

Zitat von Haralder

Ganz einfach, weil du bei der Zweiwege Lösung neben einer Setzer Logik im Arduino zusätzlich den Abgleich mit GO über ein komplexes Protokoll wie Midi abwickeln musst. Beide Teile müssen ja die identischen Informationen haben. Bei einem Spieltisch der einfach nur Taster hat ist das noch ganz simpel. Midisignal für den zugewiesenen Setzer schicken und fertig. Aber wenn der Spieltisch dann auch signalisieren soll welche Register nun aktiv sind (was erst einmal nur GO weiß), dann muss deine Steuerung irgendwie an die bei GO hinterlegten Daten kommen und abgleichen.

Diesen Gedanken verstehe ich ehrlich gesagt noch nicht, aber vielleicht reden wir auch über verschiedene Dinge. Wieso braucht es überhaupt eine Setzer-Logik im Arduino? Der Arduino, der meinen Spieltisch kontrolliert, speichert zum Beispiel gar keinen eigenen Zustand sondern zeigt einfach immer nur das an, was GO per Midi übermittelt (also vor allem den Zustand der Setzerschalter, die Setzernummer und die Registerschalter). GO schickt dabei die Midi-Nachrichten immer dann, wenn sich der Zustand eines Schalters in GO ändert, unabhängig davon wie der Schalter betätigt wurde. Es ist also egal ob ich ein Register mit der Maus einschalte, oder mit dem physischen Schalter (d.h. per noteOn-Nachricht vom Arduino an GO). In beiden Fällen schickt GO eine noteOn/noteOff-Nachricht zurück an den Arduino, wodurch die Led des betreffenden Registerschalters ein- bzw. ausgeschaltet wird. Ich muss mir im Arduino gar nicht merken, welche Register gerade ausgewählt sind, sondern einfach nur auf die eingehenden Midi-Nachrichten reagieren. Wenn ich den Setzer weiter schalte, schickt GO nicht nur per Sysex-Nachricht die neue Setzer-Nummer, sondern automatisch auch alle noteOn/noteOff-Nachrichten für diejenigen Register, die sich geändert haben. Eine Synchronisierung zwischen dem Arduino und GO, wie du sie ansprichst, ist somit eigentlich nicht nötig (oder ich verstehe nicht, was du damit meinst). Der Arduino muss einfach immer nur den Zustand ausgeben, den GO per Midi meldet. Mit den Callback-Handlern der Arduino Midi Library funktioniert das auch ganz wunderbar und ergibt schön einfachen Code .

Zitat von techlit

In beiden Fällen schickt GO eine noteOn/noteOff-Nachricht zurück an den Arduino, wodurch die Led des betreffenden Registerschalters ein- bzw. ausgeschaltet wird.

Okay, dann muss man es wirklich nicht machen. Hat sich das mal geändert? Ich weiß noch damals (zwei jahre oder so) habe ich nicht diese Signale rausbekommen. Kann aber auch durchaus ein Fehler von mir gewesen sein. Ich würde trotzdem eher nicht Sysex nutzen sondern pures Midi. Ist einfacher weil man sich beim auslesen mit MIDIUSB das konvertieren spart.

Zitat von Haralder

Okay, dann muss man es wirklich nicht machen. Hat sich das mal geändert? Ich weiß noch damals (zwei jahre oder so) habe ich nicht diese Signale rausbekommen.

Ich nutze GO in Version 3.9.0, und da ist das Verhalten wie beschrieben. Mit früheren Versionen habe ich keine Erfahrung, daher kann ich nicht sagen ob sich das irgendwann mal geändert hat.

Zitat von Haralder

Ich würde trotzdem eher nicht Sysex nutzen sondern pures Midi. Ist einfacher weil man sich beim auslesen mit MIDIUSB das konvertieren spart.

Für Labels wie z.B. die Setzernummer geht das leider nicht, weil man die in GO nur per Sysex versenden kann. Für normale Schalter ist pures Midi natürlich die bessere Wahl.

Zitat von techlit

Für Labels wie z.B. die Setzernummer geht das leider nicht, weil man die in GO nur per Sysex versenden kann.

Ich bin damit nicht so vertraut. Diese Sysex sind aber statisch wenn man es einmal eingerichtet hat? Dann würde es ja reichen den Hex einfach zu prüfen um was es sich handelt ohne ihn umwandeln zu müssen oder?

Zitat von Haralder

Ich bin damit nicht so vertraut. Diese Sysex sind aber statisch wenn man es einmal eingerichtet hat? Dann würde es ja reichen den Hex einfach zu prüfen um was es sich handelt ohne ihn umwandeln zu müssen oder?

Was meinst du mit "umwandeln"? Die Sysex versenden die Werte der Labels als Text, zusammen mit ein paar HW-spezifischen Steuerinformationen. In dem Beispiel wird die Setzernummer also nicht als Zahl, sondern als ASCII-codierter Text übertragen. Wenn man die Steuerinformationen von der Sysex-Nachricht abschneidet, kann man sie dann z.B. einfach auf ein LCD-Panel ausgeben.

Zitat von J. Brassmann

Das würde mich in der Tat sehr interessieren!

Ich find's grad nicht mehr! Ist nicht in der Projekt-History gelandet. Aber es wird auffindbar sein

Edit:
Im falschen Ordner gelandet... Beim markieren als Code sind die Einrückungen verloren gegangen, aber zum Anschauen reicht es ja.
Der Code kommt ohne Bibliothek aus, also ein reines C-Programm.

getValFromHexChar wandelt ein einzelnes Hex-Zeichen in einen binären Wert. Erlaubt sind 0..9 und a..f oder A..F.

toAscii wandelt einen binären Wert in eine 3-stellige Dezimalzeichenkette. Der Parameter fillZeroes gibt an, ob führende Nullen verwendet werden sollen, also z.B. "001". Der Code funktioniert für 8-Bit-Werte (0x00 - 0xFF).

Das Hauptprogramm wandelt den Beispielwert "0x70" in eine Dezimalzahl als Zeichenkette "112".

Das "0x" wird bei der Verarbeitung überlesen, der Code geht also von einem Hex-Wert aus.

Zwecks Übersichtlichkeit habe ich Speicherfreigaben oder Fehlerprüfung beim zu übergebenden Wert weggelassen.

// Byte-Arrays werden der Übersichtlichkeit wegen in dieser Demo nicht freigegeben...


int getValFromHexChar(char t)
{
if (t >= '0' && t <= '9')
return t - '0';

if (t >= 'A' && t <= 'F')
return t - 'A' + 10;

if (t >= 'a' && t <= 'f')
return t - 'a' + 10;

return -1; // Fehler
}

char* toAscii(int v, bool fillZeroes)
{
char* text = new char[4] { "   " };
int i = 0;
int h = v / 100;

if (h > 0)
{
text[i] = h + '0';
++i;
v -= h * 100;
}
else if (fillZeroes)
{
text[i] = '0';
++i;
}

if (v > 10)
{
int d = v / 10;
text[i] = d + '0';
++i;
v -= d * 10;
}
else if (i > 0) // gibt es schon eine Hunderter-Stelle?
{
text[i] = '0';
++i;
}
else if (fillZeroes)
{
text[i] = '0';
++i;
}

if (v > 0)
{
text[i] = v + '0';
++i;
}
else if (i > 0)
{
text[i] = '0';
++i;
} // else Ergebnis bleibt leer

text[i] = 0; // Abschluss-Byte

return text;
}


int main()
{
char* hexAscii = new char[5] { "0x70" }; // zu konvertierende Hex-Zahl
int intVal = getValFromHexChar(hexAscii[2]) * 16;
intVal    += getValFromHexChar(hexAscii[3]);
char* decimalAscii = toAscii(intVal, true/*führende Null erwünscht*/);
}

Ich kenne mich auf dem Arduino nicht aus, aber falls eine Bibliothek zur Verfügung steht wie in C,

dann kann man toAscii so ersetzen:

#include <stdlib.h>
...
char ascii[5];
_itoa_s(intVal, &ascii[0], 5, 10);