Integer oder Float umwandeln in ASCII

[Gortosch (Gast)]

Grüße,
wie wandel ich einen int bzw einen float Wert in einen ASCII-String
um...
nicht mit einer fertigen Funktion....
Der Hintergrund ist der, ich will ein Programm schreiben mitm Keil C51
für einen MC der ein Display ansteuert... so wenn ich nun Zahlen
ausgeben will muss ich die ja erst in einen Ascii-String
konvertieren...

Ich hoffe Ihr könt mir bei meinem kleinen Problem helfen...

de Gortosch...

[Oliver Keller (Gast)]

Hi,

Da guckst Du z.B. hier:
http://www.mikrocontroller.net/forum/read-4-45518.html
oder in einem anderen der zahlreichen Threads über dieses Thema.

Gruss,
oli

[fale20 (Gast)]

Ganz einfach. Addiere einfach zu jeder Dekate 0x30 dazu.
Siehe Ascii tabelle in jedem Tabellenbuch.

[Gortosch (Gast)]

Das gibts doch net... boah so einfach... man man man... nix für
ungut...

SO ich poste mal eine Lösung, denn die die ich im Netz gefunden habe
haben mir alle nicht so gut gefallen:

Aufruf:
z.b.: für den wert 190...

unsigned char *Wert;
Wert = IntToAscii(190);

Wobei der Rückgabewert die Adresse des ASCII-Strings ist...

Prototyp:
void *IntToAscii(unsigned long);

Funktion:
void *IntToAscii(unsigned long value)
{
  unsigned char b = 0, a = 0;
  unsigned long j = 1;
  unsigned long wert;
  unsigned char Temp;
  unsigned char str[10];
  if(value < 1000000000)
  {
  if(value > 9)
  {
    do
    {
      j = j * 10;
      wert = value % j;
      value = value - wert;
      do
      {
      if(wert > 9)
        {
          wert = wert / 10;
        }
      }
      while(wert > 9);

      str[a] = (unsigned char)wert + 48;
      a ++;
    }
    while((wert + value)!= 0);
    a--;
    str[a] = '\0';
    a--;

    do
    {
      Temp = str[b];
      str[b] = str[a];
      str[a] = Temp;
      a--;
      b++;
    }
    while(a > b);
  }
  else
  {
    str[a] = (unsigned char)value + 48;
    str[a+1] = '\0';
  }
  }
  else
  {
  str[0] = '0';
  str[1] = 'v';
  str[2] = 'e';
  str[3] = 'r';
  str[4] = 'f';
  str[5] = 'l';
  str[6] = 'o';
  str[7] = 'w';
  str[8] = '\0';
  }

  return(&str);
}

Bin voll zu frieden mit der Lösung... aber für Anregungen habe ich
immer ein offenes Ohr...

[fale20_crack (Gast)]

He Ihr Genies, jede Dekade plus 0x30 ist absolut richtig!!!

mal was zum ausprobieren.
(Hier wird ein Analogwert von 0-5V am Display angezeigt!!!)


char zeile_5[17]={"U = 0,000V     "};
int=z;

IADC=0;        // Flag löschen
z=ADDAT;         //Umkopieren in INT-Variable z
zeile_5[8]=((z*5000)/255) % 10 + 0x30;  //Dritte Nachkommastelle
berechnen
zeile_5[7]=((z*(5000/10))/255) % 10 +0x30; //Zweite Nachkommastelle
berechnen
zeile_5[6]=((z*(5000/100))/255) % 10 +0x30;//Erste Nachkommastelle
berechnen
zeile_5[4]=((z*(5000/1000))/255) % 10 + 0x30;//Stelle vor dem Komma
berechnen

switch_z2();          //auf Zeile 2 schalten
show_text(zeile_5);  //Messergebnis anzeigen

DAPR=0x00;    //Neuer Start des Wandlers

Good luck!!!
der grosse Bruder von fale20

[fale20_crack (Gast)]

Sorry,

hab bei meinem Programm leider nur INT Zahlen verwendet,
ist aber egal oder?

[Matthias (Gast)]

Hi

@Gortosch
Und wie lannge kann ich bei deiner Funktion auf den String zugreifen?
Du gibst einen Pointer auf einen String zurück der nur lokal in der
Funktion existiert. Beim nächsten Funktionsaufruf ist der String weg.

unsigned char *Wert1;
unsigned char *Wert2;
Wert1 = IntToAscii(190);
Wert2 = IntToAscii(240);
printf("%s%s",Wert1,Wert2);

Hier wird dann ganz sicher nicht "190240" ausgegeben. Theoretisch
könnte 240240 dabei rauskommen. Theoretisch könnte dein Controller aber
auch abschmieren.

Matthias

[Gortosch (Gast)]

das ist nicht richtig... da du die Adresse(der Rückgabewert) in einem
anderen Pointer speicherst... bei meinem Beispiel unsigned char
*wert... öhm ups das hab ich garnicht dazu geschrieben... aber die
Funktion weist dem Pointer Wert die Adresse zu...

[Matthias (Gast)]

Hi

Falsch. Deine Funktion legt unsigned char str[10]; irgendwo
(wahrscheinlich auf dem Stack) an und du gibst einen Pointer darauf
zurück. str ist aber nicht mehr im Scope und damit darf der von str
eingenommene Speicher von einer beliebigen anderen Funktion verwendet
werden. Bei der direkten Verwendung nach dem Funktionsaufruf mag das
noch funktionieren ein paar Funktionsaufrufe später kann das aber ganz
gewaltig in die Hose gehen.

Matthias

[Gortosch (Gast)]

öhm alles zurück... du hast recht hab da etwas zu minimiert man müsste
einen Pointer mit übergeben... danke für den Tip...

[Gortosch (Gast)]

so nun die änderung:
Aufruf:
  unsigned char Wert1[10];
        IntToAscii(190, Wert1);
Prototyp:
        void IntToAscii(unsigned long value, unsigned char *);
Funktion:
        void IntToAscii(unsigned long value, unsigned char *str)
{
  unsigned char b = 0, a = 0;
  unsigned long j = 1;
  unsigned long wert;
  unsigned char Temp;
  if(value < 1000000000)
  {
  if(value > 9)
  {
    do
    {
      j = j * 10;
      wert = value % j;
      value = value - wert;
      do
      {
      if(wert > 9)
        {
          wert = wert / 10;
        }
      }
      while(wert > 9);

      str[a] = (unsigned char)wert + 48;
      a ++;
    }
    while((wert + value)!= 0);
    a--;
    str[a] = '\0';
    a--;

    do
    {
      Temp = str[b];
      str[b] = str[a];
      str[a] = Temp;
      a--;
      b++;
    }
    while(a > b);
  }
  else
  {
    str[a] = (unsigned char)value + 48;
    str[a+1] = '\0';
  }
  }
  else
  {
  str[0] = '0';
  str[1] = 'v';
  str[2] = 'e';
  str[3] = 'r';
  str[4] = 'f';
  str[5] = 'l';
  str[6] = 'o';
  str[7] = 'w';
  str[8] = '\0';
  }
}

Nochmal danke an Matthias... man sollte halt doch net versuchem um 1Uhr
mit Gewalt sein Problem zu lösen... :-)