UART ein Program auf Atmega32 leufts auf Atmega1284P nicht

[Mike B. (mike13579)]

Hi

Ich habe hier einen Aufbau auf dem ich den Atmega stecken kann, somit 
immer die gleichen Voraussetzungen. Ich will einen Atmega1284P 
verwenden(habe bisher immer Atmega32 verwendet).

Nun wollte ich das Programm erstellen, da ich für den ATmega32 schon 
einmal den UART Baugleich verwendet hatte habe ich das Alte Programm als 
Basis genommen und die Register angepasst. Als ich das Testen wollte hat 
es nicht funktioniert. Um nun einen Fehler im Aufbau Ausschließen zu 
können Habe ich die selbe Formlage noch einmal genommen diesmal jedoch 
die Register gelassen und das Programm auf einen Atmega32 aufgespielt. 
Da hat es Sofort funktioniert.

Nun habe ich die Programme nebeneinander gelegt und miteinander 
verglichen.
Sie unterscheiden sich nur dadurch das ich beim einen nicht genutztes 
Gelöscht beim andren auskommentiert habe und durch die geäderten 
Register Bezeichnungen.

die Datenblätter habe ich auch nochmal durchgesehen und konnte nichts 
finden was ich meiner Meinung nach anders hätte machen müssen.

Das Programm soll das empfangene Zeichen wieder zurücksenden.

Atmega32

#include <avr/io.h>
#include <inttypes.h>
#include <stdlib.h>
#include <avr/interrupt.h>
#include <stdint.h> 

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


///////////////////////////////////////////////////////////////////////////////////init uart
 
void uart_init(void)   
{
   UBRRH = UBRRH_VALUE;
   UBRRL = UBRRL_VALUE;
   /* evtl. verkuerzt falls Register aufeinanderfolgen (vgl. Datenblatt)
      UBRR = UBRR_VALUE;
   */
#if USE_2X
   /* U2X-Modus erforderlich */
   UCSRA |= (1 << U2X);
#else
   /* U2X-Modus nicht erforderlich */
   UCSRA &= ~(1 << U2X);
#endif


  UCSRC = (1<<URSEL)|(1 << UCSZ1)|(1 << UCSZ0); // Asynchron 8N1
  UCSRB |= (1<<RXEN)|(1<<TXEN);  // UART RX, TX einschalten
 
  
}

/////////////////////////////////////////////////////////////////var def 


  volatile unsigned char uart[256];  //buffer uart empfang
  volatile uint8_t r=0;     //lese zeiger
  volatile uint8_t w=0;    //schreib zeiger
  volatile unsigned char uarts[256];  //buffer uart senden
  volatile uint8_t rs=0;      //lese zeiger senden
  volatile uint8_t ws=0;    //schreib zeiger senden
  volatile uint8_t a=0x00;    //0x01 '#\n'empfangen,0x02 Tarix neu berechnen,
  volatile uint8_t CPU1=0x00;    //CPU1
  volatile uint8_t CPU2=0x00;    //CPU2
  volatile uint8_t CPU3=0x00;    //CPU3
  volatile uint8_t CPU4=0x00;    //CPU4
  volatile uint8_t X=0x00;    //LEDX
  volatile uint8_t XB[8]={0x01,0x02,0x04,0x08,0x00,0x00,0x00,0x00};    //LEDXPortB
  volatile uint8_t XD[8]={0x00,0x00,0x00,0x00,0x04,0x08,0x10,0x20};    //LEDXPortC
  volatile uint8_t XA[8];
  volatile uint8_t XC[8];  
  volatile uint8_t i=0;      //anzeige zeiger matrix

 
///////////////////////////////////////////////////////////////////////uart 

int uart_getc(void)
{
    while (!(UCSRA & (1<<RXC)))   // warten bis Zeichen verfuegbar
        ;
//unsigned char i= UDR;
  // uart[w] = i;
  // w++;
  // if (i == '\n')a |=0x01;
   return UDR;
}


int uart_putc(unsigned char c)
{
    while (!(UCSRA & (1<<UDRE)))  /* warten bis Senden moeglich */
    {
    }                             
 
    UDR = c;                      /* sende Zeichen */
    return 0;
}


  


/////////////////////////////////////////////////////////////////main int


