UART-Fehler :(

M@cFreak wrote:
>
> Woran kann das liegen?

Welchen Prozessor benutzt du?

Danach holst du dir von Atmel das Datenblatt und siehst
nach, wie die bewussten Register in deinem Prozessor
heissen. Je nach AVR heissen die ein klein wenig anders.

>
> Woher weiß ich die Taktfrequenz vom µC?

Wenn du nichts gemacht hast, dann läuft der
Prozessor wahrscheinlich auf 1Mhz mit internem Takt.
Mach dich schon mal darauif gefasst, dass eine stabile
RS232 damit nicht funktionieren wird.

Der andere Fall ist: Du hast auf externen Quarz oder
Quarzoszillator umgestellt. Dann steht auf dem Quarz
bzw. Oszillator drauf, wie schnell er taktet.

@ M@cFreak

>also ich habe nun die Fuses auf "Int Osc 4 Mhz" gesetzt...

Falsche Einstellung!

http://www.mikrocontroller.net/articles/AVR-Tutorial:_UART#Senden

MFG
Falk

Vergiss die Tabelle.
Du hast doch eine schöne Formel in die du nur
die Werte einsetzen musst (eigentlich macht das
sogar der Compiler) und schon kriegst du die
richtigen Werte raus.

Aber du kannst ja spasseshalber einfach mal einen
Taschenrechner nehmen und deine Zahlen einsetzen
und schaun was dabei rauskommt.
Die Zahl dann probehalber mal auf Hex umrechnen
und dann beides (dezmal und hex) mit den
Angaben im Datenblatt vergleichen.

Hallo zusammen!

Also, ich habe auch kein Glück mit der UART. Ich bin leider auch 
Anfänger und hoffe, Ihr könnt mir helfen. Das mit der Taktfrequenz habe 
ich auch nicht ganz verstanden. Ja, die Formel habe ich gesehen.
[UBRR = Taktfrequenz / (16 *Baudrate)-1]

Leider weiß ich nicht, mit welcher Frequenz mein AVR Butterfly getaktet 
wird (32KHz für RTC) und ob und wie ich die Interne Taktfrequenz ändern 
kann. Liegt daran... bin Anfänger.

Wäre super, wenn Ihr mir weiterhelfen könnt...

Danke!!

Gruß Christian




#include <avr/interrupt.h>
#include <avr/io.h>
#include <avr/iom169p.h>
#include <avr/portpins.h>
#include <avr/sfr_defs.h>
#include <stdint.h>
#define BAUD 9600
#define FOSC 1843200  //Taktgeschwindigkeit 1,8 Mhz
#define MYUBRR FOSC/16/BAUD-1  //what ever that mean... Formel???

// Receive Interrupt
ISR(USART0_RX_vect ) // veraltet: SIGNAL(SIG_OVERFLOW0)

{
// ISR: Zeichen wurde empfangen
  while ( !( UCSR0A & (0x20)) ); //Warten bis alles empfangen wurde = 
UART Data empty
//  UDR0 = UDR0 + 1; // Gesendet: 0x01 Antwort: 0xFF
  UDR0 = 0x01;   // Gesendet: 0x01 Antwort: Endlosschleife 20 04 3F 20 
3F 44 80 10 20 3F 04...
  //Frage, warum bekomme ich bei 0x01 eine Endlosschleife???
}

//Zeichen wurde komplett gesendet
ISR(USART0_TX_vect ) // veraltet: SIGNAL(SIG_OVERFLOW0)
{


}

void USART_Init (unsigned int ubrr)
{
// zuerst Baudrate setzen
  UBRR0H = (unsigned char) (ubrr>>8);
  UBRR0L = (unsigned char) (ubrr);
//nun Sender und Empfänger initialisieren
  UCSR0A = 0x00;
/*
 RXC
 TXC
 UDRE
 Frame Error
 DOR
 USart Parity Error
 Double USART Transmission Speed
 MPCM: Multi processor Comm. Mode
*/

  UCSR0B = 0xF8;
/*
 RXCIE  RX Complete Interrupt Enable
 TXCIE  TX Complete Interrupt Enable
 UDRIE  USART Data Register Empty IE
 RXEN  Receiver Enable
 TXEN  Transmitter Enable
 UCSZ2  Character Size (Number of Databits
 RXB8  Receive Data Bit 8
 TXB8   Transmit Data Bit 8
*/

//Frameformat setzen: 8 Datenbits, 1 Stopbits

  UCSR0C = 0x86;

/*
 ----  No Funktion
 UMSEL USART Mode Select (Synch / ASynch)
 UMP1  Parity Mode
 UMP2  Parity Mode
 USBS  Stop Bit Select
 UCXZ1 Character Size
 UCXZ0 Character Size
 UCPOL Clock Polarity (only synch Mode)
*/
}

// UART main

int main(void)
{
  DDRD = 0xff;    //enable PortD as output
  sei();        //enable Interrupt
  USART_Init (MYUBRR);

  while (1)
  {

  };

}

Christian Beuge wrote:
> Hallo zusammen!
>
> Anfänger und hoffe, Ihr könnt mir helfen. Das mit der Taktfrequenz habe
> ich auch nicht ganz verstanden. Ja, die Formel habe ich gesehen.
> [UBRR = Taktfrequenz / (16 *Baudrate)-1]

Ist nicht weiter schwer.
Eine UART arbeitet in einem fixen Zeitraster.
Dieses Zeitraster wird durch 2 Faktoren bestimmt
* zum einen die gewünschte Baudrate,
* zum anderen die fixe Taktgeschwindigkeit des Prozessors.

Stell es dir einfach so vor: Die UART muss zwischen dem
Versenden von einzelnen Bits gewisse Wartezeiten einhalten.
Zum einen bestimmt natürlich die gewünschte Baudrate wie
lange (in Zeiteinheiten) die UART 'Däumchen drehen' muss.
Zum anderen bestimmt natürlich die vorhandene Taktfrequenz
wie schnell die UART 'Däumchen drehen kann'. Ergo muss
man irgendwann mal ausrechnen, wieviele 'Däumchen gedreht
werden müssen', damit eine bestimmte Zeit vergeht.

Genau das macht die Formel.
Sie rechnet aus, wie oft die UART in einer Schleife laufen
muss, bis die für eine bestimmte Baudrate notwendige Wartezeit
zwischen 2 Bits abgelaufen ist.

>
> Leider weiß ich nicht, mit welcher Frequenz mein AVR Butterfly getaktet
> wird (32KHz für RTC) und ob und wie ich die Interne Taktfrequenz ändern
> kann. Liegt daran... bin Anfänger.

Steht im Datenblatt.
Gewöhn dich daran. Du wirst das Datenblatt noch oft brauchen.

Laut Datenblatt arbeitet dein Mega169 mit 1Mhz Taktfrequenz
(leider auf internem Oszillator. Der ist leider meist seht
ungenau. Ob damit eine vernünftige Verbindung mittels RS232
zusatande kommt, ist fraglich. Aber möglich).

>
> Wäre super, wenn Ihr mir weiterhelfen könnt...

Schreib am Anfang kein so 'kompliziertes' Programm, das mittels
Interrupt Zeichen verschickt. Machs dir einfach.
Und im übrigen solltest du dch an die Beispiele im Tutorial
halten. Angepasst an die Registernamen die auf deinem µC gelten.

1

#include <avr/io.h>

2

#include <stdint.h>

3

4

#ifndef F_CPU

5

#define F_CPU 1000000          /* Oszillator-Frequenz in Hz */

6

#endif

7

8

// Hilfsmakro zur UBRR-Berechnung ("Formel" laut Datenblatt)

9

#define UART_UBRR_CALC(BAUD_,FREQ_) ((FREQ_)/((BAUD_)*16L)-1)

10

11

#define UART_BAUD_RATE 9600

12

13

int main(void)

14

{

15

  UCSRB |= ( 1 << TXEN );   // UART TX einschalten

16

  UCSRC |= ( 3<<UCSZ0 );    // Asynchron 8N1

17

18

  // Baudrate setzen

19

  UBRRH = (uint8_t)( UART_UBRR_CALC( UART_BAUD_RATE, F_CPU ) >> 8 );

20

  UBRRL = (uint8_t)UART_UBRR_CALC( UART_BAUD_RATE, F_CPU );

21

22

  while( 1 ) {

23

    //

24

    // warten bis die UART 'fertig' meldet

25

    //

26

    while (!(UCSRA & (1<<UDRE)))

27

      ;

28

29

    //

30

    // und ein Zeichen senden

31

    // 

32

    UDR = 'x';

33

  }

34

}

Ich kann nur sagen:

Wenn deine Taktfrequenz stimmt, dann läuft das Pgm das
ich gepostet habe einwandfrei.

Wenn das bei dir also nicht klappt, dann liegt das
* falscher Prozessor Taktfrequenz
* Kabel
* sontiges Hardwareproblem

M@cFreak wrote:
> aber wenn meines richtig ist und deines richtig ist, dann müsste doch
> auch meins funktionieren und kein Unterschied von der Funktion gegeben
> sein....
>
> Jedenfalls funktioniert die Lösung aus dem Tutorial NICHT

Doch die funktioniert.
Wenns bei dir nicht funktioniert, dann liegt der Fehler
in einem Bereich, der ausserhalb des Tutorials liegt:
* irgendwas in der Hardware
* Kabel falsch rum beschaltet
* am häufigsten aber: Die angegebene Taktfrequenz stimmt
  nicht mit der Realität überein.

Was mich zb. verblüfft ist, dass du als Anfänger in noch
nicht mal einer Stunde einen Quarz eingebaut hast und den
auch noch korrekt gefused hast.
Allerdings gibt mir der Satz zu denken:
"Somit auch 8 MHz in den Fuses eingestellt."

Das klingt nicht danach, als ob du den externen Quarz
aktiviert hast. Das hört sich eher an als ob du die CLKDIV
Fuse ausgeschaltet hast. Dein µC läuft dann zwar mit 8Mhz
aber immer noch am internen Oszillator.

@ M@cFreak

>UBRRL = 51 gesetzt. Dann habe ich unter "Fuses" das Häkchen bei "Ext.
>Crystal/Resonator Medium Frequ.; Start-up time: 1K CK + 64 ms;" gesetzt,
>welches vorher bei int RC Osc. 4 MHz stand.

Hoffentlich ist auch die DIV8 Fuse NICHT programmiert.

MFG
Falk

Ändere mal dein Programm um:

Lass den µC in einer Endlosschleife ständig senden

1

  while( 1 ) {

2

    while (!(UCSRA & (1<<UDRE)))  /* warten bis Senden moeglich */

3

    {

4

    }

5

6

    UDR = 'x';             //x zum senden ins Datenregister

7

  }

8

}

