USART und Interrupt

[Fragender (Gast)]

Hallo,
ich kann erfolgreich DAten versenden mit dem USART, nur mit dem 
Empfangen klappt es noch nicht :( Im folgenden Code wird irgendwie nie 
die Interrupt Routine angesprungen, obwohl der andere µC was schickt, 
ebenfalls mit 2400 Baud.

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

void delay_ms(int delay) {
        int i;
        for (i=0;i<=delay;i++) {
                _delay_ms(1);
        }
}


void init_usart(void) 
{ 
 uint8_t HighByte = (416 >> 8);   // Baudrate 2400
 uint8_t LowByte = 416 & 0xFF;
 UBRRL |= LowByte;
 UBRRH |= HighByte;
 UCSRB = (1<<TXEN) | (1<<RXEN) | (1<<RXCIE);
 UCSRC = (1<<URSEL) | (1<<UCSZ1) | (1<<UCSZ0);
}

void send_char(unsigned char s) 
{ 
 while (!(UCSRA & (1<<UDRE))); 
 UDR = s; 
} 

void send_string(char *s) 
{ 
 while(*s != '\0') 
  { 
   send_char(*s); 
   s++; 
  } 
} 

ISR(USART_RXC_vect) {
    uint16_t test;
    test = UDR;
  send_string("Interrrupt!!!");
}


int main(void) 
{
sei();
init_usart();
DDRB = 0xFF;
while(1)
{
  send_string("test");
  delay_ms(1000);
}
return 0;
}

[Fragender (Gast)]

Muss mich korrigieren, es geht nachdem ich eine gemeinsame Masse 
zwischen den beiden COntrollern hergestellt habe... Mein Ziel ist aber 
eine Datenübertragung per Infrarot, da habe ich ja auch keine gemeinsame 
MAsse???

[omfgrtfm (Gast)]

dafür nimmt man dann lichtleichter

[Mike J. (Gast)]

@ Fragender
Dein Signal vom TX-Pin hat einen Masse-Bezug!
Also der Strom fließt vom TX-Pin nach Masse.

Wenn du den + Pol deiner Autobatterie anfasst bekommst du doch auch 
keine gewischt, es sei denn du hast deine Hand an der Karosserie 
(Masse).

[Fragender (Gast)]

Stimmt,danke!

[Fragender (Gast)]

Bin jetzt soweit dass ich eigentlich ganze Strings empfangen sollte,
leider klappt es wieder nicht...

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#define PUFFER_GROESSE 100
volatile char *schreibzeiger;
volatile char *lesezeiger;
volatile char puffer[PUFFER_GROESSE];

void delay_ms(int delay) {
        int i;
        for (i=0;i<=delay;i++) {
                _delay_ms(1);
        }
}


void init_usart(void) 
{ 
 uint8_t HighByte = (416 >> 8);   // Baudrate 2400
 uint8_t LowByte = 416 & 0xFF;
 UBRRL |= LowByte;
 UBRRH |= HighByte;
 UCSRB = (1<<TXEN) | (1<<RXEN) | (1<<RXCIE);
 UCSRC = (1<<URSEL) | (1<<UCSZ1) | (1<<UCSZ0);
}

void send_char(unsigned char s) 
{ 
 while (!(UCSRA & (1<<UDRE))); 
 UDR = s; 
} 

void send_string(char *s) 
{ 
 while(*s != '\0') 
  { 
   send_char(*s); 
   s++; 
  } 
} 

ISR(USART_RXC_vect) {
  *schreibzeiger=UDR;
  schreibzeiger++;
  if(schreibzeiger==puffer+PUFFER_GROESSE) schreibzeiger=puffer;
  
}

int main(void) 
{
uint8_t datenbyte = 0;;
sei();
init_usart();
lesezeiger=puffer;
schreibzeiger=puffer;
while(1)
{
  if(schreibzeiger != lesezeiger) {
    datenbyte = *lesezeiger;
    lesezeiger++;
    if(lesezeiger==puffer+PUFFER_GROESSE) lesezeiger=puffer;
    send_string(datenbyte);
    }

  
}
return 0;
}

Die (woanders abgeschaute)Idee dabei ist,dass die empfangenen Daten in 
einen Ringpuffer geschrieben werden, und sobald Lese- und Schreibzeiger 
verschieden sind, ausgegeben werden sollen. Leider kommt gar nichts am 
Pc an, gesendet wird definitiv und der der Interupt wird auch ausgelöst.

[Stefan E. (sternst)]

1)
send_string(datenbyte);
->
send_char(datenbyte);

