Probleme mit neuer USART-Konfiguration

[Peter R. (Gast)]

Hallo,

ich hab mir letztes Jahr mal für mein Entwicklungsboard(ATMega2560) eine 
USART-Routine gebastelt, habe aber nun bei der Portierung in meine erste 
eigene Schaltung Probleme.
Ich bekomme beim Senden eines Zeichens mit USART_SEND_STRING("a") 
scheinbar nur 0-Terminierungen in meinem Terminal-Programm:

<0><0><0><0><0><0>

Dies ist mein Code:

/*******************************************************************************************************/
#ifndef usart_h
#define usart_h
/*******************************************************************************************************/
// Einbindung von Standardbibliotheken
#include <avr/io.h>
#include <avr/interrupt.h>
#include <string.h>
/*******************************************************************************************************/
// Definition der Baudrate
#define BAUD 9600L // das L am Ende ist wichtig, NICHT UL verwenden!

// Berechnungen:
// Runden
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)
// reale Baudrate
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))
// Fehler in Promille
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD-1000)

#if((BAUD_ERROR>10)||(BAUD_ERROR<-10))
    #error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch!
#endif
/*******************************************************************************************************/
// globale Variablen für den USART
#define uart_buffer_size 32            // Puffergrösse in Bytes(RX und TX sind gleich groß)

volatile uint8_t uart_rx_flag=0;       // Flag 'String komplett empfangen'
volatile uint8_t uart_tx_flag=1;       // Flag 'String komplett gesendet'
char uart_rx_buffer[uart_buffer_size]; // Empfangspuffer
char uart_tx_buffer[uart_buffer_size]; // Sendepuffer
/*******************************************************************************************************/
// Initialisierung
void USART_INIT(void)
{
    UBRR0H = UBRR_VAL >> 8;
    UBRR0L = UBRR_VAL & 0xFF;
    // Aktivierung der USART-Komponenten Transmitter, Receiver und RX Complete Interrupt
    UCSR0B |= (1<<RXCIE0)|(1<<RXEN0)|(1<<TXEN0);
  //UCSR0C |= (1<<UMSEL01)|(1<<UMSEL00); // USART in MasterSPI Mode
}
/*******************************************************************************************************/
void USART_SEND_STRING(char *data) // zum Senden eines Strings
{
    if(uart_tx_flag==1) // Überprüfung des uart_tx_flag
    {
        // Kopieren des Strings in den Sendepuffer...
        strcpy(uart_tx_buffer,data);
        strcat(uart_tx_buffer,"\r"); // ... und Abschließen mit RETURN
        // Löschen des Flag für 'Senden ist komplett'
        uart_tx_flag = 0;
        // Aktivieren des UDRE-Interrupts
        UCSR0B |= (1<<UDRIE0);
    }
}
/*******************************************************************************************************/
void USART_RECEIVE_STRING(char *data) // zum Empfangen eines Strings
{
    if(uart_rx_flag==1) // Überprüfung des uart_rx_flag
    {
        // String kopieren
        strcpy(data,uart_rx_buffer);
        // Flag löschen
        uart_rx_flag = 0;
    }
}
/*******************************************************************************************************/
// USART RX Complete Interrupt:
// Hier werden Daten vom PC empfangen und in einem String zwischengespeichert.
// Wird ein Stringterminator empfangen, wird ein Flag gesetzt,
// welches dem Hauptprogramm den kompletten Empfang signalisiert.
ISR(USART_RX_vect)
{
    static uint8_t uart_rx_cnt; // Zähler für empfangene Zeichen
    uint8_t data;

    // Auslesen der Daten(dadurch wird das Interruptflag gelöscht)
    data = UDR0;

    if(!uart_rx_flag) // Überprüfung, ob Puffer leer ist
    {
        if(data=='\r') // wenn ja, Überprüfung auf das Ende des Strings(RETURN)
        {
            // Terminierung des Strings
            uart_rx_buffer[uart_rx_cnt]=0;
            // Setzen des Flags für 'Empfangspuffer voll'
            uart_rx_flag=1;
            uart_rx_cnt=0;
        }
        else if(uart_rx_cnt<(uart_buffer_size-1))
        {
            // Speicherung der Daten im Puffer(Vermeidung eines Pufferüberlaufs durch if())
            uart_rx_buffer[uart_rx_cnt]=data;
            uart_rx_cnt++;
        }
    }
}
/*******************************************************************************************************/
// USART TX Data Register Empty Interrupt:
// Hier werden neue Daten in das UART-Senderegister geladen.
ISR(USART_UDRE_vect)
{
    // Zeiger auf Sendepuffer
    static char* uart_tx_p = uart_tx_buffer;
    uint8_t data;

    // zu sendendes Zeichen lesen und Erhöhung des Zeigers auf den Sendepuffer
    data = *uart_tx_p++;

    if(data==0) // Überprüfung auf das Ende des nullterminierten Strings
    {        
        UCSR0B &= ~(1<<UDRIE0);     // wenn ja, dann Deaktivierung des UDRE Interrupt
        uart_tx_p = uart_tx_buffer; // Zurücksetzung des Pointers
        uart_tx_flag = 1;           // Flag setzen und damit die Übertragung beeenden
    }
    else UDR0 = data;               // wenn nein, dann Senden der Daten
}
/*******************************************************************************************************/
#endif
/*******************************************************************************************************/

