Zeichenkette erstellen

[avr-gcc (Gast)]

   uart_putc(27);
   uart_puts("[2J");
   uart_putc(27);
   uart_puts("[H");

Wie kann man sowas als einen befehl schreiben?

[Karl H. (kbuchegg)]

  uart_puts("\x1B[2J\x1B[H"):

Escape Sequenzen in Strings sollten sich eigentlich in jedem C-Lehrbuch 
finden. Wenn nicht: schmeiss es weg und kauf dir was ordentliches

[Rolf M. (rmagnus)]

avr-gcc schrieb:
> uart_putc(27);
>    uart_puts("[2J");
>    uart_putc(27);
>    uart_puts("[H");
>
> Wie kann man sowas als einen befehl schreiben?

Ich würd's so machen:

#define ESC "\033"

uart_puts(ESC "[2J" ESC "[H");

Oder noch etwas weiter:

#define ESC    "\033"
#define CSI    ESC "["
#define ED     CSI "2J"
#define HOME   CSI "H"


uart_puts(ED HOME);

[Rufus Τ. F. (rufus)]

Rolf M. schrieb:
> #define ESC "\033"

Oktal ist natürlich obercool.

[avr-gcc (Gast)]

Habe folgende Befehle gefunden

#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")

Welche ich wie folgt einlesen möchte

void uart_command(const char *s)
{
  uart_puts(s);
}

Das ganze funktioniert auch recht gut. Nun zwei Fragen,
wenn ich das Display löschen möchte,
wie sieht der Befehl von oben nun hier aus?

 void uart_clear(void)
 {
   lcd_command(ESC_ERASE_DISPLAY);
   lcd_command(ESC_CURSOR_POS_RESTORE); // ????
 }

Des weiteren habe ich keine Möglichkeit, den Cursor zu setzen. Das 
sollte in Putty soweit bekannt eigentlich gehen. Attribute wie 
ESC_BG_RED funktionieren alle.

void uart_setCursor(uint8_t x, uint8_t y)
{
  uart_command(ESC_CURSOR_POS(x, y));
}

[Karl H. (kbuchegg)]

Frage 1:
Du gibst dir doch die Antwort schon selbst. Wenn du das Display nur 
löschen möchtest, dann mach auch genau das. Was genau hat 
CURSOR_RESTORE_POS mit dem Löschen des Displays zu tun. Du brauchst den 
Makro Namen nur zu lesen um zu wissen, dass da irgendwas mit dem Cursor 
passiert und das hat erst mal nichts damit zu tun, dass die Anzeige 
geleert wir

[Rolf M. (rmagnus)]

avr-gcc schrieb:
> void uart_setCursor(uint8_t x, uint8_t y)
> {
>   uart_command(ESC_CURSOR_POS(x, y));
> }

Wie sollte das denn auch gehen? Die Markos erstellen jeweils ein "string 
literal" also eine Zeichenkettenkonstante. Du übergibst hier aber 
Variablen. Wenn du die brauchst, mußt du den String zur Laufzeit 
zusammenbasteln. Das können diese Makros nicht leisten.
Das Makro nimmt einfach x und y als Text und fügt das ein, es ensteht 
also

"\33[x;yH"

und daß dein Terminal mit diesem String nix anfangen kann, ist klar.

[Karl H. (kbuchegg)]

Zur Frage 2:
Das kann auch nicht funktionieren, wenn dir klar waere, dass Makros im 
Grunde nur Textersetzungen sind, die zur Compilier Zeit vorgenommen 
werden.
Dein Makro expandiert also im besten Fall zu einem String, in dem  die 
Buchstaben x und y vorkommen und nicht die entsprechenden Zahlenwerte

[Rolf M. (rmagnus)]

avr-gcc schrieb:
> wie sieht der Befehl von oben nun hier aus? void uart_clear(void)
>  {
>    lcd_command(ESC_ERASE_DISPLAY);
>    lcd_command(ESC_CURSOR_POS_RESTORE); // ????
>  }

