Sleep Modus und falsche UART Sendungen

[Owen S. (senmeis)]

Hi,

ich möchte ein Byte über UART im Atmega169 pro Sekunde senden lassen. 
Ein 32.768kHz Quarz wird für Timer2 eingesetzt und der interne RC 
Oszillator wird als Systemtakt verwendet.

Das Problem ist, wenn der 169 aus dem Schlafmodus „Power Save“ erweckt 
wird, sendet dieser falsche Bytes. Ohne Schlafmodus ist alles OK.

Zu bemerken: In diesen falschen Bytes gibt es sogar Regel: Das richtige 
Byte 0x5A wird alle 25 Bytes gesendet, dazwischen nur 0x00 und 0xEB, 
also
5A 00 EB 00 EB 00 EB 00 EB 00 EB 00 EB 00 EB 00 EB 00 EB 00 EB 00 EB 00 
EB 5A

Ich vermute mal, dass der Systemtakt von 1MHz nach dem Schlafmodus 
verstellt ist, aber wieso? Inzwischen habe ich auch versucht, alle 
Initialisierungen nach jedem Schlafmodus neu zu machen, erfolgslos!

Der Code ist hier:

int main( void )
{
  clock_init_1MHz();
  
  RTC_init();
  USART_Init(12); // 9600bps bei 1MHz
 
  __enable_interrupt();
  
  for(;;)
  { 
    Delay(1000);    // wait for 1 sec to let the Xtal stabilize after a power-on
    Usart_Tx(0x5A);
    while(!(UCSR0A & (1<<TXC0)));
    
    SMCR = (3<<SM0) | (1<<SE);      // Enable Power-save mode
    __sleep();                      // Go to sleep
                
    SMCR = 0;                       // Just woke, disable sleep
  }
}

void clock_init_1MHz(void)
{
  CLKPR = (1<<CLKPCE);        // set Clock Prescaler Change Enable
    
  // set prescaler = 8, Inter RC 8Mhz / 8 = 1Mhz
  CLKPR = (1<<CLKPS1) | (1<<CLKPS0); 
}

void Delay(unsigned int millisec)
{
    int i;
    
    while (millisec--)
        for (i=0; i<125; i++);
}

void RTC_init(void)
{
    Delay(1000);            // wait for 1 sec to let the Xtal stabilize after a power-on,

    __disable_interrupt();  // disabel global interrupt

    cbi(TIMSK2, TOIE2);             // disable OCIE2A and TOIE2

    ASSR = (1<<AS2);        // select asynchronous operation of Timer2

    TCNT2 = 0;              // clear TCNT2A
    TCCR2A |= (1<<CS22) | (1<<CS20);             // select precaler: 32.768 kHz / 128 = 1 sec between each overflow
    
    while((ASSR & (0x01 | 0x04)));       // wait for TCN2UB and TCR2UB to be cleared

    TIFR2 = 0xFF;           // clear interrupt-flags
    sbi(TIMSK2, TOIE2);     // enable Timer2 overflow interrupt

    OCR2A = 200;    // set timer2 compare value
    
    __enable_interrupt();                 // enable global interrupt
}

#pragma vector = TIMER2_OVF_vect
__interrupt void TIMER2_OVF_interrupt(void)
{
}

void USART_Init(unsigned int baudrate)
{
    // Set baud rate
    UBRR0H = (unsigned char)(baudrate>>8);
    UBRR0L = (unsigned char)baudrate;

    // Enable 2x speed
    UCSR0A = (1<<U2X0);

    // Enable receiver and transmitter
    UCSR0B = (1<<RXEN0)|(1<<TXEN0)|(0<<RXCIE0)|(0<<UDRIE0);

    // Async. mode, 8N1
    UCSR0C = (0<<UMSEL0)|(0<<UPM00)|(0<<USBS0)|(3<<UCSZ00)|(0<<UCPOL0);
}

void Usart_Tx(char data)
{
    while (!(UCSR0A & (1<<UDRE0)));
    UDR0 = data;
}

Hat jemand Ideen?

Gruss
Owen

[Daniel P. (dpolz)]

