RS232 Schnittstelle außerhalb der main Datei

Hallo,
also die beiden Werte sind schon als voitaille definiert. Ich überlege 
nur gerade kommt UDR aus dem internen Puffer als char oder als int? Eher 
als char oder? Da wäre der Rückgabewert 0 irgendein Steuerzeichen. Ich 
überlege gerade, ob es überhaupt sinnvoll ist (für meine Verwendung) das 
Empfangene Byte in die Hauptdatei zurückzuführen. Weil ich möchte wenn 
bestimmte Bytes empfangen wurden Befehle ausführen das könnte ich ja 
gleich in der RS232 Datei.

ATOMIC werde ich mir mal anschauen.

hallo,
was haltet ihr von der Funktion:

1

void rs232_rxcheck(void) {

2

3

  if (UDR_new_byte) {

4

    cli();

5

    rs232_data[rs232_byte_count++] = UDR_puffer;

6

    UDR_new_byte = 0;

7

    sei();

8

    if (rs232_byte_count==5) {

9

      rs232_byte_count=0;

10

      //Auswertung von rs232_data

11

    }

12

  } 

13

14

}

dazu habe ich jetzt Global diese Variablen eingeführt:

1

unsigned int  rs232_byte_count = 0;

2

unsigned int  rs232_data [5];

1

void rs232_rxcheck(void) {

2

3

  if (UDR_new_byte) {

4

    cli();

5

    rs232_data[rs232_byte_count++] = UDR_puffer;

6

    UDR_new_byte = 0;

7

    sei();

8

    if (rs232_byte_count==5) {

9

      rs232_byte_count=0;

10

      //Auswertung von rs232_data

11

    }

12

  } 

13

14

}

Die Puffer-Behandlung kannst du direkt in die Empfangs-ISR stecken und 
dort ein Flag setzen, dass du 5 Bytes empfangen hast.
Irgendwo anders (z.B. in der main) wertest du die Daten dann aus.

1

unsigned int  rs232_byte_count = 0;

2

unsigned int  rs232_data [5];

Es dürfte sehr sinnfrei sein, int zu benutzen, wenn du nur char 
brauchst.
Das kostet unnötig Speicherplatz und Programmcode.

1

static unsigned char rs232_byte_count = 0;

gehört in die Empfangs-ISR, der Puffer muss natürlich volatile global 
vereinbart werden.

mit der Interrupt Routine ist eig ne gute Idee. Da müsste ich halt nur 
während der Auswertung die Interrupts deaktivieren und danach wieder 
aktivieren.

1

static unsigned char rs232_byte_count = 0;

kann ich ja auch nicht einfach in den Interrupt schreiben. Weil da wird 
ja bei jedem Interrupt der Zähle zurückgesetzt.

>kann ich ja auch nicht einfach in den Interrupt schreiben. Weil da wird
>ja bei jedem Interrupt der Zähle zurückgesetzt.

Hast du es ausprobiert? Solltest du mal. Funktioniert nämlich.


>mit der Interrupt Routine ist eig ne gute Idee. Da müsste ich halt nur
>während der Auswertung die Interrupts deaktivieren und danach wieder
>aktivieren.

Beim AVR können sich Interrupts nicht gegenseitig unterbrechen. Die 
werden nach der Reihenfolge der Interrupt-Vector-Tabelle abgearbeitet, 
nachdem eine ISR beendet wurde.

ok und woran liegt das, dass es trotzdem funktioniert? Am static? Also 
da müsste ich ja aber am besten die Auswertung gleich in der Intterupt 
Routine machen oder? Weil das meinte ich mit deaktivieren, nicht das er 
während der Auswertung den Puffer umschreibt.

>ok und woran liegt das, dass es trotzdem funktioniert? Am static?
Ja.

>Also da müsste ich ja aber am besten die Auswertung gleich in der Intterupt
>Routine machen oder?

Das liest sich sehr wirr...
Was willst du überhaupt machen?
Es kann sein, dass deine Auswertung wunderbar in die ISR passt, es kann 
aber auch sein, dass das viel zu lange dauert, und andere Interrupts 
deswegen nicht pünktlich genug abgearbeitet werden können.

>Weil das meinte ich mit deaktivieren, nicht das er
>während der Auswertung den Puffer umschreibt.

Wenn während deiner Protokollbearbeitung mehr als ein Byte empfangen 
wird, geht dir eh irgendwas verloren.
Guck dir mal das Thema Ringpuffer an.

