timer0 zur Zeitmessung verwenden (AVR)

[Peter M. (peter0815)]

Hallo !
ich habe ein Problem:

Ich verwende einen Teensy2.0 auf dem ein Atmega32u4 verbaut ist. Damit 
möchte ich mit dem 8-Bit Timer0 alle 10 Mikrosekunden ein Interrupt 
werfen.

Das Problem ist dass die der Timer nur mit dem TOP-Wert (255), nicht mit 
dem von mir fesgtelegten OCR0A Wert verlgeicht. Zum programmieren 
verwende ich die Arduino IDE.

Danke im Voraus

Hier der Code:

#include <avr/interrupt.h>

ISR(TIMER0_COMPA_vect){

  digitalWrite(pin4,!digitalRead(pin4));

}

void setup(){ 

  //setting waveform generation mode
  TCCR0A |= ( _BV( WGM01 ) ); // page 104 ( Mode 2 (Table 13-8))
  
  //setting the prescaler to 1/8
  TCCR0B &= ~(_BV( CS02 ) | _BV( CS00 )); 
  TCCR0B |= (_BV( CS01 )); 
  
  OCR0A = 20;
  
  //enable interrupt for a
  TIMSK0 |= ( _BV( OCIE0A ) ); 
  TCNT0 = 19;  
} 

void loop(){
  
}

[Helfer (Gast)]

/*
   Atmega32u4 (http://atmel.com/dyn/resources/prod_documents/doc7766.pdf)
   F_CPU 16 MHz (http://www.pjrc.com/teensy/)
*/
#include <avr/io.h>
#include <avr/interrupt.h>

#ifndef F_CPU
#define F_CPU 16000000UL
#endif

ISR(TIMER0_COMPA_vect)
{
  digitalWrite( pin4, !digitalRead(pin4) );
}

void setup(void)
{ 
  //setting Clear Timer on Compare Match (CTC) Mode
  TCCR0A = ( _BV( WGM01 ) ); // page 104 ( Mode 2 (Table 13-8))
  
  /*
     Berechnung des OCR0A Werts
     F_CPU = 16000000, Ziel: 10ms
     OCR0A+1 = F_CPU / Prescaler / (1000ms/10ms)

     Prescaler    OCR0A+1   Anm.
     =========================================
     1            160000     8-Bit Overflow
     8             20000     8-Bit Overflow, tauglich bei 16-Bit Timer
     64             2500     8-Bit Overflow, tauglich bei 16-Bit Timer
     256             625     8-Bit Overflow, tauglich bei 16-Bit Timer
     1024            156.25  Kein ", aber nicht exakt 10ms!

     Zeit zw. ISR = (OCR0A+1) * Prescaler * 1000 / F_CPU  ms

     Prescaler 1024
     OCR0A+1  Zeit zw. ISR   Fehler
     ==============================
     156       9,984 ms      -0,16%
     157      10,048 ms      +0,48%
  */
  OCR0A = (F_CPU / 1024 / (1000/10)) - 1;

  //setting the prescaler to 1024
  TCCR0B = (_BV( CS02 ) | _BV( CS00 )); 
  
  //enable interrupt for a
  TIMSK0 |= ( _BV( OCIE0A ) ); 
} 

void loop(void)
{
}

[Helfer (Gast)]

> Mikrosekunden

Sorry, habe das nicht genau gelesen und ms verwendet. Prescaler 8 und 
OCR0A = 20-1 = 19 passt bei 10 µs.

Deine Interrupts kommen dann bei 10 µs alle 160 Takte. Wie lange 
brauchen die Funktionen digitalRead() und digitalWrite() plus der 
Overhead für das Anspringen und Verlassen der ISR? Das müssen zusammen 
weniger als 160 Takte sein, damit keine IRQs verloren gehen!

[Peter M. (peter0815)]

Danke für die wirklich schnelle Antwort !

Die Funktionen digitalWrite() und digitalRead() brauchen ca. 40 Zyklen.
Ich habe bei OCR0A auch höhere Werte probiert aber auch da das Problem, 
dass immmer bis TOP gezählt wird.

[Ralf (Gast)]

In der Interruptroutine einfach den Startwert festlegen (256-20) und 
dann bis TOP zählen lassen?

[Stefan E. (sternst)]

Peter M. schrieb:
> dass immmer bis TOP gezählt wird.

Wie genau stellst du das fest?

Davon abgesehen:

Peter M. schrieb:
> Die Funktionen digitalWrite() und digitalRead() brauchen ca. 40 Zyklen.

Jeweils? Und wenn das womöglich noch echte und nicht ge-inline-te 
Funktionen sind, dann kommen noch mal ca 50 Takte zusätzlicher Overhead 
in der ISR selber dazu. Und das alles, um (anscheinend) lediglich einen 
Pin zu toggeln.
Umständlicher und aufwändiger geht es wohl kaum.

[Peter M. (peter0815)]

Das Programm ist deswegen so einfach um den Fehler zu finden. Es ist nur 
ein Auszug aus einem anderen. Ich habe das Signal mit einem Oszilloskop 
ausgemessen und die gesamte Periodendauer ist 255 Mikrosekunden ( Bei 
8-Bit Timer = TOP). Die Funktionen SIND inline.

[spess53 (Gast)]

HI

Bist du sicher, das du das richtige Programm flashst?

MfG Spess

[Peter M. (peter0815)]

ja, da bin ich mir ziemlich sicher ;-)

[Helfer (Gast)]

Der Sourcecode sieht für mich (und wohl auch die anderen Leser) sauber 
aus.

Deshalb ist die Frage nach dem Binärfile nicht abwegig. Fehler bei der 
Definition eines µC in der Toolchain und/oder flashen eines veralteten 
Binärfiles wurden schon beobachtet.

Wenn du nicht weiter kommst: Den Inhalt des µC mal auslesen und 
anhängen, so dass man das in den Simulator laden kann. Dort dann 
Register TCCR0A nach dem setup() auslesen und mit dem Datenblatt 
vergleichen, ob wirklich der CTC Modus gesetzt wird. Der Prescaler 
(TCCR0B) ist ja anscheinend OK (16 MHz, Prescaler8, TOP 255 => 255 µs 
ist richtig)

[Peter M. (peter0815)]

Simulator ?
Bietet AVR Studio diese Möglichkeit ?
Und wie liest man überhaupt den Inhalt eines µControllers aus ? Sry 
damit hab ich mich noch nie befasst.
Hab auf die Schnelle auch nichts wirklich verständliches finden können.

[Eingehirner (Gast)]

Das AVR-Studio bietet die Möglichkeit, deinen Quellcode zu simulieren. 
Allerdings weiß ich nicht, ob nur Assembler oder auch C...

Einfach Strg+F7 ("build and run") drücken statt nur F7 ("build"), dann 
wird der Code compiliert und der Simulator gestartet. Mit F11 gehst du 
dann immer einen Befehl weiter. Der Simulator zählt die Takte mit und 
zeigt sie links oben an, genauso wie (bei korrekt eingestellter 
Frequenz) die verstrichene Zeit. Die Inhalte der einzelnen Register, 
Ports etc. kannst du dir auch zu jedem Zeitpunkt anzeigen lassen.

Auslesen kannst du ihn, wenn du dir das Dialogfenster vom AVR-Studio mit 
dem µC anschaust, über diverse Buttons. Da, wo du ihn 
programmierst/schreibst, kannst du ihn auch auslesen und verifizieren 
(d.h., automatisch auslesen und mit deinem Hex-File vergleichen) lassen. 
Dort kommst du hin, wenn du den rechten "IC"-Button im AVR-Studio 
anklickst.