Woher beziehst du denTakt für UART? Ist der RC-Oszillator abgeglichen? 
Für UART sollte man Quarze verwenden, da der RC temperaturabhängig ist. 
Vielleicht muss nach dem Aufwachen erst noch alles sauber einschwingen, 
obwohl RCs da in der Regel die schnellsten sind. Trotzdem würde ich mal 
beim Takt anfangen zu suchen und mit einem schnellen Quarz testen.

[Daniel P. (dpolz)]

Du hast nicht zufällig ein Oszi, mit dem du mal den Takt ausmessen 
könntest?

[Turbo J (Gast)]

> Das Problem ist, wenn der 169 aus dem Schlafmodus „Power Save“ erweckt
> wird, sendet dieser falsche Bytes. Ohne Schlafmodus ist alles OK.

In den Sparmodi unterhalb von "IDLE" sind die UARTs nicht mehr 
verfügbar, siehe: Sleep Mode.

Die "komischen" Zeichen enstehen, weil dem UART mitten im Byte die 
Taktquelle verloren geht und er dann einfach seinen Pegel hält. Da die 
Übertragung asynchron ist, erhält der PC dann verwürfelte Daten.

Abhilfe: Tiefere Stromspar-Modi nur verwenden, wenn nichts über UART 
gesendet oder empfangen werden muss.

[Owen S. (senmeis)]

Vielen Dank für Deine Abhilfe.

Das funktioniert wirklich wenn der "Idle" Modus gewählt wird. Trotzdem 
verstehe ich dies nicht. In meinem Beispielcode geht der Controller in 
den "Power Save" Modus nachdem das Byte bereits fertiggeschickt wird. 
Warum wird die Taktquelle verloren?

Gruss
Owen

[Oliver J. (skriptkiddy)]

Vielleicht hilft es einen Moment zu warten, bevor du nach dem Aufwachen 
wieder Daten sendest und/oder die Startup-Time höher zu stellen.

Gruß Oliver

[Peter D. (peda)]

Du mußt vor dem Schlafen warten, bis das Senden zuende ist (TXCIE0-Bit).


Peter

[Dietrich L. (dietrichl)]

Turbo J schrieb:
> Die "komischen" Zeichen enstehen, weil dem UART mitten im Byte die
> Taktquelle verloren geht und er dann einfach seinen Pegel hält. Da die
> Übertragung asynchron ist, erhält der PC dann verwürfelte Daten.

Wenn das so ist, dann ist nur das letzte (abgebrochene) Zeichen falsch. 
Dann ist Ruhe, da ja keine neuen Startzeichen kommen.

Die Ursache muss also eine andere sein.

Gruß Dietrich

[Peter D. (peda)]

Dietrich L. schrieb:
> Dann ist Ruhe, da ja keine neuen Startzeichen kommen.

Nö, das Byte kann ja weitere 1-0 Flanken enthalten und wird erst zuende 
gesendet, wenn der Takt wieder da ist.


Peter

[Dietrich L. (dietrichl)]

Peter Dannegger schrieb:
> Nö, das Byte kann ja weitere 1-0 Flanken enthalten und wird erst zuende
> gesendet, wenn der Takt wieder da ist.
OK

[Stefan E. (sternst)]

Owen Senmeis schrieb:
> In meinem Beispielcode geht der Controller in
> den "Power Save" Modus nachdem das Byte bereits fertiggeschickt wird.

Nö. Da du das Flag nie löscht, funktioniert dein Warten nur genau ein 
Mal.

[Owen S. (senmeis)]

Ich habe die Methode Usart_Tx() so geändert und das funktioniert auch 
nicht beim „Power Save“ Modus.

void Usart_Tx(char data)
{
    while (!(UCSR0A & (1<<UDRE0)));
    UDR0 = data;
    while (!(UCSR0A & (1<<TXC0)));
}

Es scheint mit dem Flag nichts zu tun.

Cu
Owen

[Peter D. (peda)]

void Usart_Tx(char data)
{
    UCSR0A = UCSR0A;               // clear TXC0 !!!
    UDR0 = data;
    while (!(UCSR0A & (1<<TXC0)));
}

Peter