Usart (XMega) gesendeten String mit empfagenem String vergleichen

[Anemali (Gast)]

Hallo,

Ich will ein Testprogramm schreiben, welches den empfangenen String mit 
dem gesendeten vergleichen soll. Der Mikrocontroller ist ein AT XMega 
128 A1 und RX und TX sind miteinander verbunden (Er sendet also an sich 
selbst). Habe USART schon initialisiert und senden und empfangen 
funktioniert auch einwandfrei.
Jetzt weiß ich leider nicht weiter. Hatte die Idee das was gesendet und 
empfangen wird in Arrays zu schreiben und diese miteinander zu 
vergleichen aber das funktioniert bis jetzt nicht.
anbei noch mein bisheriger code:

#include <avr/io.h>
#include <stdint.h>
#include <util/delay.h>
#include <stdlib.h>
#include <avr/interrupt.h>

/*******************FUNKTIONEN********************/

void usart_sendstring(char *s) //zum Senden von Strings
{
  while (*s)
  {  
    USARTE0.DATA = *s ;
  while(!(USARTE0.STATUS & 0x40));
  s++;
  _delay_ms(500);
  }
}

ISR(USARTE0_RXC_vect)//Empfangen mit Interrupt
{
  int c = 0;
  c = USARTE0.DATA;
}

/*******************MAIN*************************/

int main(void)
{
  PORTD.DIR = 0b11111110;
  PORTD.OUT = 0b00000000;
  PORTE.DIR = 0b00001010;
  PORTE.OUT = 0b00001000;

  /************external clock (8 MHz)**************/
  OSC.CTRL |= 0x08;
  CCP = 0xD8;
     CLK.CTRL = 0x03;

  /***************USARTC initialisieren*****************/
  USARTE0.BAUDCTRLA = 52; // Formel siehe Skript AVR-GCC-Tutorial
  USARTE0.BAUDCTRLB = 0;

  USARTE0.CTRLC = 0x03; // 8-Bit-Character-Size
  USARTE0.CTRLB = 0x18; // enable Receiver & Transmitter
  USARTE0.CTRLA = 0x30; // enable Empfangsinterrupt (auf HI Level) 


PMIC.CTRL |= PMIC_HILVLEN_bm | PMIC_MEDLVLEN_bm | PMIC_LOLVLEN_bm; //Interrupts (high-, medium- und lowlevel freigeben)

  sei(); // allegemeine interruptfreigabe

  while(1)//Endlosschleife
  {
    usart_sendstring("Hallo"); //Senden des Wortes Hallo
         }
}

Danke schon mal!!!

[Ulrich P. (uprinz)]

Also es gibt jede Menge fertige U(S)ART Routinen für den AVR.

Aber im grunde musst Du nur ein Array definieren, in das Du Deine Daten 
empfängst. Du musst ein Ende-Zeichen definieren, damit Du weißt, wann 
der String zuende ist, so dass er weiter verarbeitet werden kann. 
Normalerweise ist das \n (Newline). Du musst natürlich Deinen 
Sende-String dann ebenfalls als "Hallo\n" senden.

Wenn Du dieses Zeichen empfängst, machst Du einen ordentlichen C String 
daraus, in dem Du es durch 0x00 ersetzt.

Also etwas im Sinne von:

char rxbuffer[64]; /* Puffer für Empfang */
int rxpos = 0;     /* Zeiger auf nächstes Zeichen im Puffer */
bool rxvalid = 0;  /* 1= String vollständig */
...

ISR(USARTE0_RXC_vect)//Empfangen mit Interrupt
{
  int c = 0;
  c = USARTE0.DATA;
  if (c=='\n') 
  { 
    c = 0x00; 
    rxvalid = 1; 
    rxbuffer[rxpos] = c;
    rxpos = 0;
  }
  if (c=='\r') {
    /* Windows Kompatibilität:
       c Verwerfen. */
  }
  else {
    /* Zeichen speichern */
    rxbuffer[rxpos++] = c;
  }
}

Damit sammelt der RX Interrupt die empfangenen Zeichen in xrbuffer ein.
Natürlich sind da jetzt noch einige Dinge nicht berücksichtigt. So 
müsstest Du beachten, dass nichts mehr empfangen wird, wenn \n 
eingegangen ist, sonst wird der rxbuffer wieder überschrieben.
Du musst 'manuell' in der Software rxvalid nach der Verarbeitung wieder 
zurück setzen. rxvalid kannst Du aber auch abfragen und wenn es 1 ist 
erst mal keine weiteren Zeichen zum rxbuffer hinzufügen.

Den empfangenen String kannst Du dann per

if (!strcmp(mystring, rxbuffer))
  { /* passt */ }
else
  { /* passt nicht */ }

verarbeiten.

Ist jetzt aus dem Kopf zusammen geschrieben, ich hoffe ich habe nix 
vergessen. Ist aber mehr ein Weg um Dir zu zeigen, wonach Du suchen 
musst, oder wie es im Grunde funktioniert.

Gruß, Ulrich

