Größere Datenmenge über UART

[Jack (Gast)]

Hi

ich möchte 4 integer Variablen übertragen. Dazu wollte ich sie 
aneinanderreihen und als einen langen String schicken.

Sender:

char send[80] = "";
uint32_t senden= 0;

//bx hat 3 Stellen, der Rest 2 Stellen
senden= P_Ry1*1000*100*100+P_Ly1*1000*100+1000*by+bx; 

itoa(senden,(char *)send, 10);

uart_puts((char *)send); 
uart_puts("\n");

Empfänger:

  char uart_string[80] = "";
  uint32_t buffer=0;
  char result[10];

  buffer=atoi((const char *)uart_string);
      

  bx= buffer%1000;
  itoa(bx, result1,10);
      
  by= (buffer/1000)%100;
  itoa(by, result2,10);

  P_Ly1=(buffer/100000)%100;
  itoa(P_Ly1, result3,10);

  P_Ry1=(buffer/10000000)%100;
  itoa(P_Ry1, result4,10);

allerdings bekomme ich immer nur Stücke von 5 Zeichen und nicht mehr

Danke

[Dario B. (abcd)]

> ich möchte 4 integer Variablen übertragen. Dazu wollte ich sie
> aneinanderreihen und als einen langen String schicken.

Waum denn? Was spricht dagegen, die Ints als asci, und zwischen den 
werten ein "\n" zu senden? Dann brauchst du sie beim Empfänger nicht 
wieder auseinander zu pflücken.

Hast du den die ÜPbertragung mal sonnstwie durchgetestet?

[Andreas (Gast)]

Jack schrieb:
> itoa(senden,(char *)send, 10);

itoa ist, wie der Name schon sagt, für Integer-Variablen gedacht. In 
Deinem Fall sind die 16 Bit breit. Für 32 Bit breite Variablen gibt es 
ltoa. Vermutlich wirst Du damit bessere Ergebnisse erziehlen.

[Jack (Gast)]

Dario B. schrieb:
> Hast du den die ÜPbertragung mal sonnstwie durchgetestet?

Ich habe die Übertragung egbenfalls an den Terminal geschickt und sie so 
getestet

Dario B. schrieb:
> Waum denn? Was spricht dagegen, die Ints als asci, und zwischen den
> werten ein "\n" zu senden?

Ich wollte nicht das Risiko eingehen, dass ich mit den empfangenen Werte 
vielleicht durcheinander komme und mir so den Programmablauf zerstörre.
Allerdings wäre das meine 2te Lösung gewesen, wollte erstmal das andere 
testen.

Andreas schrieb:
> itoa ist, wie der Name schon sagt, für Integer-Variablen gedacht. In
> Deinem Fall sind die 16 Bit breit. Für 32 Bit breite Variablen gibt es
> ltoa. Vermutlich wirst Du damit bessere Ergebnisse erziehlen.

guter Tipp, allerdings kann ich den Befehl Itoa nicht verwenden, er 
findet ihn trotz einbinden von #include <stdlib.h> nicht.
Was fehlt noch?

[jonas biensack (Gast)]

Itoa != itoa...

[Dieter K. (Gast)]

jonas biensack schrieb:
> Itoa != itoa...

das auch, ist ja einmal ein Großbuchstabe "i" und ein Kleinbuchstabe "i"

Abgesehen davon heißt das

ltoa vs. itoa
^
L

[Jack (Gast)]

Dieter K. schrieb:
> ltoa vs. itoa
> ^
> L

Danke, das war das Problem

allerdings bringt es keine Besserung, es fehlen immernoch Daten bzw er 
schickt nur 4 Zahlen

nochmal die uart funktionen

void uart_init(void)
{
  UBRR1 = 103;
  UCSR1B |= (1<<RXEN1)|(1<<TXEN1)|(1<<RXCIE1); 
  UCSR1C = (1<<USBS1)|(3<<UCSZ10);        

}

int uart_putc(unsigned char c) 
{
    while (!(UCSR1A & (1<<UDRE1)))  
    {
    }                             
 
    UDR1 = c;                      
    return 0;
}
 
 

void uart_puts (char *s)
{
    while (*s)
    {   
        uart_putc(*s);
        s++;
    }
}

[Frank M. (ukw) (Moderator)]

Jack schrieb:

> ich möchte 4 integer Variablen übertragen. Dazu wollte ich sie
> aneinanderreihen und als einen langen String schicken.

Was sind bei Dir die 4 Integer-Variablen? Welchen Wertebereich haben 
sie? Unter Umständen kannst Du auch gar nicht 4 Werte in einen 
32-Bit-Integer packen, weil sie z.B. negativ sind oder größer als 100 
sind.

Ich würde alle 4 Werte in den String "send" packen - durch Leerzeichen 
getrennt:

Beim Sender:

Elegant, aber speicherplatz-aufwendig:

    sprintf (send, "%d %d %d %d\n", P_Ry1, P_Ly1, by, bx);
    uart_puts(send);