int main(void)
{
  uart_init();
  DDRA = 0x00;
  DDRB = 0x00;
  DDRC = 0xFF;
  DDRD = 0x00;
  PORTA = 0x00;
  PORTC = 0x00;
  PORTB = 0x00;
  PORTD = 0x00;


  
  
//////////////////////////////////////////////////////////////////main loop
 
 
  while (1) 
  {

   if ( (UCSRA & (1<<RXC)) )
    {
    i=uart_getc();//uart zeichen angekommen
    uart_putc(i);
    }
  }
  return 0; // never reached 
}

Atmega1284P

#include <avr/io.h>
#include <inttypes.h>
#include <stdlib.h>
#include <avr/interrupt.h>
#include <stdint.h> 

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


///////////////////////////////////////////////////////////////////////////////////init uart
 
void uart_init(void)   
{
   UBRR0H = UBRRH_VALUE;
   UBRR0L = UBRRL_VALUE;
   /* evtl. verkuerzt falls Register aufeinanderfolgen (vgl. Datenblatt)
      UBRR = UBRR_VALUE;
   */
#if US0E_2X
   /* U2X-Modus erforderlich */
   UCSR0A |= (1 << U2X0);
#else
   /* U2X-Modus nicht erforderlich */
   UCSR0A &= ~(1 << U2X0);
#endif


  UCSR0C = (1<<UMSEL01)|(1 << UCSZ01)|(1 << UCSZ00); // Asynchron 8N1
  UCSR0B |= (1<<RXEN0)|(1<<TXEN0);  // UART RX, TX einschalten
 
  
}

/////////////////////////////////////////////////////////////////var def 


  volatile unsigned char uart[256];  //buffer uart empfang
  volatile uint8_t r=0;     //lese zeiger
  volatile uint8_t w=0;    //schreib zeiger
  volatile unsigned char uarts[256];  //buffer uart senden
  volatile uint8_t rs=0;      //lese zeiger senden
  volatile uint8_t ws=0;    //schreib zeiger senden
  volatile uint8_t a=0x00;    //0x01 '#\n'empfangen,0x02 Tarix neu berechnen,
  volatile uint8_t CPU1=0x00;    //CPU1
  volatile uint8_t CPU2=0x00;    //CPU2
  volatile uint8_t CPU3=0x00;    //CPU3
  volatile uint8_t CPU4=0x00;    //CPU4
  volatile uint8_t X=0x00;    //LEDX
  volatile uint8_t XB[8]={0x01,0x02,0x04,0x08,0x00,0x00,0x00,0x00};    //LEDXPortB
  volatile uint8_t XD[8]={0x00,0x00,0x00,0x00,0x04,0x08,0x10,0x20};    //LEDXPortC
  volatile uint8_t XA[8];
  volatile uint8_t XC[8];  
  volatile uint8_t i=0;      //anzeige zeiger matrix

 
///////////////////////////////////////////////////////////////////////uart 

int uart_getc(void)
{
    while (!(UCSR0A & (1<<RXC0)))   // warten bis Zeichen verfuegbar
        ;
//unsigned char i= UDR;
  // uart[w] = i;
   //w++;
  // if (i == '\n')a |=0x01;
   return UDR0;
}


int uart_putc(unsigned char c)
{
    while (!(UCSR0A & (1<<UDRE0)))  /* warten bis Senden moeglich */
    {
    }                             
 
    UDR0 = c;                      /* sende Zeichen */
    return 0;
}


  


/////////////////////////////////////////////////////////////////main int


int main(void)
{
  uart_init();
  DDRA = 0x00;
  DDRB = 0x00;
  DDRC = 0xFF;
  DDRD = 0x00;
  PORTA = 0x00;
  PORTC = 0x00;
  PORTB = 0x00;
  PORTD = 0x00;

  // Timer 1 konfigurieren
//  TCCR0 = (1<<WGM01); // CTC Modus
//  TCCR0 |= (1<<CS01); // Prescaler 8
//  TCCR0 |= (1<<CS00); // Prescaler 64 wen  TCCR0 |= (1<<CS01);0 
// (16000000/64/1600) = 156,25
// (16000000/8/408000) = 4,9
//  OCR0 = 156-1;
// Compare Interrupt erlauben
//  TIMSK |= (1<<OCIE0);
// Global Interrupts aktivieren// Global Interrupts aktivieren

//  sei();
  
  
//////////////////////////////////////////////////////////////////main loop
 
 
  while (1) 
  {
   
   if ( (UCSR0A & (1<<RXC0)) )
   {
   i=uart_getc();//uart zeichen angekommen
  PORTC=i;
   uart_putc(i);
  }
  }
  return 0; // never reached 
}
//time interupt
//ISR (TIMER0_COMP_vect)
//{

