Echo-Test zwischen PC und Atmega644p

[Luffy M. (monkeydluffy)]

Moin,

ich versuche ein Echo-Test zwischen PC und Atmega644p mit hilfe der 
Interruptsfunktion ISR(USART0_TX_vect) aufzubauen. Der PC sendet über 
RS232 nacheinander Daten zum Atmega644p. Der Atmega644p empfängt über 
USART0 die Daten vom PC und sendet wieder über USART0 die Empfangene 
Daten zum PC zurück.

Momentan ist der Atmega644p in der Lage Daten vom PC zu empfangen. Aber 
der Atmega644p sendet nicht die Daten zum PC zurück. Also,meine 
interruptsfunktion ISR(USART0_TX_vect) funktioniert nicht.

Ich wäre sehr dankbar, wenn jemand mir hilft.

Danke im Voraus.

Code vom Atmega644p:

#include <avr/io.h>
#include <avr/interrupt.h> 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <avr/pgmspace.h>

#define F_CPU 3686400UL
#define FOSC 7372000 // Clock Speed
#define BAUD 9600UL

// Berechnungen zur Baudrate:

#define UBRR_VAL ((FOSC+BAUD*8)/(BAUD*16)-1)   // clever runden

#define usart0_rx_buffer_max_size 50 
/***************************************************/

char usart0_rx_buffer[usart0_rx_buffer_max_size];
volatile uint8_t usart0_rx_buffer_size = 0;

/****************************************************/
void USART_Init (unsigned int ubrr)
{
  UBRR0H = (unsigned char)(ubrr>>8);
  UBRR0L = (unsigned char) ubrr;
//  UBRR1H = (unsigned char)(ubrr>>8);
//  UBRR1L = (unsigned char) ubrr;
  

  UCSR0B = (1<<RXEN0)|(1<<TXEN0)|(1<<RXCIE0)|(0<<TXCIE0)|(0<<UCSZ02)|(0<<UDRIE0);
  UCSR0C = (0<<USBS0) | (1<<UCSZ01)|(1<<UCSZ00);// 1 Stopbit, 8 Bits
  DDRB = 0b11111111; // Setting PB7-PB0 as output
  PORTB = (0<<PB7); // USART0 receive data from pc 
} 

ISR(USART0_RX_vect)
{
  char data = UDR0;
  
  if (usart0_rx_buffer_size < usart0_rx_buffer_max_size)
  {
    usart0_rx_buffer[usart0_rx_buffer_size] = data;
    ++usart0_rx_buffer_size;
   /* Activation transmission of data, then we have data in the buffer */
    UCSR0B |= (1<<TXCIE0);
  }
}

ISR(USART0_TX_vect)
{
  int i;
  if (usart0_rx_buffer_size == 0) // If we have no data to send
    UCSR0B &= ~(1<<TXCIE0);// we stop transmission
  else
  {
    UDR0 = usart0_rx_buffer[0];
    --usart0_rx_buffer_size;
    
    if (usart0_rx_buffer_size == 0)
      UCSR0B &= ~(1<<TXCIE0);
    else
      // it can be a circular buffer 
      for (i = 0; i < usart0_rx_buffer_size; ++i)
        usart0_rx_buffer[i] = usart0_rx_buffer[i + 1];
  } 
}

int main (void)
{ 
  USART_Init(UBRR_VAL) ;  // USART Initialisation
  
  sei();
  while(1)

  {   
  }

}

[spess53 (Gast)]

Hi

Der TX-Interrupt wird ausgelöst, wenn der TX-Puffer vom ATMega 
vollständig geleert wurde. Wie soll das bei dir passieren? Du sendest ja 
nichts.

MfG Spess

[Luffy M. (monkeydluffy)]

Danke schön für deinen Hinweis Spess.

Ich habe versucht mit folgenden Schritten, der TX-Interrupt auszulösen:

1- TX-Interrupt ist deaktiviert
2- Im RX-Interrupt:
  - Daten in Puffer schreiben
  - UDRE-Interrupt aktivieren(UDRIE0 auf high setzen)
3- Im UDRE-empty-Interrupt:
  - Zeichen übertragen
  - Nach dem Senden des Zeichens, TXC0 löschen und TXCIE0 auf high 
setzen
4- Im TX-Interrupt (Übertragung vom Zeichen abgeschlossen)
  - UDRIE0 auf low setzen.
  - TXCIE0 auf low setzen
5- Im RX-Interrupt wird auf nächste Zeichen gewartet.

Mit meinem aktuellen Code kann ich der TX-Interrupt auslösen, wenn ich 
schritt für schritt der code ausführt. Aber der Echo-Test läuft trotzdem 
nicht. Der Atmega644p sendet nicht die Zeichen zurück.

Was mache ich denn falsch ! Danke im Voraus.

ISR(USART0_RX_vect)
{
  char data = UDR0;
  
  if (usart0_rx_buffer_size < usart0_rx_buffer_max_size)
  {
    usart0_rx_buffer[usart0_rx_buffer_size] = data;
    ++usart0_rx_buffer_size;
   /* Activation transmission of data, then we have data in the buffer */
    UCSR0B |= (1<<UDRIE0);
  }
}

ISR(USART0_TX_vect)
{
 UCSR0B &= ~((1<<UDRIE0)|(1<<TXCIE0));
}

ISR(USART0_UDRE_vect)
{
  int i;
  if (usart0_rx_buffer_size == 0) // If we have no data to send
  {
    UCSR0B &= ~(1<<UDRIE0);// we stop transmission
  }
  else
  {
    UDR0 = usart0_rx_buffer[0];
    --usart0_rx_buffer_size;
    
    if (usart0_rx_buffer_size == 0)
    {
      UCSR0A = (0<<TXC0);
      UCSR0B = (1<<TXCIE0; // TX-Interrupt aktivieren
    }
    else
      // it can be a circular buffer 
      for (i = 0; i < usart0_rx_buffer_size; ++i)
        usart0_rx_buffer[i] = usart0_rx_buffer[i + 1];
  } 
}

[J.-u. G. (juwe)]

Luffy Monkey schrieb:
> UCSR0A = (0<<TXC0);

Diese Anweisung löscht alle Bits im Register UCSR0A. Willst Du das?


> UCSR0B = (1<<TXCIE0; // TX-Interrupt aktivieren
Mal abgesehen von der fehlenden Klammer, mit dieser Anweisung setzt Du 
zwar das TXCIE0-Bit, alle anderen Bits dieses Registers werden aber 
gelöscht, was unter anderem zur Folge hat, das Transmitter und Receiver 
(TXEN0 und RXEN0) abgeschaltet werden. Kein Wunder, dass Du nichts 
senden kannst.

Wie man Bits richtig setzt und löscht:
http://www.mikrocontroller.net/articles/Bitmanipulation

[Luffy M. (monkeydluffy)]

Danke schön,
 ich habe deine Anweisungen befoglt und habe das Problem gelöst.

mfg.