USART Routine von ATMEL

[Matthias (Gast)]

Hallo zusammen,

ich habe auf der Atmel Seite unter
http://www.atmel.com/dyn/products/app_notes.asp?family_id=607
eine wie ich finde sehr gute USART Interrupt gesteuerte Routine in C 
gefunden. Diese habe ich nun für meinen ATMEGA8 umgeschrieben. Leider 
kommt nichts zurück. In HTerm und HTerminal stelle ich folgendes ein:

Baudrate 19,2 k
Databits = 8
Stopbits = 1

Ich habe den CHip auf der STK500 und verbinde ihn mit meinem Laptop über 
die 2te Rs-232 Schnittstelle.

// Das ist die Headerfile USART.h ////////////////////////////////

#define USART_RX_BUFFER_SIZE 128
#define USART_TX_BUFFER_SIZE 128
#define USART_RX_BUFFER_MASK ( USART_RX_BUFFER_SIZE - 1 )
#define USART_TX_BUFFER_MASK ( USART_TX_BUFFER_SIZE - 1 )

#if (USART_RX_BUFFER_SIZE & USART_RX_BUFFER_MASK)
  #error RX buffer size is not a power of 2
#endif
#if (USART_TX_BUFFER_SIZE & USART_TX_BUFFER_MASK)
  #error TX buffer size is not a power of 2
#endif

static unsigned char USART_RxBuf[USART_RX_BUFFER_SIZE];
static volatile unsigned char USART_RxHead;
static volatile unsigned char USART_RxTail;
static unsigned char USART_TxBuf[USART_TX_BUFFER_SIZE];
static volatile unsigned char USART_TxHead;
static volatile unsigned char USART_TxTail;

void USART_Init ( unsigned int baudrate );
unsigned char USART_Receive ( void );
void USART_Transmit ( unsigned char data );

// Das ist das kurze Hauptprogramm ////////////////////////////////

#include "USART.h"
#include <avr/Interrupt.h>

int main ( void )
{
  USART_Init( 11 );

  sei();

  while(1)
  {
    USART_Transmit( USART_Receive() );
  }
  
  return 0;  
}

// und die USART.c liegt im Anhang
Grüsse
Matthias

[Matthias (Gast)]

Ok jetzt hab ich meinen Kopf aus dem "A..." gezogen und auf der STK die 
Leitungen verbunden. Hatte ich gestern abgesteckt, argh !

So nun  kommt was an aber nicht das gewünschte.

Im HTerminal hab ich folgende Einstellungen:

Baudrate 19,2 k
Databits = 8
Stopbits = 2

Und die USART_Init hab ich folgendermassen abgeändert.

void USART_Init ( unsigned int baudrate )
{
  unsigned char x;

  UBRRH = (unsigned char) (baudrate>>8);
  UBRRL = (unsigned char) baudrate;

  UCSRB |= ( (1 << RXCIE) | (1 << RXEN)  | (1 << TXEN)  );
  UCSRC |= (1<<URSEL) | (1<<USBS) | (1<<UCSZ1) | (1<<UCSZ0);

  x = 0;

  USART_RxTail = x;
  USART_RxHead = x;
  USART_TxTail = x;
  USART_TxHead = x;
}

Wenn ich (1<<URSEL) nicht auf eins setze bevor ich UCSRC beschreibe 
krieg ich kein Signal, ist ja auch so im DB beschrieben. Ich bekomme im 
Hterminal eigentlich immer ein "@" Zeichen oder für die meisten ASCII 
Zeichen ein "0xC0".

Grüsse
Matthias

[Stefan B. (stefan)]

> Baudrate 19,2 k
> USART_Init( 11 );

bedeutet, dass du mit 3,6864 MHz Prozessortakt arbeiten willst. Hast du 
das STK500 auch so eingestellt (XTAL1, OSCSEL Jumper und Einstellung im 
AVR Studio)?

[Matthias (Gast)]

Ja, sind die Standardeinstellungen der STK 500

