Timers et ordonnancement

Candençage

Comme nous l'avons vu précédemment, le microcontrôleur est candencé à une certaine fréquence, qui dépend très souvent d'un élément hardware externe, le quartz. Cette fréquence est appelée fréquence d'horloge.

Fonctionnement

Un timer est un module hardware qui permet de compter le nombre de cycles d'horloge. Il est incrémenté à une certaine période \(T\), et réinitialisé lorsqu'il dépasse un certain plafond \(P\) (on parle d'overflow).

Réglage de la période

La période d'un timer peut se régler à l'aide d'un registre, appelé prescaler. Ce dernier permet de diviser la fréquence d'horloge par un certain nombre \(N\), on peut alors calculer la période \(T\) à l'aide de la formule:

Où \(f_{CPU}\) est la fréquence d'horloge du microcontrôleur.

En général, le prescaler \(N\) est une valeur que l'on peut choisir parmis une liste de valeurs prédéfinies. Par exemple, la liste des valeurs possibles pour le prescaler du TIMER0 de l'ATmega328P est: 1, 8, 64, 256 ou 1024.

Page 87 de la datasheet

Réglage du plafond

En fonction du mode d'utilisation du timer, le plafond peut être sa valeur maximale (par exemple 0xFF pour un timer 8 bits), ou une valeur arbitraire fixée par un registre.

Page 86 de la datasheet

La fréquence à laquelle le timer overflow (c'est à dire repasse à zéro) est alors:

Où \(f_{CPU}\) est la fréquence d'horloge du microcontrôleur, \(N\) est le prescaler, et \(P\) le plafond.

Modulation en longueur d'impulsion (PWM)

Définition

Dans le TD1, nous avons fait briller une LED plus ou moins fort en jouant sur le ratio \(t_1\) entre le temps où la LED est allumée et le temps \(t_0\) où elle est éteinte.

Utilisation de timers en mode PWM

En ajoutant un autre registre de comparaison, il est possible de produire ce signal en utilisant un timer en mode PWM:

Ici:

• Lorsque le timer atteint son plafond, il est réinitialisé à zéro, et une broche correspondante est mise à l'état haut (5V),
• Lorsque le timer atteint la valeur du registre de comparaison, la broche correspondante est mise à l'état bas (0V).

Interruptions

Les timers permettent de déclencher des interruptions à chaque overflow (c'est à dire à chaque fois que le timer revient à zéro), ainsi qu'à chaque fois que le timer atteint la valeur du registre de comparaison.

Ordonnancement

Introduction

Comme vous l'avez remarqué, nous programmons actuellement sans système d'exploitation.

Ordonnancement coopératif

La solution la plus simple est de pratiquer un ordonnancement coopératif. C'est à dire que le programme est découpé en plusieurs tâches, et que chacune de ces tâches est exécutée à tour de rôle.

DDRB |= (1 << PB5);

while (1) {
    PORTB |= (1 << PB5);
    _delay_ms(1000);
    PORTB &= ~(1 << PB5);
    _delay_ms(1000);
}

Supposons que l'on dispose d'une méthode uint32_t system_clock() qui utilise un timer et nous retourne le temps écoulé depuis le démarrage du microcontrôleur en millisecondes.

uint32_t last_change = 0;
uint8_t led_state = 0;

void blink_init() {
    DDRB |= (1 << PB5);
}

void blink_tick() {
    if (system_clock() - last_change >= 1000) {
        last_change = system_clock();
        led_state = !led_state;
        if (led_state) {
            PORTB |= (1 << PB5);
        } else {
            PORTB &= ~(1 << PB5);
        }
    }
}

Ainsi, la fonction main ressemblerait alors à:

int main() {
    blink_init();
    // Initialisation d'autre tâches

    while (1) {
        blink_tick();
        // Exécution d'autre tâches
    }
}

Ordonnancement préemptif

Une autre approche consiste à interrompre les tâches afin de donner du temps de calcul à d'autres tâches.

Ce type de mécanisme est appelé ordonnancement préemptif. Il est plus complexe à mettre en oeuvre, et la meilleure solution est d'utiliser un système d'exploitation, dont une des principale valeur ajoutée est préciement de gérer ce type de mécanisme.