itoa in Verbindung mit Einerstellen im "xx" Format.

[Marius MWH (Gast)]

...ja, es geht wie so häufig um die Darstellung einer Uhrzeit im Format 
xx:xx, aber leider konvertiert itoa (natürlich) die Einerstellen von zB 
5 Min nicht ins Format "05" - wie macht man das geschickt, gibts da 
vll direkt eine Verwandte von itoa?

Danke, Marius.

[Einer K. (Gast)]

snprintf() und seine Brüder gefallen dir nicht?

[Marius MWH (Gast)]

...ne, zu krass. itoa macht mir schon fast zuviel selbst :)

-> Gibts ne lean-e Lsg? Sonst kopiere ich in dem array per hand um 
"if(einstellig)" und adde eine führende 0...aber das ist 
irgendwie...so...hemdsärmelig :)

Marius.

[Teo D. (teoderix)]

Marius MWH schrieb:
> gibts da
> vll direkt eine Verwandte von itoa?

Mach ne Copy in deinem Projektordner, benenn und Strick sie um!?
(Viel is da ja eh nich dran)

[Bauform B. (bauformb)]

#include <stdio.h>
#include <stdlib.h>

char *
ito02a (int value, char *buf)
{
   int  c1;

   if (value < 0 || value > 99) {
      buf[0] = '?';
      buf[1] = '?';
   } else {
      for (c1 = '0'; c1 <= '9'; c1++) {
         if (value < 10) { break; }
         value -= 10;
      }
      buf[0] = c1;
      buf[1] = value + '0';
   }
   buf[2] = '\0';
   return buf;
}

int
main (int argc, char *argv[])
{
   char  buf[32];

   printf ("'%s'\n", ito02a (atoi (argv[1]), buf));
   return 0;
}

[Marius MWH (Gast)]

@Teo: Ja, wird vll am besten sein...ich schaue mir das morgen mal an und 
mache eine itoclk draus.

@Bauform: subfcn ito02a -> Ready 2 use?

Marius.

[Stefan F. (Gast)]

Bauform B. schrieb:
> printf("'%s'\n", ito02a(...))

Soll das ein Aprilscherz sein?

[foobar (Gast)]

> for (c1 = '0'; c1 <= '9'; c1++)

AI warning: condition c1 <= '9' is always true ;-)


> Soll das ein Aprilscherz sein?

Was passt dir denn daran nicht?

[Stefan F. (Gast)]

foobar schrieb:
>> Soll das ein Aprilscherz sein?
> Was passt dir denn daran nicht?

Printf kann bereits Zahlen zweistellig formatieren. Die alternative 
Methode macht nur Sinn, wenn man zugleich auf printf verzichtet.

[foobar (Gast)]

Das ist doch nur Test-/Beispielkode, um zu zeigen, was die Funktion 
macht.

[Rolf M. (rmagnus)]

foobar schrieb:
>> for (c1 = '0'; c1 <= '9'; c1++)
>
> AI warning: condition c1 <= '9' is always true ;-)

Vielleicht so?

c1 = '0';
while (value >= 10)
{
    c1++;
    value -= 10;
}

Stefan ⛄ F. schrieb:
> Printf kann bereits Zahlen zweistellig formatieren. Die alternative
> Methode macht nur Sinn, wenn man zugleich auf printf verzichtet.

Das printf ist hier ganz offensichtlich nur Teil des Beispielcodes, 
damit man ein vollständiges Programm hat, das man mal laufen lassen 
kann. Es dient nur dazu, die Funktion ito02a mal in Aktion sehen zu 
können. Der TE hat ja ausdrücklich geschrieben, dass er kein *printf() 
nutzen will.

[foobar (Gast)]

> Vielleicht so?

zum Beispiel, ja.  Aber höchstwahrscheinlich benutzt er eh irgendwo 
Divisionen, dann wäre

    buf[0] = '0' + value / 10;
    buf[1] = '0' + value % 10;

zwar nicht schneller aber eleganter und kürzer.

[Bauform B. (bauformb)]