[Matthias (Gast)]

Vielleicht kann das noch weiterhelfen.

Der Compiler gibt mir folgende Warnung raus:

"USART_RxBuf defined but not used"
"USART_TxBuf defined but not used"

Versteh das nicht ?

Grüsse
Matthias

[Matthias (Gast)]

Also ich bin ehct ratlos, habe jetzt den Polling Modus gemacht, da geht 
auch nichts, versteh das einfach nicht, jetzt kommen immer nur die 
Zeichen 0xC0 oder 0xF8 an. Echt frustrierend und hier weiss anscheinend 
auch keiner Bescheid.

Grüsse
Matthias

[xyz (Gast)]

Kannst du kein Englisch?

[Johannes M. (johnny-m)]

Matthias wrote:
> Der Compiler gibt mir folgende Warnung raus:
>
> "USART_RxBuf defined but not used"
> "USART_TxBuf defined but not used"
>
> Versteh das nicht ?
Was ist daran nicht zu verstehen? Es sind zwei Puffer-Arrays definiert, 
die in Deinem Programm aber nicht benutzt werden...

[Jörg W. (dl8dtl) (Moderator)]

Den ATmega8 hast du auch umgestellt vom 1-MHz-RC-Oszillator auf
externen Takt, ja?

UCSRC brauchst du übrigengs nicht anfassen, wenn du das
Standardframing 8N1 benutzt.

[xyz (Gast)]

Wo wird in deinem Programm die Baudrate eingestellt?

[Matthias (Gast)]

??

USART_RxBuf[tmphead] = data;

in USART.c wird in der ISR verwendet.. und
USART_TxBuf auch.

[Matthias (Gast)]

>Den ATmega8 hast du auch umgestellt vom 1-MHz-RC-Oszillator auf
>externen Takt, ja?

? Hab den internen Takt der STK 500 mit 3,86....

[Jörg W. (dl8dtl) (Moderator)]

Matthias wrote:

> USART_RxBuf[tmphead] = data;
>
> in USART.c wird in der ISR verwendet.. und
> USART_TxBuf auch.

Sind aber in USART.c "static" deklariert und damit nur innerhalb
dieses Moduls sichtbar.  Die ISR liegt offenbar woanders.  Aber
solange du uns keinen geschlossen compilierbaren Code zeigst,
kann man hier nur die Kristallkugel befragen.

[Matthias (Gast)]

>Wo wird in deinem Programm die Baudrate eingestellt?

Na in der USART_Init

  UBRRH = (unsigned char) (baudrate>>8);                  
  UBRRL = (unsigned char) baudrate;

[Jörg W. (dl8dtl) (Moderator)]

Matthias wrote:

>>Den ATmega8 hast du auch umgestellt vom 1-MHz-RC-Oszillator auf
>>externen Takt, ja?

> ? Hab den internen Takt der STK 500 mit 3,86....

Woher weiß das aber dein ATmega8?  Den interessiert das einfach
gar nicht, was an seinem XTAL1 passiert, solange du ihm nicht die
low fuse änderst.

[xyz (Gast)]

Welchen Wert hat die Variable -> baudrate?

[Matthias (Gast)]

>Aber solange du uns keinen geschlossen compilierbaren Code zeigst,
>kann man hier nur die Kristallkugel befragen.

Naja also die USART.C mit USART.h und dem MainProgramm ist doch normale 
C-Syntax.

Zusammen würde das dann so lauten:

#include <avr/Interrupt.h>
#include <avr/io.h>

#define USART_RX_BUFFER_SIZE 128
#define USART_TX_BUFFER_SIZE 128
#define USART_RX_BUFFER_MASK ( USART_RX_BUFFER_SIZE - 1 )
#define USART_TX_BUFFER_MASK ( USART_TX_BUFFER_SIZE - 1 )

#if (USART_RX_BUFFER_SIZE & USART_RX_BUFFER_MASK)
  #error RX buffer size is not a power of 2