Habt ihr vl. eine Ahnung, was da los sein kann?

Viele Grüße und danke schon mal im Voraus

[holger (Gast)]

>Habt ihr vl. eine Ahnung, was da los sein kann?

Baudrate falsch.

[Peter R. (Gast)]

Hallo Holger,

die Brechnung der Baudrate kann nicht falsch sein. Ich habe diese 
Einstellung bis jetzt für alle meine Projekte hergenommen.

LG

[g457 (Gast)]

> die Brechnung der Baudrate kann nicht falsch sein.

Doch, kann sie, z.B. wenn der µC mit dem falschen Takt läuft.

[Peter R. (Gast)]

Der ATMega88 arbeitet aber mit den gleichen Einstellungen wie vorher 
schon mein ATmega2560.

Viele Grüße

[Peter R. (Gast)]

Upps.

Ich hab' ganz die externe Beschaltung vergessen. Hat sich also 
erledigt.;-)

LG

[Peter R. (Gast)]

Hallöchen,

leider hab' ich das Problem immer noch. Es werden nur Terminierungen 
bzw. '0' übertragen - aber stets mehr Zeichen(oder was das auch immer 
sein soll^^) als gesendet.

Vielleicht kennt ja jemand diese Konfiguration:

Als Programmer (und auch Kommunikationsschnittstelle zum PC) benutze ich 
das mySmartUSB_MK3 von myAVR. Und zwischen meinem MEGA und den 
Programmer(an die UART-PINs R7/R8) habe ich nun einen RS232-Baustein 
geklemmt.
Zudem ist mein MEGA (noch) nicht mit einem Quarz verbunden(läuft also 
ausschließlich über den Internen).
Die USART-Routinen samt Einstellungen MÜSSEN wie gesagt funktionieren - 
sie sind letztes Jahr durch Hilfe der Mods und des AVR-Tutorials 
entstanden und haben bisher bei allen Projekten(auf meinem damaligen 
Experimentierboard) sehr gute Dienste geleistet.

Woran könnte es denn liegen?

Viele Grüße

[holger (Gast)]

CKDIV8 Fuse löschen (1 setzen).

[Peter R. (Gast)]

Hallöchen Holger,

das Häkchen hab ich weggenommen. Aber was meinst du denn mit '1 setzen'?

LG

[Peter R. (Gast)]

Ps.:

Jetzt werden Hyroglyphen übertragen.

Ist das gut?;-)

LG

[spess53 (Gast)]

Hi

>Jetzt werden Hyroglyphen übertragen.

Beim internen RC-Oszillator leicht möglich.

Ist das gut?;-)

Wenn du damit leben kannst.