[xmega (Gast)]

Hallo,


Anemali schrieb:
> Jetzt weiß ich leider nicht weiter.

das wast du brauchst ist hier als Software zu bekommen.

Atmel USART Demo "TXT raus, RX rein, dann verglaichen"

http://www.atmel.com/dyn/resources/prod_documents/AVR1307.zip


Gruß XMEGA

[Anemali (Gast)]

Ok ich probiers gleich mal aus und lass euch wissen obs geklappt hat!
Danke für eure Hilfe.

[xcdark (Gast)]

Ulrich P. schrieb:
> Den empfangenen String kannst Du dann perif (!strcmp(mystring, rxbuffer))
>   { /* passt */ }
> else
>   { /* passt nicht */ }
> verarbeiten.
>
> Ist jetzt aus dem Kopf zusammen geschrieben, ich hoffe ich habe nix
> vergessen. Ist aber mehr ein Weg um Dir zu zeigen, wonach Du suchen
> musst, oder wie es im Grunde funktioniert.

Warum string.h mitkompilieren, wenn es ein paar Zeilen Code auch tun?

[c]char mystrcmp (unsigned char *s1, unsigned char *s2){
    while (*s1&&*s2){
        if (*s1!=*s2) return 1;
        s1++;
        s2++;
    }
    return 0;
}[c]

[Karl H. (kbuchegg)]

xcdark schrieb:

> Warum string.h mitkompilieren,

Weil string.h schon fertig ist und beim Linken sowieso nur die 
Funktionen in den Code kommen, die du auch benutzt. Es gibt keinen 
Grund, die bereits vorhandenen Funktionen zu ignorieren. Zumal der 
Compilerhersteller gewisse Freiheiten in der Implementierung hat, die du 
selber nicht hast. Soll heißen: Wenn es eine Möglichkeit gibt, 
schnelleren Code zu erhalten, dann kriegst du den eher indem du strcmp 
aus string.h benutzt als wie wenn du deine eigene Implementierung 
schreibst.

[Anemali (Gast)]

Guten Morgen,

also ich habe den Code jetzt mal etwas umgeschrieben, angelehnt an das 
Muster von Atmel. Habe wohl irgendwo eine endlosschleife drinnen, weil 
er nur das erste Byte von meinem Array sendet bzw. empfängt. Ich 
vermute, dass mein Fehler beim Empfangen liegt aber ich komm nicht drauf 
wie ich das umschreiben könnte.

#include <avr/io.h>
#include <stdint.h>
#include <util/delay.h>
#include <stdlib.h>
#include <avr/interrupt.h>
#include <stdbool.h>

#define K1_ON    (PORTD.OUT |= 0x80)
#define K1_OFF    (PORTD.OUT &= ~0x80)
#define K2_ON    (PORTD.OUT |= 0x40)
#define K2_OFF    (PORTD.OUT &= ~0x40)
#define K3_ON    (PORTD.OUT |= 0x20)
#define K3_OFF    (PORTD.OUT &= ~0x20)
#define ON_ON    (PORTD.OUT |= 0x08)
#define ON_OFF    (PORTD.OUT &= ~0x08)
#define RXEN_ON    (PORTD.OUT |= 0x04)
#define RXEN_OFF  (PORTD.OUT &= ~0x04)
#define DXEN_ON    (PORTD.OUT |= 0x10)
#define DXEN_OFF  (PORTD.OUT &= ~0x10)
#define DE_ON    (PORTD.OUT |= 0x02)
#define DE_OFF    (PORTD.OUT &= ~0x02)
#define DZ_ON    (PORTE.OUT |= 0x02)
#define DZ_OFF    (PORTE.OUT &= ~0x02)

#define RS232    1
#define DS102    2
#define DS101    3

#define NUM_BYTES   51 //Anzahl der Bytes 

int i = 0;
int c = 0;
// Array: the quick brown fox jumps over the lazy dog's back 
int sendArray[NUM_BYTES] = {0x74,0x68,0x65,0x20,0x71,0x75,0x69,0x63,0x6B,0x20,0x62,0x72,0x6F,0x77,0x6E,0x20,0x66,0x6F,0x78,0x20,0x6A,0x75,0x6D,0x70,0x73,0x20,0x6F,0x76,0x65,0x72,0x20,0x74,0x68,0x65,0x20,0x6C,0x61,0x7A,0x79,0x20,0x64,0x6F,0x67,0x60,0x73,0x20,0x62,0x61,0x63,0x6B,0x20};
int receiveArray[NUM_BYTES];
bool success;

ISR(USARTE0_RXC_vect)  //Interruptroutine zum Empfangen
{
  receiveArray[i] = USARTE0.DATA;   // empfangene Zeichen in ein Array schreiben
  i++;
}

/*******************MAIN*************************/

