Tipps und Tricks

Diese Seite ist lediglich eine Sammlung von Befehlen, Codeschnipseln sowie Bauteilen bzw. Schaltungen, die ich häufiger verwende. Eine weitaus umfangreiche Sammlung gibt es zum Beispiel auf mikrocontroller.net.

APPLICATION NOTE 4377 - Comparison of the DS18B20 and DS18S20 1-Wire Digital Thermometers

Mikrocontroller.net: Basiswiderstand

DDRx = Datenrichtungsregister für Portx.
PORTx = Datenregister für Portx.

// PB7,PB6,PB5,PB4=Ausgang(Low), PB3,PB2,PB1,PB0=Eingang(Pull-Up)
DDRB = 0xF0; // 1111 0000
PORTB= 0x0F; // 0000 1111

Prüfen ob Pin7 an PortB auf HIGH gesetzt ist:

if ( PINB & (1<<PB7) ) {
    // do something
}

Prüfen ob Pin7 an PortB auf LOW gesetzt ist:

if ( !(PINB & (1<<PB7)) ) {
    // do something
}

Warten bis Pin7 an PortB auf HIGH gesetzt wurde:

 while ( !(PINB & (1<<PB7)) ); // busy waiting 

Warten bis Pin7 an PortB auf LOW gesetzt wurde:

 while ( PINB & (1<<PB7) ); // busy waiting 

Pin4 und Pin5 an PortB auf HIGH setzen:

 PORTB |= (1<<PB4) | (1<<PB5); 

Pin4 und Pin5 an PortB auf LOW setzen:

 PORTB &= ~((1<<PB4) | (1<<PB5)); 

Pin4 an PortB invertieren:

 PORTB ^= (1<<PB4); 

In diesem Beispiel wird der Timer0 des Mikrocontrollers dazu benutzt, um jede Millisekunde einen Interrupt auszulösen. Beim Timer0 handelt es sich um einen 8-bit Timer, der immer genau dann einen Interrupt auslöst, wenn das 8-bit Zählregister (TCNT0) überläuft. Würde man das Zählregister des Timers synchron zum Prozessortakt (in diesem Fall 8 MHz) hochzählen, dann würde alle 32 µS ein Interrupt ausgelöst werden. Um diese Rate zu verringern gibt es den sogenannten "Prescaler", mit dem man den Prozessortakt um einen bestimmten Faktor teilen kann. Stellt man den Prescaler beispielsweise auf 8, so wird Zählregister des Timers nur bei jedem achten Impuls vom Prozessortakt um 1 erhöht.

Mögliche Werte für den Prescaler von Timer0:

Für den Timer Interrupt muss also zunächst ein passender Prescaler festgelegt werden. In diesem Beispiel soll jede Millisekunde ein Interrupt ausgelöst werden, was einer Frequenz von 1000 Hz entspricht. Die Anzahl der notwendigen Inkrementierungen, um einen Timer Overflow Interrupt auszulösen muss kleiner oder gleich dem höchsten Wert des Zählregister sein.

Bei einem Prozessortakt von 8 MHz ergeben sich folgende Werte für die Anzahl der notwendigen Inkrementierungen:

Anhand der Tabelle ist ersichtlich, dass in dem Fall nur ein Prescaler von 64 geeignet ist. Damit der Timer Overflow Interrupt nach genau einer Millisekunde ausgelöst wird, muss das Zählregister in diesem Fall noch mit dem Wert 131 (256-125) vorgeladen werden.

#include <avr/interrupt.h>
 
volatile uint32_t millis = 0;
 
ISR (TIMER0_OVF0_vect) {
    millis++;
    TCNT0 = 131;
}
 
int main (void) {
 
    TIMSK |= (1<<TOIE0);            // enable Timer 0 Overflow Interrupt
    TCCR0 |= (1<<CS01) | (1<<CS00); // set prescaler to 64
    TCNT0 = 131;                    // set preload value
 
    sei(); // enable interrupts
 
    while(1) {
        // do something
    }
 
    return 0;
}

Weiterführende Links zum Thema Timer:
heise Developer: Timer, Counter und Interrupts
Prescaler - Berechnung für AVR - Timer

In diesem Beispiel wird der Timer1 des Mikrocontrollers dazu benutzt, um ein PWM-Signal mit variablem Tastverhältnis zu erzeugen. Die resultierende PWM-Frequenz ist abhängig vom Prozessortakt, dem Prescaler und der Auflösung der PWM. Der Prescaler für den Timer sollte dabei so hoch wie möglich gewählt werden, um die Prozessorlast durch die Interrupt-Routine (Timer Overflow) so gering wie möglich zu halten.

Die Formel zur Berechnung der PWM-Frequenz lautet:

PWM-Frequenz = Prozessortakt / Prescaler / Schritte bis Timer-Overflow / PWM-Schritte

#include <avr/interrupt.h>
 
#define PWM_MAX 100
volatile uint8_t pwmCounter = 0;
uint8_t pwmValue = 0;
 
ISR (TIMER1_OVF1_vect) {
    if (++pwmCounter > PWM_MAX) {
        pwmCounter = 0;
    }
    if ( (pwmCounter == 0) && (pwmValue > 0) ) {
        // set output high
    } else if ( (pwmCounter == pwmValue) && (pwmValue < PWM_MAX) ) {
        // set output low
    }
}
 
int main (void) {
 
    TIMSK |= (1<<TOIE1); // enable Timer 1 Overflow Interrupt
    TCCR1B |= (1<<CS10); // set prescaler to 1
 
    sei(); // enable interrupts
 
    while(1) {
        // do something (e.g. set pwmValue)
    }
 
    return 0;
}