MfG Spess

[Peter R. (Gast)]

NEIN!;-))

Das war doch Spasssss.^^

Wie kann ich das denn ändern?

LG

[holger (Gast)]

>das Häkchen hab ich weggenommen. Aber was meinst du denn mit '1 setzen'?

das Häkchen wegnehmen;)
Ohne CKDIV8 müsste F_CPU 8MHz sein.

>(an die UART-PINs R7/R8)

Der UART0 liegt aber auf den Pins 2 und 3.

[spess53 (Gast)]

Hi

>Wie kann ich das denn ändern?

Du kannst ja mal versuchen mit dem OSCCAL-Register den Takt zu 
verändern.
Ist aber keine Dauerlösung.

MfG Spess

[Peter R. (Gast)]

@Holger:

Hmmm... naja... er scheint ja jetzt zumindest mal 'irgendwas' zu 
übertragen^^.
Ich meinte PIN R7/R8 an meinem Programmer.

@Spess:

Werd ich gleich mal versuchen.
Es soll auch keine Dauerlösung sein. Auf meiner gebastelten Platine ist 
ja ein 20MHz-Quarz, dieser wird aber erst durch einen anderen 
Schaltkreis dazugeschaltet - dessen Programmierung ich noch nicht fertig 
habe.

LG

[holger (Gast)]

>Hmmm... naja... er scheint ja jetzt zumindest mal 'irgendwas' zu
>übertragen^^.

Dann ist die Baudrate immer noch falsch oder dein
RS232-Baustein möglicherweise sogar falsch angeschlossen.

Du scheinst ja immer noch nicht zu wissen mit welchem Takt deine
CPU wirklich läuft. Mach dir erst mal ein kleines Programm das
eine LED im Sekundentakt blinken lässt. Dann sehen wir weiter.

[Dietrich L. (dietrichl)]

Wo ist denn F_CPU definiert? In Deinem Code oben habe ich nichts 
gefunden.

Gruß Dietrich

[Peter R. (Gast)]

