Abfrage ob Buffer zu ende ist.

[simon (Gast)]

Ich habe hier eine Funktion die z.B. ein byte formatiert ausgibt:

void usart_write_P (const char *Buffer,...) {

  by = pgm_read_byte(Buffer++);
    if(by==0) break; // end of format string

}

Aufruf mit:

int u;
u = 0x00; (oder irgend ein anderer wert)

usart_write_P("receive: %i \n", (int) u);

Wieso kann man hier mit by==0 abfragen ob der Buffer zu Ende ist?
würde das nicht zu einem Problem führen wenn u == 0?

if(by==0) break;

[na (Gast)]

'0' (0x30 im string) != 0x00 ('\0' als stringende)

in C wird 0x00 oft als Markierung für das Ende eines Strings genutzt, 
sofern deine usart_write_P() wie printf() arbeiten sollte, fügt auch sie 
das am Ende ein.

Lass dir auf einem PC vielleicht mal einen String als HEX ausgeben, 
damit du die einzelnen Bytes siehst

[simon (Gast)]

Ich kann mir einfach nicht erklären Warum der XC18 Compiler hier diesen 
Fehler ausschreibt:



../../../Microchip/TCPIP Stack/UART.c:213:Error: syntax error

        void usart_write_P (const char *Buffer,...)
        {

        char str_buffer[10];
  char str_null_buffer[10];
  char move = 0;
  char Base = 0;
        int format_flag;
  int tmp = 0;
  char by;
  char *ptr;

        va_list ap;
  va_start (ap, Buffer);

  //Ausgabe der Zeichen
    for(;;)
  {
    by = Buffer++;
    if(by==0) break; // end of format string

    if (by == '%')
    {
                by = Buffer++;
      if (isdigit(by)>0)
        {

         str_null_buffer[0] = by;
        str_null_buffer[1] = '\0';
        move = atoi(str_null_buffer);
                by = Buffer++;
        }

      switch (by)
        {
                case 's':
                    ptr = va_arg(ap,char *);
                    while(*ptr) { putsUSART(*ptr++); }
                    break;
        case 'b':
          Base = 2;
          goto ConversionLoop;
        case 'c':
          //Int to char
          format_flag = va_arg(ap,int);
          putsUSART(format_flag++);
          break;
        case 'i':
          Base = 10;
          goto ConversionLoop;
        case 'o':
          Base = 8;
          goto ConversionLoop;
        case 'x':
          Base = 16;
          ConversionLoop:

          itoa(va_arg(ap,int),str_buffer,Base);

          int b = 0;    // <---------- Zeile 213 

          while (str_buffer[b++] != 0){};
          b--;
          if (b<move)
            {
            move -=b;
            for (tmp = 0;tmp<move;tmp++)
              {
              str_null_buffer[tmp] = '0';
              }
            //tmp ++;
            str_null_buffer[tmp] = '\0';
            strcat(str_null_buffer,str_buffer);
            strcpy(str_buffer,str_null_buffer);
            }
          putsUSART(str_buffer);
          move =0;
          break;
        }

      }
    else
    {
      putsUSART( by );
    }
  }
  va_end(ap);
}

[na (Gast)]

Vermutlich erlaubt der Compiler es nicht ohne weiteres, in einem 
switch/case-Konstrukt Variablen zu definieren:

Probier mal, entweder i vorher zu definieren oder um die ganzen 
Anweisungen {} zu setzen:

       case 'x':
       {
          Base = 16;
          ConversionLoop:

          itoa(va_arg(ap,int),str_buffer,Base);

          int b = 0;    // <---------- Zeile 213 

          while (str_buffer[b++] != 0){};
          b--;
          if (b<move)
            {
            move -=b;
            for (tmp = 0;tmp<move;tmp++)
              {
              str_null_buffer[tmp] = '0';
              }
            //tmp ++;
            str_null_buffer[tmp] = '\0';
            strcat(str_null_buffer,str_buffer);
            strcpy(str_buffer,str_null_buffer);
            }
          putsUSART(str_buffer);
          move =0;
          }
          break;

[Tom M. (Gast)]

simon schrieb:
> void usart_write_P (const char *Buffer,...)
> ...
> Aufruf mit:
> usart_write_P("receive: %i \n", (int) u);

Der Aufruf passt nicht zum Prototypen. usart_write_P erwartet einen 
Zeiger auf Characters, nicht einen int. Was versuchst du hier zu tun?

[simon (Gast)]

Ich habe mal die ConversionLoop ganz auskommentiert.

Nun klagt er über

UART.c:202:Warning [2054] suspicious pointer conversion

