asynchroner Timer2 im AVR

[Owen S. (senmeis)]

Hi,

ich möchte eine Zeichenkette über UART im Atmega169 alle 5 Sekunde 
senden lassen. Dazwischen wechselt der Controller in den Schlaf Modus. 
Ein 32.768kHz Quarz wird für Timer2 eingesetzt und der interne RC 
Oszillator wird als Systemtakt verwendet.

Das Problem ist, statt 5s wird diese Zeichenkette alle 2s geschickt. 
Woran kann das liegen?

extern char gPowerSaveTimer;    // external Counter from "RTC.c"
char PowerSaveTimeout = 5;
char PowerSave = FALSE;     

int main( void )
{
  char str[] = "12345";
  
  clock_init_8MHz();
  USART_Init(103); // 9600bps by 8MHz
  RTC_init();
  
  __enable_interrupt();

  for(;;) // main loop
  {
    if (!PowerSave)
    {
        uart_put_string(str);   
        PowerSave = TRUE;   // enter sleep mode
        gPowerSaveTimer = 0;
    }
      
    else 
    {
      SMCR = (3<<SM0) | (1<<SE);      // Enable Power-save mode
      __sleep();                      // Go to sleep
    }            
    SMCR = 0;                       // Just woke, disable sleep
  }
}

void clock_init_8MHz(void)
{
  CLKPR = (1<<CLKPCE);        // set Clock Prescaler Change Enable
    
  // set prescaler = 8, Inter RC 8Mhz / 1 = 8Mhz
  CLKPR = 0; 
}

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

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)
{
  UCSR0A = UCSR0A;               // clear TXC0 !!!  
  UDR0 = data;
  while (!(UCSR0A & (1<<TXC0)));
}

void uart_put_string (char *data_string)
{
    while(*data_string) Usart_Tx(*(data_string++));
}

/******************************************************************************
*
*   Function name:  RTC_init
*
*   returns:        none
*
*   parameters:     none
*
*   Purpose:        Start Timer/Counter2 in asynchronous operation using a
*                   32.768kHz crystal.
*
*******************************************************************************/
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
}

/******************************************************************************
*
*   Timer/Counter2 Overflow Interrupt Routine
*
*   Purpose: Increment the real-time clock
*            The interrupt occurs once a second (running from the 32kHz crystal)
*
*******************************************************************************/
#pragma vector = TIMER2_OVF_vect
__interrupt void TIMER2_OVF_interrupt(void)
{
  gPowerSaveTimer++;
  if (gPowerSaveTimer >= PowerSaveTimeout)
  {
    gPowerSaveTimer = 0;
    PowerSave = FALSE;
  }
}

Gruss
Owen

[Peter D. (peda)]

Im asynchronen Modus brauchts ne Flanke des 32kHz Taktes, damit Werte 
übernommen werden, z.B. das Löschen des Interruptflags.
Dafür gibt es allerdings kein Busy-Bit.
Daher wacht er wieder auf und Du bekommst mehrere Interrupts.
Als Lösung kann man ein Dummy-Write auf TCCR2A machen und warten, bis 
TCR2UB wieder gelöscht ist.


Peter

[(prx) A. K. (prx)]

Ein letztes Mal schreib ich dir das noch, aber dann nicht mehr, 
versprochen: Wenn TCCR2A nach setzen von AS2 per Definition Schrott ist, 
dann ergibt
  TCCR2A |= (1<<CS22) | (1<<CS20);
schlicht und einfach keinen Sinn.