Empfangene Daten der UART vergleichen

[Eugen.S (Gast)]

Hallo zusammen,

ich habe da ein Problem und hoffe einer von euch kann mir den 
entscheidenden Tipp geben. Eigentlich kann es nicht so schwer sein und 
bin echt frustriert, dass ich nicht darauf komme.

Was ich machen möchte:

Ich lese mit Hilfe der Lib von Peter Danneger (im Anhand) ein String von 
bis zu 9 Byte ein. Diese werden in seine Lib im rx_buffer angelegt. 
Meine Idee war ein konstantes Array anzulegen und diese mit dem 
rx_buffer zu vergleichen. Dann das Ergebnis des Vergleich in einem 
String über rx wider heraus zu senden.

Frage 1:

Um an den Inhalt von rx_buffer zu kommen, muss ich meine Funktion zum 
Vergleichen in der UART0.c schreiben?

Fragen 2:

Wenn ich eine Konstante z.B.

const uinte8_t test [] =
{
   0x00,0x01,0x02,0x03,0x04
};

anlegen und über den Debugger dann schaue, steht da was ganz anderes 
drin. Ich verstehe nicht warum es so ist. Was kann mein Problem sein?

[Eugen.S (Gast)]

So sieht es bei meinem Array aus wenn ich Ihn nicht als konstant anlege.

[Peter Hacke (Gast)]

Mal auf das + neben age geklickt?

[Eugen.S (Gast)]

Die Werte vom age sind im Bild zu sehen.

[Karl H. (kbuchegg)]

Eugen.S schrieb:

> Ich lese mit Hilfe der Lib von Peter Danneger (im Anhand) ein String von
> bis zu 9 Byte ein. Diese werden in seine Lib im rx_buffer angelegt.
> Meine Idee war ein konstantes Array anzulegen und diese mit dem
> rx_buffer zu vergleichen. Dann das Ergebnis des Vergleich in einem
> String über rx wider heraus zu senden.

Nein das funktioniert nicht.
Die UART Routinen verwalten einen Ringbuffer. Der geht dich nichts an. 
Du musst schon über die offizielle Funktionsschnittstelle gehen um dir 
dort die einzelnen Bytes zu holen und in einem eigenen Array 
zusammensetzen. Der von den UART Routinen verwaltete Ringbuffer ist nur 
dazu da, dein Programm in sofern zu entlasten, dass du kein Byte 
verlierst während dein Programm anderweitig beschäftigt ist und momentan 
keine Zeit hat, die eintrudelnden Bytes abzuholen. Dann werden sie von 
der Interrupt Routine in diesem Ringbuffer zwischengeparkt. Der ist 
sozusagen der Postkasten, in den der Briefträger deine Post steckt, wenn 
du nicht zu Hause bist und die Tür nicht öffnest.

Vergiss die Idee. Du hast 2 Funktionen. Die eine sagt dir, ob ein 
Zeichen vorrätig ist. Die andere holt dir das jeweils nächste Zeichen, 
wenn eines da ist. Mit denen arbeitest du. Was die UART Funktionen 
intern machen geht dich nichts an, und ist nicht dein Bier.

int main()
{
   char c;
   char receivedString[80];
   unsigned char receivedCnt;
   ....

   receivedCnt = 0;

   while( 1 )
   {

     if( ukbhit0() ) // es gibt ein nächstes Zeichen
     {
       c = ugetchar0();  // hole das Zeichen

       if( c == '\n' ) // das vereinbarte Ende der Übertragung, zb '\n'
       {
         receivedString[receivedCnt] = '\0';
         receivedCnt = 0;

         // mach was immer du mit dem String machen willst
         // zb
         if( strcmp( receivedString, "hallo" ) == 0 )
           uputs0( "Dir auch ein hallo\n" );
         else
         {
           uputs0( "Ich verstehe nicht, was du mit '" );
           uputs0( receivedString );
           uputs0( "' meinst!\n" );
         }
       }

       else  // kein Übertragungsende. Zeichen in den Buffer und somit
             // den String aufbauen
       {
         if( receivedCnt < sizeof(receivedString) )
         {
           receivedString[receivedCnt++] = c;
         }
       }
     }  // end if( ukbhit0() )


   }  // end while
}

[Eugen.S (Gast)]

Hallo Karl Heinz,

wenn ich dich richtig verstanden habe, dann arbeite ich mit diesen 
Funktionen:

ukbhit0();      // 0 = rx buffer empty
ugetchar0();      // get received byte
utx0_ready();      // 0 = tx still busy
uputchar0();      // send byte

Alles was intern passiert, fasse ich nicht an.

Richtig?

[Karl H. (kbuchegg)]

Eugen.S schrieb:
> Hallo Karl Heinz,
>
> wenn ich dich richtig verstanden habe, dann arbeite ich mit diesen
> Funktionen:
>
>

> ukbhit0();      // 0 = rx buffer empty
> ugetchar0();      // get received byte
> utx0_ready();      // 0 = tx still busy
> uputchar0();      // send byte
>

>
> Alles was intern passiert, fasse ich nicht an.
>
> Richtig?

Genau.
Ich hab dir im vorhergehenden Post noch ein Beispiel konstruiert.

[Eugen.S (Gast)]

uputs0();

habe ich bewusst ausgelassen.

[Eugen.S (Gast)]

Super, vielen DANK erstmal!

[Eugen.S (Gast)]

Habe noch eine Frage zu meinem Array Problem.
Wenn Ihr euch mal das Bild anschauen würden.
Wie kommt der Unterschied in den Array zustande, der eine hat{data} und 
der andere {prog} stehen? Was ist der Unterschied?

In meinem Fall hat der mit dem {prog} die falschen werde drin und der 
mit {data} die richtigen! Bei wurden von mit identisch aufgebaut nur mir 
anderen Werten.

[Karl H. (kbuchegg)]

Eugen.S schrieb:
> Habe noch eine Frage zu meinem Array Problem.
> Wenn Ihr euch mal das Bild anschauen würden.
> Wie kommt der Unterschied in den Array zustande, der eine hat{data} und
> der andere {prog} stehen? Was ist der Unterschied?

Ich weiss nicht, was du da für eine Entwicklungsumgebung benutzt aber 
ich würde mal schätzen, dass das eine Array im Flash liegt und das 
andere im SRAM.

Daher denke ich, das ist ein Problem im Debugger, der das nicht 
berücksichtigt und dir mit der Adresse den SRAM Inhalt anzeigt, wenn er 
eigentlich den Flash Inhalt anzeigen sollte.