int main(void)
{
  PORTD.DIR = 0b11111110; //definieren von Ein- und Ausgängen
  PORTD.OUT = 0b00000000;
  PORTE.DIR = 0b00001010; //definieren von Ein- und Ausgängen
  PORTE.OUT = 0b00001000;

  int mode = RS232 ; //Einstellen der Kommunikationsart (RS232, DS101, DS102)

  /************external clock (8 MHz)**************/
  OSC.CTRL |= 0x08;
  CCP = 0xD8;
     CLK.CTRL = 0x03;

  /***************USARTC initialisieren*****************/
  USARTE0.BAUDCTRLB = 0;

  USARTE0.CTRLB = 0x18; // enable Receiver & Transmitter
  USARTE0.CTRLA = 0x30; // enable Empfangsinterrupt (auf HI Level) 


  PMIC.CTRL |= PMIC_HILVLEN_bm | PMIC_MEDLVLEN_bm | PMIC_LOLVLEN_bm; //Interrupts (high-, medium- und lowlevel freigeben)


  sei(); // allegemeine interruptfreigabe


  while(1)
  {
    switch(mode)
    {

/*****************************RS232******************************/ 
//funktioniert, bis auf das Vergleichen des gesendeten und empfangenen Wertes (mit Hilfe von Arrays)

      case RS232: 

        USARTE0.BAUDCTRLA = 52; // Formel siehe Skript AVR-GCC-Tutorial, bei 9600bps
        USARTE0.CTRLC = 0x03; // 8-Bit-Character-Size, asynchron

        K1_ON;
        K2_OFF;
        K3_OFF;
        ON_ON;
        RXEN_ON;
        DXEN_ON;
        DE_OFF;
        DZ_OFF;  

         if(i>=NUM_BYTES) //wenn das letzte Zeichen gesendet ist, soll wieder bei 0 angefangen werden
        {
          i = 0;
        }    
          
        USARTE0.DATA = sendArray[i];
        while(!(USARTE0.STATUS & 0x40));
          i++;

        _delay_ms(200);

        /*********Test zum Vergleichen von Gesendetem und Empfangenem*****/
        //funktioniert noch nicht!!!

        PORTA.DIR = 0xFF;

        success = true; 
        for(i=0; i<NUM_BYTES; i++)
        {
          if (sendArray[i] != receiveArray[i])
          { 
            success = false;
          }
        }

        if(success)
        {
          PORTA.OUT = 0b00000100;
        }
        else
        {
          PORTA.OUT = 0b00000001;
        }
                  
      break; 

/*************************noch unbearbeiteter Teil (nicht wichtig)***************/

/*****************************DS102******************************/ 

      case DS102:

        K1_OFF;
        K2_ON;
        K3_OFF;
        ON_ON;
        RXEN_ON;
        DXEN_ON;
        DE_OFF;
        DZ_ON; // Takt???

      break;

/*****************************DS101******************************/ 

      case DS101:

        K1_OFF;
        K2_OFF;
        K3_ON;
        ON_OFF;
        RXEN_OFF;
        DXEN_OFF;
        DE_ON; // RTS???
        DZ_OFF;

      break; 
      
      default: 

      break;
    }  
  }  
}

[Karl H. (kbuchegg)]

// Array: the quick brown fox jumps over the lazy dog's back 
int sendArray[NUM_BYTES] = {0x74,0x68,0x65,0x20,0x71,0x75,0x69,0x63,0x6B,0x20,0x62,0x72,0x6F,0x77,0x6E,0x20,0x66,0x6F,0x78,0x20,0x6A,0x75,0x6D,0x70,0x73,0x20,0x6F,0x76,0x65,0x72,0x20,0x74,0x68,0x65,0x20,0x6C,0x61,0x7A,0x79,0x20,0x64,0x6F,0x67,0x60,0x73,0x20,0x62,0x61,0x63,0x6B,0x20};

Bitte besorg dir ein C Buch und lies dir zumindest das erste Drittel 
durch.
UNd das das alles den Datentyp int benötigt, halte ich auch für ein 
Gerücht

char sendArray[] = "the quick brown fox jumps over the lazy dog's back";

 ...
         if(i>=NUM_BYTES) //wenn das letzte Zeichen gesendet ist, soll wieder bei 0 angefangen werden
        {
          i = 0;
        }    
....

du verwendest in deinem restlichen Code wie ein wilder i. D.h. diese 
Abfrage wird alles mögliche machen. Aber sicher nicht funktionieren. Für 
wichtige Variablen, wie zb die Anzahl der bereits gesendeten Zeichen 
benutzt man eine Variable mit sprechendem Namen, wie zb nrCharSent. Aber 
sicher nicht i. Einbuchstabige Variablennamen reserviert man 
ausschliesslich für Einsatzzwecke wie zb in kurzen for-schleifen, deren 
Inhalt man überblicken kann. Innerhalb der Schleife wird i benutzt und 
welchen Wert i danach hat interessiert keinen mehr, weil dieses i in der 
nächsten for-Schleife sowieso wieder auf einen neuen Wert initialisiert 
wird. Kurz und gut: Das ist eine Variable, deren Inhalt man zerstören 
kann, weil davon nichts anderes abhängt. Was man von einer Variablen 
namens nrCharSent nicht sagen kann.