Nein. Um eine Cursor-Position zu restoren, mußt du erstmal eine 
gespeichert haben. Dein ESC [H gibt es in deinen Makros nicht. Das habe 
ich auch erstmal eine Weile suchen müssen, weil es offenbar keine 
Standard-ANSI-Escape-Sequenz ist. Da kommen vor dem H normalerweise noch 
die Zielkoordinaten (Siehe ESC_CURSOR_POS).
Übrigens kannst du die Kommandos auch mit einem Aufruf schicken:

    lcd_command(ESC_ERASE_DISPLAY ESC_CURSOR_POS_RESTORE);

[Noch einer (Gast)]

> Oktal ist natürlich obercool.

Ach was, damit hat Rolf auf dem International Obfuscated C Code Contest 
keine Chance.

Problem ist, einen sinnvollen Mittelweg zu finden.

Nimmt man "\033[2J", weiß der nächste nicht mehr, was 2J eigentlich 
macht. Nimmt man ein geniales System an Defines, weiß der nächste nicht 
mehr, wie man des Programm auf ein anderes Terminal umstellt.

Mit den gefundenen Befehlen hast du dir halt 2 Probleme eingehandelt. Du 
musst herausfinden, was Putty erwartet. Und zusätzlich musst du 
herausfinden, ob diese Defines das richtige liefern.

Wenn beides zusammen zu verwirrend ist, warum bleibst du dann nicht 
einfach bei dem Vorschlag von Karl Heinz? Oder einfach bei den 4 Zeilen, 
mit denen du es ursprünglich gelöst hast?

[avr-gcc (Gast)]

void uart_clear(void)
{
  uart_command(ESC_ERASE_DISPLAY);
  uart_command(ESC_CURSOR_POS(0,0));
}

Geht so.

Nur bin ich noch nicht weiter, wie ich das mit dem setCursor realisieren 
soll. Konstante Werte gehen ja.

uart_command(ESC_CURSOR_POS(5,5));

Nur sowas leider nicht

    _delay_ms(200);
    int y= 0;
    uart_command(ESC_CURSOR_POS(0,y));
    uart_putc('a');
    y++;

[avr-gcc (Gast)]

void uart_setcursor(uint8_t x, uint8_t y)
{
  char buffer[20];
  char buffer2[10];
  strcat(buffer, '\33');
  itoa(x, buffer2, 10);
  strcat(buffer, buffer2);
  itoa(y, buffer2, 10);
  strcat(buffer, buffer);
  strcat(buffer, y+'0');
  strcat(buffer, 'H');

  uart_command(buffer);
}

Bringt meinen µC leider in einem undefinierten Zustand -> stürzt ab.

[Karl H. (kbuchegg)]

avr-gcc schrieb:
>

> void uart_clear(void)
> {
>   uart_command(ESC_ERASE_DISPLAY);
>   uart_command(ESC_CURSOR_POS(0,0));
> }

> Geht so.
>
> Nur bin ich noch nicht weiter, wie ich das mit dem setCursor realisieren
> soll. Konstante Werte gehen ja.
>
>

> uart_command(ESC_CURSOR_POS(5,5));
>

>
> Nur sowas leider nicht
>

>     _delay_ms(200);
>     int y= 0;
>     uart_command(ESC_CURSOR_POS(0,y));
>     uart_putc('a');
>     y++;

Wie kriegt man denn zur Laufzeit einen String, bei dem Zahlenwerte aus 
dem laufenden Programm eingesetzt werden?

Sorry. Aber ein bisschen Nachdenken musst du schon auch selbst. Vergiss 
mal die Makros

[avr-gcc (Gast)]

Hallo kh,

habe es jetzt nun mal Testweise mit sprintf versucht. Geht, aber erzeugt 
auf dem Attiny einen ordentlichen Zuwachs des Programm Speichers. (+10%)

Ich würde gerne die Funktion (sprintf) aus diesem Grund vermeiden, da 
sie nicht wirklich andersweitig benötigt wird.

void uart_setcursor(uint8_t x, uint8_t y)
{
  char str[20];
  sprintf(str,"\33[%d;%dH",y,x);

  uart_command(str);
}

[Rolf M. (rmagnus)]

avr-gcc schrieb:
> Bringt meinen µC leider in einem undefinierten Zustand -> stürzt ab.

Da sind auch ziemlich viele Fehler drin.

> void uart_setcursor(uint8_t x, uint8_t y)
> {
>   char buffer[20];
>   char buffer2[10];
>   strcat(buffer, '\33');

Das strcat sucht im uninitialisierten Puffer nach dem ersten \0. 
Außerdem erwartet es die Adresse eines Strings. '\33' ist keine Adresse.

>   itoa(x, buffer2, 10);
>   strcat(buffer, buffer2);
>   itoa(y, buffer2, 10);
>   strcat(buffer, buffer);

Warum wird da der Buffer an sich selbst gehängt?

>   strcat(buffer, y+'0');
>   strcat(buffer, 'H');

Dei beiden haben das gleiche Problem wie oben. Und wo ist das Semikolon 
zwischen den beiden Zahlen? Warum wird y zweimal angehängt?

>   uart_command(buffer);
> }

[Karl H. (kbuchegg)]

avr-gcc schrieb:
> Hallo kh,
>
> habe es jetzt nun mal Testweise mit sprintf versucht. Geht, aber erzeugt
> auf dem Attiny einen ordentlichen Zuwachs des Programm Speichers. (+10%)

ok. Dann musst du dir einen gleichwertigen Ersatz dafür sorgen, der 
genau das kann, was du erreichen willst.

Hinweis: dem Terminal ist es völig egal, ob du in Etappen ausgibst, oder 
ob du dir die Mühe machst, den String erst mal komplett zusammen zu 
setzen. Das Terminal sieht nur die Zeichen, die aus der Schnittstelle 
rauskommen. Und das geht in jedem Fall langsamer, als ein paar 
Funktionsaufrufe für Subfunktionen, die zb einen String oder eine Zahl 
per UART auf die Reise schickt.

Du willst also
* eine textuelle 'Eröffnungsseqqquenz' senden
* dann die Zeile (in ihrer gewandelten Form als Text)
* dann einen ,
* dann die Spalte (in ihrer gewandelten Form als Text)
* die Abschlusssequenz, in der dann ausgesagt wird, welches Kommando das 
ist


Niemand sagt, dass du alles erst mal in einen String sammeln musst. Du 
kannst es auch auf Etappen machen und einzeln auf die Reise schicken.

[Karl H. (kbuchegg)]

Karl H. schrieb:

Und noch ein Hinweis. Hier ...
> * dann die Zeile (in ihrer gewandelten Form als Text)
... verbirgt sich eine weitere Hilfsfunktion drinnen, die man praktisch 
ständig immer wieder braucht: Nämlich die Ausgabe einer Zahl in lesbarer 
Form über die UART. Es wird also sinnvoll sein, ähnlich wie bei der 
Hilfsfunktion die einen String ausgeben kann, sich hier eine 
Hilfsfunktion zu machen die eben genau das kann: Zahlen in ihrer 
textuellen Form über die UART auszugeben.

[avr-gcc (Gast)]

Meinst du das so?

void uart_setcursor(uint8_t x, uint8_t y)
{
  /*char str[20];
  sprintf(str,"\33[%d;%dH",y,x);
  uart_command(str);*/
  char buffer[4];
  uart_command("\33[");
  uart_command(itoa(y, buffer, 10));
  uart_command(";");
  uart_command(itoa(x, buffer, 10));
  uart_command("H");
}

Funktioniert zumindest bedingt schon einmal.
Er macht einmal den Zeilensprung in die 2. Zeile. Danach schreibt er 
aber alle Werte immer in die erste Zeile. Die Spalten werden richtig 
gesetzt.

int main(void)
{
  uart_init();
  lcd_init();
  _delay_ms(500);
  sei();
  
  uart_clear();
  uart_puts_P("      Test      ");
  uart_setcursor(0,2);
  uart_puts_P(" ATtiny841 INIT ");
  
  lcd_clear();
  lcd_puts("      Test      ");
  lcd_setcursor(0,1);
  lcd_puts(" ATTiny841 INIT ");
  _delay_ms(2000);
  
  uart_clear();
  lcd_clear();
  
  while(1)
  {
    const int16_t val[] = {-16000, -9999, - 999, -99, -9, 0, 9, 99, 999, 9999, 16000};
    static int16_t count;
    uart_setcursor(5,0);
    uart_puts_P("      ");
    uart_setcursor(5,0);
    uart_puti(val[count]);
    uart_setcursor(7, 1);
    uart_puti_format(val[count], 5);
    
    lcd_setcursor(5,0);
    lcd_puts("      ");
    lcd_setcursor(5,0);
    lcd_puti(val[count]);
    lcd_setcursor(7, 1);
    lcd_puti_format(val[count], 5);
    
    count = (count + 1) % 11;
    _delay_ms(500);
  }
}

[Karl H. (kbuchegg)]

avr-gcc schrieb:
> Meinst du das so?

IM Prinzip: ja.

Nur wie schon gesagt: Dia Ausgabe einer Zahl ist etwas, was man immer 
wieder mal braucht. D.h. man baut sich da eine Hilfsfunktion

void uart_puti( int zahl )
{
  char str[7];

  itoa( zahl, str, 10 );
  uart_command( zahl );
}

btw. uart_command ist ein schlechter Name. Denn tatsächlich tut die 
Funktion nichts anderes als einen String auszugeben. Dass dieser String 
ein Kommando ist, braucht hier nicht mehr zu interessieren.

Damit reduziert sich deine Funktion zu

void uart_setcursor(uint8_t x, uint8_t y)
{
  uart_command("\33[");
  uart_puti( y );
  uart_command(";");
  uart_puti( x );
  uart_command("H");
}

und das sieht dann doch gar nicht mehr so schlecht aus.


Ooops

>     uart_puts_P("      ");
>     uart_setcursor(5,0);
>     uart_puti(val[count]);

du hast die Funktion bereits!
Warum verwendest du sie dann nicht?

[Karl H. (kbuchegg)]

avr-gcc schrieb:

> Funktioniert zumindest bedingt schon einmal.
> Er macht einmal den Zeilensprung in die 2. Zeile. Danach schreibt er
> aber alle Werte immer in die erste Zeile. Die Spalten werden richtig
> gesetzt.

Na ja. Was erwartest du. Sieh dir mal deine Aufrufe an.
Du schickst den Cursor immer an dieselben Positionen.

[avr-gcc (Gast)]

Hallo Karl Heinz,

verstehe das nicht, dass ich immer in der gleichen Zeile schreibe.

Im ersten Teil setze ich den Cursor auf Spalte 5, Zeile 0.
Der alte Text wird ersetzt durch Leerzeichen.
Danach wird der Cursor wieder auf Spalte 5, Zeile 0 gesetzt, damit dort 
der neue Wert überschrieben werden kann.

Danach soll in Spalte 7, Zeile 1 gewechselt werden. Dort erfolgt eine 
formatierte Ausgabe. Löschen der alten Zeichen nicht erforderlich, da es 
die Funktion macht.

    uart_setcursor(5,0);
    uart_puts_P("      ");

    uart_setcursor(5,0);
    uart_puti(val[count]);

    uart_setcursor(7, 1);
    uart_puti_format(val[count], 5);

[Karl H. (kbuchegg)]

avr-gcc schrieb:
> Hallo Karl Heinz,
>
> verstehe das nicht, dass ich immer in der gleichen Zeile schreibe.

Was verstehst du daran nicht.
Wenn du uart_setcursor mit immer den gleichen Zahlenwerten aufrufst, 
dann setzt dir die Funktion den Cursor auch immer in genau die 
Zeile/Spalte, die du angegeben hast.

> Danach soll in Spalte 7, Zeile 1 gewechselt werden. Dort erfolgt eine
> formatierte Ausgabe. Löschen der alten Zeichen nicht erforderlich, da es
> die Funktion macht.

Ja schön.
Danach ist deine Schleife einmal durch und das Spielchen beginnt von 
vorne: Cursor nach 5,0, ausgeben, etc.

Wenn ich deine Frage richtig verstanden habe, dann ist das auch genau 
das, was du siehst. Also passiert genau das, was du programmiert hast.

[Karl H. (kbuchegg)]

avr-gcc schrieb:

> Danach soll in Spalte 7, Zeile 1 gewechselt werden. Dort erfolgt eine
> formatierte Ausgabe. Löschen der alten Zeichen nicht erforderlich, da es
> die Funktion macht.

OK. Und wie macht das die Funktion?

[avr-gcc (Gast)]

Hallo,

also nach meiner Überlegung dürfte es so nicht aussehen.

Erwartet wird hier eine Ausgabe wie folgt. ('.' = ' ')

1)
.....abcdef..... 
.......abcdef...

