Arduino Serial Communication JAVA ???

[fucktheking]

Hallo Leute,

langsam arbeite ich mich im Arduino business vor :-) Nach wie vor möchte ich eine Schnittstelle von einem MIDI Interface zu meinen alten analogen Instrumenten bauen. Der C++ code ist fertig, hochgeladen und der Arduino funktioniert wie er soll. Nun möchte ich mit JAVA eine GUI schreiben, mit der ich die Werte der Arrays (notes[],pins[]) ändern kann. Der Arduino soll hierfür per USB verbunden werden.

Arduino C++ Code



byte incomingByte;
byte note;
byte velocity;
int action=2;


int notes[]= {36, 40, 41, 43, 44, 46, 42, 39, 37, 52};
int pins[]= { 6, 5, 2, 8, 7, 10, 11, 4, 3, 9};
unsigned long pintime[]= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
const unsigned long pininterv[]= {10, 20, 10, 10, 10, 10, 30, 10, 10, 70};
int pinstate[]= {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int delayseq[]= {20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180};


void setup() {
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
pinMode(10,OUTPUT);
pinMode(11,OUTPUT);
pinMode(13,OUTPUT);

for (int i=0; i<=9; i++) {
pintime[i]=millis ();
digitalWrite(pins[i], LOW);
}

Serial.begin(31250);
}


void loop () {....}


Kann ich hier mit der jSerialComm Jar Bibliothek arbeiten ?
Die Java Programmierung ist bekannt und klar, es geht nur um das Verändern der Array Werte des schon im Flash Speicher liegenden C++ Programms. Muss ich vllt. mit dem SRAM/EEPROM arbeiten. Wenn ja, wie ?
Was ist mit der Baudrate die ja für die Serial Comm 9600 sein muss...
Weis leider nicht wie ich vorgehen soll, stehe gerade mitten im Wald und sehe die Bäume nicht. Wäre schön wenn mir hier jemand einen Denkanstoss geben könnte. :confused:

[Rabenauge]

Warum machst du das nicht direkt im Arduino?

Ich hab im Midi-Keyboard nen Mega 2650 drin, aus dem Ding geht nix ausser den fertigen Midi-Daten raus.
Kanäle wechseln, Oktaven anpassen, das alles wird direkt im Keyboard gemacht. Macht auch Sinn, denn während dem Spiel noch den Rechner bedienen, das wird doch nix.
Ne Midi-Out ist schnell gebaut, einfach eine der seriellen Schnittstellen (der Mega hat vier) auf die Midi-Baudrate einstellen, Midi-Buchse dran (oder USB-Adapter) und ab mit den fertigen Daten, zum Synthie. Beim Uno oder so könnte man SoftSerial verwenden.
EEPROM nutze ich momentan nur für eines: den Punkt, an dem die Tastatur gesplittet wird, abspeichern. Macht Sinn, wenn man den verändern kann, aber nicht jedes Mal.

Wenn du partout normal seriell senden willst, kannst du dir die Hairless Midi-Serial-Bridge mal anschauen, die kann auch mit anderen Baudraten arbeiten, und dann ggf. Midi weiterleiten.
Wäre mir allerdings das Routing dann zu viel Gewurstel...ich benutze die lediglich zum debuggen.

Edit sagt gerade: 9600 ist für Midi ohnehin zu wenig, wenn man noch nen paar Controllerdaten mit sendet, reicht es nicht mehr um "live" zu spielen.

[fucktheking]

midi verarbeitung läuft im arduino. ich lese im arduino die midi bytes aus und sende dann entsprechende infos an die Digitalen Ausgänge. Jedoch welche infos wann und wie gesendet werden möchte ich gerne über die GUI anwendung bestimmen können. Ist quasi das routing das man immer vornehmen kann. einfach per usb anstecken und dann das routing ändern welches signal vom midi an welchem ausgang landet. das könnte man eben easy über die arrays realisieren. wenn ich nur wüsste wie ich die aus java heraus verändern kann.... hmmmm
ich habe mich für diesen weg entschieden weil ich 5 analoge drumcomputer habe die alle 5V trigger brauchen. ich will eben einen arduino kaufen, C++ programm drauf, einbauen und die usb buchse nach aussen legen. und wenn man dann mal sein set arrangieren will, würde ich einfach gerne mit dem usb ran, und zb den midikanal ändern oder die bassdrum von C1 auf C2 setzten.
wie gesagt, dass Programm dafür steht schon und funktioniert. würde nur ungerne jedes mal in den programmcode und dann händisch die parameter einstellen.
baudrate bei midi is 31250

[HaWe]

wieso aus "Java" raus?
wo ist denn hier Java?
Arduino Sketch ist C, nicht Java - oder hast du eine externe Java IDE?


Arrays änderst du wie üblich per

foo[0]=...
foo[1]=...
usw

und Serial ist hier beschrieben:
https://www.arduino.cc/en/Reference/Serial

[fucktheking]

habe leider keine externe Java IDE
hab mal schnell bild gezeichnet. bin anscheinend mit erklären nicht so gut.

31539

Das java programm schreibe ich gerade. und jetzt suche ich eben nach einer möglichkeit um von dem java programm aus, den arrayinhalte vom C++ Programm im Arduino zu ändern.

[Rabenauge]

..im Zeichnen auch nicht?
So richtig klar wird es mir nicht.
Was soll bitte ne "analoge Drummachine" sein? Ein Schlagzeug-Synthie?
Was ist der "Midi Signal Sender"? Nen Midi-Keyboard oder Touchpad oder so?

Wenn ich das richtig erraten habe, frag ich mich, wozu da Arduino und PC (samt Schwachstelle "Java" )nötig sind?
Dieser Aufbau _kann_ nix brauchbares ergeben, die Latenzen müssen jenseits gut und böse liegen, weil alles zigmal verwustelt wird.
Wenn der Sender allerdings irgendein Midi-Gerät ist, und du das Ganze gar nicht "live" spielen willst, wäre die Latenz evtl. nicht tragisch, aber dann kanst du auch direkt die Midi-Datei vom PC zum Synthie schicken, und ggf. zum aufnehmen zurück.
Oder willst du lediglich verschiedene Presets (angepasst an den jeweiligen Drumcomputer) vom PC zum Arduino senden, damit der z.B. die einzelnen Instrumente anpasst?

Falls dem so ist: speichere die Presets direkt im Arduino ab- so wie das da aussieht klappt das in Echtzeit nie und nimmer.
Hab ich bei meinem Keyboard auch gemacht:
ich kann ein (bisher nur eins...) Preset für Aeolus (Orgel-Synthie) direkt beim starten einstellen.
Hier wählt der Arduino automatisch die passenden Kanäle (drei insgesamt) aus, ich kann wahlweise die Tastatur splitten (oder auch eine der beiden Tastaturen aufs ganze Brett nehmen, und das in Echtzeit), mit dem dritten Kanal übertrage ich nen Program-Change, mit dem wiederum ich dann voreingestellte Presets im Laptop abrufen kann.
Momentan hat das Keyboard lediglich ne normale Midi-Buchse, USB besorg ich mir mittels Midi2USB-Adapterkabel (das Teil bau ich irgendwann direkt ins Keyboard, so weit isses aber noch nicht), einfacher und flexibler geht es nicht.
Wenn _ich_ mehrere solcher Spezialfälle (der Aeolus _ist_ etwas speziell) hätte, würd ich mir einfach für jeden davon nen eigenes Preset ins Keyboard programmieren, die kann man dann ggf. auch zur Laufzeit (also während dem Spiel!) wechseln.

Bei dir würde ich wahrscheinlich das Routing ganz einfach so machen:
Eingabegerät->PC, dort dann den Jack-Server mit passenden Routings (kann man abspeichern) laufen lassen, Synthie an nen anderen Anschluss, fertig.
Da brauchts echt kein rumgewurstele mit Java...
Falls du kein Linux nutzt, könnte man das Gleiche mit LMMS (kostenlos) machen, auch dort kann man Midi nahezu beliebig routen- Jack ist aber wesentlich effektiver.
Da brauchts keinen Arduino für.
Aber wenn der eben mitspielen soll, mach das doch so: leg dir fertige Presets an, die du, meinetwegen in der Setup-Routine, abfragst. Brauchst halt sowas wie ein Display (geht im Notfall mit ner LED, die Blinkmuster ausgibt schon, ich hab ein 1.8er Farb-TFT drin), und nen Button-wobei du da ja auch dein normales Eingabegerät nutzen kannst.
Da brauchste nicht erst mit Java rum basteln.
Auch Midi aus nem Arduino raus zu bekommen, ist nicht schwer, das geht über ne serielle Schnittstelle wunderbar (Widerstand dran, Midibuchse, fertig), Midi rein ist etwas aufwendiger, hier muss noch nen Optokoppler zwischen.

Während der Arduino Midi-Daten verarbeitet, noch über den Umweg PC (und Java-Krücke) daran was zu ändern, kannst du vergessen.
Wenn du das unter 10ms Latenz noch hin kriegst, bist du entweder sehr gut, oder hast nen sehr schnellen Rechner- aber auch die 10ms sind inakzeptabel.
Alles was oberhalb 5-6ms an Latenz liegt, ist zum live spielen nicht mehr zu gebrauchen, hier muss schon synchronisiert werden, und _dann_ wirds richtig aufwendig.

Immer wichtig bei Midi: das Timing. Je weniger an nem Signal noch nachträglich rumgebastelt wird, umso gut. Du gehst da gerade völlig den falschen Weg.
Falls du eines dieser Midi-Eingabe-Wunder hast (son Ding hab ich auch, aber nen einfaches, da mein Schlagzeug Hydrogen heisst), mit Tasten, Reglern, Pads- schnapp dir einfach mal die Hairless-Midi-Serial-Bridge und guck mal, was dein Teil wirklich an Daten schickt.
Bei meinem Miditech war ich entsetzt....drum mache ich das auch selber jetzt.

[fucktheking]

hey, danke für die Antwort. Die Konstellation muss leider so sein, da ich einen Java Kurs mache und das mein Projekt ist .... :rolleyes:
"""Oder willst du lediglich verschiedene Presets (angepasst an den jeweiligen Drumcomputer) vom PC zum Arduino senden, damit der z.B. die einzelnen Instrumente anpasst?""" <--- ganz genau.

es funktioniert schon alles ohne die usb verbindung! roland tr505 schickt midinoten (C1 für Bassdrum) an den RX eingang. Dann Kommt auf DI3 (OUT) ein +5V signal, welches den analogen bassdrum schaltkreis des hohner rhythm 80 antriggert.
ich möchte über das java programm lediglich die möglichkeit haben, dem arduino zu sagen, dass er, sobald die note für C1 kommt nicht auf den DI3 (Out) sondern den DI4 (OUT) auf HIGH setzten soll. das ist ein einmaliges anstecken per usb, java programm starten, einstellung rüberschicken, usb weg und arduino läuft wieder autark.

[Rabenauge]

Hm- und aus der Sache kommste da nicht ohne weiteres raus, oder?
Total uuuuumständlich.
Aber wenn es um weiter nix geht: schreib das Duino-Programm so, dass du meinetwegen im EEPROM die passenden Zuordnungen liegen hast.
Die kannst du dann leicht bei jedem "umprogrammieren per Java-Programm" (ich kringel mich grad so bisschen wegen dieser Umständlichkeit, sorry ;) ), überschreiben.
Das dürfte nicht allzu schwer sein.
EEPROM hält 100 000 Schreibzugriffe garantiert aus, wenn du willst, kannst du nen Ringspeicher anlegen, dann geht das praktisch "endlos".
Beim eigentlichen Spiel werden dann einfach die Daten ausm EEPROM geladen.
Brauchst hat ein Protokoll, was du arduinomässig verstehen kannst. Beispielsweise sendest du zuerst eine Art Kennung (wie in Midi, die CC-Bytes oder so), damit der Arduino weiss, da kommt jetzt was rein. Genau darauf wartet der Arduino beim einschalten einfach nen paar Sekunden (wie es der Ardu-Bootlader auch tut).
Danach einfach nen paar Variablen, und die schreibt er brav ins EEPROM.
Dann neu starten (ohne PC) und ab dafür.

Und wenn du mit diesem Test dann durch bist, lös das vernünftiger...:cool:
Hast du nicht nen Micro oder sowas, der kompatibel zum Leonardo ist? Die lassen können sich doch ohnehin als HID ausgeben, da dürft das nicht schwer sein.

[Rabenauge]

Bei Gelegenheit sollten wir uns übrigens mal unterhalten: ich bräuchte auch mal ne halbwegs brauchbare eingabemöglichkeit für Schlagzeug, aber keine Fingertipp-Pads bitte. Einfach, um mal schnell ne Idee aufnehmen zu können. Nen richtiges (midi-)Schlagzeug aber ist mir zu voluminös (kein Platz).
Ich überleg schon, mir so ein Playstation-Schlagzeug zu besorgen und umzubauen.