naja ich möchte halt per RS232 befehle senden, und je nach Befehl andere 
Funktionen auslösen,

und haben die ATMEL USARTS nicht schon generell einen Ringpuffer?

>und haben die ATMEL USARTS nicht schon generell einen Ringpuffer?

Nein. Naja, es werden 2 Bytes gepuffert. Das würde ich noch nicht als 
Ringpuffer bezeichnen.

1

ISR(USART_RXC_vect) { 

2

  static unsigned char rs232_byte_count = 0;

3

  rs232_data[rs232_byte_count++] = UDR;

4

  if (rs232_byte_count==5) {

5

    UDR_new_bytes = 1;

6

  }

7

}

hier der Header Ausschnitt:

1

volatile unsigned char  rs232_data [5];

2

volatile unsigned char  UDR_new_bytes = 0;

verursacht erstmal Fehler.

rs232.c:13: multiple definition of `UDR_new_bytes'

der Header wird 2x included einmal in der main Datei und einmal in der 
RS232 Datei. Aber ich habe um den Header:

1

#ifndef RS232_H_INCLUDED

2

#define RS232_H_INCLUDED

3

4

#endif

>der Header wird 2x included einmal in der main Datei und einmal in der
>RS232 Datei.

Muss nicht sein. Es ist eher der Fall, dass zwei Variablen mit dem 
gleichen Namen definiert werden. Ob die sich in Header-Dateien befinden 
oder im Hauptprogramm, steht da nicht.

Vielleicht sollte sich RS232 mal ein C-Buch besorgen, in dem das alles 
beschrieben wird. Das sind nämlich C-Grundlagen.

sie ist auf keinen Fall doppelt definiert. In der Main Datei steht gar 
nichts weiter groß. Und wenn ich das: #include "rs232.h" aus der Main 
entferne funktioniert es ja.

>Und wenn ich das: #include "rs232.h" aus der Main entferne funktioniert es >ja.

Dann liegt der Fehler wohl in deinen RS232-Dateien...

ich kann sie ja mal posten:
c:

1

#include <avr/io.h>

2

#include <avr/interrupt.h>

3

#include <inttypes.h>

4

5

#include "rs232.h"

6

7

ISR(USART_RXC_vect) { 

8

  static unsigned char rs232_byte_count = 0;

9

  rs232_data[rs232_byte_count++] = UDR;

10

  if (rs232_byte_count==5) {

11

    UDR_new_bytes = 1;

12

  }

13

}

14

15

void rs232_init(void) {

16

  UCSRB |= (1<<TXEN);                // UART TX einschalten

17

    UCSRC |= (1<<URSEL)|(3<<UCSZ0);    // Asynchron 8N1 

18

19

    UBRRH = UBRR_VAL >> 8;

20

    UBRRL = UBRR_VAL & 0xFF;

21

}

h:

1

#ifndef RS232_H_INCLUDED

2

#define RS232_H_INCLUDED

3

4

5

#define BAUD 9600L

6

7

#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)  

8

#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))   

9

#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD-1000)

10

11

volatile unsigned char  rs232_data [5];

12

volatile unsigned char  UDR_new_bytes = 0;

13

14

15

#endif

ok das ist natürlich war. Da vielen Dank für den Hinweis.
Und was war hier heran jetzt falsch:

1

RS232_H_INCLUDED

2

.

3

.

4

.

in den Header muss doch dann aber das rein:

1

extern volatile unsigned char  rs232_data [5];

2

extern volatile unsigned char  UDR_new_bytes;

oder kann ich nicht auch die Variablen im header komplett weglassen?

weil auch wenn ich die Variable als extern einführe und ihr einen Wert 
zuweise bekomme ich einen Fehler.

Also was ich jetzt so gelesen habe ist das in der Headerdatei verboten:

1

extern volatile unsigned char  UDR_new_bytes = 0;

Nur bekomme ich, wenn ich das = 0 lasse immer noch einen Redefinition 
Fehler:
h:

1

#ifndef RS232_H_

2

#define RS232_H_

3

4

5

#define BAUD 9600L

6

7

#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1) 

8

#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1))) 

9

#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD-1000) 

10

11

extern volatile unsigned char  rs232_data [5];

12

extern volatile unsigned char  UDR_new_bytes = 0;

13

14

15

void rs232_init(void);

16

17

#endif

c:

1

#include <avr/io.h>

2

#include <avr/interrupt.h>

3

#include <inttypes.h>

4

#include "motor.h"

5

6

#include "rs232.h"

7

8

9

volatile unsigned char  rs232_data [5];

10

volatile unsigned char  UDR_new_bytes = 0;

11

12

13

ISR(USART_RXC_vect) { 

14

  static unsigned char rs232_byte_count = 0;

15

  rs232_data[rs232_byte_count++] = UDR;

16

  if (rs232_byte_count==5) {

17

    UDR_new_bytes = 1;

18

  }

19

}

20

21

void rs232_init(void) {

22

  UCSRB |= (1<<TXEN);                // UART TX einschalten

23

    UCSRC |= (1<<URSEL)|(3<<UCSZ0);    // Asynchron 8N1 

24

25

    UBRRH = UBRR_VAL >> 8;

26

    UBRRL = UBRR_VAL & 0xFF;

27

}

ok ich habe mich nur auf den Beitrag von Lothar Miller bezogen, wo auch 
im Header ein = 0 war. Das war wahrscheinlich aber nur ein Tippfehler.

ok danke jetzt ist mir so einiges klar. Ich habe vorher noch nie mehr 
als eine C Datei benutzt, deswegen ist das Neuland für mich.

@docean was ist mit den Typen?

Und noch was. Wie löse ich jetzt am besten die Auswertung der 
Empfangenen Bytes. Soll ich die Auswertung in der ISR machen, oder 
lieber extern? Für den Anfang reicht es, wenn ich einzelne Bytes senden 
kann. Also nicht automatisiert, sondern per Hand vom PC.

>> oder lieber extern?
>...und wertest sie in der Hauptschleife aus.

In einer eigenen Header-Datei... SCNR

Ok. Aber wenn ich sie extern Auswerte muss ich ja aber auch die 
Interrupts für den Zeitraum deaktivieren, damit nicht der Puffer 
verändert werden kann.

So ich habe mich gerade mal ein wenig mit Ringpuffern beschäftigt. Das 
Prinzip beruht ja bei Peter Fleury auf der Bitweisen Verknüpfung. Das 
ganze ist eigentlich relativ genial. Ich werde jetzt mal versuchen mit 
der Teilen der Library mein Vorhaben zu realisieren.

>Das Prinzip beruht ja bei Peter Fleury auf der Bitweisen Verknüpfung.
Echt? Ich dachte, es beruht darauf, dass man einen Puffer hat, für den 
es eine Schreib- und einen Lesezeiger gibt.
Die bitweise Verknüpfung hängt eher mit dem beschränkten Platz des 
Puffers zusammen. Wenn man den Puffer 256 Bytes groß macht, und als 
Indizes welche vom Type unsigned char nimmt, dann kann man sich die 
bitweisen Verküpfungen sparen...

1

    /* calculate buffer index */ 

2

    tmphead = ( UART_RxHead + 1) & UART_RX_BUFFER_MASK;

3

4

  /* store new index */

5

  UART_RxHead = tmphead;

6

  /* store received data in buffer */

7

  UART_RxBuf[tmphead] = data;

also das ist der entsprechende Code Ausschnitt.

zur Überprüfung hätte ich auch nochmal ne Frage. Hier mal code 
Ausschnitte:

1

#define UART_NO_DATA          0x0100              /* no receive data available   */

2

3

unsigned int rs232_receive(void) {    

4

5

    return UART_NO_DATA;   /* no data available */

6

}

7

8

if ( c & UART_FRAME_ERROR )

wie Funktioniert die Bedingung in dem Fall. Wenn 0x0100 zurückgegeben 
wird wird das mit 0x0100 binär verknüpft. Es kommt also wieder 0x0100 
raus. Aber Sind nicht alle positiven Zahlen true?

1

if ( c & UART_NO_DATA

das meine ich natürlich.

1

if ( c & UART_FRAME_ERROR )

Das ist eine gewissermassen abkürzende Schreibweise von

1

if ((c & UART_FRAME_ERROR) != 0)

Als True im Sinne einer wahren Bedingung wird hier jeder Wert ungleich 0 
betrachtet. 0 ist False.

Siehe K&R ISBN: 3-446-15497-3, Seite 55

Ok ich verstehe. ALso alles, was nciht der Bitmaske entspricht wird 
durch die Verknüpfung 0. Aber knnte man da ncit gleich schreiben c==...?

>ALso alles, was nciht der Bitmaske entspricht wird durch die Verknüpfung 0.

So würde ich das nicht formulieren.
Was ist denn das was nicht der Bitmaske entspricht? Der andere Operand 
der Und-Verknüpfung.
Ist die Bitmaske selbst strukturiert? Ja. In Bits.
Was wird 0? Das Ergebnis der Und-Verknüpfung.
Ist das Ergebnis selbst strukturiert? Ja. Auch in Bits.
Was läßt sich über die Bits, des Ergebnisses sagen? Das jedes Bit des 
Ergebnisses 0 ist, bei dem das entsprechende Bit der Bitmaske gleich 0 
oder das entsprechende Bit des anderen Operanden gleich 0 ist.

>Aber knnte man da ncit gleich schreiben c==...?
In diesem Fall vielleicht schon. Aber der Code

1

unsigned int rs232_receive(void) {    

2

3

    return UART_NO_DATA;   /* no data available */

4

}

läßt mich bezweifeln ob es sich um ein reales bzw. vollständiges 
Beispiel handelt.

Im allgemeinen verwendet man diese Bitmasken mit Und, wenn noch weitere 
Information in anderen Bits stecken.
Daher kann man nicht mit == arbeiten. Man will ja die anderen Bits 
vielleicht garnicht betrachten.
Komplizierter wird es noch wenn man einige Bits auf 0 und andere auf 1 
testen will.

1

unsigned int uart_getc(void)

2

{    

3

    unsigned char tmptail;

4

    unsigned char data;

5

6

7

    if ( UART_RxHead == UART_RxTail ) {

8

        return UART_NO_DATA;   /* no data available */

9

    }

10

11

    /* calculate /store buffer index */

12

    tmptail = (UART_RxTail + 1) & UART_RX_BUFFER_MASK;

13

    UART_RxTail = tmptail; 

14

15

    /* get data from receive buffer */

16

    data = UART_RxBuf[tmptail];

17

18

    return (UART_LastRxError << 8) + data;

19

20

}/* uart_getc */

das War der vollständige Code ich habe ihn für meine Zwecke gekürzt. 
Also verwendet man die Bitmaske, weil man mehrere Informationen über 
return zurückgibt. Da ich da ja aber nicht mache kann ich auch mit == 
und != arbeiten.

Dein Code gibt auch ein wunderschönes Beispiel für einen Fall wo Du eben 
nicht einfach nur mit == arbeiten kannst. Es bezieht sich nur nicht auf 
UART_NO_DATA.

Aber mit

1

return (UART_LastRxError << 8) + data;

wird in den höherwertigen Bits noch der UART-Fehler zurückgegeben.
Um also nur die Fehlerbits zu berücksichtigen brauchst Du 0xFF00 als 
Maske. Um nur die Datenbits zu lesen hingegen 0x00FF.

Falls man etwa damit rechnen kann (das hängt von der 
UART-Implementierung ab) das sowohl das Datenbyte (zumdinest teilweise) 
gültig ist und auch die Fehlerbits so brauchst Du beide Masken und 
kannst nicht mit == arbeiten.

ok. Aber die Auswertung kann ich doch jetzt wie geplant machen in der 
Main Datei, oder eben wieder in einer extra Funktion.

1

  while(1) {

2

    rs232_byte=rs232_receive();

3

    if ( rs232_byte & UART_NO_DATA ) {

4

      //no data avaible

5

    } else {

6

      //new data avaible

7

      rs232_buffer[rs232_byte_count++];

8

      if (rs232_byte_count == 5) {

9

        rs232_byte_count=0;

10

        //analyses

11

      }

12

13

    }

14

  }

naja die Funktion rs232_receive liest ja schon aus dem Ringpuffer. Sie 
ist nur zur Kommunikation da. Die Zuweisung des Puffers habe ich aus 
versehen vergessen.

1

ISR(USART_RXC_vect) { 

2

  unsigned char tmphead;

3

    unsigned char data;

4

5

6

    data = UDR;

7

    tmphead = ( UART_RxHead + 1) & UART_RX_BUFFER_MASK;

8

  UART_RxHead = tmphead;

9

  UART_RxBuf[tmphead] = data;

10

11

}

12

13

14

15

unsigned int rs232_receive(void)

16

{    

17

    unsigned char tmptail;

18

    unsigned char data;

19

20

21

    if ( UART_RxHead == UART_RxTail ) {

22

        return UART_NO_DATA;

23

    }

24

25

    tmptail = (UART_RxTail + 1) & UART_RX_BUFFER_MASK;

26

    UART_RxTail = tmptail; 

27

28

    data = UART_RxBuf[tmptail];

29

    return (data);

30

31

}

also das ist die Library von Fleury nicht von mir. Ziel ist es wie 
gesagt, das ich Befehle (5 Bytes) per RS232 sende und diese dann 
ausgewertet werden sollen. Also muss ja irgendwo eine Abfrage rein, ob 
die 5 Bytes fertig sind.

naja ich hätte einfach ein timeout eingebaut.

Also Gegenstelle soll ein PC sein indem ich erstmal die Daten per Hand 
sende und später auf dem PC ein Programm dafür schreiben werde.

Und selbst wenn ich mit Start und Stoppzeichen arbeite muss ich ja 
trotzdem einen Zähler mitlaufen lassen und bzw. auf das Endzeichen 
warten.

Oder ich könnte die Zeichen ab dem Startzeichen Zählen und prüfen, ob 
das 5. Zeichen z.B. das Endzeichen ist. eine andere Möglichkeit sehe ich 
eig nicht.

Ok da würde ich das ganze jetzt aber zur Übersicht in eine Funktion 
auslagern, die das übernimmt und mit so einer art Satemachine arbeiten. 
Also je nach Status eine Globale Variable ändern oder eine static in der 
Funktion.

ein anderes Problem wäre noch, wenn ich Zahlen über 256 senden möchte. 
Da weis ich noch nicht, wie das gehen soll.

ok also muss ich das noch zusammenbasteln, dass es das 12345 dann wieder 
in ein 16bit int Feld reinschreibt.

achja das atio() direkt über den Rinpuffer laufen lassen? Das ist vlt. 
nicht so gut, weil er ja über das letzte Zeichen wieder bei 0 Anfängt. 
und wenn ich das ganze nochmal puffere weis ich ja nicht, wie lang das 
wird.

Hallo,
so hatte ih das auch schon probiert. Das Problem hierbei ist ja 
allerdings, das man maximal 8 Zahlen senden kann was ja aber ausreicht. 
Deshalb habe ich nach einer besseren Lösung gesucht.

ok. Also ich würde das ganze jetzt so realisieren. Mit verschachtelten 
Zählern.

Start of Transmission
Start of text
1
2
3
End of Text
Start of text
4
5
6
End of Text
.
.
.
End of Transmission

Bei Start of Transmission geht der Zeiger des Auswertungspuffers auf 0, 
in dem letztendlich 5 uint16_t Zahlen gespeichert werden. Bei jedem 
Start of text geht der Zeiger des Zwischenpuffers auf 0. Nach jedem 
Textblock wir der Zeiger des Auswertungspuffer erhöht. Nach 5 Zahlen im 
Auswertungsarray wird geprüft, ob das letzte Zeichen ein End of 
Transmission ist. Dann wird das Array Ausgewertet.

so ich habe mal schnell was geschrieben:

1

    if ( data == END_TRANSMISSION ) {

2

      //Auswertung

3

    } else if ( data == START_TRANSMISSION ) {

4

      analysis_counter=0;

5

    } else {

6

      if ( data == END_TEXT ) {

7

        analysis_buffer[analysis_counter]=atoi(text_buffer);

8

        analysis_counter++;

9

      } else if (data==START_TEXT) {

10

        text_counter=0;

11

      } else {

12

        text_buffer[text_counter]=data;

13

        text_counter++;

14

      }

15

    }

16

    }

Den Pufferüberlauf muss ich noch einbauen. Es geht aber erstmal nur ums 
Prinzip, ob das so klappt.

ok das mit den Namen kann man noch ändern. Mir ist nur nichts besseres 
eingefallen auf die Schnelle. SO sollten die schütze eigentlich 
funktionieren:

1

if ( data == END_TRANSMISSION ) {

2

      //Auswertung

3

    } else if ( data == START_TRANSMISSION ) {

4

      analysis_counter=0;

5

    } else {

6

      if ( data == END_TEXT ) {

7

        analysis_buffer[analysis_counter]=atoi(text_buffer);

8

        if  (analysis_counter < 5) analysis_counter++;

9

      } else if ( data == START_TEXT ) {

10

        text_counter=0;

11

      } else {

12

        text_buffer[text_counter]=data;

13

        if (text_counter < 10) text_counter++;

14

      }

15

    }

Also das gefällt mir nicht so. Wie ich das sehe hängt das Porgramm ja an 
der Stelle:

1

while( ( c = uart_getc() ) == SOT )

2

    ReceiveParameter();

Ja also es währe schon gut, wenn in der Hauptschleife weiter gearbeitet 
werden könnte. Also ich werde erstmal bei der obigen Lösung bleiben. Bei 
den paar Zeilen sieht man ja auch noch durch.