Ich hab jetzt mal schnell einen 16MHz Quarz dazwischengeklemmt. Sind die 
Kondensatoren am Quarz zwingend?
Es hat sich nichts geändert?!:(

LG

[Peter R. (Gast)]

@Dietrich:

Hier mal meine Hauptroutine:

********************************************************************************************************/
#ifndef F_CPU
#define F_CPU 16000000
#endif
/*******************************************************************************************************/
// Einbindung von Standardbibliotheken...
#include <stdint.h>          // Datentypen (standardisiert)
#include <avr/io.h>          // Registernamen
#include <avr/interrupt.h>
#include <stdio.h>           // Rechenoperationen, etc.
#include <math.h>
//#include <string.h>        // Zeichenketten-Funktionen
// ... und externen Dateien
#include "buttons.h"
//#include "SPI.h"
#include "usart.h"
/*******************************************************************************************************/
#define RELAIS_ON_DDR  DDRD
#define RELAIS_ON_PORT  PORTD
#define RELAIS_ON    7
#define RELAIS_OFF_DDR  DDRB
#define RELAIS_OFF_PORT  PORTB
#define RELAIS_OFF    0

#define PWM1_DDR    DDRB
#define PWM1_PORT    PORTB
#define PWM1      1
/*******************************************************************************************************/
// Enumeration: Typen-Definition von bool(Boolean)
typedef enum {
  false = 0,
  true
} bool;
/*******************************************************************************************************/
void LED_FADING(int16_t data,int16_t mode); // zum Ein-/Ausblenden von LEDs
/*******************************************************************************************************/
// Deklaration globaler Variablen
volatile uint8_t sreg_local;

#define SECOND ((F_CPU/16)/1024) // Wert für 1s Durchlaufzeit im Timer1-Overflow-Interrupt
#define RELAIS_TIMEOUT 15        // Timeout-Wert(in ~m) für die Abschaltung des 230V-Verbrauchers
#define nBtnModeTimeout 300      // Timeout-Wert(in ~ms) für das 'key_press'-Ereignis
#define nFadingTime 200          // Ein-/Ausblendzeit(in ~ms)
#define DIMM_TIMEOUT 150       // Zählerschritte(keine s!), bevor von 100% wieder heruntergedimmt wird

int16_t bRelaisSignal = 0;
int32_t nRelaisCount = 0;
int16_t nBtnMode = 0;            // Programm-Modus des Tasters
int16_t nBtnModeCount = 0;       // Zähler für das 'key_press'-Ereignis
int16_t nDimmCount = 0;         // Zähler für 
int16_t bDimmDirection = 1;      // Dimmungrichtung(1:EIN;0:AUS)
int16_t bFadingSignal = 0;
int16_t nFadingCount = 0;        // Zähler für die Ein-/Ausblendfunktion(Fading)
int16_t nFadingLED = 0;
int16_t nSavedPWM = 50;          // Variable zur Speicherung des letzten PWM- bzw. Helligkeitswertes
/*******************************************************************************************************/
// zum Speichern und Deaktivieren der Interrupts auf globaler Ebene
void ISR_0()
{
    sreg_local = SREG; // Erstellung einer lokalen Sicherungskopie von SREG
    cli();
}
/*******************************************************************************************************/
// zum Laden und Aktivieren der Interrupts auf globaler Ebene
// (Es werden nur die Interrupts aktiviert, die auch vor dem Abschalten schon in Benutzung waren!)
void ISR_1()
{
    SREG = sreg_local; // Sicherungskopie von SREG laden
}
/*******************************************************************************************************/
// Auswertung des Timer1-Overflow-Interrupts
ISR(TIMER1_OVF_vect)
{
  if(bRelaisSignal != 0)
  {
    nRelaisCount++;
    if(bRelaisSignal == 1)
    {
      if(nRelaisCount <= SECOND/3)
        RELAIS_ON_PORT |= (1<<RELAIS_ON);
      else
        RELAIS_ON_PORT &= ~(1<<RELAIS_ON);

      if(nRelaisCount > ((int32_t)(SECOND*RELAIS_TIMEOUT)*60))
      {
        bRelaisSignal = 2;
        nRelaisCount = 0;
      }
    }
    else
    {
      if(nRelaisCount <= SECOND/3)
        RELAIS_OFF_PORT |= (1<<RELAIS_OFF);
      else
      {
        RELAIS_OFF_PORT &= ~(1<<RELAIS_OFF);
        bRelaisSignal = 0;
        nRelaisCount = 0;
      }
    }
  }
  /***************************************************************************************************/
  if(nBtnMode != 0) // sobald irgendein Programm-Modus(s. Tasterabfragen) ausgewählt wurde,...
  {
    nBtnModeCount++; // ... Start des Zählers für die 'key'-Events(Timeout)

    if(KEY_PIN & (1<<KEY1))
    {
      if(nBtnModeCount > nBtnModeTimeout && nBtnModeCount < nBtnModeTimeout*3)
      {
        switch(nBtnMode)
        {
          /*---------------------------------------------------------------------------------*/
          case(1): if(!(PINB & (1<<PINB1)))
               {
                 OCR1A = nSavedPWM;
                 TCCR1A |= (1<<COM1A1);
                 bRelaisSignal = 1;
               }
               else
               {
                 OCR1A = 0;
                 TCCR1A &= ~(1<<COM1A1);
               }
               break;
          /*---------------------------------------------------------------------------------*/
          case(2): nFadingLED = 4;
               if(!(PINB & (1<<PINB1)))
                 bFadingSignal = 1; // Signal:FadeIN
               else
                 bFadingSignal = 2; // Signal:FadeOUT
               break;
          /*---------------------------------------------------------------------------------*/
        }
        nBtnMode = 0;      // Zurücksetzung des Programm-Modus
        nBtnModeCount = 0; // Zurücksetzung des Zählers
      }
      if(nBtnModeCount >= nBtnModeTimeout*3)
      {
        nBtnMode = 0;      // Zurücksetzung des Programm-Modus
        nBtnModeCount = 0; // Zurücksetzung des Zählers
      }
    }
  }
  /***************************************************************************************************/
  if(bFadingSignal != 0)
  {
    nFadingCount++;
    
    if(nFadingCount <= nFadingTime)
      if(bFadingSignal == 1)
        LED_FADING(nFadingLED,1);
      else
        LED_FADING(nFadingLED,0);
    else
    {
      bFadingSignal = 0;
      nFadingCount = 0;
    }
  }
}
/*******************************************************************************************************/
// zum Überblenden(Ein-/Ausblenden) von LEDs
void LED_FADING(int16_t data,int16_t mode)
{
  int16_t tmp;

  if(mode == 1) // FadeIN
  {
    // da 'nFadingCount*(nSavedPWM/nFadingTime)' nur int-Werte verarbeiten kann, wird
    // hier durch Benutzung einer temporären größeren 32Bit-Variable UND der
    // LEFT-Shift-Operation in einem 'Vielfachen' der Ausgangswerte weitergerechnet
    tmp = (nFadingCount*(((int32_t)nSavedPWM << 16)/nFadingTime)) >> 16;

    if(data == 1)      TCCR0A |= (1<<COM0A1);
    else if(data == 2) TCCR0B |= (1<<COM0B1);
    else if(data == 3) TCCR2B |= (1<<COM2B1);
    else if(data == 4) TCCR1A |= (1<<COM1A1);
  }
  else          // FadeOUT
    // mit 'nSavedPWM-Zählerfaktor(s.o.)' wird hier der Zähler rückwärts ausgewertet
    tmp = nSavedPWM-((nFadingCount*(((int32_t)nSavedPWM << 16)/nFadingTime)) >> 16);

  // Zuweisung des PWM-Wertes an das jeweilige Compare-Register
  if(data == 1)     OCR0A = tmp;
  else if(data == 2) OCR0B = tmp;
  else if(data == 3) OCR2B = tmp;
  else if(data == 4) OCR1A = tmp;

  if(tmp == 0)
  {
    if(data == 1)      TCCR0A &= ~(1<<COM0A1);
    else if(data == 2) TCCR0B &= ~(1<<COM0B1);
    else if(data == 3) TCCR2B &= ~(1<<COM2B1);
    else if(data == 4) TCCR1A &= ~(1<<COM1A1);
  }
}
/*******************************************************************************************************/
int main (void)
{
  // Initialisierung des USART
  char stringbuffer[32];        // Definition eines allgemeinen Puffers für die Strings

    USART_INIT();                 // Grundeinstellungen des USART

  // Konfiguration der I/Os:
  KEY_DDR &= ~ALL_KEYS;         // Taster als Eingang
  KEY_PORT |= ALL_KEYS;              // Aktivierung der internen Pull-Ups

  RELAIS_OFF_DDR |= (1<<RELAIS_OFF); // Relais1 als Ausgang
  RELAIS_ON_DDR |= (1<<RELAIS_ON);   // Relais2 als Ausgang

  PWM1_DDR |= (1<<PWM1);         // PWM1 als Ausgang
    /***************************************************************************************************/
  // Konfiguration von Timer1 für die PWM und den allg. Zeitgeber:
  // Mode:Fast PWM;TOP:OCR1A;Update:BOTTOM;TOV1:TOP;Prescaler:1(FRQ@16MHz = 16MHz)
  TCCR1A = (1<<WGM11);
  TCCR1B = (1<<WGM13)|(1<<WGM12)|(1<<CS10);
    OCR1A = 0;                    // PWM-Wert
  ICR1 = 1023;                  // TOP-Wert des Zählers
  TIMSK1 |= 1<<TOIE1;       // Aktivierung des Interrupts(Timer1 Overflow Interrupt Enable)

  // Konfiguration von Timer0 für die Tasterentprellung:
  TCCR0B = (1<<CS02)|(1<<CS00); // Prescaler:1024
  TIMSK0 |= 1<<TOIE0;        // Aktivierung des Interrupts(Timer0 Overflow Interrupt Enable)
  sei();              // Aktivierung der Interrupts auf globaler Ebene
  /***************************************************************************************************/
  

  while(1)
  {
    // USART-Kommunikation
    if(uart_rx_flag==1) // String komplett empfangen?
        {
            USART_RECEIVE_STRING(stringbuffer);   // Einlesen des Strings
            //SWITCHBOARD_PINS_USART(stringbuffer); // PIN-Ansteuerung
      //USART_SEND_STRING(stringbuffer);
        }

    // Abfrage der Taster:
    // (Für die zeitliche Signal-Verarbeitung wird bei jedem 'key_press'-Ereignis ein Zähler in
    // TIMER1_OVF_vect(s.o.) gestartet!)
    /***********************************************************************************************/
    if(get_key_press(1<<KEY1))
    {
      //nBtnMode++;        // Umschalten/Hochzählen des Programm-Modus
      //nBtnModeCount = 0; // Zurücksetzung des Zählers(s.TIMER1_OVF_vect)
      USART_SEND_STRING("Dynasoft' autoDesk: ...loaded.");
    }
    /***********************************************************************************************/
    if(get_key_short(1<<KEY1) || get_key_long_r(1<<KEY1) || get_key_rpt_l(1<<KEY1))
    {
      /*if(!(TCCR1A & (1<<COM1A1)))
      {
        TCCR1A |= (1<<COM1A1);
        OCR1A = 0;
        nSavedPWM = 0;
      }*/
      // bei COM1A1=0 auch den PIN auf 0 schalten!

      switch(nBtnMode)
      {
        /*-------------------------------------------------------------------------------------*/
        case(2): if(bDimmDirection == 1)
             {
               TCCR1A |= (1<<COM1A1);

               if(OCR1A < ICR1)
                 OCR1A += 5;
              else
              {
                nDimmCount++;
                if(nDimmCount > DIMM_TIMEOUT)
                   bDimmDirection = 0;
               }
             }
             else
             {
               if(OCR1A > 0)
                 OCR1A -= 5;
               else
              {
                OCR1A = 0;
                TCCR1A &= ~(1<<COM1A1);
                bDimmDirection = 1;
                nDimmCount = 0;
              }
             }
             nSavedPWM = OCR1A;
             break;
        /*-------------------------------------------------------------------------------------*/
      }
    }
  }
  return 0;
}
/*******************************************************************************************************/

LG

[Thomas E. (thomase)]

Peter R. schrieb:
> Habt ihr vl. eine Ahnung, was da los sein kann?
Nein. Da kann man nur raten.

Du sitzt jetzt wahrscheinlich seit dem ganzen Wochenende ratlos vor 
deiner Kiste, anstatt mal nur die Übertragung zu testen.

//#define F_CPU 1000000UL
#define F_CPU 8000000UL
//#define F_CPU 16000000UL
//#define F_CPU 2000000UL

// Definition der Baudrate
#define BAUD 9600L // das L am Ende ist wichtig, NICHT UL verwenden!
// Berechnungen:
// Runden
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)
// reale Baudrate
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))
// Fehler in Promille
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD-1000)

