Ce tutoriel explique comment avoir un timing précis en utilisant les quartz périphériques.

Dans ce tutoriel, nous allons utiliser des fonctions prédéfinies pour utiliser les horloges. Nous n'allons pas expliquer en détail comment tout cela fonctionn, mais juste les utiliser. Pour des informations complémentaires, le lecteur peut se reporter au manuel d'utilisation du processeur.

Ces fonctions sont dans les fichiers F5659Utils.h et .c. Nous en profiterons pour introduire Types.h qui contient des redéfinitions de types largement utilisés. Et nous allons aussi introduire un fichier HardwareConfig.h dans la rubrique bonnes pratiques, qui permet de simplifier la transition d'un hardware à un autre.

Généralités sur le programme

Comme nous l'avons dit dans les tutoriels précédents, la fréquence de défaut du MSP430 est de 1MHz environ. Il va donc démarrer à cette fréquence par défaut. Par contre, si nous voulons utiliser une horloge plus rapide (24 MHz dans cet exemple), nous devons d'abord élever la tension du coeur. Ceci est possible grâce à une première fonction, SetCoreVoltage qui permet de choisir entre 4 tensions différentes de VCORE14 (pour 1,4V) à VCORE19 (pour 1,9V).

Ensuite seulement nous pourrons augmenter la frequence par FLL (frequency locked loop). L'oscillateur DCO est divisé puis comparé à la fréquence de l'horloge temps réel. De cette façon, nous avons un timing d'une précision de 20 à 50 ppm suivant le choix du quartz. Une précision de 50 ppm (donc 5 pour 100 000) correspond à 5 secondes par jour en arrondissant 1 jour à 100 000 secondes.

Le reste du programme est le même.

La seule différence réside dans la configuration du timer. Nous avons dans les exemples précédents utilisé l'horloge de 1 MHz pour le timer. Par contre, à 24 MHz, même en mettant une valeur de timer proche de la limite, par exemple 60 000, nous aurions une période de 0,4 milliseconde qui ne permettrait pas de voir la LED s'éteindre. TASSEL_1 remplace donc TASSEL_2, ce qui fait passer la fréquence à 32768. Si nous voulons une période à 1 seconde, nous mettrons donc la moitié de cette valeur, 16384 pour la période. Précision: ce n'est pas 16384 mais 16383 qui est effectivement utilisé. Le timer va donc compter de 0 à 16383, ce qui donnera une période de 16384. La polarité changera donc exactement 2 fois par seconde, ce qui donnera une période d'exactement une seconde.

--------------------

#include <msp430F5659.h>
#include "F5659Utils.h"

int main(void) {
    WDTCTL = WDTPW + WDTHOLD;               //    Stop WDT
    SetCoreVoltage(VCORE19);                //    Set the core to 1.9V
    SetFLL(24);                             //    Set SMCLK to 24 MHz
    P2DIR |= 0x03;                          //    P2.0 output + P2.1 output (oscillo)
    TA0CCTL0 = CCIE;                        //    CCR0 interrupt enabled
    TA0CCR0 = 16383;
    TA0CTL = TASSEL_1 + MC_1 + TACLR;       //    ACLK, upmode, clear TAR
    __bis_SR_register(LPM0_bits + GIE);     //    Enter LPM0, enable interrupts
}

// Timer0 A0 interrupt service routine
#pragma vector=TIMER0_A0_VECTOR
__interrupt void TIMER0_A0_ISR(void) {
    P2OUT |= 0x02;
    P2OUT ^= 0x01;                          // Toggle P2.0
    P2OUT &= ~0x02;
}

--------------------

L'image suivante montre le résultat. Le curseur b (valeur en haut à droite) montre une différence delta (b-a) qui est exactement 1 seconde.

AccurateClock

 

 

 

 

 

 

 

 

 

 

 

 

En partant d'un programme comme celui-ci il, il est donc possible de faire un programme avec un timing précis. En pilotant par exemple un moteur pas à pas, il serait par exemple possible de faire une horloge à aiguilles, relativement précise.

Comme nous le voyons, le programme est très simple. Il ne fait que configurer la fréquence d'horloge, après quoi il configure un timer et attend les interruptions.

Dans le tutoriel suivant, nous allons introduire une autre utilisation des timers: PWM (pour Pulse Width Modulation).

 

Téllécharger le programme

Un sommaire de ces prmiers programmes est téléchargeable en fichier zip ici.