foobar schrieb:
> höchstwahrscheinlich benutzt er eh irgendwo
> Divisionen, dann wäre    buf[0] = '0' + value / 10;
>     buf[1] = '0' + value % 10;
> zwar nicht schneller aber eleganter und kürzer.

Eleganz liegt im Auge des Betrachters. In dieser speziellen Anwendung 
wäre eine Division Overkill, weil nämlich:

Marius MWH schrieb:
> ...ne, zu krass. itoa macht mir schon fast zuviel selbst :)

Außerdem: sind das nicht sogar zwei Divisionen? Oder schafft es der 
Compiler tatsächlich, den Rest aus der ersten Division zu nutzen?

[foobar (Gast)]

> sind das nicht sogar zwei Divisionen? Oder schafft es der
> Compiler tatsächlich, den Rest aus der ersten Division zu nutzen?

Aus

    buf[0] = '0' + value / 10;
    buf[1] = '0' + value % 10;

wird

    ldi r22,lo8(10)
    call __udivmodqi4
    subi r24,lo8(-(48))
    st Z,r24
    subi r25,lo8(-(48))
    std Z+1,r25

[Rolf M. (rmagnus)]

Bauform B. schrieb:
> Außerdem: sind das nicht sogar zwei Divisionen? Oder schafft es der
> Compiler tatsächlich, den Rest aus der ersten Division zu nutzen?

Falls der Compiler es nicht schaffen sollte, könnte man schauen, ob er 
die Standard-Funktion div() unterstützt. Die gibt Ergebnis und Rest 
zurück.

[Stefan F. (Gast)]

Bauform B. schrieb:
> Außerdem: sind das nicht sogar zwei Divisionen? Oder schafft es der
> Compiler tatsächlich, den Rest aus der ersten Division zu nutzen?

Das ist eine gute Frage auf die ich auch schon einmal gestossen bin. Wie 
kann ich ohne großartige Klimzüge das Ergebnis einer Division und den 
Rest in einem Abwasch bekommen? Das scheint zumindest im C Quelltext 
nicht möglich zu sein.


foobar schrieb:
>> sind das nicht sogar zwei Divisionen? Oder schafft es der
>> Compiler tatsächlich, den Rest aus der ersten Division zu nutzen?
>
> Aus
>     buf[0] = '0' + value / 10;
>     buf[1] = '0' + value % 10;
> wird
>     ldi r22,lo8(10)
>     call __udivmodqi4
>     subi r24,lo8(-(48))
>     st Z,r24
>     subi r25,lo8(-(48))
>     std Z+1,r25

Sehr interessant. Ich hätte nicht gedacht, dass der Compiler so "schlau" 
ist.

[foobar (Gast)]

> Wie kann ich ohne großartige Klimzüge das Ergebnis einer Division und
> den Rest in einem Abwasch bekommen?

Wie oben gezeigt, einfach ausschreiben.  Das kommt so häufig vor, dass 
der GCC das schon in der 1er-Version optimieren konnte ;-)

[Rolf M. (rmagnus)]

Stefan ⛄ F. schrieb:
> Das scheint zumindest im C Quelltext nicht möglich zu sein.

Wie gesagt:

Rolf M. schrieb:
> die Standard-Funktion div()

http://www.cplusplus.com/reference/cstdlib/div/

[W.S. (Gast)]

Marius MWH schrieb:
> ...ne, zu krass. itoa macht mir schon fast zuviel selbst :)
>
> -> Gibts ne lean-e Lsg? Sonst kopiere ich in dem array per hand um
> "if(einstellig)" und adde eine führende 0...aber das ist
> irgendwie...so...hemdsärmelig :)


Tja, immer wieder stolpern die Leute über Kleinigkeiten, die bereits 
seit Jahren gelöst sind und als fertige benutzbare Lösungen vorliegen. 
Aber man ist ja über die einfachen und kleinen Lösungen erhaben...

Das ist ne Universalroutine, die man auch ganz leicht auf int64 
erweitern kann (falls das gebraucht wird) - aber für den vorliegenden 
Fall kann man sie auch drastisch zusammenkürzen, weil die Uhrzeit ja 
wohl nicht als long vorliegen muß und auch nicht negativ werden kann...