#if((BAUD_ERROR>10)||(BAUD_ERROR<-10))
    #error Systematischer Fehler der Baudrate grösser 1% und damit zu 
hoch!
#endif

void USART_INIT(void)
{
    UBRR0H = UBRR_VAL >> 8;
    UBRR0L = UBRR_VAL & 0xFF;
    UCSR0B |= (1<<RXCIE0)|(1<<RXEN0)|(1<<TXEN0);
}

int main(void)
{
  USART_INIT();
  sei();

  while(1)
  {
  }
}

ISR(USART_RX_vect)
{
   char nUdr = UDR0;
   UDR0 = nUdr;
}

Terminal ran, Taste drücken.
Taste wird quittiert: Hardware läuft.
Tsate wird nicht quittiert: Hardware läuft nicht.
Dazu gehört dann auch die Quarzgeschichte.
Teste einfach mal alle Möglichkeiten durch. Sind doch nicht viele:
1MHz, 8MHz,..,...

Das ganze String- und LED-Gedöns ist doch erstmal völlig unwichtig.

Und das macht natürlich auch Sinn:
holger schrieb:
> Du scheinst ja immer noch nicht zu wissen mit welchem Takt deine
> CPU wirklich läuft. Mach dir erst mal ein kleines Programm das
> eine LED im Sekundentakt blinken lässt. Dann sehen wir weiter.

