UART Interrupt toggelt PORT nicht

[Joe (Gast)]

Hallo,

nach langem Probieren und Googeln habe ich es geschafft, dass mein 
Smartphone endlich über das Bluetooth-Modul HC-06 kommunizieren kann.

Verwendet wird ein ATmega8, der über 5V versorgt wird, genauso auch das 
Modul.
Am Pin PB1 soll eine LED getoggelt werden, sobald der USART was 
empfängt. Nur leider will das nicht so recht. Die LED wird zu 
Programmbeginn ausgeschaltet (bzw. der Pin PB1.

Hier der Code dazu:

#define F_CPU 1843200UL

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


//USART DEFS
#define BAUDRATE 9600UL    // Baudrate
//#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)
//#define UBRR_VAL ((F_CPU/(16UL*BAUD))-1)
#define uart_maxstrlen 25    // Definiere maximale Laenge für Empfang

volatile uint8_t uart_str_complete=0;
volatile uint8_t uart_str_count=0;
volatile char uart_string[uart_maxstrlen+1]= "Test";

int received = 0;

ISR(USART_RXC_vect)
{
  PORTB ^= (1<<PB1);
  /*
  if(received==0)
  {
  PORTB |= (1<<PB1);
  received = 1;
  }
  else if(received==1)
  {
    PORTB &= ~(1<<PB1);
    received = 0;
  }
  */
  
  
  //PORTB ^= (1<<PB2);
  /*
  unsigned char buffer;
  buffer = UDR;
  if( uart_str_complete==0 )
  {
    if(buffer!= '\n' && buffer!= '\r' && uart_str_count<uart_maxstrlen-1)
    {
      uart_string[uart_str_count]=buffer;
      uart_str_count++;
    }
    else
    {
      uart_string[uart_str_count]= '\0';
      uart_str_count=0;
      uart_str_complete=1;
    }
  }
  uart_str_complete=0;
  */
}

void uart_init(void)
{
  //uint16_t ubrr = (uint16_t) ((uint32_t) F_CPU/(16UL*BAUDRATE) -1);
  unsigned int ubrr = F_CPU/16/BAUDRATE-1;
  UBRRH = (unsigned char) (ubrr>>8);
  UBRRL = (unsigned char) ubrr;
  
  cli();
  UCSRB |= (1<<RXEN)|(1<<TXEN)|(1<<RXCIE);    // UART RX, TX und RX Interrupt einschalten
  UCSRC |= (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);    // Asynchron 8N1
}


int uart_putc(unsigned char c)
{
  while(!(UCSRA & (1<<UDRE)))
  {
  }
  UDR = c;
  return 0;
}

void uart_puts (char *s)
{
  while(*s)
  {
    uart_putc(*s);
    s++;
  }
}


uint8_t uart_getc(void)
{
  while(!(UCSRA & (1<<RXC)))    // warten bis Zeichen verfuegbar
  ;
  return UDR;    // Zeichen aus UDR an Aufrufer zurueckgeben
}

void uart_gets(char* Buffer, uint8_t MaxLen )
{
  uint8_t NextChar;
  uint8_t StringLen = 0;
  NextChar = uart_getc();
  // Warte auf und empfange das nächste Zeichen
  // Sammle solange Zeichen, bis:
  // * entweder das String Ende Zeichen kam
  // * oder das aufnehmende Array voll ist
  while( NextChar != '\n' && StringLen < MaxLen - 1 )
  {
    *Buffer++ = NextChar;
    StringLen++;
    NextChar = uart_getc();
  }
  // Noch ein '\0' anhängen um einen Standard
  // C-String daraus zu machen
  *Buffer = '\0';
}


int main (void)
{
  DDRB = 0xFF;
  
  PORTB |= (0<<PB1);
  
  
  //uart_puts("AT");
  
  uart_init();
  sei();
  while(1)
  {
    /*
    uart_puts(uart_string);
    uart_puts("\n");
    _delay_ms(500);
    */
  }
}

Vielen Dank im Voraus für jede Idee / Hilfe!

Joe

[Frank L. (frank_l)]

Hallo Joe,

schau Dir mal die beiden Tutorials an:

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Datenrichtung_bestimmen

und

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART

dann wird Dir sicher auffalen, was Du falsch machst.


Gruß
Frank

[Joe (Gast)]

Danke für Deine Antwort sowie den Hinweis.
Ich werde mir die vorgeschlagenen Links vergleichend zu meinem Code 
ansehen.

Gruß
Joe

[Joe (Gast)]

So.....jetzt habe ich meine ISR mal angepasst und nun geht das 
"toggeln":

ISR(USART_RXC_vect)
{
  unsigned char nextChar;
  
  //Daten aus dem Puffer lesen
  nextChar = UDR;
  uart_string[uart_str_count] = nextChar;
  
  if(uart_string[uart_str_count] == '1')
  {
    PORTB |= (1<<PB1);
  }
  
  if(uart_string[uart_str_count] =='0')
  {
    PORTB &= ~(1<<PB1);
  }
  
  uart_str_count = 0;
}

Warum das normale Toggeln nicht ging, ist mir allerdings auch nach 
Einsehen Deiner Links nicht wirklich klar.

Gruß Joe

[Karl H. (kbuchegg)]

Joe schrieb:

> Warum das normale Toggeln nicht ging, ist mir allerdings auch nach
> Einsehen Deiner Links nicht wirklich klar.

Weil du im Receive Complete Interrupt das UDR auch auslesen musst. Die 
Interrupt Anforderung wird erst durch das Auslesen von IDR gelöscht. 
List du UDR nicht aus, wird die ISR daher wieder und immer wieder 
aufgerufen. Dein Programm kommt zu nichts anderem mehr, als ständig ISR 
Aufrufe abzuarbeiten.