void putsUSART( char *data) {

}


   void usart_write_P (const char *Buffer,...)
        {
        int format_flag;



           case 'c':
          //Int to char
          format_flag = va_arg(ap,int);
          putsUSART(format_flag++);  // <___ Fehler
          break;

Also wir halten mal fest, der code hat auf einem ATxmega bestens 
funktioniert.

Nur was ich mich nun Frage va_arg Liefert doch ganz klar ein integer 
zurück.
Der Integer wird mit format_flag++ um eins erhöht (ist aber kein 
Pointer)
putsUSART erwartet ein char pointer.

kann ich hier nun einfach casten mit

 putsUSART (  ( char *)format_flag++  ); ?

[simon (Gast)]

Tom M. schrieb:
>> void usart_write_P (const char *Buffer,...)
>> ...
>> Aufruf mit:
>> usart_write_P("receive: %i \n", (int) u);
>
> Der Aufruf passt nicht zum Prototypen. usart_write_P erwartet einen
> Zeiger auf Characters, nicht einen int. Was versuchst du hier zu tun?


der *Buffer ist das "receive: %i \n" danach folgt (int) u was ein 
weiterer Parameter der funktion ist.

[simon (Gast)]

also ich es scheint so als "na" recht hatte,

er erlaubt mir keine Variablen inerhalb von switch zu definieren.


Und ito weicht zwischen GCC und XC18 auch ab

GCC:
char *itoa (int __val, char *__s, int __radix)

XC18:
char *itoa (auto int value, auto char *s);


es gibt da kein radix.

[simon (Gast)]

Gibt es da beim XC18 irgend eine Standard Funktion um ein byte
umzuwandeln in ein string der den hex wert enthällt?


BYTE b = 255;

sooo mir in einen string 0xFF schreiben.

[Fabian O. (xfr)]

Warum nimmst Du nicht einfach das fertige printf()? Brauchst Du wirklich 
die paar Byte Programmspeicher, die Du mit der Selbstbauvariante ggf. 
sparst? Mir wärs das nicht wert ...

[simon (Gast)]

eh ja, ich würde natuerlich auch sprintf oder printf nehmen wenn ich das 
mit meiner UART funktion verwenden kann

[simon (Gast)]

#include <stdio.h> /* for sprintf, printf */
int main(void)
{
char sbuf[100], s[]="Print this string";
int x = 1, y;
char a = '\n';


y = sprintf(sbuf, "%s %d time%c", s, x, a);


printf("Number of characters printed to "
"string buffer = %d\n", y);
printf("String = %s\n", sbuf);
}

Ansich könnte ich doch hier auch einfach sbuf nehmen, das ist doch ein 
pointer auf char oder liege ich da falsch?

[Karl H. (kbuchegg)]

Na offenbar hast du ja ein

         putsUSART(str_buffer);

zur Verfügung.

Also:

void putiUSART( int i )
{
  char buffer[10];
  itoa( buffer, i );    // weil dein itoa ja kein radix Argument hat
  putsUSART( buffer );
}

oder

void putiUSART( int i )
{
  char buffer[10];
  sprintf( buffer, "%d", i );
  putsUSART( buffer );
}


das sollte es wohl fürs erste tun.


Edit: Argh. WEnn man keine Tippfehler machen würde. Arrays werden 
natürlich mit [ ] geschrieben und nicht mit ( )

[simon (Gast)]

Danke dir!

Das funzt... kein wunder warum Microchip keine funktionen dafür hatte, 
weil sprintf das ganze abdeckt was ich wollte.

[Fabian O. (xfr)]

simon schrieb:
> eh ja, ich würde natuerlich auch sprintf oder printf nehmen wenn ich das
> mit meiner UART funktion verwenden kann

Du brauchst nur eine Funktion, die ein einzelnes Zeichen per UART 
ausgibt:

int uart_putchar(char c, FILE* stream)
{
  return putcUSART(c);
}

Die registrierst Du als Ausgabefunktion eines FILEs. Beim AVR 
funktioniert das so:

FILE uart_stdio = FDEV_SETUP_STREAM(uart_putchar, NULL, _FDEV_SETUP_WRITE);

Über dieses FILE kannst Du jetzt Ausgaben per UART schreiben.

fprintf(&uart_stdio, "Hallo Welt\n");

Du kannst das FILE auch als Standardausgabe festlegen:

stdout = &uart_stdio;

Dann reicht für UART-Ausgaben einfach:

printf("Hallo Welt\n");

Du müsstest nur nachschauen, wie man bei Deinem Compiler einen 
Ausgabestream so initialisiert, so dass die UART-Ausgabefunktion genutzt 
wird.

[Bronco (Gast)]

Um Deine ursprüngliche Frage zu beantworten:

simon schrieb:
> wieso kann man hier mit by==0 abfragen ob der Buffer zu Ende ist?
> würde das nicht zu einem Problem führen wenn u == 0?

Die Funktion

void usart_write_P (const char *Buffer,...)

ist eine Funktion mit variablen Argumenten ("VarArgs"), zu erkennen an 
dem "..." als Argument(enliste).

In einer solchen Funktion wird mithilfe von "stdarg.h" die variable 
Liste von Argumenten abgearbeitet.

Dein Code-Ausschnitt

  by = pgm_read_byte(Buffer++);
    if(by==0) break; // end of format string

bezieht sich nun einzig und allein auf den String, den Du in "buffer" 
übergeben hast, aber keineswegs auf die weiteren Argumente.

Das heißt

usart_write_P("receive: %i \n", (int) u);

übergibt in "buffer" den String "receive: %i \n", welcher mit dem 
impliziten Character 0x00 abgeschlossen ist.
Die Bedingung

    if(by==0)

wird also wahr, wenn dieses implizite 0x00 erreicht wird.

Was die Funktion aber mit den anderen Argumenten anfängt, hat damit gar 
nichts zu tun.