#endif
#if (USART_TX_BUFFER_SIZE & USART_TX_BUFFER_MASK)
  #error TX buffer size is not a power of 2
#endif

static unsigned char USART_RxBuf[USART_RX_BUFFER_SIZE];
static volatile unsigned char USART_RxHead;
static volatile unsigned char USART_RxTail;
static unsigned char USART_TxBuf[USART_TX_BUFFER_SIZE];
static volatile unsigned char USART_TxHead;
static volatile unsigned char USART_TxTail;

void USART_Init ( unsigned int baudrate );
unsigned char USART_Receive ( void );
void USART_Transmit ( unsigned char data );
unsigned char DataInReceiveBuffer ( void );

void USART_Init ( unsigned int baudrate )
{
  unsigned char x;

  UBRRH = (unsigned char) (baudrate>>8);
  UBRRL = (unsigned char) baudrate;

  UCSRB |= ( (1 << RXCIE) | (1 << RXEN)  | (1 << TXEN)  );
  UCSRC |= (1<<URSEL) | (3<<UCSZ0);

  x = 0;

  USART_RxTail = x;
  USART_RxHead = x;
  USART_TxTail = x;
  USART_TxHead = x;
}

ISR(SIG_UART_RECV)
{
  unsigned char data;
  unsigned char tmphead;

  data = UDR;

  tmphead = ( USART_RxHead + 1 ) & USART_RX_BUFFER_MASK;
  USART_RxHead = tmphead;

  if( tmphead == USART_RxTail )
  {
    // Buffer overflow
  }

  USART_RxBuf[tmphead] = data;
}

ISR(SIG_UART_DATA)
{
  unsigned char tmptail;

  if( USART_TxHead != USART_TxTail )
  {
    tmptail = ( USART_TxTail +1 ) & USART_TX_BUFFER_MASK;
    USART_TxTail = tmptail;

    UDR = USART_TxBuf[tmptail];
  }
  else
  {
    UCSRB &= ~(1<<UDRIE);
  }
}

unsigned char USART_Receive ( void )
{
  unsigned char tmptail;

  while( USART_RxHead == USART_RxTail );
  tmptail = ( USART_RxTail +1 ) & USART_RX_BUFFER_MASK;

  USART_RxTail = tmptail;

  return USART_RxBuf[tmptail];
}

void USART_Transmit ( unsigned char data )
{
  unsigned char tmphead;
  
  tmphead = ( USART_TxHead +1 ) & USART_TX_BUFFER_MASK;
  while ( tmphead == USART_TxTail );
  
  USART_TxBuf[tmphead] = data;
  USART_TxHead = tmphead;

  UCSRB |= (1<<UDRIE);
}

unsigned char DataInReceiveBuffer ( void )
{
  return ( USART_RxHead != USART_RxTail );
}

Das heisst ich muss dem ATMEGA8 noch sagen, dass er den Takt von XTAL1 
nehmen soll und nicht einen eigenen Takt. Meinst du das so, dass hab ich 
nicht gewusst. Dachte Standardeinstellung wäre das ein uC auf XTAL1 
hört.

[Matthias (Gast)]

Sry hab die Main vergessen:

int main ( void )
{
  USART_Init( 11 );

  sei();

  while(1)
  {
    USART_Transmit( USART_Receive() );
  }
  
  return 0;  
}

>Welchen Wert hat die Variable -> baudrate?
USART_Init( 11 ); => 11

[Matthias (Gast)]

Hab aber schon alle möglichen Werte ausprobiert (mit DB)

[Jörg W. (dl8dtl) (Moderator)]

Matthias wrote:

> Das heisst ich muss dem ATMEGA8 noch sagen, dass er den Takt von XTAL1
> nehmen soll und nicht einen eigenen Takt. Meinst du das so,

Ja.

> dass hab ich
> nicht gewusst.

RTFDatasheet.

> Dachte Standardeinstellung wäre das ein uC auf XTAL1
> hört.

Wie hieß der Spruch früher so schön?  ,,Überlass das Denken den
Pferden, die haben einen größeren Kopf.'' ;-)

