24bit int -> char

[Jens H. (Gast)]

Hallo Community,

vorweg: Ich habe nicht sonderlich viel Ahnung vom C-Programmieren.

Grundlegendes Ziel: Den Wert eines

long int

(eigentlich nur 24 Bit) als Decimalzahl über UART auszugeben. Dazu 
verwende ich bisher die Funktion

sprintf ()

. Allerdings scheint es mir so dass ich damit nur 16 Bit verarbeiten 
kann. Denn sobald der Dezimalwert 65535 überschritten wird, fängt er 
wieder bei 0 an.

Weiß jemand wie ich das Problem lösen kann? Gibt es Argumente oder 
Funktionen mit denen ich das einstellen kann?

Ich verwende Code Composer Studio 5 für einen MSP430.

Mein bisheriger Test-Code:

testwert = 0xfffa;     
sprintf( Buffer, "%d", testwert );
while (Buffer[i] != 0)      // Ausgabe ueber UART
{
    while (!(IFG2 & UCA0TXIFG));
    UCA0TXBUF = Buffer[i];
    i++;
}
testwert++;

Ich habe auch schon "%ld" versucht doch das bringt auch keinen 
Fortschritt.

Vielen Dank schonmal, lg

[Mighty (Gast)]

Wandel die Zahl in eine String um und gib sie dann über UART aus.

[g457 (Gast)]

> sprintf( Buffer, "%d", testwert );
                     ^
ld. Details stehen in der Doku.

HTH

[Jens H. (Gast)]

g457 schrieb:
> ld. Details stehen in der Doku.

Ich weiß nicht welche Doku du meinst. Aber wie gesagt, "%ld" bringt mir 
nur dass er mir 'ld' ausgibt.

Mighty schrieb:
> Wandel die Zahl in eine String um und gib sie dann über UART aus.

Ich werd mal probieren ob ich das hinkriege.

Falls es übrigens noch von Bedeutung ist, habe folgende Deklarationen:

 char Buffer 
long int testwert

[g457 (Gast)]

> Ich weiß nicht welche Doku du meinst.

Die Doku-mentation halt, hier die von sprintf. 'l' wie 'long'.

> char Buffer

∗hust∗ mach da mal einen Puffer draus, der größer ist als wie nur ein 
char.

[Jens H. (Gast)]

g457 schrieb:
> ∗hust∗ mach da mal einen Puffer draus, der größer ist als wie nur ein
> char.

Sorry, mein Fehler. Habs natürlich als char Buffer[10]; deklariert.

[Jens H. (Gast)]

Habe nach sehr langem rumgooglen und ausprobieren nun einen Workaround 
gefunden der vorerst zu funktionieren scheint. Habe eine Funktion aus 
einem anderen Forenbeitrag übernommen. Falls es jemanden interessiert:

int m = 10;
Buffer[m] = '\0';
while(--m >= 0)
{
Buffer[m] = '0' + spannung % 10;
spannung /= 10;
}

Trotzdem danke für eure Bemühungen!

lg

[Klaus W. (mfgkw)]

Jens H. schrieb:
> Sorry, mein Fehler. Habs natürlich als char Buffer[10]; deklariert.

dann ist das aber keine gute Idee:

Jens H. schrieb:
> int m = 10;
> Buffer[m] = '\0';

Wie wäre es, mal die Grundlagen von C zu lernen?

Ohne Häme, nur eine ernsthafte Empfehlung.

[Rolf M. (rmagnus)]

Jens H. schrieb:
> Ich verwende Code Composer Studio 5 für einen MSP430.

Das ist aber kein PC.

Jens H. schrieb:
> g457 schrieb:
>> ld. Details stehen in der Doku.
>
> Ich weiß nicht welche Doku du meinst. Aber wie gesagt, "%ld" bringt mir
> nur dass er mir 'ld' ausgibt.

Dann ist da wohl ein Fehler in der Implementation der 
Standardbibliothek, oder nicht alle Format-Spezifizierer werden 
unterstützt. %ld ist eigentlich der richtige.

[W.S. (Gast)]

sowas wie sprintf finde ich für Mikrocontroller Mist.

Grund: Man schleppt viel zu viel unbenutztes Zeug in den zumeist knappen 
ROM hinein.

Meine Alternative, die für alles was nicht float ist wohl ausreichen 
dürfte:

/***************************************************
   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 LONGtoString (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.

[Jens H. (Gast)]

Deine Alternative funktioniert einwandfrei. Vielen Dank, das hat mir 
wirklich weitergeholfen.

lg