mfg.

[Peter R. (Gast)]

@Thomas:

Damit hab' ich's jetzt getestet...

#include <stdint.h>          // Datentypen (standardisiert)
#include <avr/io.h>          // Registernamen
#include <avr/interrupt.h>

#define F_CPU 1000000UL
//#define F_CPU 8000000UL
//#define F_CPU 16000000UL
//#define F_CPU 2000000UL

#define BAUD 9600
#include <util/setbaud.h>

void USART_INIT(void)
{
    UBRR0H = UBRRH_VALUE;
    UBRR0L = UBRRL_VALUE;

  #if USE_2X
    /* U2X-Modus erforderlich */
    UCSR0A |= (1 << U2X0);
  #else
     /* U2X-Modus nicht erforderlich */
     UCSR0A &= ~(1 << U2X0);
  #endif

    UCSR0B |= (1<<RXCIE0)|(1<<RXEN0)|(1<<TXEN0);
}


ISR(USART_RX_vect)
{
   char nUdr = UDR0;
   UDR0 = nUdr;
}

int main(void)
{
  DDRC &= ~(1<<PC0);         // Taster als Eingang
    PORTC |= (1<<PC0);
  DDRB |= (1<<PB1);

  USART_INIT();
  sei();

  while(1)
  {
    if(!(PINC & (1<<PINC0)))
    {
      while (!(UCSR0A & (1<<UDRE0)))  /* warten bis Senden moeglich 
*/
        {
        }

        UDR0 = 'x';
    }
  }
}


