UART Daten Salat mit fleury lib

[Dani (Gast)]

Hallo Zusammen,

Ich habe ein kleines Programm, das über UART eine Anfrage schickt und 
diese Empfangen soll, klappt auch soweit, zu mindest mit den einzelnen 
Bytes.

Mein UART Slave schickt die daten so: 
0x06,0x00,0x02,0x43,0x34,0x31,0x33,0x03
(0x06 ACK, 0x02 = STX , 0x03 = ETX, etc)

Die einzelne Ausgabe funktioniert auf UART1 da kann ich alles lesen, 
sobald ich aber die Daten in einen Buffer schreibe, kommt auf dem UART1 
aus dem Buffer nur müll und wirre zeichen.

Die While-Schleife wird korrekt beendet, da alle Zeichen empfangen und 
ausgegeben werden.

Aber ich möchte meine Empfangenen Daten in einem String haben und weiter 
verarbeiten können, was so nicht funktioniert. In diesem Falle sind die 
Daten einfach nur Zahlen.

Ist das denn so überhaupt korrekt?

#define F_CPU 8000000UL
#define UART_BAUD_RATE  9600

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <avr/sleep.h>

init_usart0(UART_BAUD_SELECT (UART_BAUD_RATE, F_CPU));
init_usart1(UART_BAUD_SELECT (UART_BAUD_RATE, F_CPU));
#define CR "\r\n"

unsigned const char *hexDigits = "0123456789ABCDFEF";

int main(void)
{
  uart0_putc(STX);
  uart0_puts("0464");
  uart0_putc(ETX);

  unsigned int response;
  char Buffer[32];
  
  while(1)
  {
    response = uart0_getc();
    
    if(response & UART_NO_DATA)
    {} 
    else 
    {
      Buffer[count] = (unsigned char)response;
      uart1_putc((unsigned char) response);

      if(response == ETX)
      break;
    }
  }
  
  uart1_puts("Empfangen"CR);
  uart1_puts(Buffer);
}

Grüße,
Daniel

[Peter II (Gast)]

Wo kommt count her?

[Dani (Gast)]

Peter II schrieb:
> Wo kommt count her?


Hallo,

Steht im Code drin, copy@paste hat es verschluckt, hab die Kommentare 
entfernt.

uint8_t count=0;

In der Main und

count++;

Unter Buffer[count]

Kanns leider via Handy nicht ändern :(

[Udo S. (urschmitt)]

Dani schrieb:
> Kanns leider via Handy nicht ändern :(

Programmierst du auch via Handy?

[Karl H. (kbuchegg)]

Dani schrieb:

> In der Main und
>
>

> count++;
>

Das wär die nächste Frage gewesen: und wo wird count erhöht.

Es macht relativ wenig Spass, wenn du nicht den Code postest, der 
tatsächlich läuft. Denn dann suchen wir nicht existente Fehler.

Hast du auch aus deinen Charactern einen String gemacht, indem du noch 
ein '\0' anhängst? Oder ist das auch wieder in deinem richtigen Code 
enthalten und nur hier im Forum sehen wir das nicht?

[Eric B. (beric)]

Ja, wenn die gelesene Daten mit 0x06,0x00,0x02 anfangen wirst du nicht 
viel sehen da:

1) 0x00 den auszugebenen String terminiert
2) 0x06 und 0x02 non-printable ASCII sind.

[Dani (Gast)]

Hallo,

Sorry, dafür das die hälfte gefehlt hat. (Wenn man es mal eilig hat)...

#define F_CPU 8000000UL
#define UART_BAUD_RATE  9600

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <avr/sleep.h>

init_usart0(UART_BAUD_SELECT (UART_BAUD_RATE, F_CPU));
init_usart1(UART_BAUD_SELECT (UART_BAUD_RATE, F_CPU));

#define CR "\r\n"

unsigned const char *hexDigits = "0123456789ABCDFEF";

int main(void)
{
  uart0_putc(STX);
  uart0_puts("0464");
  uart0_putc(ETX);

  unsigned int response;
  char Buffer[32];
  int count = 0;
 
  while(1)
  {
    response = uart0_getc();
    
    if(response & UART_NO_DATA)
    {} 
    else 
    {
      Buffer[count] = (unsigned char)response;
      uart1_putc((unsigned char) response);
      count++;
      
      if(response == ETX)
         break;
    }
  }
  
  uart1_puts("Empfangen"CR);
  uart1_puts(Buffer);
}

Das ist mein ganzer Code den ich habe, nein die Daten kommen so wie Sie 
mir von der Fleury übergeben werden in den Buffer, da ich in meinen 
Daten ein NULL Charakter habe, ist der denn nötig um den Buffer zu 
füllen?

Ich möchte mir ja nur den Buffer als ganzes ausgeben, anstatt in Bytes..

Grüße,
Daniel

[Dani (Gast)]

Eric B. schrieb:
> Ja, wenn die gelesene Daten mit 0x06,0x00,0x02 anfangen wirst du
> nicht viel sehen da:
>
> 1) 0x00 den auszugebenen String terminiert
> 2) 0x06 und 0x02 non-printable ASCII sind.

