Das könnte dich auch interessieren: Raspberry Pi Timer programmieren in C

Liste der Komponenten

• Arduino Uno
• LED
• Jumper Kabel
• 220 Ohm Widerstand
• Steckbrett

Was ist eigentlich ein Timer?

Ein Timer ist im Grunde nichts anderes als ein bestimmtes Register im Mikrocontroller, das hardwaregesteuert kontinuierlich um 1 erhöht (oder verringert) wird. Anstatt Anweisungen im Programm zu kodieren, die regelmäßig ausgeführt werden und ein Register um 1 erhöhen, macht der Mikrocontroller das ganz von alleine!

Dies wird nützlich, wenn eine Aktion bei bestimmten Zählerwerten ausgeführt wird. Einer dieser ‚bestimmten Zählerstände‘ ist zum Beispiel der Überlauf. Das Zählregister eines Timers kann nicht beliebig lange inkrementiert werden. Z.B. ist der höchste Zählerstand, den ein 8-Bit-Timer erreichen kann, 2^8 – 1 = 255. Der nächste Schritt ist nicht 256, sondern es kommt zu einem Überlauf, der den Timer wieder auf 0 setzt. Das ist die ganze Magie! Wir können den Controller so konfigurieren, dass ein Interrupt ausgelöst wird, wenn der Timer überläuft. Anschließend können wir einen Code in das Arduino Programm schreiben, der im Falle eines Interrupts ausgeführt wird. Zum Beispiel können wir eine LED zum Leuchten bringen oder einen bestimmten Sensorwert abfragen.

Arduino Uno Mikrocontroller ATMEGA328P

Der ATMEGA328P-Mikrocontroller ist das Herzstück des Arduino Uno-Boards. (ACHTUNG: Der Arduino Mega z.B. hat einen anderen Mikrocontroller!) Der ATMEGA328P Mikrocontroller hat 3 Timer (Datenblatt), die teilweise in Arduino-Funktionen und/oder teilweise in Bibliotheken verwendet werden. Das Überschreiben der Timer-Register kann daher zu Komplikationen mit bestehenden Timer-Funktionen wie millis(), micros() oder delay() führen und sollte mit Vorsicht verwendet werden. Die 3 Timer sind Timer0 (8Bit), Timer1 (16Bit) und Timer2 (8Bit).

• 8 Bit-Timer0: wird genutzt für die Funktionen millis(), micros(), delay() und für PWM an Pin D5 und D6
• 16 Bit-Timer1: wird z. B. für die Bibliothek Servo, VirtualWire, TimerOne und für PWM an Pin D9 und D10 genutzt
• 8 Bit Timer2: wird genutzt für Funktion tone() und für PWM an Pin D3 und D11

Wie variiert man die Taktgeschwindigkeit?

Der Systemtakt des Arduino Uno beträgt 16 MHz (CPU-Frequenz). Das bedeutet, dass Timer0, Timer1 und Timer2 16 Millionen Mal pro Sekunde hochlaufen. Die 8-Bit-Timer zählen z. B. jeweils von 0 bis 255. Bei 256 tritt ein Überlauf auf und die Timer beginnen wieder bei 0. Das bedeutet 16000000/256 = 62500 Überläufe pro Sekunde (62,5kHz Taktrate). Das ist für die meisten Timer-Anwendungen wahrscheinlich zu schnell!

Deshalb gibt es einen Trick, um die Taktraten zu verlangsamen. Man verwendet einen sogenannten Vorteiler (Prescaler). Ein Vorteiler kann auf die Werte 1, 8, 64, 256 oder 1024 eingestellt werden. Er ermöglicht es, den Systemtakt (16MHz) durch den gewählten Faktor zu teilen und eine niedrigere Taktrate für die Timer einzustellen. Ein Vorteiler von 1024 würde z. B. die Timer-Register nur beim 1024sten Systemtakt um 1 erhöhen. Das wären 16000000/1024=15625 Inkremente pro Sekunde und damit bei einem 8-Bit-Timer 15625/256= 61,035 Überläufe pro Sekunde (~61 Hz Taktrate des Timers).

Anwendungsbeispiel: LED soll mit 50 Hz blinken

Im Folgenden wird die Ansteuerung von Arduino Timer Interrupts mit dem 16-Bit Timer1 gezeigt. Damit soll eine LED im 50 Hz-Takt aufleuchten. Schaltplan, Arduino-Code und Bilder sind ebenfalls enthalten. (Die Vorgehensweise für den 8-Bit-Timer0 und Timer2 ist analog.) Für den zeitgesteuerten Impuls benötigen Sie den sogenannten „CTC-Modus“.