Es hat sich aber nicht viel dabei geändert. Das Terminal spuckt nur 
Buchstabensalat aus.:(

Wie soll das denn mit dem Sekundentakt aussehen???????????????????

Viele Grüße

[holger (Gast)]

>Damit hab' ich's jetzt getestet...
>
>#define F_CPU 1000000UL

DU HAST DIE CKDIV8 FUSE DOCH GERADE A SO UMGESTELLT
das deine scheiss CPU mit 8MHz läuft. Warum zum Teufel
stellst du jetzt 1MHz im Code ein?

[fdssd (Gast)]

er weiß immernoch nicht das beim AVR der UART takt aus dem CPU takt 
erechnet wird
leider mit schrägen teilern


stimmt der ECHTE CPU takt  nicht mit der definition in der SW zusammen 
kommt eben scheiße bei raus


deswegn gibts sogar  BAUDRATENQUARZE

[fdssd (Gast)]

nochmal :   der echte CPUtakt wird durch den externen Quarz oder durch 
den internen 8MHz RC bestimmt
( bzw dieser takt /8 wenn die CLKDIV8 Fuse gesetzt ist )


dein F_CPU ist nur für die berechnung innerhlab der SW
und bestimmt NICHT den CPU takt

[Peter R. (Gast)]

Hey Mädls,

ihr müßt ja ned gleich so ordinär werden.^^
Ich habe mit F_CPU genau aus dem selben Grund herumprobiert, warum ich 
auch HIER poste - weil ich ein Neuling mit µC bin. Und ich habe bis dato 
gedacht, dass F_CPU den Takt physikalisch verändert.

Ich hab jetzt einen 20MHz-Quarz und zwei 22pF große Kondensatoren 
angeschlossen, F_CPU auf 20Mhz umgestellt und CLKDIV8 ist ebenfalls 
draußen.
Ist die FUSE 'SUT_CKSEL' noch wichtig, dort steht jetzt noch 'Int. Osc 
8MHz'?

#include <stdint.h>          // Datentypen (standardisiert)
#include <avr/io.h>          // Registernamen
#include <avr/interrupt.h>

#define F_CPU 20000000

#define BAUD 9600
#include <util/setbaud.h>

void USART_INIT(void)
{
    UBRR0H = UBRRH_VALUE;
    UBRR0L = UBRRL_VALUE;

  #if USE_2X
    /* U2X-Modus erforderlich */
    UCSR0A |= (1 << U2X0);
  #else
     /* U2X-Modus nicht erforderlich */
     UCSR0A &= ~(1 << U2X0);
  #endif

    UCSR0B |= (1<<RXCIE0)|(1<<RXEN0)|(1<<TXEN0);
}


ISR(USART_RX_vect)
{
   char nUdr = UDR0;
   UDR0 = nUdr;
}

int main(void)
{
  DDRC &= ~(1<<PC0);         // Taster als Eingang
    PORTC |= (1<<PC0);
  DDRB |= (1<<PB1);

  USART_INIT();
  sei();

  while(1)
  {
      while (!(UCSR0A & (1<<UDRE0)))  /* warten bis Senden moeglich                   */
        {
        }


    if(!(PINC & (1<<PINC0)))
    {
      
 
        UDR0 = 'ö';
    }
  }
}

Bis jetzt kommt trotzdem nur Datenschrott an.

Viele Grüße

[Krapao (Gast)]

> Ist die FUSE 'SUT_CKSEL' noch wichtig, dort steht jetzt noch 'Int. Osc
> 8MHz'?

Ja. Und das versucht man dir die ganze Zeit zu erklären. Du kannst das 
aber auch nachlesen: 
http://www.mikrocontroller.net/articles/AVR-Tutorial:_Equipment#Erg.C3.A4nzende_Hinweise_zur_Taktversorgung_.28kann_.C3.BCbersprungen_werden.29 
und im Datenblatt sowieso

[Thomas E. (thomase)]

Peter R. schrieb:
> Ist die FUSE 'SUT_CKSEL' noch wichtig, dort steht jetzt noch 'Int. Osc
> 8MHz'?
Damit teilst du dem Controller, also diesem kleinen schwarzen Ding 
itself, mit, wo er sich seinen Takt herholen soll. Momentan nimmt er 
seinen internen 8-MHZ-Oszillator. Damit er den Quarz nimmt, stellst du 
ein:
Full Swing Oscillator... Crystal...
Nimm' die letzte der 3 Optionen, die da angeboten werden.

Damit: #define F_CPU 20000000UL
sagst du dem Compiler mit welchem Takt die CPU läuft. Damit der seine 
Zeitberechnungen richtig durchführen kann.

#define F_CPU 20000000UL Da gehört immer ein "UL" hinter.
Dann weiss der Compiler, daß die Zahl ein "unsigned long" ist. Sonst 
hält er das für integer und verrechnet sich.

Das muss beides korrekt eingestellt werden.

mfg.

[Peter R. (Gast)]

Hallo,

es scheint jetzt wirklich zu gehen.;-) Danke!

Es geht sogar mit dem int.OSC und ohne das 'UL'(ich werd es aber stets 
verwenden^^). Lebenswichtig sind wohl nur SUT_CKSEL, CLKDIV8 und 
natürlich die richtige Verwendung von F_CPU^^.

Habt DANK! Vielen DANK!

LG

[Ingo (Gast)]

Peter R. schrieb:
> Es geht sogar mit dem int.OSC und ohne das 'UL'(ich werd es aber stets
> verwenden^^). Lebenswichtig sind wohl nur SUT_CKSEL, CLKDIV8 und
> natürlich die richtige Verwendung von F_CPU^^

Na bitte... Fast alle USART Probleme kommen von falschen 
Geschwindigkeitseinstellungen.

Ingo

[Peter R. (Gast)]

Aber "... man schließt nur EINMAL seinen ERSTEN µC an.";-)

So einen Fehler mache ich kein zweites Mal.^^

Viele Grüße