Probleme mit Zusammenspiel von Uart-Interrupts

[Tobias (Gast)]

Hallo zusammen,

ich möchte mehrere µC mit einander verbinden und mit RS485 ein Netzwerk 
aufbauen.

Dazu senden ein Master eine Nachricht (siehe Bild im Anhang), obere 
Nachricht.
Ein Atmega 8 als Slave soll darauf antworten. Da geht bis jetzt auch 
sehr gut. Ich habe allerdings 2 Probleme, die ich einfach nicht in den 
Griff bekomme.
1. Der slave senden irgenwoher noch ein "\0" (siehe 3. Zeile, rot 
eingekreist)
2. Der Slave hört danach nicht mehr auf Nachrichten vom Master.

Ich bin mir sicher, es sind meine Interrupts. Da es mein erstes großes 
Projekt mit Interrupts ist, lasse ich mir gern auch erklären, wie es 
richtig oder eleganter geht. Diese Anwendung der Interrupts für RX und 
TX habe ich aus einem bestehenden Quelltext.

Hier nun mein Quelltext des Slaves:

#define BAUDRATE 9600
#define F_CPU 8000000
#define MYADRESS 2
#define SLAVETYPE Akustik

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


uint8_t inputbuf [10];
uint8_t outputbuf [10];
static uint8_t receivebytes, sendbytes=0;
static uint8_t zeichen;
static uint8_t protocollstart =0;
static uint8_t msgend=0;

void rs485_slave_init()
{
  DDRC |= (1 << PC0);              // PC0 als Output setzen
  PORTC &= ~(1 << PC0);            // Max481 auf empfangen stellen
  _delay_us(500);                // 500µs warten

  uint16_t ubrr = (uint16_t) ((uint32_t) F_CPU/(16UL*BAUDRATE) - 1);

  UBRRH = (uint8_t) (ubrr>>8);
  UBRRL = (uint8_t) (ubrr);
  
  // UART Receiver und Transmitter anschalten, Receive-Interrupt aktivieren
  // Data mode 8N1, asynchron
  UCSRA = 0;
  UCSRB = (1 << RXCIE)| (1 << RXEN) | (1 << TXEN);
  UCSRC = (1<<URSEL) | (1 << UCSZ1)| (1 << UCSZ0);
}

int rs485_slave_send(uint8_t outdata [3])
{
  outputbuf[0]=0x02;                    //Startzeichen für Protokoll STX
  outputbuf[1]=MYADRESS;                  //Empfängeradresse in Array spreichern
  outputbuf[2]=0x42;
  outputbuf[3]=0;
  outputbuf[4]=0;
  outputbuf[5]=0;
  
  int x=0;
  for (int i=6;i <= 8;i++)
  {
    outputbuf[i]=outdata[x++];              //Datenarray in Outputbuf 3-5 schreiben
  }
  outputbuf[9]=0x03;
  
  PORTC |= (1 << PC0);                  // Max481 auf senden stellen
  
  cli();
  UCSRB &= ~(1 << RXEN);
  UCSRB |= (1 << UDRIE);                  //Interrupt zum Senden aktivieren
  sei();
  
  
  return 1;
}

int rs485_slave_read(uint8_t indata[], uint8_t size)
{
  uint8_t n=0;
  if (inputbuf[0]== 0x02)                  //Start einer Nachricht feststellen
  {
    while (n <= 9)
    {
      indata[n]=inputbuf[n];
      n++;
    }
    return n;
  }
  else
  {
    return 0;
  }
  
  
}

void deleteInputbuf()
{
  int i=0;
  while (i <= 11)
  {
    inputbuf[i++] = 0;
  }
}


int main(void)
{
  DDRD |= (1 << PD6) | (1 << PD7);              //PC0 als Ausgang für Signalisierung RX an Slave
  //DDRC &= ~(1 << PC1);
  
  uint8_t statusbyte[3];
  uint8_t inputdata [10];
  
  cli();
  //Initialisierung RS45
  rs485_slave_init();
  sei();
  
  
    while(1)
    {
    
    
    rs485_slave_read(inputdata, sizeof(inputdata));
    
    if(inputbuf[0] == 0x02 && msgend)
    {
      //Start und Ende von Frame erkannt, prüfen ob Nachricht für Teilnehmer ist
       if (inputbuf[1] == MYADRESS)
       {
        //Nachricht ist für diesen Teilnehmer
        //Auswerten der Steuerbytes
        PORTD |= (1 << PD7);
        if (inputbuf[3] & (1 << 2))
        {
          PORTD |= (1 << PD6);
        } 
        else if (!(inputbuf[3] & (1 << 2)))
        {
          PORTD &= ~(1 << PD6);
          
        }
       
      
       statusbyte[0]= (1 << 0);          //ACK Nachricht
       statusbyte[1]=0x58;
       statusbyte[2]=0x58;
       
       rs485_slave_send(statusbyte);
       deleteInputbuf();
       }
       else
       {
         PORTD &= ~(1 << PD7);
       }
    
    }  
  }
        
  return 0;
}

ISR(USART_RXC_vect)                //Interrupt-Routine, wird ausgelöst, wenn Zeichen empfangen wird
{
  zeichen = UDR;                
  
  if (zeichen == 0x02 && receivebytes==0)
  {
    protocollstart=1;  
  }
  
  
  if (protocollstart)
  {
    inputbuf[receivebytes++]=zeichen;
  }
  
  if (receivebytes==10 && protocollstart)
  {
    //Ende der Nachricht erreicht
    //UCSRA |= (1 << RXC);
    UCSRB &= ~(1 << RXCIE);
    msgend=1;
    receivebytes=0;
    protocollstart=0;
  }
}

ISR(USART_UDRE_vect)
{
  if (sendbytes==1)
  {
    UCSRB |= (1 << TXCIE);                //Transmit Complete Interrupt aktivieren
  }
  
  if (sendbytes == 10)
  {
    UCSRB &= ~(1 << UDRIE);                //Interrupt zum Senden deaktivieren
    UCSRA |= (1 << TXC);
    sendbytes =0;
  }
  else
  {
    //while (!(UCSRA & (1<<UDRE)))            // warten bis Senden moeglich ist
    //{
    //}
    UDR = outputbuf[sendbytes++];            //Zeichen senden aus Outputbuf
  }
}


//Transmit Complete Interrupt Routine
ISR(USART_TXC_vect)
{
  // Transmit is complete: terminate
  PORTC &= ~(1 << PC0);                  //MAX485 auf Receive stellen
  UCSRB &= ~(1 << TXEN);                  
  UCSRB |= (1 << RXEN) | (1 << RXCIE);          //Receive Interrupt einschalten
  UCSRB &= ~(1 << TXCIE);                  //Transmit Complete Interrupt deaktivieren
}

Wäre sehr dankbar, wenn mir jemand helfen würde.

Vielen Dank.

Gruß Tobias

[Mark R. (stevestrong)]

Versuch mal die Variabeln die in IRQ benutz werden auch als "volatile" 
zu deklarieren.