malerlein:
Nur ich möchte gerne wenn das machbar ist mir einen Monitor basteln, wo die Uhrzeit, Datum temperatur ausgegeben wird ohne das jedesmal die Anzeige gelöscht wird und neu geschrieben wird, wenn Du weist was ich meine. So wie bei einer Digitalen UHR wo die Sekunden hoch gezählt werden in der Anzeig. ist das möglich oder müsste ich die Daten erst auslesen aus dem Arduino und auf dem PC mit einem anderen Programm so zur Anzeige brnigen wie ich mir das vorstelle?????
Natürlich kannst Du die Daten so an das Terminal senden, dass das Terminal die Daten darstellt, die Du möchtest.
Und zwar auch ohne jedesmal den Bildschirm zu löschen.
Im Prinzip hast Du die Vorgabe ja durch die Funktionen setup und loop:
Setup läuft nach einem Reset einmalig, loop läuft dauernd und wieder und wieder.
Da der Controller jedesmal ein Reset ausführt, wenn Du im PC das Terminal startest, ist es einfach:
- In der setup-Funktion sendest Du einmalig eine feste "Bildschirmmaske"
- In der loop-Funktion sendest Du die sich ständig ändernden Daten, immer in die Datenfelder und immer "mit gleicher Datenbreite"
Ich habe da mal ein Beispiel vorbereitet:
// Demonstration code for ANSI/VT100 terminal codes on Arduino
// Created by "jurs" for German Arduino forum
// Do NOT use the Arduino serial monitor with this sketch!
// You must use a terminal emulation software to show the serial output correctly.
// When using Windows you can use "PUTTY" configured to your Arduino COM Port.
// defines taken from list at http://www.fourwalledcubicle.com/files/LUFA/Doc/090605/html/dd/d6d/a00111.html
#define ANSI_ESCAPE_SEQUENCE(c) "\33[" c
#define ESC_RESET ANSI_ESCAPE_SEQUENCE("0m")
#define ESC_BOLD_ON ANSI_ESCAPE_SEQUENCE("1m")
#define ESC_ITALICS_ON ANSI_ESCAPE_SEQUENCE("3m")
#define ESC_UNDERLINE_ON ANSI_ESCAPE_SEQUENCE("4m")
#define ESC_INVERSE_ON ANSI_ESCAPE_SEQUENCE("7m")
#define ESC_STRIKETHROUGH_ON ANSI_ESCAPE_SEQUENCE("9m")
#define ESC_BOLD_OFF ANSI_ESCAPE_SEQUENCE("22m")
#define ESC_ITALICS_OFF ANSI_ESCAPE_SEQUENCE("23m")
#define ESC_UNDERLINE_OFF ANSI_ESCAPE_SEQUENCE("24m")
#define ESC_INVERSE_OFF ANSI_ESCAPE_SEQUENCE("27m")
#define ESC_STRIKETHROUGH_OFF ANSI_ESCAPE_SEQUENCE("29m")
#define ESC_FG_BLACK ANSI_ESCAPE_SEQUENCE("30m")
#define ESC_FG_RED ANSI_ESCAPE_SEQUENCE("31m")
#define ESC_FG_GREEN ANSI_ESCAPE_SEQUENCE("32m")
#define ESC_FG_YELLOW ANSI_ESCAPE_SEQUENCE("33m")
#define ESC_FG_BLUE ANSI_ESCAPE_SEQUENCE("34m")
#define ESC_FG_MAGENTA ANSI_ESCAPE_SEQUENCE("35m")
#define ESC_FG_CYAN ANSI_ESCAPE_SEQUENCE("36m")
#define ESC_FG_WHITE ANSI_ESCAPE_SEQUENCE("37m")
#define ESC_FG_DEFAULT ANSI_ESCAPE_SEQUENCE("39m")
#define ESC_BG_BLACK ANSI_ESCAPE_SEQUENCE("40m")
#define ESC_BG_RED ANSI_ESCAPE_SEQUENCE("41m")
#define ESC_BG_GREEN ANSI_ESCAPE_SEQUENCE("42m")
#define ESC_BG_YELLOW ANSI_ESCAPE_SEQUENCE("43m")
#define ESC_BG_BLUE ANSI_ESCAPE_SEQUENCE("44m")
#define ESC_BG_MAGENTA ANSI_ESCAPE_SEQUENCE("45m")
#define ESC_BG_CYAN ANSI_ESCAPE_SEQUENCE("46m")
#define ESC_BG_WHITE ANSI_ESCAPE_SEQUENCE("47m")
#define ESC_BG_DEFAULT ANSI_ESCAPE_SEQUENCE("49m")
#define ESC_CURSOR_POS(L,C) ANSI_ESCAPE_SEQUENCE(#L ";" #C "H")
#define ESC_CURSOR_UP(L) ANSI_ESCAPE_SEQUENCE(#L "A")
#define ESC_CURSOR_DOWN(L) ANSI_ESCAPE_SEQUENCE(#L "B")
#define ESC_CURSOR_FORWARD(C) ANSI_ESCAPE_SEQUENCE(#C "C")
#define ESC_CURSOR_BACKWARD(C) ANSI_ESCAPE_SEQUENCE(#C "D")
#define ESC_CURSOR_POS_SAVE ANSI_ESCAPE_SEQUENCE("s")
#define ESC_CURSOR_POS_RESTORE ANSI_ESCAPE_SEQUENCE("u")
#define ESC_ERASE_DISPLAY ANSI_ESCAPE_SEQUENCE("2J")
#define ESC_ERASE_LINE ANSI_ESCAPE_SEQUENCE("K")
#define ESC_CURSOR_OFF ANSI_ESCAPE_SEQUENCE("?25l")
#define ESC_CURSOR_ON ANSI_ESCAPE_SEQUENCE("?25h")
void s(char* str)
{ // put string to Serial - short form
Serial.print(str);
}
void sendcursor(int r, int c)
{ // set ANSI terminal cursor to specified row and column
char str[12];
sprintf(str,"\33[%d;%dH",r,c);
s(str);
}
void settext(char* fg, char* bg, char* cup, char* str)
// send text to terminal with foreground color, background color, cursor position
{
s(cup);
s(fg);
s(bg);
s(str);
}
void clearsquare(char* fg, char* bg, int r1, int c1, int r2, int c2)
{ // clears a square on the terminal window with colors set
s(fg);
s(bg);
for (int i=0;i<r2-r1;i++)
{
sendcursor(r1+i, c1);
for (int i=0;i<c2-c1;i++) s(" ");
}
}
char time[]=__TIME__;
int stunden,minuten,sekunden;
void ShowScreen()
// Die Bildschirmmaske ausgeben (was gleich bleibt)
{
char* color;
s(ESC_BG_BLUE);
s(ESC_FG_GREEN);
s(ESC_ERASE_DISPLAY);
s(ESC_CURSOR_OFF);
for (int i=0;i<6;i++)
{
switch (i)
{
case 0: color=ESC_BG_RED;break;
case 1: color=ESC_BG_YELLOW;break;
case 2: color=ESC_BG_GREEN;break;
case 3: color=ESC_BG_MAGENTA;break;
case 4: color=ESC_BG_CYAN;break;
case 5: color=ESC_BG_BLACK;break;
}
clearsquare(ESC_FG_BLACK,color, 2+i,2+2*i, 15-i,32-2*i);
}
}
void showTime()
// Die veränderlichen Teile des Bildschirms ausgeben (Zeitanzeige)
{
char textbuffer[10];
sprintf(textbuffer,"%02d:%02d:%02d",stunden,minuten,sekunden);
settext(ESC_FG_WHITE, ESC_BG_BLACK, ESC_CURSOR_POS(8, 13), textbuffer);
}
void tickOneSecond()
{
sekunden++;
if (sekunden>=60) {sekunden=0;minuten++;}
if (minuten>=60) {minuten=0;stunden++;}
if (stunden>=24) {stunden=0;}
}
void setup()
{
Serial.begin(9600);
ShowScreen();
stunden=atoi(time);
minuten=atoi(&time[3]);
sekunden=atoi(&time[6]);
}
unsigned long alteSekunde;
void loop()
{
if (alteSekunde==millis()/1000) return; // selbe Sekunde, loop verlassen
alteSekunde=millis()/1000;
tickOneSecond(); // Uhrzeit weiterticken lassen
showTime(); // Uhrzeit anzeigen
}
Die setup-Funktion sendet einmalig den bunten Multi-Rahmen.
Die loop-Funktion sendet jede Sekunde einmal die neue Zeit (und nur die Zeit, ohne den Rahmen)
Das mit der Zeit ist in dem Fall natürlich ein kleiner Fake, weil der Sketch keine Echtzeituhr ausliest, sondern die Zeit aus der Zeitangabe ermittelt, zu der Du das Programm kompiliert hast. Diese Zeitangabe hole ich aus dem fertigen Programm. Nach jedem Reset fängt die Zeit daher mit demselben Startwert an zu laufen, nämlich mit der Uhrzeit, zu der Du das Programm kompiliert und hochgeladen hast. Also jedesmal beim Starten von Putty startet wieder dieselbe Zeit auf dieser "Uhr".
malerlein:
Dein Beispiel in dem Link den Du gepostet hast gefällt mir echt Gut nur das ist ja nur die Grafik und da bewegt sich nichts. Aber so stelle ich mir mein Netbook als Monitor schon vor.
Dann teste mal den Sketch mit der sich bewegenden Uhrzeit.
Geschwindigkeit ist keine Hexerei.
Damit es am Bildschirm nicht flimmert, mußt Du Änderungen im Prinzip in weniger als 1/25s ausführen, dann liegt die Änderungszeit unterhalb der Trägheit des Auges.
Flimmerfrei hältst Du den Bildschirm also dadurch, dass Du
- nur die wenigen geänderten Daten auf den Bildschirm schickst
- und im Zweifelsfall die Baudrate erhöhst (bei Arduino im Serial.begin und auch bei Putty)
malerlein:
Schön wäre natürlich wenn es noch eine Funktion gäbe wo, wenn die Uhrzeit sich mal ändert vor der nach läuft ich über den Monitor die Uhr neu stellen könnte.
So eine Konfigurationsmöglichkeit ist natürlich nicht ganz so einfach, je nachdem wie nett es optisch aussehen soll.
Wenn es optisch gar nicht aussehen soll, könntest Du eine "Kommando-Blindeingabe" vorsehen. Dann müßtest Du etwa zum Setzen der Zeit eine solche Zeile eingeben können, ohne dass die Zeichen am Bildschirm sichtbar werden:
time 21:37
und mit der Enter-Taste abschließen, um die Zeit z.B. auf 21:37 Uhr zu setzen.
Die nächsthöhere Schwierigkeitsklasse wäre, dass Du oben oder unten am Bildschirm zusätzlich zu den dargestellten Daten einen Zeileneditor programmierst, in dem die eingegebenen Zeichen erscheinen. So wie im seriellen Monitor der Arduino-Software die Sendezeile oben oberhalb des Datenfensters.
Die höchste Schwierigkeitsklasse wäre es schließlich, wenn Du eigene Dateneingabebildschirme programmierst, so dass Du komplett verschiedene Bildschirme für Dateneingabe und Datendarstellung hast. Das ist alles möglich, aber da ein Arduino nur ein Mikrocontroller ist und kein Betriebssystem hat, bekommst Du natürlich auch keine Betriebssystemunterstützung, z.B. bei der Darstellung eines Eingabefelds. Da mußt Du Cursorverschiebung nach rechts und links, Eingabe, Löschen und alles komplett selbst programmieren.
und so erfüllt das Netbook noch einen Sinn , so das ich schnell an das Programm komme und wenn es da steht ist es ein schöner Monitor.