Und dann begibst du dich mit einem Voltmeter auf Fehlersuche.
Du kannst auch eine LED + Vorwiderstand (330 Ohm) nehmen.
Damit überprüfst du mal direkt an den Prozessorpins (PD0,
PD1), ob der Prozessor sendet. Mit einer LED müsstest du
an einem der Pins ein deutliches Flackern sehen.

Wenn du das Flackern hast, dann verfolgst du es weiter
(über alle Verbindungen), bis du am Stecker angelangt bist.


(Led + Vorwiderstand: Ein Bein von der Led kommt an den
Prozessorpin, das andere an den Vorwiderstand. Von dort
gehts weiter zum Widerstand und das andere Bein vom Widerstand
kommt fix an Masse. Probier aber aus, ob du die Led richtig
rum gepolt hast. Wenn du das frei Led Beinchen an +5V hälts,
muss sie leuchten).

M@cFreak wrote:
> achso, du meinst diese While-Schleife....die habe ich schon drin...
>
> Dass er praktisch nonstop dieses Zeichen schickt: ich sagte, mit der
> "Modifikation" leuchtet meine Diode permanent. (wird wohl flackern, ist
> eben nicht zu sehen).
>

Dann geh mit der Baudrate runter.
300 Baud musst du sehen können.

> Habe leider kein Oszi zur verfügung.

