Ich mache Ausgaben von einem ATMega32 in C über UART in picocom. Ich meine, daß man mit dem X-Server über die serielle Schnittstelle Linien und Polygone zeichnen kann. Kann mir jemand ein Beispiel dazu sagen ?
Gustav, Gasthof. Picocom wird nicht mit dem X-Server kommunizieren können, das ist ein dummes terminal. Damit fällt IMHO auch VT100 aus, mit dem man Textfenster "bunt" machen könnte. Lösung: Eigenes Programm (oder Skript) das mit dem µC kommuniziert. X-Server will man nicht selbst programmieren, dafür gibt es Frameworks wie Qt oder Tk.
Es soll von einem C-Programm auf dem PC ein X-Server-Fenster geöffnet werden, das seine Daten über die serielle Schnittstelle in Empfang nimmt. Über die serielle Schnittstelle kann dann ein ATMega32 über UART Nachrichten an dieses Fenster senden, die der X-Server als Malbefehle für Linien und Polygone versteht. Ich habe mal davon gehört, daß das geht. Man hätte dmit eine sehr billige Graphikausgabe in 24-Bit-Auflösung für den ATMega.
Moin, - frueher (wirklich frueher) hatte das xterm einen Tekronix Mode (emultierte einen Tektronix 4010). Da konnte man (mit einer Library) eine Grafikausgabe machen fuer Programme, die eigentlich keine Grafikausgabe vorgesehen hatte (z.b. Daten von einem Grossrechner). Gucke mal hier: https://github.com/hansake/Tektronix_Plot_10_graphics Gruesse Th.
Ich würde einen Browser benutzen. Mit Javascript kann man SVG-Objekte, die in der HTML-Datei definiert sind, beliebig manipulieren. Der Atmega könnte also seriell in JS-Syntax Variablen ausgeben, die dann vom Javascript-Programm ausgewertet und in Grafik übersetzt werden. Es wäre dann auch leicht mit einem Webserver erweiterbar, dass man die Grafiken auf beliebigen Geräten ansehen kann.
picocom kann Dateien empfangen (X-Modem). Diese kann man irgendwo ins Dateisystem legen, darauf macht man einen i-node-watcher, und der triggert was Du willst: z.B. einen Web-Browser, falls Du SVG erzeugst.
Nach meinem Wissen ist ein X-Server ein Client, auch wenn er Server heißt. Der Benutzer startet als erstes den X-Server und weist ihn an, auf dem mit ihm verbundenen Rechner ein Programm zu starten, das nun seineseits passende Grafikausgaben absondert, die vom X-Server dargestellt werden. Den ATMega32 wird der X-Server nicht ansprechen können, da der Mega32 das zugehörige Protokoll vermutlich nicht versteht, es sei denn, Du implementiertest es. Also braucht ein Programm auf einem vom X-Server erreichbaren Rechner, das als Interface die Daten vom ATMega abholt und an den X-Server weiterleitet. Ob es das schon fertig gibt, weiß ich nicht. Meine persönliche Datenbank listet für Grafikausgaben von einem Mikrocontroller die folgenden Links und Schlagworte: =========================== Anzeigen serieller Daten auf PC: Beitrag "Re: Messwerte von einem Arduino auf den Pc Bildschirm Anzeigen lassen" Beitrag "Projekt: Virtuelle Instrumente an serielle Schnittstelle" Beitrag "Serielle Visualisierung mit Comvisu" Grafana Gruß Klaus (der soundsovielte)
Die bisherign Antworten verweisen auf lange Programmpakete, mir ging es um wenige Anweisungen in C (100 bis 200 Anweisungen). Gemeint ist: Man kann in C ein Fenster des X-Servers öffnen und auf dieses Fenster zugreifen und Linien, Bilder und auch 3D-Objekte über OpenGL darstellen. Man kann weiterhin von einem C-Programm ein Fenster auf dem X-Server öffnen, das über TCP einem anderen Rechner erlaubt, Graphik-Ausgaben auf dem eigenen Rechner machen zu lassen. Und es gibt die Möglichkeit, in C ein Programm zu schreiben, das den X-Server ein Fenster öffnen läßt, das für kleinere CPUs und Controller die Möglichkeit bietet, über eine serielle Schnittstelle (ohne TCP) Graphik-Kommandos abzuschicken, die dann angezeigt werden. Es soll ein C-Programm ein Fenster geöffnet werden, das seine Kontrolle an den ATMega angibt, der dann über die serielle Schnittstelle Linien zeichnen kann.
Klaus S. schrieb: > Nach meinem Wissen ist ein X-Server ein Client, auch wenn er Server > heißt. > Der Benutzer startet als erstes den X-Server und weist ihn an, auf dem > mit ihm verbundenen Rechner ein Programm zu starten, das nun seinerseits > passende Grafikausgaben absondert, die vom X-Server dargestellt werden. Das kenne ich anders, von der Kombination: PC am Arbeitsplatz, während das Anwendungsprogramm auf einem Applikations-Server im Rechenzentrum läuft. Auf dem PC startet man einen X-Server, der hält sich unsichtbar im Hintergrund und wartet darauf, dass ihn irgend jemand per TCP/IP Socket auf Port 6000 kontaktiert. Dann loggt man sich wie auch immer auf den Applikations-Server im Rechenzentrum ein und gibt ein: export DISPLAY=meine_ip:0 Dann startet man irgendein grafisches Programm, zum Beispiel Firefox. Das Programm verbindet sich mit der IP Adresse die in der DISPLAY Variable steht. Zur Zahl hinter dem Doppelpunkt wird 6000 addiert, also meine_ip:6000, das ist der X-Server auf meinem PC. Der zeugt dann das Bild von Firefox an. Für das Projekt des TO würde ich spontan etwas mit SVG versuchen, das scheint mir deutlich einfacher, als mich mit dem alten X11 Protokoll zu beschäftigen.
Oliver K. schrieb: > Die bisherign Antworten verweisen auf lange Programmpakete, mir ging es > um wenige Anweisungen in C (100 bis 200 Anweisungen). > > Gemeint ist: Man kann in C ein Fenster des X-Servers öffnen und auf > dieses Fenster zugreifen und Linien, Bilder und auch 3D-Objekte über > OpenGL darstellen. Klaro geht das. Besorgt Dir das Xlib Reference Guide und schon gehts los. > > Man kann weiterhin von einem C-Programm ein Fenster auf dem X-Server > öffnen, das über TCP einem anderen Rechner erlaubt, Graphik-Ausgaben auf > dem eigenen Rechner machen zu lassen. Klaro geht das. Zusätzlich socket erzeugen und Protokoll nach belieben definieren. > Und es gibt die Möglichkeit, in C ein Programm zu schreiben, das den > X-Server ein Fenster öffnen läßt, das für kleinere CPUs und Controller > die Möglichkeit bietet, über eine serielle Schnittstelle (ohne TCP) > Graphik-Kommandos abzuschicken, die dann angezeigt werden. Klaro geht das. Statt Socket dann eben ein /dev/tty... öfnnen. > Es soll ein C-Programm ein Fenster geöffnet werden, das seine Kontrolle > an den ATMega angibt, der dann über die serielle Schnittstelle Linien > zeichnen kann. s.o. Aber: mit picocom und rx etc. bist Du auf der Server-Seite schon fertig und musst nur noch den Client-Teil auf dem µC schreiben.
Hallo, vielleicht hilft Dir diese Seite weiter https://tronche.com/gui/x/ https://tronche.com/gui/x/xlib-tutorial/ https://tronche.com/gui/x/gwm/html-manual/
1 | "Sending commands to GWM |
2 | |
3 | Any program can make GWM execute any WOOL code by putting the WOOL code to execute as an ASCII string in the GWM_EXECUTE property on any root window or client window of the screens managed by GWM, which will parse and evaluate the given string with the current window being the one on which the property was set. |
4 | |
5 | This feature is built in, so that it will work regardless of the profile used. |
6 | |
7 | You can also use the program gwmsend in the contrib/gwmsend directory in the distribution to send commands to GWM. It takes its first argument and puts in the GWM_EXECUTE property on the root window. It can thus be used like: |
8 | |
9 | gwmsend '(? "Hello there\n")' |
10 | |
11 | A better way is to use the -I option to make GWM read its standard input for commands. a recommended use is to run not gwm directly but a command like: |
12 | |
13 | xterm -title gwm -e fep gwm -IP |
14 | |
15 | fep is a pseudo-tty driver which gives its argument line editing and history capabilities, like ile or the GNU library readline. |
16 | Using gwmchat as a shell to GWM " |
.. oder dieser Link https://x.org/releases/X11R7.7/doc/libX11/libX11/libX11.html
Oliver K. schrieb: > Es soll ein C-Programm ein Fenster geöffnet werden, das seine Kontrolle > an den ATMega angibt, der dann über die serielle Schnittstelle Linien > zeichnen kann. Bis auf den Part "gibt seine Kontrolle an den ATMega ab" ist das kein Problem. Kleines (C) - Programm, öffnet X11-Fenster, öffnet seriellen Port, behält die Kontrolle, überwacht was auf dem Port reinkommt, und wenn der Atmega da Befehle wie "Linie 100,200 400,300" sendet, kann das C-Programm das auswerten und einen entsprechende Linie in sein X11-Fenster zeichnen.
1 | Display *dpy = XOpenDisplay(NULL); |
2 | Window w = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0, ... |
3 | XMapWindow(dpy, w); // sonst wird's nicht angezeigt |
4 | |
5 | // Hier müsste man warten, bis das MapWindow erfolgreich war, d.H. auf ein "MapNotify"-XEvent warten..
|
6 | // while (XPending(dpy)) XNextEvent(dpy, ...)
|
7 | // oder einfach
|
8 | sleep(10); |
9 | |
10 | // den Grapics Context braucht man zum darauf zeichnen
|
11 | GC gc = XCreateGC(dpy, w, 0, NULL); |
12 | |
13 | // dem GC sollte man jetzt noch seine Linien-Farbe konfigurieren, XSetForeground usw.
|
14 | |
15 | // Finally:
|
16 | XDrawLine(dpy, w, gc, 100, 20, 400, 300); |
17 | |
18 | // Damit die Linie auch an den X-Server geht:
|
19 | XFlush(dpy); |
20 | ...
|
Für jeden der genannten Befehle gibts Dokumentation. Selber nachschauen, was die machen, und welche Parameter erwartet werden.
Jim M. schrieb: > Lösung: Eigenes Programm (oder Skript) das mit dem µC kommuniziert. > X-Server will man nicht selbst programmieren, dafür gibt es Frameworks > wie Qt oder Tk. Genau, Qt auf einem Atmega32… Klaus S. schrieb: > Nach meinem Wissen ist ein X-Server ein Client, auch wenn er Server > heißt. Nein, er ist ein Server. > Der Benutzer startet als erstes den X-Server und weist ihn an, auf dem > mit ihm verbundenen Rechner ein Programm zu starten, das nun seineseits > passende Grafikausgaben absondert, die vom X-Server dargestellt werden. Der X-Server startet keine Programme. Der wird gestartet, und danach können sich Programme damit verbinden und ihm dann Befehle senden, die er ausführt. Also genau das, was ein Server eben so tut. > Den ATMega32 wird der X-Server nicht ansprechen können, da der Mega32 > das zugehörige Protokoll vermutlich nicht versteht, es sei denn, Du > implementiertest es. Natürlich müsste man das X11-Protokoll dafür implementieren - zumindest die Teile, die man dafür nutzen will. Das findet man hier: https://www.x.org/releases/X11R7.7/doc/xproto/x11protocol.html > Also braucht ein Programm auf einem vom X-Server erreichbaren Rechner, > das als Interface die Daten vom ATMega abholt und an den X-Server > weiterleitet. Ob es das schon fertig gibt, weiß ich nicht. Das muss eigentlich nur den UART und einen Socket zum X-Server öffnen und die miteinander verbinden. Das sollte man mit zwei Zeilen Shellscript hinbekommen. Dann muss man natürlich auch das Kommando zum Erzeugen des Fensters vom µC aus schicken. Εrnst B. schrieb: > Kleines (C) - Programm, öffnet X11-Fenster Heute nimmt man eher xcb. https://xcb.freedesktop.org/tutorial/
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.