Jupp ist mir klar, die sehe ich lediglich im hTerm und im Logic Analyzer 
:-)

Aber da sind ja auch Zahlen wie auch printable ASCII Codes drin

[Dani (Gast)]

Hier mal ein Beispiel:

00 02 38 32 32 38 30 30 30 30 30 30 46 34 03
-> <NUL><STX>8228000000F4<ETX>

[Georg G. (df2au)]

Was passiert mit count nach 32 Zeichen? Es wird nur einmal am 
Programmanfang mit 0 initialisiert. Wäre es nicht sinnvoller, das nach 
dem Senden von buffer erneut zu machen? So zeigt buffer[count] sehr 
schnell ins Nirwana.

[Dani (Gast)]

Georg G. schrieb:
> Was passiert mit count nach 32 Zeichen? Es wird nur einmal am
> Programmanfang mit 0 initialisiert. Wäre es nicht sinnvoller, das nach
> dem Senden von buffer erneut zu machen? So zeigt buffer[count] sehr
> schnell ins Nirwana.

Hallo,

Ja ist schon klar das es sinnvoller ist, Problem ist aber das im Buffer 
nur Mist steht, der Counter bleibt immer unter 32, da die Länge nicht 
größer wie 16 Bytes wird und nur einmal aktuell zum test gesendet wird. 
Aber ich ändere das gleich im Code :-)

[Georg G. (df2au)]

Mach doch (wie von Eric bereits gesagt) noch kleine Änderungen:

IST
Buffer[count] = (unsigned char)response;

WIRD
Buffer[count] = (unsigned char)(response & 0xff);

Dann bist du sicher, dass der "Flag Anteil" von response sauber 
abgetrennt wurde.

IST
> if(response == ETX)
>          break;

WIRD
if(response == ETX) {
           buffer[count] = 0x00;
           break;
           }

Dann hat uart_puts() ein sauberes String Ende.

Und zeig doch mal, was du als Ausgabe bekommst. Ist die Ausgabe immer 
die gleiche?

[Dani (Gast)]

Hallo,

So habe den Code jetzt wie folgt geändert:

#define F_CPU 8000000UL
#define UART_BAUD_RATE  9600

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <avr/sleep.h>



#define STX 0x02
#define ETX 0x03

int main(void)
{
        init_usart0(UART_BAUD_SELECT (UART_BAUD_RATE, F_CPU));
        init_usart1(UART_BAUD_SELECT (UART_BAUD_RATE, F_CPU));

  uart0_putc(STX);
  uart0_puts("0464");
  uart0_putc(ETX);

  unsigned int response;
  char Buffer[32];
  
  int count = 0;
  
  while(1)
  {
    response = uart0_getc();
    
    if(response & UART_NO_DATA)
    {} 
    else 
    {
      Buffer[count] = (unsigned char)(response & 0xFF);
      //uart1_putc((unsigned char) response);
      count++;

      if(response == ETX)
      {
        count = 0;
        Buffer[count] = 0x00;
        break;
      }
    }
  }
  
  uart1_puts("Empfangen"CR);
  uart1_puts(Buffer);
}

void uart1_putc(unsigned char data)
{
  unsigned char temphead;
  
  temphead = (UART1_TxHead +1 ) & UART_TX_BUFFER_MASK;
  
  while (temphead == UART1_TxTail){}
  ;
  
  UART1_TxBuf[temphead] = data;
  UART1_TxHead = temphead;
  
  // Enable TX Interrupt
  UCSR1B |= _BV(UDRIE1);
}

unsigned int uart0_getc(void)
{
  unsigned char tmptail;
  unsigned char data;
  
  if(UART_RxHead == UART_RxTail)
    return UART_NO_DATA;
    
  tmptail = (UART_RxTail +1) & UART_RX_BUFFER_MASK;
  UART_RxTail = tmptail;
  
  data = UART_RxBuf[tmptail];
  return (UART_LastRxError << 8) + data;
}

So, mein hTerm sagt mir folgendes:
45 6D 70 66 61 6E 67 65 6E 0D 0A =>  Empfangen<\r><\n>

Mit NICHT auskommentiertem (uart1_putc((unsigned char) response)):
00 02 43 34 31 33 34 30 33 35 34 32 30 44 03 => <\0><2>C4134035420D<3>

Sobald es aber aus dem Buffer kommen soll, kommt mit dem Code jetzt 
aktuell nichts mehr...

[Dani (Gast)]

Hier mal der Mitschnitt von UART Slave zu Atmega

[Dani (Gast)]

Hallo,

So bin etwas weiter gekommen, habe nun ein bischen hin und her debuggt, 
das Problem an der Ausgabe des Buffers liegt wohl an dieser Funktion:

void uart1_puts(const char *s)
{
  while(*s)
    uart1_putc(*s++);
}

Wenn ich anstatt uart1_puts(Buffer); / uart1_putc(Buffer[3]) ausführe, 
kriege ich ein C in Putty.