Im CTC-Modus („Clear Timer on Compare Mode“) wird der Zähler gelöscht, wenn der Wert des Zählers (TNCT1) entweder mit dem Wert des OCR1A-Registers oder dem Wert des ICR1-Registers (in unserem Fall OCR1A) übereinstimmt. Das OCR1A-Register bestimmt also den Maximalwert des Zählers und damit seine Auflösung.

Der 16 Bit Timer1 braucht die folgenden Register:

• Timer Counter Register 1: TCNT1
• Output Compare Register A: OCR1A
• Timer Counter Control Register A: TCCR1A
• Timer Counter Control Register B: TCCR1B
• Timer/Counter Interrupt Mask Register: TIMSK1
• (Für Timer0 und Timer2 würden die entsprechenden Register TCNT0 bzw. TCNT2 heißen)

Berechnung des OCR1A Registers für Arduino Timer Interrupts

Der Wert des Registers OCR1A ist abhängig von der gewünschten Interruptfrequenz und dem gewählten Vorteiler. Es gilt die folgende Formel:

Wir setzen unsere Spezifikationen in die Formel ein:

• CPU-Frequenz Arduino Uno: 16.000.000 Hz
• Gewünschte Interruptfrequenz: 50 Hz (= 20 ms Periodendauer)
• Möglicher Vorteiler: 1, 8, 64, 256 oder 1024

Berechnungsbeispiel mit Vorteiler 1024:
OCR1A= (16.000.000 / (1024 * 50)) – 1 = 311,5

Berechnungsbeispiel mit Vorteiler 8:
OCR1A= (16,000,000 / (8 * 50)) – 1 = 39,999

ACHTUNG: Der OCR1A-Wert muss kleiner als 65,536 (2^16 ) sein!

Daher kann ein Vorteiler 8 NICHT die 10 Hz Interruptfrequenz erreichen:
OCR1A= (16.000.000 / (8 * 10)) – 1 = 199.999

Der Wert 199,999 ist größer als das Register mit 65,536, daher muss ein anderer Vorteiler verwendet werden, um 10 Hz zu erreichen

Stattdessen ein Vorteiler 64 für 10 Hz Interruptfrequenz:
OCR1A= (16.000.000 / (64 * 10)) – 1 = 24.999

Wird nun ein Timer1-Interrupt ausgelöst, springt der Programmablauf in eine zu erstellende Interrupt-Service-Routine „ISR(TIMER1_COMPA_vect)“. (Siehe Arduino Code)

Bit Kombination für die gewünschten Vorteiler

Arduino Timer Interrupts Code für die 50 Hz Frequenz

void setup() {

  pinMode(11,OUTPUT);  //LED pin (to blink in 50Hz frequency)
  
//START TIMER SETUP
//TIMER SETUP for highly preceise timed measurements 

  cli();//stop all interrupts

  // turn on CTC mode
  TCCR1A = 0;// set entire TCCR1A register to 0
  TCCR1B = 0;// same for TCCR1B
  TCCR1B |= (1 << WGM12);

  // Set CS11 bit for prescaler 8
  TCCR1B |= (1 << CS11); 
  
  //initialize counter value to 0;
  TCNT1  = 0;
  
  // set timer count for 50Hz increments
  OCR1A = 39999;// = (16*10^6) / (50*8) - 1  
  
  // enable timer compare interrupt
  TIMSK1 |= (1 << OCIE1A);
  
  sei();//allow interrupts
  //END TIMER SETUP
}



ISR(TIMER1_COMPA_vect) {//Interrupt at frequency of 50 Hz
 //write your timer code here

 digitalWrite(11,HIGH);
 delay(15);
 digitalWrite(11,LOW);
}




void loop() {

//when the timer is over, your program will stop in the loop function and jump to the timer code. 
//After the timer code it will jump back to the point where it left the loop function
}

The post Arduino Timer Interrupts – Arduino Register programmieren appeared first on Nerd Corner.

Nachfolgend eine Erklärung wieso die Library „sys/time.h“ genutzt wurde, sowie ein Codebeispiel mit anschließender Erläuterung. Dieses Codebeispiel eignet sich sehr gut für bitweise Datenübertragung in der Kommunikationstechnik.