Weniger elegant, aber vom Speicherplatz sparsamer:

    itoa (P_Ry1, send, 10);
    strcat (send, " ");
    itoa (P_Ly1, send + strlen (send), 10);
    strcat (send, " ");
    itoa (by, send + strlen (send), 10);
    strcat (send, " ");
    itoa (bx, send + strlen (send), 10);
    strcat (send, "\n");
    uart_puts(send);

Beim Empfänger:

Elegant, aber speicherplatz-aufwendig:

  if (sscanf (uart_string, "%d %d %d %d", &P_Ry1, &P_Ly1, &by, &bx) != 4)
  {
      ... // Fehler beim einlesen
  }
  else
  {
      ... // tue was
  }

Weniger elegant, aber vom Speicherplatz sparsamer:

    char * p;

    P_Ry1 = atoi(uart_string);
    p = strchr (uart_string, ' ');

    if (p)
    {
       p++;
       P_Ly1 = atoi(p);

       p = strchr (p, ' ');

       if (p)
       {
         p++;
         by = atoi(p);

         p = strchr (p, ' ');

         if (p)
         {
           p++;
           bx = atoi(p);
         }
       }
    }

   if (p)
   {
       ... // tue was
   }
   else
   {
       ... // Fehler
   }

Letzteres könnte man schöner machen, indem man sich eine eigene 
Scan-Funktion schreibt.

uint8_t
myscan (char * p, uint8_t pos, uint8_t * valuep)
{
    while (pos)
    {
        p = strchr (p, ' ');

        if (!p)
        {
            return 0;  // FEHLER!
        }
        p++;
        pos--;
    }

    *valuep = atoi (p);
    return 1;     // OK!
}

Aufruf dann:

   if (myscan (uart_string, 0, &P_Ry1) &&
       myscan (uart_string, 1, &P_Ly1) &&
       myscan (uart_string, 2, &by) &&
       myscan (uart_string, 3, &bx))
   {
       ... // tue was
   }
   else
   {
       ... // Fehler
   }

Ist nicht getestet, sollte aber so laufen.

[Jack (Gast)]

dickes danke für deine mühe, ich werde es nachher mal einbauen und 
testen

[Frank M. (ukw) (Moderator)]

Jack schrieb:
> dickes danke für deine mühe, ich werde es nachher mal einbauen und
> testen

Du hattest leider nicht meine Fragen beantwortet:

Was sind bei Dir die 4 Integer-Variablen? Welchen Wertebereich haben
sie?

Wäre nett, wenn Du dazu noch eine Aussage treffen würdest. Das wäre 
schon wichtig für den Code, den ich da oben hinschrieb. Dieser ist 
momentan darauf ausgerichtet, dass Deine 4 Variablen tatsächlich 
Integer-Variablen (also 16 Bit breit) sind, d.h. bei Dir steht irgendwo:

int P_Ry1;
int P_Ly1;
int by;
int bx;

Zeige bitte die Definition Deiner Variablen. Die hast Du in Deinen 
Code-Listings leider immer weggelassen.

Wenn sie vom Typ int sind, muss die Zeile

  myscan (char * p, uint8_t pos, uint8_t * valuep)

in

  myscan (char * p, uint8_t pos, int * valuep)

geändert werden, sonst kracht es.

[Karl H. (kbuchegg)]

Jack schrieb:

> Ich wollte nicht das Risiko eingehen, dass ich mit den empfangenen Werte
> vielleicht durcheinander komme und mir so den Programmablauf zerstörre.

Dann stell jeder Zahl einen Buchstaben vorran, der eindeutig 
kennzeichnet, worum es sich bei dieser Zahl handelt.

Dann sieht deine 'Auswertung' so aus

  ...
  ... irgendwo ist eine neue Zeile hergekommen. Sie steht in uart_string

  if( uart_string[0] == 'X' )
      bx = atoi( &uart_string[1] );

  else if( uart_string[0] == 'Y' )
      by = atoi( &uart_string[1] );

  else if( uart_string[0] == 'L' )
      P_Ly1 = atoi( &uart_string[1] );

  else if( uart_string[0] == 'R' )
      P_Ry1 = atoi( &uart_string[1] );

und das Versenden so:

void send_value( char label, int value )
{
  char buffer[10] = "";

  itoa( value, buffer, 10 );

  uart_putc( label );
  uart_puts( buffer ); 
  uart_putc( '\n' );
{

int main()
{

  ......

  send_value( 'X', bx );
  send_value( 'Y', by );
  send_value( 'L', P_Ly1 );
  send_value( 'R', P_Ry1 );

Simpel, einfach, durchschaubar und nicht besonders fehleranfällig.
Und das schönste am Ganzen: wenn sich dann tatsächlich irgendwann nur 1 
einziger Wert ändert, dann brauchst du auch nur diesen einen Wert der 
Gegenstelle übermitteln.

[Jack (Gast)]

klar, es sind momentan normale integer Variablen, also 16 bit
aber im Prinzip würden 8 bit auch reichen, daher wollte ich sie noch 
ändern

danke