2)
Du schreibst in den Puffer, ohne zu überprüfen, ob darin überhaupt noch 
Platz ist.

3)
Du schaltest die Interrupts ein, bevor schreibzeiger initialisiert 
ist.

4)
In main muss der Zugriff auf schreibzeiger vor der Unterbrechung durch 
den Interrupt geschützt werden. Und wenn du den Sourcecode bezüglich 2) 
änderst, auch die Zugriffe auf lesezeiger.

[Fragender (Gast)]

Ok, hab die SAchen berücksichtigt, bis auf die Paltzfrage im Puffer, 
aber zumindest amAnfang müsste es ja so gehn, gehts aber leider immer 
noch nicht :( Die andere SEite sendet im Sekundentakt "hallo\0"

[c]
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#define PUFFER_GROESSE 100

volatile char *schreibzeiger;
volatile char *lesezeiger;
volatile char puffer[PUFFER_GROESSE];

void delay_ms(int delay) {
        int i;
        for (i=0;i<=delay;i++) {
                _delay_ms(1);
        }
}

void init_usart(void)
{
 uint8_t HighByte = (416 >> 8);   // Baudrate 2400
 uint8_t LowByte = 416 & 0xFF;
 UBRRL |= LowByte;
 UBRRH |= HighByte;
 UCSRB = (1<<TXEN) | (1<<RXEN) | (1<<RXCIE);
 UCSRC = (1<<URSEL) | (1<<UCSZ1) | (1<<UCSZ0);
}

void send_char(unsigned char s)
{
 while (!(UCSRA & (1<<UDRE)));
 UDR = s;
}

void send_string(char *s)
{
 while(*s != '\0')
  {
   send_char(*s);
   s++;
  }
}

ISR(USART_RXC_vect) {
  *schreibzeiger=UDR;
  schreibzeiger++;
  if(schreibzeiger==puffer+PUFFER_GROESSE) schreibzeiger=puffer;

}

int main(void)
{
uint8_t datenbyte = 0;;
sei();
lesezeiger=puffer;
schreibzeiger=puffer;
init_usart();
while(1)
{
  if(schreibzeiger != lesezeiger) {
    cli();
    datenbyte = *lesezeiger;
    lesezeiger++;
    if(lesezeiger==puffer+PUFFER_GROESSE) lesezeiger=puffer;
    send_char(datenbyte);
    sei();
    }
}
return 0;
}[/]

[Fragender (Gast)]

Kann es sein, dass Schreibzeiger immer auf den Anfang vom Array zeigt? 
wenn ich in der ISR direkt send_string(*schreibzeiger) einfüge,bekomme 
ich hallo, dann hallohallo, dann hallohallohallo etc. ??

[Fragender (Gast)]

Ach und wenn ich in der ISR send_char einfüge,kommt es nur einmal, die 
if-schleife in der main-funktion wird trotzdem nciht angesprungen

[Stefan E. (sternst)]

Die Deklaration von schreibzeiger ist falsch. Der Zeiger selber muss 
volatile sein, nicht das Ziel.

volatile char *schreibzeiger;
->
char * volatile schreibzeiger;

(die beiden anderen volatiles sind im aktuellen Code übrigens 
überflüssig)


> wenn ich in der ISR direkt send_string(*schreibzeiger) einfüge

"send_string(*schreibzeiger)" ist schlicht Unsinn, genau wie das 
"send_string(datenbyte)" im vorigen Code.

[Fragender (Gast)]

Super, geht jetzt! Hier der Code falls jemand mal das gleiche Problem 
hat:

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

#define PUFFER_GROESSE 100

char *volatile schreibzeiger;
char *volatile lesezeiger;
volatile char puffer[PUFFER_GROESSE];

void delay_ms(int delay) {
        int i;
        for (i=0;i<=delay;i++) {
                _delay_ms(1);
        }
}

void init_usart(void) 
{ 
 uint8_t HighByte = (416 >> 8);   // Baudrate 2400
 uint8_t LowByte = 416 & 0xFF;
 UBRRL |= LowByte;
 UBRRH |= HighByte;
 UCSRB = (1<<TXEN) | (1<<RXEN) | (1<<RXCIE);
 UCSRC = (1<<URSEL) | (1<<UCSZ1) | (1<<UCSZ0);
}

void send_char(unsigned char s) 
{ 
 while (!(UCSRA & (1<<UDRE))); 
 UDR = s; 
} 

void send_string(char *s) 
{ 
 while(*s != '\0') 
  { 
   send_char(*s); 
   s++; 
  } 
} 

void get_string(char *s) 
{ 
 while(*s != '\0') 
  { 
   send_char(*s); 
   s++; 
  } 
} 

ISR(USART_RXC_vect) {
  *schreibzeiger=UDR;
  schreibzeiger++;
  if(schreibzeiger==puffer+PUFFER_GROESSE) schreibzeiger=puffer;
  
}


int main(void) 
{
uint8_t datenbyte = 0;
char c;
sei();
lesezeiger=puffer;
schreibzeiger=puffer;
init_usart();
while(1)
{
  if(schreibzeiger != lesezeiger) {
    cli();
    datenbyte = *lesezeiger;
    while(*lesezeiger != '\0') {
      send_char(datenbyte);
        lesezeiger++;
      }
    if(lesezeiger==puffer+PUFFER_GROESSE) lesezeiger=puffer;
    sei();
    }
  
}
return 0;
}

[Fragender (Gast)]

Arg,noch eine letzte Frage: Leider scheint der Zeiger nicht zum ANfang 
zurückzuspringen, nachdem der Puffer voll ist... D.h. wird hallo\0 
gesendet, kommt es bei puffer_groesse 50 9mal richtig an und beim 10. 
mal nur ein teil und dann nicht mehr richtig. muss ich da auch was 
anders deklarieren?

[Stefan E. (sternst)]

Das liegt daran, dass du in main lesezeiger nicht richtig verwaltest. 
Spiel mal durch, was passiert, wenn bei Eintritt in den if-Block 
lesezeiger auf ein '\0' zeigt.

[STK500-Besitzer (Gast)]

Wieso finde ich die Arbeitsweise mit Pointern bei einem Ringpuffer nur 
so umständlich?
Mit ein paar Variablen, die einfach die Indizes hochzählen, finde ich es 
wesentlich leichter. Zumindest funktionieren meine Ringpuffer-Routinen 
einwandfrei ohne Pointer-Operationen.

[Stefan E. (sternst)]

Natürlich ginge es mit einem Index einfacher, insbesondere wenn er als 
Puffergröße auch noch eine 2er-Potenz wählen würde. Er wollte ja aber 
wissen, warum sein Ansatz nicht geht, und die Antwort darauf lautet ja 
nicht "mit Zeigern geht es gar nicht, nimm einen Index".

[STK500-Besitzer (Gast)]

>und die Antwort darauf lautet ja nicht "mit Zeigern geht es gar nicht, nimm 
>einen Index".

Wohl wahr.
Klar geht es mit Zeigern. Nur sollte man schon etwas sicherer beim 
Umgang damit sein...

[Peter D. (peda)]

STK500-Besitzer wrote:
> Wieso finde ich die Arbeitsweise mit Pointern bei einem Ringpuffer nur
> so umständlich?

Weil sie es ist.


> Mit ein paar Variablen, die einfach die Indizes hochzählen, finde ich es
> wesentlich leichter.

Und wenn ein Byte (0..255) als Index reicht, ist das sogar effizienter 
(weniger Code, schneller):

Beitrag "AVR-GCC: UART mit FIFO"


Peter

[Peter D. (peda)]

Stefan Ernst wrote:
> insbesondere wenn er als
> Puffergröße auch noch eine 2er-Potenz wählen würde.

Das spart gerade mal einen Befehl ein, lohnt also nicht.


Peter