Dann stimmt am Timing was nicht.

Also nochmal: Taktfrequenz kontrollieren

#define F_CPU  8000000
#include <avr/io.h>
#include <utils/delay.h>

int main()
{
  int i;

  DDRB = 0xFF;  // Port B auf Ausgang oder wo du halt sonst
                // ein paar LED drann hast

  while( 1 ) {
    PORTB = 0xFF;

    for( i = 0; i < 100; ++i )
      _delay_ms( 10 );

    PORTB = 0x00;

    for( i = 0; i < 100; ++i )
      _delay_ms( 10 );
  }
}

Die Leds müssen im Sekundentakt blinken (das kann man auch
mit freiem Auge noch gut abschätzen).

Hast du debug compiliert, oder den Optimizer eingeschaltet.
Damit die delay Funktionen klappen, muss der Optimizer
eingeschaltet sein.

Im AVR Studio findest sich das im 2-ten Menüpunkt
ganz unten (hab keines da, drum kann ich nicht nachschauen
wie der heist: Irgendwas mit Project - Properties oder so
ähnlich).

Stell die Optimierung auf -Os

Wenn du dann immer noch 1.9 Sekunden hast, dann
läuft der µC offensichtlich nicht mit 8 Mhz.

M@cFreak wrote:
> ok habe das gemacht. Schwer mit der Stoppuhr zu messen.