2)
uart_setcursor(5,0);
uart_puts_P("      ");
................ (alter Wert wird mit Leerzeichen überschrieben)
.......abcdef... (noch unverändert)

3)
uart_setcursor(5,0);
uart_puti(val[count]);
.....uvwxyz.....  (neuer Wert wird geschrieben)
.......abcdef... (noch unverändert)

4)
uart_setcursor(7, 1);
uart_puti_format(val[count], 5);
.....uvwxyz.....
.......uvwxyz... (neuer Wert wird geschrieben)

[avr-gcc (Gast)]

void uart_setcursor(uint8_t x, uint8_t y)
{
  uart_puts("\33[");
  uart_puti(y);
  uart_puts(";");
  uart_puti(x);
  uart_puts("H");
}

[Karl H. (kbuchegg)]

avr-gcc schrieb:
> Hallo,
>
> also nach meiner Überlegung dürfte es so nicht aussehen.

Das Problem ist, dass hier keine sieht oder weiss, wie es bei dir am 
Terminal *tatsächlich aussieht.

Beschreib es nicht, sondern mach einen Screenshot

[avr-gcc (Gast)]

Bild 1:
Wird so ausgeführt, wie erhofft.

Bild 2 wird nicht so ausgeführt wie erhofft, es findet kein Sprung in 
die angegeben Zeile statt.

