Kann mir einerein gutes Tutorial empfehlen(oder es mir so erklären), wie
man eine Grafische Oberfläche mit dem Arduino "kommunizieren" lässt. Man
muss doch für diese Aktion nur den Serial Port auslesen und verarbeiten?
Aber leider weiß ich net wie das praktisch möglich ist.
PS: Ich hab ein Uno und das bevorzugte OS ist Linux, Windows geht aber
zur Not auch.
PPS: Die Programmiersprache ist mir egal(VB, C, C++ ...), mir geht es
hauptsächlich ums Prinzip.
Abend,
Wenn du eine grafische Interaktionsmöglichkeit suchst, schau dir mal
Processing an. Da ist es möglich in Sketches organisiert zustände zu
visualisieren bzw. Auch zu interagieren.
Die Programmierung ist sehr nah an der Arduino IDE. Daher sollte es kaum
Probleme geben.
MfG
Ich versteh das ganze RS232-getue nicht. Das war/ist duch die Serielle
Schnittstelle am PC??
Processing:
Hat jemand mal Links?
Ich war auf Titelwww.processing.org , aber da hab ich nichts
gefunden.
Hallo,
Also RS232 ist die andere Bezeichnung (normierte) für die Serielle
Schnittstelle des PC. Der hat definierte Pegel und es gibt einen festen
"Datenpaketaufbau"...
Zusätzlich ist definiert wie Sender und Empfänger arbeiten. Es gibt
synchrone und asynchrone Übertragung (mit und ohne Dataclock).
Wenn man seriell kommunizieren will, muss man meist nur wissen wo RX
(recieve) und TX (trancive) sind, bei 2 Leitungen nicht schwer, und die
Baudrate und Parität kennen. Seriell ist die "einfachste"
Übertragungsart nach paralleler Kommunikation.
Für Grundlagen empfehle ich die Wikipedia Seite oder die Infos in der
Wissensdatenbank hier auf der Seite.
MfG
Danke für die Links, aber das ganze RS232-Getue ist mir schleierhaft.
Ich schließe doch an mein Arduino keine RS232 an. Soll das eine virt.
Schnittstelle darstellen??
12V DC schrieb:> Danke für die Links, aber das ganze RS232-Getue ist mir schleierhaft.> Ich schließe doch an mein Arduino keine RS232 an. Soll das eine virt.> Schnittstelle darstellen??
Also wenn du solche basics nach mehrfachen erläuterungen und google
nicht verstehst, dann wir es etwas eng für dich.
Dein Atmega hat eine serielle, asynchrone schnittstelle mit 5 (3,3V)
volt pegel.
rs232 ist genau das gleiche, nur mit anderen spannungspegeln.
dafür gibt es dann standard ics wie dan max232 von maxim welche die
reine pegelkonvertierung durchführen.
das sollte doch jeder verstehen der lesen kann!!
Ich habe übewr die Links mal drübergeschaut, aber die benutzen alle
irgendwelche Processing-plugins/libs für die Arduino IDE (oder seh ich
da was falsch?). Ich dachte eher an das auslesen und schreiben über den
seriellen Monitor.
12V DC schrieb:> PS: Ich hab ein Uno und das bevorzugte OS ist Linux, Windows geht aber> zur Not auch.> PPS: Die Programmiersprache ist mir egal(VB, C, C++ ...), mir geht es> hauptsächlich ums Prinzip.
Wow, jemand der mehr als 3 Programmiersprachen und 2 Betriebssysteme
beherrscht, das muss ein Profi sein. Unter Linux nimmst du am besten VB.
Günther schrieb:> Wow, jemand der mehr als 3 Programmiersprachen und 2 Betriebssysteme> beherrscht, das muss ein Profi sein. Unter Linux nimmst du am besten VB.
1.) Man kann fast jeden sourcecode einigermaßen verstehen, wenn der nur
annähernd kommentiert ist. C++ kann ich selber nicht.
2.)Unter Linux nimmt man am besten C, da VB(visualbasic) unter Linux gar
net geht(is von Microsoft).
12V DC schrieb:> Ich habe übewr die Links mal drübergeschaut, aber die benutzen alle> irgendwelche Processing-plugins/libs für die Arduino IDE (oder seh ich> da was falsch?). Ich dachte eher an das auslesen und schreiben über den> seriellen Monitor.
Welchen 'seriellen Monitor'?
Egal.
Wenn du das selber machen willst, dann wirst du nicht umhin kommen, dir
ein Protokoll bzw. Kommandos auszudenken, mit denen 2 Programme (eines
auf dem Arduino, eines auf dem PC) miteinander kommunizeren.
Dann schickt halt das Programm auf dem Arduino dem Programm auf dem PC
den Befehl
'mal eine Texteingabebox an deine Fensterposition 10,10. Die Textbox
soll 40 Zeichen breit sein'
'mal den Text an die Fensterposition 10, 0. Und zwar den Text "Eingabe
Name"'
'mal einen Knopf an die Fensterposition 30, 40 und schreib 'OK' drauf'
Das Programm auf dem PC dekodiert die Befehle und führt sie aus.
Dann hat dein Benutzer auf dem PC ein Fenster (das Frontend deines
Arduino-Programms) in dem auf Anweisung vom Ardiuno diese 3 Elemente
auftauchen. Er gibt den Namen ein, drückt auf OK, und das PC-Programm
schickt wieder ein Kommando zum Arduino zurück: "Benutzer hat ok
gedrückt". Woraufhin der Arduino ein Kommando zum PC Programmschickt
"Gib mir den Inhalt der Textbos" und das PC-Programm antwortet darauf
mit dem Inhalt, warauf der Arduino wieder ein Kommando an das
PC-Programm schickt "Fenster löschen"
Du bist der Programmierer (und zwar beider Programme). Du denkst dir was
zu diesem Thema aus.
dorian schrieb:> hier........>> ach was solls , ich glaube wir reden aneinander vorbei
Im Prinzip nicht falsch, aber sein Ardunio hat bereits eine serielle
Datenverbindung zum PC. Schliesslich arbeitet ja der Bootloader bzw.
dieses 'Processing' auch da drüber.
Mit meinem Programm geht das auf anhieb:
Beitrag "Projekt: Virtuelle Instrumente an serielle Schnittstelle"
Lade Dir einfach die letzte Version 0.41a runter und lies Dir die Hilfe
durch. Damit kannst Du wahrscheinlich alles das grafisch darstellen was
Du möchtest. In der Hilfe gibt es auch Beispiele für Arduino.
Zum Test häng ich da auch immer einen Arduino dran, allerdings
programmier ich den mit Luna (über den Bootloader).
Wenn Deine Daten schneller kommen probier es hiermit:
Beitrag "Daten von der seriellen Schnittstelle einfach darstellen"
Da nimmst Du die Version 0.66
Meint ihr mit der seriellen Schnittstelle des Arduino den USB Port? Das
ist das einzige, wasch mit dem PCS verbinde.
@Dorian
Vielen Dank ich habs verstanden. Ich wollte eher wissen wie man das
programmier-technische macht.
@Albert M
Genau so meine ich es. Da ist auch meine Frage wie sendet man und wie
empfängt man??
-Ja gut via USB, aber wie empfange ich die gesendeten Daten vom Arduino
und wie sende ich die? -via serial.print?
Muss ich ans Arduino ne extra Schnittstelle ranhängen, wie dorian
bewschrieben hat?
Nein Du musst an den Arduino keine extra Schnittstelle hängen. Der PC
erkennt den über USB angeschlossenen Arduino als virtuelle serielle
Schnittstelle. Unter Windows greifts Du dann mit der Programmiersprache
Deiner Wahl (C, C#, VB, Delphi ...) auf diese virtuelle Schnittstelle
zu. Wie das dann genau im Einzeln geht, steht bestimmt im Manual der
Programmiersprache. Da fängt dann Deine Eigeninitiative an ...
Ich würde sagen: Die Anzahl an grafischen Oberflächen - was auch immer
Du darunter Verstehst - die RS232 sprechen, ist recht gering. Meistens
sind dann Terminals gemeint oder intelligente Touch-Screens.
Viele haben ihr eigenes Format (Befehlssatz) und werden über einen
parallel Bus, einen "halben" Bus oder auch I²C und CAN angesprochen.
Auch findet man hier oft Billigschnittstellen wie TTL-RS232 und
verschiedene andere serielle Protokolle.
Vielleicht kannst Du uns ein wenig, zu Deiner Vorstellung von einer
grafischen Oberfläche, erleuchten.
Dann sind so Antworten wie: >>Es gibt<<, >>Du brauchst<< usw. leichter
zu Formulieren.
Vor allem: Brauchst Du einen Rückwärtsgang? Also nur Anzeige von
Irgendwas, oder auch Bedienung (Rückmeldung).
@AlbertM
Ok schon mal verstanden, aber das wird doch nicht in den Manuals stehen,
da braucht man doch Libs oder irre ich mich?
@Amateur
Ich meine so Oberflächen, wie du sie als 'normale' windowsfenster
kennst, also mit Buttons, Labels & Co. Unter Linux meine ich dann Gtk
Fenster.
Im Prinzip soll das Programm so aussehen: Button wird gedrückt, LED am
Arduino geht an.
@12V
Dann brauchst Du das volle Programm, bestehend aus Schlüsselbefehlen und
Strukturierten Antworten.
Wenn es nicht eilt, macht man so etwas natürlich am Besten in ASCII. Da
kann man dann auch ein einfaches Terminal für den Test verwenden.
In wie fern sich die USB-Schnittstelle (Emulator) hierfür verwenden
lässt weiß ich nicht.
Auf Seite des Arduino gibt es einen ausreichenden Befehlssatz zur
Steuerung der seriellen Schnittstelle. Auf PC-Seite kommt es natürlich
auf die Programmierumgebung an. Sowohl Linux als auch Windoof sind hier
ausreichend bestückt.
Mein Rat.
Vergiss erst mal die ganzen grafischen Oberflächen.
Du hast mit dem Arduino eine einfache vorkonfigurierte Möglichkeit, wie
du am PC ein Textfenster aufmachen kannst und per Serieller
Schnittstelle (die intern über USB geführt wird) auf dieses Terminal
Text ausgeben und von dort Text einlesen kannst.
Beschäftige dich erst mal damit. Dafür gibt es auch jede Menge Tutorien
am Netz.
Und wenn du da dann erst mal firm bist, dann kommt der nächste Schritt.
Das lernen, wie man auf dem PC unter einem bestimmten Betriebssystem ein
Programm mit grafischer Oberfläche aufbaut.
Aber im Moment willst du zu viel. Das kannst du nicht mehr stemmen.
Jetzt noch nicht.
12V DC schrieb:> @AlbertM> Ok schon mal verstanden, aber das wird doch nicht in den Manuals stehen,> da braucht man doch Libs oder irre ich mich?
Kommt auf Deine bevorzugte Programmiersprache an. So viel ich mich
erinnere geht das z.B. in VB direkt, in Delphi immer über zusätzliche
Components, in anderen Sprachen über Lib's.
Für alle Programmiersprachen gibt es gute deutsche Foren. Einfach da
nachfragen. Im Allgemeinen ist es relativ einfach die serielle
Schnittstelle anzusprechen.
Da Du Dich aber nicht festlegen magst, unter welcher Umgebung und
welcher Programmiersprache Du was machen willst, wirst Du hier keine
passende Antwort bekommen.
Eine Gehhilfe zur Fragestellung z.B.:
Wie spreche ich unter Windows 7 mit C die serielle Schnittstelle an.
@karl heinz
Gut dann halt ohne Grafische Oberfäche. Aber das Problem bleibt:Wie
lasse ich das ganze miteinander kommunizieren?
Schreibe ich auf Arduino-Seite einen Skech, der auf Signale von der
seriellen Schnittstelle Wartet(nebenbei: wie würde da der befehl lauten
'Serial.read'?)?
PS: Ich lege mich fest: C + Linux(Windows ist aber auh kein Problem)
Hier geht es nicht um Kreativität. Hier sollte mir jemand sagen, der das
schon mal gemacht hat, wie man das macht, oder wo es ein gutes Tutorial
gibt.
Klar irgendwie serielle Kommunikation, aber wie??
12V DC schrieb:> Hier geht es nicht um Kreativität.
Doch natürlich. Weil DU dir für deine Anwendung ein Protokoll ausdenken
musst. Deine Anwendung gibt es nämlich nur einmal. Darum gibts dafür
kein fertiges Protokoll.
> Hier sollte mir jemand sagen, der das> schon mal gemacht hat, wie man das macht, oder wo es ein gutes Tutorial> gibt.
Tutorial für was? Wie man die serielle Schnittstelle benutzt? Findest du
reichlich für AVR, Arduino und noch mehr für sämtliche
Programmiersprachen am PC.
Alles weitere ist DEIN Protokoll. Welche Daten werden gesendet? Pakete,
Länge, Header? Checksumme?. Welche Kommandos gibt es. Welche Argumente
für welches Kommando usw usw. Das alles läuft oberhalb der seriellen
Verbindnung.
Dein Problem wird aber sein, du kannst das mit der seriellen Verbindung
noch gar nicht. Und dafür gibts aber reichlich Infos im Netz. Also üben
üben. Erstmal die Basics dann kommt deine Anwendung.
gruß cyblord
12V DC schrieb:> Hier geht es nicht um Kreativität
Doch genau darum gehts. Dein Computer und der Arduino "reden" mit
einander und wie genau das bestimmst du alleine.
Stell dir doch mal vor du hast vier LEDs an den Arduino angeschlossen
und hast ein ganz einfaches Programm auf dem PC laufen. Einfach ein
Fenster mit 4 Buttons die mit 1,2,3 und 4 beschriftet sind. Mit jedem
Button kannst du eine LED am Arduino an oder aus schalten. Du klickst
auf einen Button (z.b. den der mit 1 beschriftet ist) dann sendet bein
PC das Byte 0b00000001 an den Arduino. Der liest das und "weiß" (weil du
das so programmiert hast) dass er jetzt LED 1 anschalten soll. bei den
Buttons 2 3 und 4 sendet der PC halt jeweils 0b00000010, 0b00000011 oder
0b00000100.
Fertig ist das simple serielle Protokoll.
@ 12V DC
Albert M. schrieb:> Mit meinem Programm geht das auf anhieb:> Beitrag "Projekt: Virtuelle Instrumente an serielle Schnittstelle"> Lade Dir einfach die letzte Version 0.41a runter und lies Dir die Hilfe> durch. Damit kannst Du wahrscheinlich alles das grafisch darstellen was> Du möchtest. In der Hilfe gibt es auch Beispiele für Arduino.
Anscheinend bist Du auch Hilfe-Resistent.
Also nochmal:
Die von Dir gewünschten Beispiele für verschiedene Programmiersprachen (
C, C für Arduino, Bascom, Luna ) findest Du in der Hilfe meines
Programms. Da kannst Du sehen wie die Schnittstelle auf der MC-Seite
angesprochen wird.
Aber das ist wahrscheinlich wieder in den Wind gesprochen.
Aber ich habe langsam auch so das Gefühl wie die anderen hier, dass Du
besser ganz klein bei den Grundlagen anfängst.
>Anscheinend bist Du auch Hilfe-Resistent.
Es könnte aber auch sein, der Poster "12DC" die Beiträge in diesem
Thread noch nicht verstehen konnte.
Hier eine vereinfachte Anleitung:
1. das Programm von Albert auf den PC laden
2. Den Arduino an den PC mit einem USB-Kabel anschließen
3. die Arduino IDE starten
4. die Arduino Beispiele von Alberts Programm auf Arduino laden
5. das PC-Programm von Albert starten
@Eumel
Ja aber ich kann mir nichts ausdenken, wenn ich nicht weiß, wie ich
signale via USB ans Arduino sende(mit C). genau das möchte ich wissen.
@Albert, chris_
Ich bin nicht hilferesistent, aber ich finde in den viuelen Beiträgen
halt die Sources net(nur den setup(das sind doch net die sources?)).
Wenn ihr mir einen ungefähren Zeitraum sagen könnt, wann das gepodstet
wurde, wäre ich schon zufrieden. ;)
12V DC schrieb:> @Eumel> Ja aber ich kann mir nichts ausdenken, wenn ich nicht weiß, wie ich> signale via USB ans Arduino sende(mit C). genau das möchte ich wissen.
Welchen Teil des Satzes "Vergiss USB, du hast damit nichts zu tun."
verstehst du nicht?
Welchen Teil des Satzes "Du musst dich damit beschäftigen, wie eine
serielle Datenverbindung mit dem Arduino System Software-mässig
funktioniert. Dazu gibt es Tutorien im Netz" verstehst du nicht?
12V DC schrieb:> Ich bin nicht hilferesistent, aber ich finde in den viuelen Beiträgen> halt die Sources net(nur den setup(das sind doch net die sources?)).
Schon ausprobiert?
Also wenn ich ein Zip File downloade, in dem lediglich ein EXE drinnen
ist, dann führe ich das halt mal aus (wenn ich dem Autor vertraue). Und
dann schau ich nach, was dieses Setup mir alles auf die Festplatte
kopiert hat.
Ich geb dir recht, dass es im gegenständlichen Fall netter wäre, wenn im
Zip-File die einzelnen Dateien direkt enthalten wären. Aber so hat das
auch seine Berechtigung. Man hat ein EXE und ist sich sicher, dass man
beim weiterkopieren dieses einen EXE keine Datei vergessen haben kann.
Ich hab das Programm installiert! Keine Sources gefunden! Aber ich lasse
mich da eines besseren belehren.
"Vergiss USB" USB ist die einzige Schnittstelle, die das Arduino hat,
also vergesse ich sie nicht.
"Tutorien im Netz" ich würde ja hier wohl nicht fragen, wenn ich welche
gefunden hätte.
Also ich benötige einfach eine Anleitung, da ich auf dem Gebiet(Grafik
fürs Arduino) komplett neu bin. So schwer zu verstehen?
12V DC schrieb:> Ich hab das Programm installiert! Keine Sources gefunden! Aber ich lasse> mich da eines besseren belehren.
Wäre das erste mal. Du bist Beratungs- und Bildungsresistent.
> "Vergiss USB" USB ist die einzige Schnittstelle, die das Arduino hat,> also vergesse ich sie nicht.
Du kapierst nicht, dass es nicht um USB geht, sondern um die serielle
Schnittstelle, welche hier über eine USB-Verbindung aufgebaut wird. Aber
für dich ist es eine serielle Schnittstelle. Egal ob echt oder virtuell.
> Also ich benötige einfach eine Anleitung, da ich auf dem Gebiet(Grafik> fürs Arduino) komplett neu bin. So schwer zu verstehen?
Um Grafik gehts hier noch gar nicht. So schwer zu verstehen? Erstmal
musst du mit dem Grafischen System (z.B. PC) kommunizieren können.
Du bist hoffnungslos. Werd Gärtner. So schwer zu verstehen?
12V DC schrieb:> Ich hab das Programm installiert! Keine Sources gefunden! Aber ich lasse> mich da eines besseren belehren.>> "Vergiss USB" USB ist die einzige Schnittstelle, die das Arduino hat,> also vergesse ich sie nicht.
Doch.
Vergiss sie.
Denn du hast mit USB nichts zu tun.
Auf der Arduino Seite sprichst du die Datenverbindung als ganz normale
serielle Verbdinung an. Auf der PC Seite kommen die Daten wieder aus
einer ganz normalen seriellen Verbdinung raus.
Dass die Daten zwischendurch mal auf einem USB Kabel waren, ist nichts,
was dich interessieren müsste. Sie hätten auch per Brieftaube befördert
werden könnnen. Das alles ist für dich nicht relevant. Für dich als
Programmierer der Arduino Seite steckst du deine Daten in eine serielle
Schnittstelle rein und für dich als Programmierer der PC-Seite kommen
sie wieder aus einer seriellen Schnittstelle raus. Um den Transport
dazwischen musst du dich nicht kümmern.
Jetzt klarer?
> "Tutorien im Netz" ich würde ja hier wohl nicht fragen, wenn ich welche> gefunden hätte.
Ah geh.
In 10 Sekunden kann ich mit Google haufenweise Tutorien finden, die
haarklein auf das Thema "Arduino serielle Schnittstelle" eingehen.
>> Also ich benötige einfach eine Anleitung, da ich auf dem Gebiet(Grafik> fürs Arduino) komplett neu bin. So schwer zu verstehen?
Vergiss erst mal "Grafik für Arduino". Erst mal musst du die
Kommunikation hinkriegen. Denn die Grafik findet nicht am Arduino statt.
Die Grafik findet am PC statt. Dein Arduino ist ein Kiebitz am Pariser
Mont Matre, der dem eigentlichen Zeichner Kommandos zuruft, was er
zeichnen soll. Dazu muss er aber erst Reden und dann Französisch lernen.
Bei dir eben "der UMgang mit der seriellen Schnittstelle und der
Vereinbarung von Kommandos". Aber erst kommt der Umgang mit der
seriellen Schnittstelle.
Also, irgendwie funktioniert das mit dem HTTP-Protokoll auch rund um die
Welt und letztlich werden da nur Textblöcke über eine quasi-serielle
Leitung (was das Analogon TCP im IP darstellt) hin und her geschoben.
Wenn du schon einmal grafische Oberflächen programmiert hast, weißt du
auch, das der Button-Click als Ereignis-Botschaft in deiner
Click-Routine ankommt, und wenn du das schon öfters gemacht hast, auch,
dass die Click-Routine die Erledigung zurückgibt.
So ähnlich passiert das im HTT-Protokoll.
Also auf Arduino-Seite hast du einen Kommando-Interpreter, der solange
Ziechen in einen Puffer sammelt, bis die Befehlsbestätigung Linefeed
kommt. Dann wird der Puffer-Inhalt interpretiert. Wenn er nicht
verstehbar ist (weil keine Ausführungsroutine für hinterlegt ist) gibt
er sicherheitshalber "NOK" (für nicht verstanden) abgeschlossen mit
einen LF zurück.
Alle verstehbaren Befehle werden entweder mit OK oder einen passenden
Wert beantwortet (und natürlich mit LF anbgeschlossen).
In der grafischen Oberfläche übersetzt du deine Ereignisse als Befehle
in die serielle Schnittstelle (deine Ereignisbehandlung übersetzt in die
serielle Schnittstelle). An die serielle Schnittstelle (welche in .net
z.B. als Objekt einrichtbar ist) hängst du ebenfalls eine
Ereignisbehandlungsroutine, die die Antworten deines Arduino auszuwerten
im Stande ist.
Geschickt in dem Fall ist, wenn dein Arduino Antworten gibt, die auf den
ursprünglichen Befehl zurückschließen lassen. Denn dann braucht deine
Routine an der seriellen Schnittstelle nichts von den übergebenen
Befehlen zu wissen.
So weit die Skizze, Inhalte musst du selber erfinden. Was ich noch
ausprobieren wollte, war die SLIP-Client-Implementierung mit Port-Server
auf dem Arduino. Dann braucht dein SLIP-Host nämlich nur noch eine Route
ins Netz und dein Arduino kann von jeden beliebigen Netzwerk-Rechner
angesprochen werden. Aber das schluckt natürlich ordentlich Speicher im
Arduino.
12V DC schrieb:> Ich hab das Programm installiert! Keine Sources gefunden! Aber ich lasse> mich da eines besseren belehren.
Was an meinem Satz:
"In der Hilfe gibt es auch Beispiele für Arduino."
verstehst Du nicht?
Also nochmal für Dich: Im Programm klick auf "Hilfe". Dann öffnet sich
die Hilfe/Anleitung (als PDF-File). Darin findest Du die
Programmierbeispiele, unter anderem auch für Arduino.
... und ich bin jetzt hier raus.
Vielen Dank genauso hätte es doch auch am Anfang sein können. Ich hab
halt das Hilfe auf irgendeinen File bezogen, der in der zip herumliegen
sollte. sorry.
Danke Karl Heinz und pst, jetzt habe ich auch verstanden wonach ich
suchen muss. War halt mich so auf die serielle aus.
Die Seriell-Emulation über USB scheint nur veraltet, sie ist aber die
universellste Anbindungsmöglichkeit. Auch deswegen weil sie seit langen
in der Computertechnik eingesetzt wird (siehe SLIP).
Zur Beruhigung: Auch die COM-Emulation über USB überträgt mit der
Verfügung stehenden USB-Geschwindigkeit von 1,5 oder 12 MBit/s. Die in
diesen Emulationen implementierten "Übertragungsgeschwindigkeiten" (z.B.
9600 Baud) dienen lediglich der Mitteilung dem Client auf der
Gegenseite, der das ggfls. auf eine reale dran angeschlossene serielle
Schnittstelle übersetzen kann. Wenn der Host bei der Übertragung "zu
schnell" wird, gibt es auch im USB-Protokoll das "Nicht verstanden"
Signal, welches so lange zurückgegeben wird, bis wieder Daten
verarbeitet werden können.
Der im Arduino Leonardo oder Micro (Atmega32u4) enthaltene Stack kann
das aber direkt weiterverarbeiten. Die effektive Übertragungsrate hängt
eher von der Verarbeitungsgeschwindigkeit des Arduino ab, denn von der
eingestellten Übertragungsrate. Durch Erfindung eines eigenen
USB-Protokolls erreichst du keinen Geschwindigkeitsvorteil, eher im
Gegenteil, nämlich jeden Pipifax im USB-Protokoll selbst feintunen zu
müssen, bis hin zum Treiber im Host selber.
Interessant währe villeicht auch die Verwendung der remote display
funktion von µGFX. Als Interface würde man halt einfach seriall statt
TCP/IP implementieren.
http://ugfx.org
