Uart Receiver daten speichern und auswerten wie mach ich das

[malius]

Hallo,
Kann mir jemand weiterhelfen.
Ich schicke über den UART zu einen senor 6 byte :00 02 20 00 00 00 (hex) und dieser antwortet mir auch mit 6 Byte über UART Receiver . Nun möchte ich das 4 und 3 byte für die Auswertung verwenden. Der minimum wert ist 80 32 wobei 80 im 4. und 32 im 3. Byte steht.
Der maximum wert ist 81 F4 wobei wiederum 81 im 4.und F4 im 3.Byte steht.
Der µC soll jenachdem ob jetzt der max. oder min. wert ankommt einen Ausgang setzten
Wie kann ich die Empfangenen Byte von receiver für die Auswertung verwenden, und wie setzte ich die grenzwerte.

Stimmt es das die Empfangenen Bytes im UDR Register gespeichert werden und das der µC diesen byte –weise erneuert. d.h. wenn dieses Register ein Byte hat und es kommt ein neues so wir das alte gelöscht oder?

Kann mir jemand da weiterhelfen

[Arexx-Henk]

Hallo,

so weit ich verstehe

die USART (Atmega hat ein empfanger (1 * byte, nenne mal E1) und zwei buffer (2 * byte, nenne mal B1/B2, ist eine Art FIFO = First In First Out, auslesen mit UDR).

Wenn ein byte vollig in die empfanger (E1) hereingeschoben ist wird das byte in B1 oder B2 gespeichert wenn noch einer Leer ist (die bytes werden abwechselnd in B1 oder B2 gespeichert) und wenn mann die UDR auslehst lehst man die zuerst gespeicherten Wert (ob B1 ob B2). Wenn noch mahl UDR lesen wird die andere B register Wert ausgelesen (angenommen darin ist ein gultige Wert).

Wenn B1 und B2 voll sind und noch nicht ausgelesen von UDR und ein drittes byte ist schon empfangen in E1 ist noch immer kein Problem. Nur wenn ein neues startbit empfangen wird wird die byte in E1 verloren gehen (nicht B1 und B2) und erscheint ein overun-interrupt (wenn eingeschaltet)

Die mikrokontroller steurt die B1/B2 speicher/auslese reien folge, braucht mann sich keine Sorgen zu machen. So mindestens die letzte 2 empfangen bytes sind immer da.

in 'C' hier ein etwas cryptisches beispiel, nur um ein idee zu bekommen

//Mach platz fur 6 bytes
unsigned char RX[6];
//index fur RX
unsigned char iRX;
//bytes nach integer umsetzen
int RxVal;


//solange RXC bit hoch ist (byte empfangen, oder mehere bytes)
while(UCSRA&(1<<RXC){

//empfange byte in array speichern (und nachste array position wahlen(++))
RX[iRx++]=UDR;

//wenn 6 bytes empfangen sind
if(iRX==6){

//umsetzen von 2 bytes RX[3]+RX[4] nach 1 integer (integer = 2 bytes)
RxVal=*(int*)&RX[3]; //hahaha...

//wenn empange wert grosser ist als...
if(RxVal>0x81F4){
//mach etwas
}//if
}//if
}//while


Ich bin mir bewust dass dies kein complettes antwort ist aber irgendwo mit dieser information solls gehen.

gruss

Henk

[malius]

Hallo Henk,

Danke für das beispiel, aber ganz den durchblick habe ich nicht, bin leider ein anfänger was das programmiern angeht.
Ich nehme mal an das auch der Atmega128 1 empfänger- und 2 buffer byte hat.

//umsetzen von 2 bytes RX[3]+RX[4] nach 1 integer (integer = 2 bytes)
RxVal=*(int*)&RX[3]; //hahaha...
in der zeile sind beide bytes enthalten oder habe ich das falsch verstanden.

was macht den diese zeilen ( hat mir ein schulekollege geschrieben)

// Get a character from the USART1 Receiver
#pragma used+
char getchar1(void)
{
char status,data;
while (1)
{
while (((status=UCSR1A) & RX_COMPLETE)==0);
data=UDR1;
if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0)
return data;
};
}

#pragma used-

// Write a character to the USART1 Transmitter
#pragma used+
void putchar1(char c)
{
while ((UCSR1A & DATA_REGISTER_EMPTY)==0);
UDR1=c;
}

ist das nur die Initialiesierung oder so ganz verstehe ich das nicht, nur leider kann ich ihn nicht mehr fragen , habe ihn lage nicht mehr gesehen.

wär echt super wenn mir jemand den C-code für die auswertung schreiben könnte.

MFG
malius
Kann mir das einer genau erläutern.

[Arexx-Henk]

Hallo,

RxVal=*(int*)&RX[3];

mit &RX[3] ist gemeint die speicher adresse von byte nummer 3 (z.B. adresse 2222 irgendwo im computer) byte nummer 4 liegt immer auf die nachtste speicher adresse 2223

(int*) heist interpretiere mal die adresse 2222 als sei es ein anzeiger/anweiser nach einen integer wert (ein wert der aus 2 bytes besteht).

* heist lese mal die inhalt von adresse 2222. Durch die (int*) wird die addresse 2222 als ein integer gelesen dass heisst die addresse 2223 wird auch in bezug genommen und mit ausgelesen.

Aber da gibt's viele 'C' bucher dazu.


[list]
#pragma used+
//#pragma ist ein anweisung fur die compiler und die 'used +' soll irgendwo im compiler handbuch stehen (ich hab keine ahnung was dies hier fur die compiler bedeutet

char getchar1(void)
{

//hier ist eine function 'getchar' definiert, dieze function kann
mann von irgendwo im program anrufen/ausfuren durch einfach
'getchar();' zu schreiben

char status,data;
//reserviere mahl computer speicher platz fur 2 bytes 'status' und 'data'

while (1)
{
//alles zwischen die '{' und zubehorende '}' zeigen wird unendlich mal ausgefuhrt

while (((status=UCSR1A) & RX_COMPLETE)==0);
//1. (status=UCSR1A) die inhalt vom UCSR1A register wird in speicherplatz 'stastus' kopiert
//2. ((...) & RX_COMPLETE) hier wird getestet ob dat bit RX_COMPLETE (so irgendwo definiert sein) in 'status' anwesend ist
//3. while((())==0) solange das resultat der test null ist wird die while schleiife immer wieder aufneu ausgefuhrt, in diesen fall wird die schleife verlassen wenn RX_COMPLETE hoch ist, wenn ein byte empfangen ist

data=UDR1;
//speicher dass empfange byte im 'data' speicherplatz

if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0)
//vorher in die 'while' schleife war register UCSR1A in 'status' kopiert, jetzt wird getestet ob einer oder mehere der drei fehler bits in diesem register hoch sind, so ob irgendwo etwas fehl geslagen hat

return data;
//schicke dass empfangene byte zuruck an die function die diesen function (getchar1) angerufen hat

void putchar1(char c)
//function um ein byte zu versenden
{
while ((UCSR1A & DATA_REGISTER_EMPTY)==0);
//so lange bit DATA_REGISTER_EMPTY im UCSR1A register nicht hoch (sondern niedrich) ist, oder anders gesagt, solange kein byte im versand register anwesend ist, bleib in diese schleife hangen

UDR1=c;
//kopier dass zu versenden byte in die versend buffer, damit wird dass byte automatisch vom mikrokontroller versendet.

....pppffffffffffffffffffffff

und jetzt mahl irgendwo 'C' lernen....

gruss

Henk

[malius]

Hallo Henk,
Danke für die super Erklärungen.
ich habe e vor 'C' zu lernen, nur zurzeit bin ich heut in matura stress.
ursprünglich sollte ja mein Projektpartner das programm schreiben, er kennt sich mit 'C' auch aus. Leider ist er aus unerkärlichen Gründen abgesprungen d.h. er hat die schule geschmissen.
Und Ich mache das Projekt jetzt alleine, denn ich gebe nie auf.

Ich werde mal schauen das ich das programm irgendwie hinbekomme.

Danke und schöne Grüße
malius