Dann fiel mir beim durch steppen auf, das in der puts funktion 
uart1_putc niemals erreicht wird.

grübel

[holger (Gast)]

>Dann fiel mir beim durch steppen auf, das in der puts funktion
>uart1_putc niemals erreicht wird.

Buffer selber plattgemacht würde ich da mal behaupten;)

      if(response == ETX)
      {
        count = 0;
        Buffer[count] = 0x00;

[Karl H. (kbuchegg)]

Dani schrieb:
> Hallo,
>
> So bin etwas weiter gekommen, habe nun ein bischen hin und her debuggt,
> das Problem an der Ausgabe des Buffers liegt wohl an dieser Funktion:

Nope. Das Problem liegt in deinem Code bzw. darin, dass du etwas 
versuchst als String anzusehen, was kein String ist.

> *grübel*

Anstatt zu grübeln solltest du vielleicht erst mal die C Grundlagen 
lernen. Insbesondere wie Strings in C funktionieren. Sobald in deinen 
Datenbytes ein Byte mit dem Wert 0x00 vorkommt, kannst du das nicht mehr 
als String ansehen. Denn genau diese 0x00 bedeuten in einem String: hier 
ist der Text zu Ende.

Wenn das also die empfangenen Bytes sind:

00 02 43 34 31 33 34 30 33 35 34 32 30 44 03

dann ist für uart_puts der 'String' bereits hier

00 02 43 34 31 33 34 30 33 35 34 32 30 44 03
 ^
 |
 |

zu Ende. Den hier findet sich der Bytewert, der in einem String das 
Textende kennzeichnet. Selbst wenn du dir hier

      if(response == ETX)
      {
        count = 0;
        Buffer[count] = 0x00;
        break;

nicht selbst mutwillig deinen String zerstört hättest, würde trotzdem 
das erste Byte im Buffer immer noch ein '\0' (mit dem COde 0x00) sein 
und damit dort der String zu Ende sein.

Deine ganze Auswertung ist so ziemlicher Mist. WEnn die Daten mit einem 
Byte von 0x02 anfangen, dann wird alles vor diesem 0x02 ignoriert. Und 
das 0x02 brauchst du auch nicht speichern. Deine Empfangsroutine muss 
also zuallererst mal einen Status haben: Bin ich gerade beim EMpfang 
einer Antwort oder bin ich das nicht. Der Übergang von 'nicht' auf 
'Nachricht wird empfangen, Bytes müssen gespeichert werden' erfolgt 
genau dadurch, dass ein 0x02 aus der UART rauskommt. Erst dann wird 
alles nachfolgende gespeichert. Alles vorhergehende ist dagegen 
uninteressant.

Die Fleury Funktionen können da genau gar nichts dafür, wie nicht anders 
zu erwarten war. Dieses Nicht-Funktionieren ist schon auf deinem Mist 
gewachsen.

[Georg G. (df2au)]

Versuch es doch mal so:

(ganz oben einfügen "int i;")

 if(response == ETX)
       {
         for (i = 0; i < count; i++) {
             uart_putc(Buffer[i]);
             }
         uart1_puts("Empfangen"CR);
         count = 0;
         break;
       }
     }
   }
 }

[Eric B. (beric)]

probier mal das

#define INIT 0
#define RECEIVING 1
#define FINISHED 2

int main()
{
   unsigned int response;
   char Buffer[32];
   int count = 0;
   int rcv_state = INIT;
   
   /* Init UARTS */
   init_usart0(UART_BAUD_SELECT (UART_BAUD_RATE, F_CPU));
   init_usart1(UART_BAUD_SELECT (UART_BAUD_RATE, F_CPU));

   /* Send */
   uart0_putc(STX);
   uart0_puts("0464");
   uart0_putc(ETX);

   /* Receive */
   do {
      response = uart0_getc();
      
      if (!(response & UART_NO_DATA))
      {
         response &= 0xFF;
         
         switch(response)
         {
            case STX:
               rcv_state = RECEIVING;
               break;
            
            case ETX:
               rcv_state = FINISHED;
               break;
            
            default:
               if(rcv_state == RECEIVING)
               {
                  Buffer[count] = response;
                  count++;
                  if(count > 31) rcv_state = FINISHED;
               }
               break;
         }
      }
   } while (rcv_state != FINISHED);

   /* Print received data */
   uart1_puts("Received:")
   for(count = 0; count < 32; count ++)
   {
      uart1_putc(' ');
      uart1_putc("0123456789ABCDEF"[(Buffer[count] >> 4) & 0x0F]);
      uart1_putc("0123456789ABCEDF"[(Buffer[count]     ) & 0x0F]);
   }
   uart1_puts("\n");
}

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Karl Heinz schrieb:
> Deine ganze Auswertung ist so ziemlicher Mist.
Nicht nur das. Bevor wir es vergessen: für einen uC sollte die 
Hauptschleife niemals ein Ende haben. Was sollte er denn nach Ablauf 
des Programms machen?

@Dani
Ich weiß, was er macht. Aber weißt du es auch?