/******************************************************************************
   Dezimal-Konvertierung Long in Pufferbereich.
   digits = gewünschte Anzahl Stellen.
            digits<0 = mit führenden Nullen,
      sonst    = mit führenden Leerzeichen
   Buffer = Zeiger auf den Ergebnispuffer, mindestens 4 Byte groß.
   BufLen = Gesamtgröße des Ergebnispuffers. Soll mindestens 3 Byte größer
            sein als digits
 ******************************************************************************/

long LONGtoStr (long aValue, int digits, char* Buffer, int BufLen)
{ char* P;
  char* Q;
  long  L;
  char  v;
  int   i, j, k;
  ldiv_t T;

  *Buffer = 0;
  if (BufLen<4) return aValue;

  i = BufLen - 1;
  j = digits;
  if (j<0) j = -j;

  if (i < (j+3))      /* mehr Stellen als Bufferplatz */
  { Buffer[0] = '?';
    Buffer[1] = 0;
    return aValue;
  }

  Buffer[i--] = 0;    /* Endemarker setzen */
  if (aValue<0)
       { L = -aValue;
         v = 1;
       }
  else { L = aValue;
         v = 0;
       }

  if (!L)  Buffer[i--] = '0';
  while (i)
  { if (!L) goto _lready;
    T = ldiv(L,10);
    L = T.quot;
    Buffer[i--] = '0'+T.rem;
  }

                     /* i = 0, d.h. der Buffer ist voll! */
  i = 0; j = BufLen - 2;
  Buffer[i++] = '>';
  while (i<j) Buffer[i++] = '9';
  return aValue;


/* So, die Ziffern sind erzeugt, jetzt wird formatiert.
   i zeigt auf freien Platz vor 1. Ziffer
 */

_lready:
  k = BufLen - i - 2;       /* k = Anzahl gehabter Digits */

  if (digits < 0)           /* mit Nullen auffüllen */
  { j = -digits;            /* j = Sollstellenzahl */
    if (v) k++;             /* eine Stelle für '-' berücksichtigen */
    while (k++ < j)
    { if (i > 0) Buffer[i--] = '0'; }

    if (v) Buffer[i--]= '-'; /* Vorzeichen eintragen */
  }

  else                      /* mit Spaces auffüllen */
  { if (v)
     { Buffer[i--] = '-';   /* Vorzeichen eintragen */
       k++;                 /* Stelle berücksichtigen */
     }
     j = digits;
     while (k++ < j)
     { if (i > 0) Buffer[i--] = ' '; }
  }
  ++i;                 /* i zeigt jetzt auf 1. Zeichen */
  if (i)
  { P = Buffer;
    Q = &Buffer[i];
    j = BufLen - 1;
    while (j--) *P++ = *Q++;
    *P = 0;
  }
  return aValue;
}

W.S.

[Marius MWH (Gast)]

...ehm, ich geb zu, ich habe keinen Plan (mehr):

Wo finde ich itoa.c in WINAVR? Ich suche mit der Suche, finde aber nur 
die .h?

Danke, Marius.

[Einer K. (Gast)]

Marius MWH schrieb:
> ...ehm, ich geb zu, ich habe keinen Plan (mehr):
>
> Wo finde ich itoa.c in WINAVR? Ich suche mit der Suche, finde aber nur
> die .h?
>
> Danke, Marius.

Steckt sicherlich vorkompiliert in einer *.a

Musst also in die LibC Quellen schauen.
z.B.
https://github.com/vancegroup-mirrors/avr-libc/blob/06cc6ff5e6120b36f1b246871728addee58d3f87/avr-libc/libc/stdlib/atoi.S

[Marius MWH (Gast)]

Hallo zusammen,

@Bauform: Klappt wunderbar - Danke!

Was mich wurm - ich schreibe die Zeit - und momentan testweise NUR diese 
- auf das LCD. Aber da fehlen manchmal ganze Werte (buffer) oder diese 
sind leer...iwie willkürlich.