Das könnte Sie ebenfalls interessieren: Präzise Timer Interrupts für den Arduino programmieren!

Liste der Komponenten

• Linux Betriebssystem (zum Beispiel Raspberry Pi)
• Editor für C – Programmierung

Die Library „sys/time.h“

Funktionen wie „usleep()“ oder „nanosleep()“ würden das komplette Programm anhalten. Für einfache Anwendungen mag das vielleicht ausreichen, allerdings war das für meine Zwecke zu ungenau. Ich wollte einen Timer, der wirklich exakt im 1 ms Takt bzw. 0,1 ms Takt arbeitet. Deswegen wurde anstelle von „usleep()“ oder „nanosleep()“ eine andere Lösung gewählt. Die Library „sys/time.h“. Diese kann die aktuelle „System Clock Time“ (System Uhrzeit) auslesen und vergleichen.

Codebeispiel für präzisen Timer in C

#include <sys/time.h>

int main()
{
    struct timeval tval_before, tval_after, tval_result;
    int counter=0;
    bool stop=false;
   
    gettimeofday(&tval_before, NULL);
    while(stop!=true)
    {
        gettimeofday(&tval_after, NULL);
        timersub(&tval_after, &tval_before, &tval_result);
        double time_elapsed = (double)tval_result.tv_sec + ((double)tval_result.tv_usec/1000000.0f);
        
        while(time_elapsed < 0.001)  //1ms; you can change your desired time interval here
        {
            gettimeofday(&tval_after, NULL);
            timersub(&tval_after, &tval_before, &tval_result);
            time_elapsed = (double)tval_result.tv_sec + ((double)tval_result.tv_usec/1000000.0f);
        }
        gettimeofday(&tval_before, NULL);
        
        if (counter==10000)
        {
            stop=true;
        }
            
        else 
        {
            counter++;
        }
    }
    return 0;
}

Erklärung zum Codebeispiel:

Eine Funktion „gettimeofday“ schreibt die aktuelle System Uhrzeit in die Variable „tval_before“. Eine While Schleife wird anschließend solange ausgeführt bis die eigentliche Aufgabe erledigt ist.

Innerhalb der While Schleife wird als Erstes erneut die System Uhrzeit in eine Variable „tval_after“ abgespeichert. Anschließend wird die zeitliche Differenz zwischen „tval_after“ und „tval_before“ gemessen und in „tval_result“ abgespeichert.

Der nächste Schritt des Timers in C erschließt sich nicht sofort auf den ersten Blick: „tv_result“ besteht per Definition aus 2 Teilen. Zum einen ein Sekunden Anteil „.tv_sec“ und zum anderen ein Mikrosekunden Anteil „.tv_usec“. Eben dieser Mikrosekundenanteil muss erst noch durch eine Million geteilt werden, damit man den Wert in Sekunden erhält. Anschließend, kann der Mikrosekundenanteil zum Sekundenanteil addiert werden.

Der addierte Wert wird im Code als „time_elapsed“ bezeichnet. Falls dieser Wert kleiner als eine Millisekunde ist, wird eine weitere innere While Schleife geöffnet, die solange den Wert für „time_elapsed“ neu berechnet, bis exakt 1 ms vergangen ist. Anschließend wird mittels der „gettimeofday“ Funktion der Wert für „tval_before“ neu festgelegt.

Da zu diesem Zeitpunkt exakt 1 ms vergangen ist, kann der Timer nun seinen eigentlichen Arbeitsschritt ausführen. In diesem einfachen Codebeispiel wird lediglich eine Variable „counter“ um 1 erhöht. Das bedeutet für jeden Intervallschritt (im Codebeispiel 1 ms) erhöht sich der counter um 1. Sobald ein festgelegter Wert für counter erreicht wurde stoppt das Programm. In diesem Fall ist der festgelegte Wert 10000. Anschließend wird die While Schleife beendet. Aber dieser Teil des Codes kann natürlich problemlos für die eigenen Zwecke angepasst werden.

Meine Messungen mit dem Oszilloskop haben eine exakte Frequenz von 1 ms gemessen, sogar 0,1 ms wurde exakt gemessen. Dieses Codebeispiel eignet sich deswegen auch sehr gut für eine exakte Datenübertragung in der Kommunikationstechnik.

Dateien herunterladen

• Downloadfile Timer in C

The post Wie programmiert man einen präzisen Timer in C für Linux appeared first on Nerd Corner.