Das brauchts auch nicht.
Meistens hat man ja ein Vielfaches.
Wenn also im Pgm 8 Mhz steht und der µC macht in Wirklichkeit
4Mhz, dann sind die Leds anstelle von 1 Sekunde deren 2
eingeschaltet.
Läuft der µC gar nur auf 1 Mhz, dann leuchten die Led
ganze 8 Sekunden statt 1

Das erkennt auch ein Blinder.

> Jedenfalls länger als 1 Sekunde blinken die.

Schlecht.

http://www.mikrocontroller.net/articles/AVR_Fuses

Da du einen Quarz benutzt ist die richtige Einstellung
bei dir "external Crystal".

Stefan wrote:
>> ok habe das gemacht. Schwer mit der Stoppuhr zu messen.
>
> Miss den Puls deines AVR ;-)
>
> Setz dir eine vernünftige Zeitspanne fest z.B. 20 Sekunden. Zähle wie
> oft es in der Zeitspanne blinkt. Teile Zählwert durch Zeitspanne und du
> hast die Frequenz.

Aber Achtung: Das Programm lässt die LED 1 Sekunde eingeschaltet
und 1 Sekunde ausgeschaltet. Das ergibt eine Soll-Frequenz
von 0.5 Herz.

Und weil es wichtig ist: Die Zeiten stimmen nur dann, wenn
im Compiler die Optimierung eingeschaltet ist.

M@cFreak wrote:
> Ja die Optimierung ist eingeschaltet. Habe ich so gemacht, wie es
> Karl-Heinz beschrieben hat.
>
> Möchte vielmehr sicher gehen, dass der Mikrocontroller "einfach" über
> den Quarz taktet. Anscheinend tut er das ja nicht, habe ja vorhin scho
> ngeschrieben, dass die Daten in das Terminal weiterhin strömen, wenn ich
> den Quarz rausziehe!
>

Oha.
Das ist aber ein deutliches Indiz dafür, dass
der µC auf 'interner Oszillator' läuft.

Wenn du nach dem Programmieren die Fuses wieder einlesen
lässt, ist der Haken dann immer noch gesetzt?


Blöde Frage:
Den Haken bei 'int Oszillator' hast du weg gemacht?

Und wieder die übliche Frage:
Was funktioniert denn nicht?

('funktioniert nicht' ist keine vernünftige Fehlermeldung)


PS: Du solltest dir wirklich angewöhnen, solche
Dinge in Schleifen zu packen.

  while( 1 ) {
    // warte auf ein Zeichen
    while (!(UCSRA & (1<<RXC)));

    // und am Port das Bitmuster ausgeben
    PORTB = UDR;
  }
}


PS2: Einrückungen sind kein Luxus! Sie helfen die
Struktur eines Programmes schneller zu erfassen.