Ist es böse, z.B. folgendes * zu tun (nein, das ist kein code sondern 
nur der relevante ablauf)?

char char clock_min=55, LCD_clock_min[2];

itoclk(clock_min, LCD_clock_min);

LCD_print(1,2, LCD_clock_hour);
LCD_print(1,4, ":");
LCD_print(2,5, LCD_clock_min);
LCD_print(2,7," - ");
LCD_print(3,10, LCD_clock_day);

void LCD_print (char LCD_row, char LCD_column, char LCD_txt[12]) {

...

}

-> Vll ist die übergabe eines buffers an einen buffer gefährlich?

Marius.

[MaWin (Gast)]

W.S. schrieb:
> fertige benutzbare Lösungen

Für eine 2-stellige Zahl ?

Derselbe Irrsinn, der heute zu megabytegrossen Programmen führt die nur 
Kinderkacke ausrechnen  (Und dann kann es nichtmal int64).

[W.S. (Gast)]

MaWin schrieb:
> Für eine 2-stellige Zahl ?

Habe ich nicht ausdrücklich geschrieben, daß man sie für den 
vorliegenden Fall DRASTISCH zusammenkürzen kann?

Ja, natürlich habe ich das. Du konntest das offenbar nicht lesen.

Abgesehen davon erwarte ich von einem C-Programmierer, daß er div und 
ldiv kennt und anzuwenden weiß. Warum wird dann in diesem Thread von 
itoa und Puffer-Akrobatik gefaselt?

Abgesehen davon ist die gezeigte Routine in übersetzter Form 
ausgesprochen klein im Vergleich zu sowas wie printf und Konsorten. 
Genau DAS führt nämlich zu schlanken Programmen - im Gegensatz zu 
deiner Annahme.

W.S.

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

MaWin schrieb:
> W.S. schrieb:
>> fertige benutzbare Lösungen
>
> Für eine 2-stellige Zahl ?
>
> Derselbe Irrsinn, der heute zu megabytegrossen Programmen führt die nur
> Kinderkacke ausrechnen  (Und dann kann es nichtmal int64).

Und dann noch Spaghetticode mit goto hingerotzt.
Der Herr programmiert wie ne eins!

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

W.S. schrieb:
> Abgesehen davon ist die gezeigte Routine in übersetzter Form
> ausgesprochen klein im Vergleich zu sowas wie printf und Konsorten.
> Genau DAS führt nämlich zu schlanken Programmen - im Gegensatz zu
> deiner Annahme.

Willst du dir schonwieder ne blutge Nase holen?
Es wurde dir schon zig mal erklärt wie man printf klein bekommt.

[Marius MWH (Gast)]

...ehm, könnt ihr mir vll kurz bei meinem Buffer->Buffer Problem helfen? 
:)

Testweise LCD_print(1,2, "12"); schreibt sauber in Zeile 1, Pos 2 eine 
"12". Das geht aber halt nicht mit dem Buffer...

Marius.

[foobar (Gast)]

> könnt ihr mir vll kurz bei meinem Buffer->Buffer Problem helfen?

> char char clock_min=55, LCD_clock_min[2];

"char char" gibts nicht, ein "char" reicht.  Weiter: LCD_clock_min muß 3 
Elemente fassen können, die 2 Ziffern und das terminierende \0.

> void LCD_print (char LCD_row, char LCD_column, char LCD_txt[12])

Zwar nicht falsch, aber verbesserungswürdig: Bei row und column wäre ein 
(definiter) unsigned Typ angemessener, z.B. uint8_t.  LCD_txt wird 
üblicherweise als "char *LCD_txt" definiert (dazu degeneriert das 
nämlich) - alles andere führt nur in die Irre.

[MaWin (Gast)]

W.S. schrieb:
> Abgesehen davon erwarte ich von einem C-Programmierer, daß er div und
> ldiv kennt und anzuwenden weiß. Warum wird dann in diesem Thread von
> itoa und Puffer-Akrobatik gefaselt

Eigentlich nicht mehr, seit

foobar schrieb:
> dann wäre
>     buf[0] = '0' + value / 10;
>     buf[1] = '0' + value % 10;
>