//}

Das Problem beim Atmega1284P Äußert sich dadurch das anstelle des 
gesendeten Zeichens ein "Leer" Zeichen zurück kommt. Um zu sehen ob da 
überhaupt was empfangen wird, habe ich mir was zeichne beim Atmega1284P 
auf Port C Anzeigen lassen, dieser ist mit 8 LEDs ausgestattet. Dabei 
ist mir Aufgefallen das wen ich das Gleiche Zeichen mehrfach sende die 
LEDs nicht immer das Gleiche anzeigen.

Zum Taktgeber ich verwende momentan ein 16MHz Quarzoszillator und habe 
in beiden Projekten 16MHz in der Konfiguration stehen später wollte ich 
auf 20MHz erhöhen.

die Variablen Bezeichnungen machen eigentlich keinen Sinn, sind noch 
nicht angepasst.

Kann mir jemand sagen was ich falsch mache. Ich möchte doch nur das, das 
gesendet Zeichen zurückkommt.

MFG MIKE

[Karl H. (kbuchegg)]

Mike B. schrieb:

> Zum Taktgeber ich verwende momentan ein 16MHz Quarzoszillator

und ist der auch auf deinem 1284 aktiviert?
Anschliessen alleine ist zu wenig. Der muss auch per Fuse aktiviert 
werden.

[Mike B. (mike13579)]

Sollte  so sein habe eben mal geschaut, das ist ausgewählt :

Ext. Crystal Osc. 8.0-    MHz; Start-up time: 16K CK + 65 ms

MFG MIKE

[Karl H. (kbuchegg)]

Mike B. schrieb:
> Sollte  so sein habe eben mal geschaut, das ist ausgewählt :
>
> Ext. Crystal Osc. 8.0-    MHz; Start-up time: 16K CK + 65 ms


ok.
Ich würde das noch kontrollieren, deine 'Symptome' klingen ganz stark 
nach falscher Taktfrequenz.

Aber gut, wenn du sicher bist, dass der Takt passt, dann mach das als 
dein erstes Testprogramm

int main(void)
{
  uart_init();

  while (1) 
  {
    uart_putc( 'x' );
  }
}

und dann gehst du mal mit einer LED auf die Suche, ob am Tx Pin der 
UART0 was rauskommt und verfolgst es bis zur Gegenstelle.

[Stefan E. (sternst)]

Mike B. schrieb:
> das Alte Programm als
> Basis genommen und die Register angepasst.

  UCSR0C = (1<<UMSEL01)|(1 << UCSZ01)|(1 << UCSZ00); // Asynchron 8N1

Nun, es wäre sinnvoll, sich beim Anpassen auch mal die Beschreibungen im 
Datenblatt zu Gemüte zu führen, und nicht nach dem Motto vorzugehen
"oh, der Mega1284 hat ja gar kein URSEL, dann nehme ich halt UMSEL, das 
klingt ja fast gleich".

[Mike B. (mike13579)]

darauf wies klingt hab ich nicht geachtet fiel mehr darauf wo es stand.
gut das scheint auch keine gute Lösung gewesen zu sein.

es scheint es nicht zu geben aber mit weglassen funktioniert es auch 
nicht.
hat mir jemand ein Beispiel das funktioniert?

aktueller stand :

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


  UCSR0C = (1 << UCSZ01)|(1 << UCSZ00); 
  UCSR0B |= (1<<RXEN0)|(1<<TXEN0);  // UART RX, TX einschalten
 UBRR0 = UBRR_VALUE;
  
  
}

while (1) 
  {
    uart_putc( 'X' );
}

Das Ergebnis ist jedoch noch immer das selbe

[Stefan E. (sternst)]

Mike B. schrieb:
> Sollte  so sein habe eben mal geschaut, das ist ausgewählt :
>
> Ext. Crystal Osc. 8.0-    MHz; Start-up time: 16K CK + 65 ms

Und was ist mit CKDIV8?

[Mike B. (mike13579)]

CKDIV8 kante ich gar nicht, habe eben nachgelesen was das ist und die 
Fuses der Beiden Atmegas verglichen und festgesetzt das die sich 
unterscheiden.

Mit CKDIV8 aus und
Ext. Clock; Start-up time: 6 CK + 65 ms
funktioniert es

hab ich das richtig verstanden, wen CKDIV8 an ist habe ich einen 
Vorteiler von 8 und somit nur 2MHz anstelle von 16MHz ?

MFG MIKE

[Timmo H. (masterfx)]

Ja