M@cFreak wrote:
> hm ich kann schon garnichts auf mein Terminal schreiben.

Das ist bei Hyperterminal normal.
Da ist standardmässig das 'lokale Echo' ausgeschaltet.
Das heist: Du siehst nicht was du tippst.
Das heist aber nicht, dass die Zeichen nicht rausgehen.

Die Zeichen gehen sehr wohl raus. Das Standardverfahren
ist: Die Zeichen gehen raus und der Empfänger schickt
die empfangenenn Zeichen sofort wieder zurück. Und erst
dann zeigt das Terminal sie an.
Das hat den Vorteil, dass man eine unterbrochene Verbindung
sofort erkennt.

Man kann allerdings auf den meisten Terminals auch ein
sog. 'lokales Echo' einschalten. Dann schreibt das Terminal
mit, was es so rausgeschickt hat.

Moment:
Du hast 'lokal Echo' aktiviert und siehst immer noch nicht
was du tippst?
Ja: Schalte das Hardwarehandshaking im Hyperterminal aus.

Probier das mal aus:

1

#include <avr/io.h>

2

#include <stdint.h>

3

4

#ifndef F_CPU

5

#define F_CPU 8000000          /* Oszillator-Frequenz in Hz */

6

#endif

7

8

// Hilfsmakro zur UBRR-Berechnung ("Formel" laut Datenblatt)

9

#define UART_UBRR_CALC(BAUD_,FREQ_) ((FREQ_)/((BAUD_)*16L)-1)

10

11

#define UART_BAUD_RATE 9600

12

13

int main(void)

14

{

15

  char c;

16

17

  UCSRB |= ( 1 << TXEN ) | ( 1 << RXEN );

18

  UCSRC |= ( 1 << URSEL) | ( 3<<UCSZ0 );    // Asynchron 8N1

19

20

  // Baudrate setzen

21

  UBRRH = (uint8_t)( UART_UBRR_CALC( UART_BAUD_RATE, F_CPU ) >> 8 );

22

  UBRRL = (uint8_t)UART_UBRR_CALC( UART_BAUD_RATE, F_CPU );

23

24

  while( 1 ) {

25

    // warte auf ein Zeichen

26

    while (!(UCSRA & (1<<RXC)))

27

      ;

28

29

    // das Zeichen holen

30

    c = UDR;

31

32

    // warten bis die UART 'fertig' meldet

33

    while (!(UCSRA & (1<<UDRE)))

34

      ;

35

36

    // und das Zeichen zurückschicken

37

    UDR = c;

38

  }

39

}

Stefan wrote:
> Tut er aber anscheinend nicht. Und das kann verschiedene Ursachen haben.
>

Ich denke mal die Hauptursache ist das fehlende

  UCSRC |= ( 1 << URSEL) | ( 3<<UCSZ0 );    // Asynchron 8N1


aber um ehrlich zu sein bin ich jetzt zu faul im
Datenblatt nachzusehen, wofür die UCSZ0 und UCSZ1 Bits
gut sind (Was URSEL macht weiss ich auswendig :-)

Das ist meine Standard-UART-Initialisierung. Wenn ich eine
UART brauche, dann hole ich mir den Code mit Cut&Paste
in das aktuelle Projekt und fertig. Von dem Code weiss
ich dass er funktioniert und ich sehe wirklich keinen
Sinn darin, jedesmal wieder für dieselbe Funktionalität
die Bits aus dem Datenblatt raussuchen zu müssen.

Aus demselben Grund bin ich auch gegen die Zuweisung von 51
an das Baudratenregister allergisch. Ich setzte einfach
die Formel mittels Cut&Paste ein, achte darauf dass der
F_CPU Wert stimmt und mach ein #define für die gewünschte
Baudrate.
Ich mach mir doch nicht die Finger mit schnöden
Taschenrechnertricks ( FOSC/16/BAUD-1 selber ausrechnen, igitt)
oder raussuchen aus Tabellen schmutzig.
Diese 'Drecksarbeit' überlasse ich dem Compiler. Ich kümmere
mich lieber darum wo die Daten herkommen, die über
die UART müssen.