sollte das Problem durch sein.

[foobar (Gast)]

W.S. schrieb:
> Tja, immer wieder stolpern die Leute über Kleinigkeiten, die bereits
> seit Jahren gelöst sind

Tja, du leider auch:

>  long L;
>  ...
>  if (aValue<0)
>       { L = -aValue;
>         v = 1;
>       }

Probier deine Routine mal mit -2147483648 aus.


Btw, ist das Absicht, dass die Routine so ziemlich gegen jede 
Konvention verstößt?

[Marius MWH (Gast)]

foobar schrieb:
>> könnt ihr mir vll kurz bei meinem Buffer->Buffer Problem helfen?
>
>> char char clock_min=55, LCD_clock_min[2];
>
> "char char" gibts nicht, ein "char" reicht.

-> Sry, Tippefehler - ist natürlich nur ein char :)

>Weiter: LCD_clock_min muß 3
> Elemente fassen können, die 2 Ziffern und das terminierende \0.

-> OK, die Darstellung wir auch besser wenn ich buf[2]="\0" 
auskommentiere...aber es fehlen immer noch Inhalte *

>
>> void LCD_print (char LCD_row, char LCD_column, char LCD_txt[12])
>
> Zwar nicht falsch, aber verbesserungswürdig: Bei row und column wäre ein
> (definiter) unsigned Typ angemessener, z.B. uint8_t.  LCD_txt wird
> üblicherweise als "char *LCD_txt" definiert (dazu degeneriert das
> nämlich) - alles andere führt nur in die Irre.

-> Hm, da hört mein Verständnis leider auf...

* -> Ich poste gleich mal ein Bild des LCDs, damit man versteht, was ich 
meine...

Marius.

[Marius MWH (Gast)]

...ich flipp aus - wenn ich ALLE buf von [2] auf [3] ändere, gehts, 
einwandfreie Darstellung! Ich hatte gestern immer nur minute ODER std 
von [2] auf [3] geändert, aber dann wird itoclk das "\0" einfach über 
den nächsten geschrieben haben und dann war dort "blanko"...oder sowas. 
Also kein sauberes buf-Mgmt :)

Danke vielmals für den Wink, foobar!!!

Marius.

[foobar (Gast)]

> ... wenn ich ALLE buf von [2] auf [3] ändere, gehts, ...

Deshalb macht man das einmal richtig und kann es danach vergessen:

#include <stdio.h>
#include <stdint.h>
#include <stdarg.h>
...
void LCD_printf(uint8_t row, uint8_t col, char *fmt, ...)
{
    char buf[16]; // enough for one LCD line
    va_list va;

    va_start(va, fmt);
    vsnprintf(buf, sizeof(buf), fmt, va);
    va_end(va);

    LCD_print(row, col, buf);
}
...
    LCD_printf(1, 1, "%02u:%02u:%02u", hours, minutes, seconds);
    LCD_printf(2, 1, "%04u-%02u-%02u", year, month, day);
...

[Einer K. (Gast)]

foobar schrieb:
> Deshalb macht man das einmal richtig und kann es danach vergessen:

printf und seine Brüder sind in diesem Thread explizit unerwünscht!

[foobar (Gast)]

> printf und seine Brüder sind in diesem Thread explizit unerwünscht!

Na ja, Anfänger sind evtl ja noch nicht so beratungsresistent ;-)

[W.S. (Gast)]

MaWin schrieb:
> Eigentlich nicht mehr, seit..

Man müßte das bloß den übrigen Disputanden mal klarmachen.


Eigentlich ist das sowas von trivial, daß mich dieser gesamte Thread im 
Grunde graust.

Trotz der inzwischen wirklich sinnreichsten Lösung (ein paarmal div() 
und der String ist final fertig) wird hier immer noch mit obskuren 
Puffer-Basteleien gearbeitet - mit eigentümlichem Ergebnis wie man 
sieht:

Marius MWH schrieb:
> ...ich flipp aus

nana, lieber nicht. Stattdessen einfach den String selber aufsetzen. Wie 
wurde dir ja schon gezeigt.

W.S.