[Karl H. (kbuchegg)]

Mach da
>   uart_puts("\33[");
mal

  uart_puts("\033[");

draus. Theoretisch sollte es keinen Unterschied machen. Aber sicher ist 
sicher

[Karl H. (kbuchegg)]

Hast du schon kontrolliert, ob die enstprechende Emulation in deinem 
Terminal Programm auch aktiviert ist?

Alternativ könntest du auch einfach mal den \33 Teil weglassen und dir 
am Terminal ansehen, was du tatsächlich innerhalb der Escape Sequenz 
schickst (wenn dein Terminal keine Möglichkeit hat, dir das in Rohform 
anzuzeigen)

[Karl H. (kbuchegg)]

Ich bin mir ausserdem jezt gar nicht mehr sicher, mit welcher Zahlen bei 
der Cursorpositionierung begonnen wird zu zählen. Ist schon zu lange 
her.

Ist die oberste Zeile die Zeile 0 oder die Zeile 1?

Einfach ausprobieren. Schicke den Cursor mal in die Zeile 2

  uart_setcursor(7, 2);

[avr-gcc (Gast)]

Mit 1. Nicht 0.

Das war der Fehler

[Karl H. (kbuchegg)]

avr-gcc schrieb:
> Mit 1. Nicht 0.
>
> Das war der Fehler

Manchmal hat man aber auch Tomaten auf den Augen :-)

[Rolf M. (rmagnus)]

Ist ja auch fies. Kein normal denkender Programmierer fängt bei der 1 
an. ;-)