Im Ernst: mit dem Datenblatt solltest du dich schon befassen.  In diesem
Falle mit dem Kapitel über die Takterzeugung.

[Matthias (Gast)]

>Wie hieß der Spruch früher so schön?  ,,Überlass das Denken den
>Pferden, die haben einen größeren Kopf.'' ;-)

Das is aber nett von dir. Da die Pferde ja jetzt für mich denken, 
könntest du mir ja sagen in welchen Registern ich was zu setzen habe um 
das ganze mit dem internen Takt der STK 500 zu betreiben.

Grüsse
Matthias

[Jörg W. (dl8dtl) (Moderator)]

Matthias wrote:

> Das is aber nett von dir.

Daher ja auch der Smiley.

> könntest du mir ja sagen in welchen Registern ich was zu setzen habe um
> das ganze mit dem internen Takt der STK 500 zu betreiben.

Du musst die low fuse passend einstellen.  Sie steht per default auf
0xe1.  Eine Möglichkeit, die das gewünschte Ziel errreicht ist, sie
auf 0xe0 zu setzen.

Und woher weißt du nun, wie du das beim nächsten Mal beim nächsten
AVR rausfindest wenn du dir gar nicht die Mühe machst, mal selbst ins
Datenblatt zu gucken?

[Matthias (Gast)]

Ich hab das Datenblatt die ganze Zeit neben mir und werd jetzt nachsehen 
wo ich deine Lösung finden kann. Das hat mehr Wert, als ständig im 
Dunkel zu tappen. Worte wie "low fuse" sagen mir eben gerade nichts. 
Aber jetzt weiss ich wonach ich suchen muss.

[Matthias (Gast)]

Sind das die CKSEL Fuses

[Jörg W. (dl8dtl) (Moderator)]

Matthias wrote:

> Sind das die CKSEL Fuses

Ja, das sind die entscheidenden dabei, die unteren 4 Bits der low
fuse.  Im Prinzip kannst du auch beliebige Varianten von internem
Quarzoszillator einstellen, da diese auch alle ihren Takt an XTAL1
einlesen, aber 0xe0 (also CKSEL = 0) ist die offizielle Variante
für den externen Takt.

[Matthias (Gast)]

Ist das OSCCAL Register dann das richtige.

Wenn ja würde ja ein

[c]

OSCCAL = 0xE0;

[c/]

richtig sein. Allerdings bringt das nicht den gewünschten Effekt.

[Jörg W. (dl8dtl) (Moderator)]

> Ist das OSCCAL Register dann das richtige.

Das ist nur für den internen RC-Oszillator interessant, aber gerade
den willst du ja nicht nehmen.

Die Fuses sind keine Register.   Die stehen im Abschnitt "Memory
programming", weil man sie nur über die Programmierschnittstelle
einstellen kann.  Das laufende Programm kann die Fuses nicht
ändern.

[Matthias (Gast)]

Bin hier fündig geworden
http://www.mikrocontroller.net/articles/AVR_Fuses
das werd ich jetzt mal in aller Ruhe durchlesen

[Matthias (Gast)]

Habn nun folgenden Satz in der STK 500 ANleitung gefunden:

"When using the STK500 software-generated clock system as main clock, 
the target
AVR microcontroller fuses should be configured for “external clock” as 
clock source."

Also als normaler externer Clock einstellen, was für die low-Bits 0000 
bedeuten würde. Start-TIme hätte ich auf 10 gesetzt, um Fehler zu 
vermeiden.

[Matthias (Gast)]

So nun wieder in der Arbeit, alles an der STK eingestellt und siehe da. 
Das Programm funktioniert 1 a. Ich danke dir  Jörg für die Geduld und 
die Hilfe. Und das mit den Fuses hab ich auch theoretisch und in diesem 
Fall jetzt auch praktisch kapiert.

Grüsse
Matthias

[Jörg W. (dl8dtl) (Moderator)]

Freut mich!