Delay mittels Timer

[Spurius]

Hallo,
ich versuche in folgendem Code eine Delay-funktion zu realisieren.
Leider funktioniert es nicht wirklich, kann vllt. von euch jemand erkennen, warum nicht im Sekundentakt gesendet wird, sondern viel schneller?

#include <avr/io.h> 
#include <avr/interrupt.h>
#include <avr/signal.h>

volatile uint8_t count;

void init_usart(void) 
{ 
 UBRRL |= 0b01100111; 
 UCSRB = (1<<TXEN) | (1<<RXEN); 
 UCSRC = (1<<URSEL) | (1<<UCSZ1) | (1<<UCSZ0); 
} 

void send_char(unsigned char s)
{
 while (!(UCSRA & (1<<UDRE)));
 UDR = s;
}

void send_string(char *s)
{
 while(*s != '\0')
  {
   send_char(*s);
   s++;
  }
}

void waitms(uint16_t s)
{
 
 uint16_t i;
 uint8_t j;
 TCCR0 |= (1<<CS01) | (1<<CS00);  //Vorteiler 64
 TIMSK |= (1<<TOIE0);
 
 for(i=0;i<s;i++)
  {
   TCNT0 = 6;                 // Timer auf 6 vorladen, da (16000000/64)^-1 = 0.000004s
  }                           // -> 1ms = 0.000004s*250
  
 TIMSK |= (0<<TOIE0);
} 
 
SIGNAL(SIG_OVERFLOW0)
{
 count++;
 TCNT0 = 6;
}
 
int main(void) 
{ 
 sei();
 unsigned int i; 
 char a = "108:158#13#10";
 i = 0; 
 init_usart(); 
 do
  {
   send_string(a);
   waitms(1000); 
  }
  while (i == 0);  
}

Gruß
Spurius

[SprinterSB]

Versuch mal sowas:

#include <avr/io.h> 
#include <avr/interrupt.h>
#include <avr/signal.h>

volatile uint8_t count;

void init_usart(void) 
{ 
 UBRRL |= 0b01100111; 
 UCSRB = (1<<TXEN) | (1<<RXEN); 
 UCSRC = (1<<URSEL) | (1<<UCSZ1) | (1<<UCSZ0); 
} 

void send_char (unsigned char s)
{
 while (!(UCSRA & (1<<UDRE)));
 UDR = s;
}

void send_string (char *s)
{
 while (*s++)
   send_char(*s);
}

void init_timer0()
{
 TCCR0 = (1<<CS01) | (1<<CS00);  //Vorteiler 64
 TIMSK |= (1<<TOIE0);
}

void waitms (uint16_t s)
{
 while (s--)
 {
    uint16_t cnt;

    cli();
    count = 0;
    TCNT0 = 6;

    do 
    {
         cli();
         cnt = count;
         sei();
    }
    while (cnt < 1000);
  }
} 
 
SIGNAL (SIG_OVERFLOW0)
{
 TCNT0 = 6;
 count++;
}
 
char a[] = "108:158#13#10";

int main(void) 
{ 
 init_usart(); 
 init_timer0(); 

 sei();

 while (1)
  {
   send_string (a);
   waitms (1000); 
  }
}

[Spurius]

Hi,
bei deiner Version wird nur einmal gesendet
Was ist bei mir denn konkret falsch? Hab ich nen Logikfehler oder eher was C-Spezifisches?

[SprinterSB]

Sorry, count muss uint16_t sein, nicht uint8_t (zählt bis 1000). Und in der Schleife muss es heissen while(*s) { foo (*s++); }

Was bei dir konkret inkorrekt ist, ist schwer zu fprmulieren. Es geht eben nicht so. Interrupts hast du inaktiv und setzt in der Schleife nur s mal TCNT0 auf 6. Da müsste noch das Flag aus TIFR abgefrage/gelöscht werden, heisst glaub TOV0 oder so.

[super_castle]

nimm diese hier, delay_us_(...) und delay_ms_(...):

#define delay_us_(us) _delayFourCycles_( ( ( 1*(F_CPU/4000) )*us)/2005)

static inline void _delayFourCycles_(uint16_t z)
{
uint16_t i;

for (i=0; i<z; i++)
asm volatile("nop");
}

static inline void delay_ms_(uint16_t z)
{
uint16_t i;

for (i=0; i<z; i++)
delay_us_(999);
}

[Spurius]

Hallo,
danke für eure Hilfe, ich habs jetzt so gelöst:

#include <avr/io.h> 
#include <avr/interrupt.h> 
#include <avr/signal.h> 

volatile uint8_t count = 0; 

void init_usart(void) 
{ 
 UBRRL |= 0b01100111; 
 UCSRB = (1<<TXEN) | (1<<RXEN); 
 UCSRC = (1<<URSEL) | (1<<UCSZ1) | (1<<UCSZ0); 
} 

void send_char(unsigned char s) 
{ 
 while (!(UCSRA & (1<<UDRE))); 
 UDR = s; 
} 

void send_string(char *s) 
{ 
 while(*s != '\0') 
  { 
   send_char(*s); 
   s++; 
  } 
} 

void waitms(uint16_t s) 
{ 
  
 uint16_t i; 
 uint8_t j; 
 TCCR0 |= (1<<CS01) | (1<<CS00);  //Vorteiler 64 
 TIMSK |= (1<<TOIE0); 
  
 for(i=0;i<s;i++) 
  {
   count = 0; 
   TCNT0 = 6;                 // Timer auf 6 vorladen, da (16000000/64)^-1 = 0.000004s 
   while(count != 1)
    {}
    
  }                           // -> 1ms = 0.000004s*250 
  
 TIMSK |= (0<<TOIE0); 
} 
  
SIGNAL(SIG_OVERFLOW0) 
{ 
 count = 1; 
} 
  
int main(void) 
{ 
 sei(); 
 unsigned int i; 
 char a = "Hallo Welt"; 
 i = 0; 
 init_usart(); 
 do 
  { 
   send_string(a); 
   waitms(1000); 
  } 
  while (i == 0);  
}

Gruß
Spurius