introduction aux MCU ATtiny, partie 4

Aujourd'hui je me suis un peut amusé dans l'électronique analogique car j'ai décidé que j'avais besoin d'un petit ampli audio pour la suite de ces chroniques car en plus d'une pulsation 3Hz j'ai ajouter une alarme audio double tonalité pour accompagner cette alarme visuelle. Voici le schéma de l'ampli.

L'entrée de l'ampli est branché sur la broche PORTB1. Même avec la résistance de 22K à l'entrée le son est suffisamment fort pour être entendu à la grandeur de la maison.

Interruption

L'un des concepts important de la programmation système et qu'il faut apprendre très tôt est celui d'interruption et c'est ce que nous allons étudier dans cette chronique.

Les micro-contrôleurs doivent répondrent à des événements extérieurs qui ne sont pas synchronisés avec leur horloge interne, donc qui peuvent survenir à n'importe quel moment dans l'exécution du programme. Il y a deux façon de répondre à ces événements, la première consiste à lire à intervalle régulier les entrées pour savoir quand l'une d'elle a changé d'état. C'est ce que fait la routine attend_pression_bouton présenté dans les chroniques précédentes. Mais cette façon de faire n'est pas très pratique pour plusieurs raisons. Premièrement elle demande beaucoup de temps CPU, temps pendant lequel les autres tâches sont misent en attendent. Si l'événement externe requiert une réponse rapide il faut vérifier l'entrée le plus fréquemment possible ce qui diminu d'autant le temps disponible pour les autres tâches. Cette technique dites de poling n'est vraiment pas efficace. Dans nos exemples précédent ça n'avait pas d'importance puisque le MCU n'avait aucune tâche à accomplir en attendant que le bouton soit enfoncé. Mais le plus souvent le MCU a plusieurs tâches concurrentes à accomplir et doit partager son temps le plus efficacement entre celles-ci.

C'est dans ces situations qu'on a besoin des interruptions. Une interruption comme son nom l'indique est un mécanisme par lequel le déroulement d'un programme est interrompu pour répondre à un événement qui s'est produit. Les sources d'interruptions peuvent-être interne ou externe. Par exemple une minuterie interne au MCU peut déclencher une interruption lorsqu'elle expire. Mais une interruption peut aussi être déclenchée lorsqu'une broche d'entrée a changée d'état, il s'agit alors d'un événement externe.

Dans un cas comme dans l'autre le MCU doit interrompre ce qu'il est en train de faire pour réponde à l'interruption. Les interruptions sont répondues par des routines spécifiques qui ne s'éxécutent pas dans le déroulement normal du programme mais seulement lorsqu'un événement qui les concernes c'est produit. On les appelle sans surprise les routines de service d'interruption, en anglais interrupt service routine, abrégé ISR.

Donc une interruption se produit et le MCU interrompt l'exécution normmale du programme. Mais ça ne peut se faire n'importe comment. D'abord il faut converser la valeur du pointeur d'instruction car lorsque l'ISR sera répondue il faudra revenir à l'endroit où le programme était rendu avant l'interruption. De plus tous les registres utilisés par la routine d'interruption doivent-être préservés. Toutes ces donnés sont conservées sur la pile. La même pile qui est utlisée pour conserver les adresses de retour lorqu'une qu'une sous-routine est appellée.

Ce n'est pas tout, le MCU doit savoir où se trouve la routine qui sert tel ou tel interruption. C'est le rôle de la table des vecteurs d'interruptions. Pour les MCU ATtiny cette table se trouve à l'adresse zéro de la mémoire programme. Chaque source d'interruption a un numéro qui correspond à un index dans cette table. Et le vecteur lui-même dans cette table est simplement une instruction de saut vers l'ISR requise. Pour le code d'aujourd'hui j'ai créé une ISR pour répondre au débordement du compteur TCNT0. Chaque fois que ce compteur retombe de 255 à 0 l'interruption no. 3 est déclenchée. voici de quoi à l'air la table des vecteurs et le code assembleur de la routine ISR.
00000000 <__vectors>: 0: 09 c0 rjmp .+18 ; 0x14 <__ctors_end> 2: 21 c0 rjmp .+66 ; 0x46 <__bad_interrupt> 4: 20 c0 rjmp .+64 ; 0x46 <__bad_interrupt> 6: 2b c0 rjmp .+86 ; 0x5e <__vector_3> 8: 1e c0 rjmp .+60 ; 0x46 <__bad_interrupt> a: 1d c0 rjmp .+58 ; 0x46 <__bad_interrupt> c: 1c c0 rjmp .+56 ; 0x46 <__bad_interrupt> e: 1b c0 rjmp .+54 ; 0x46 <__bad_interrupt> 10: 1a c0 rjmp .+52 ; 0x46 <__bad_interrupt> 12: 19 c0 rjmp .+50 ; 0x46 <__bad_interrupt> 0000005e <__vector_3>: 5e: 1f 92 push r1 60: 0f 92 push r0 62: 0f b6 in r0, 0x3f ; 63 64: 0f 92 push r0 66: 11 24 eor r1, r1 68: 8f 93 push r24 6a: 9f 93 push r25 6c: 80 91 60 00 lds r24, 0x0060 70: 91 e0 ldi r25, 0x01 ; 1 72: 89 27 eor r24, r25 74: 80 93 60 00 sts 0x0060, r24 78: 9f 91 pop r25 7a: 8f 91 pop r24 7c: 0f 90 pop r0 7e: 0f be out 0x3f, r0 ; 63 80: 0f 90 pop r0 82: 1f 90 pop r1 84: 18 95 reti
Comme on peut le voir l'entrée 3 de la table contient une instruction rjmp .+86 qui conduit à l'adresse effective 0x5e qui est le début de l'ISR pour l'overflow du timer0, c'est à dire du compteur TCNT0. Si on examine cette routine on constate que les premières instructions push consiste en l'empilement des registres r0 et r1. L'ISR va se servir de ces 2 registres donc elle en préserve le contenu en l'envoyant sur la pile et va les restaurer avant de quitter avec les instructions pop. Cette routine est très longue et pourtant elle ne fait que basculer la valeur d'une variable (adresses 0x6c à 0x74). Il n'y a que 4 instructions pour le code effectif toutes les autres ne servent qu'à préserver et restaurer le contexte du progamme qui a été interrompu.

On va maintenant regarder comment on cré une interruption en 'C'.
/* * Intro_AtTiny.c * * Created: 2013-01-05 22:13:50 * Author: Jacques * Description: introduction aux MCU ATtiny * étape 1: allumer/éteindre un LED avec un bouton momentané. */ #define F_CPU 9600000UL // CPU à la fréquence maximale de l'oscillateur interne soit 9.6Mhz #include <avr/io.h> #include <util/delay.h> #include <avr/interrupt.h> // tout ne peut pas être fait en C alors on utilise des macros avec directive asm #define disable_interrupt asm("cli") #define enable_interrupt asm("sei") #define watchdog_reset asm("wdr") // définition est E/S #define BOUTON PORTB3 // bit 3 du PORTB entrée bouton #define LED PORTB0 // bit 0 du PORTB sortie LED #define AUDIO PORTB1 // bit 1 du PORTB sortie audio // délais pour l'anti-rebond 20msec. #define ANTI_REBOND 20 #define DELAIS_3HZ 1000 // délais tonalités #define TONE_500HZ 62 #define TONE_750HZ 42 #define LED_ETEINT 0 #define LED_MAX 255 // pré-scale pour le timer Fosc/256 #define PS_256 (1<<CS02) #define PS_1024 ((1<<CS02) | (1<<CS00) | (1<<WGM02)) // configuration pour le mode fast pwm 3 #define FAST_PWM3_A ((1<<COM0A1) | (1<<WGM01) | (1<<WGM00)) // configuration pour le mode FAST_PWM2, basculement sortie (toggle) #define FAST_PWM2_A ((1<<COM0A0) | (1<<WGM01) | (1<<WGM00)) //diviseur fréquence Fosc #define FOSC_MAX 0 #define FOSC_600KHZ 4 void WDT_off(void) // emprunté tel quel au datasheet de l'ATtiny13A, j'ai juste remplacé les macros { disable_interrupt; watchdog_reset; /* Clear WDRF in MCUSR */ MCUSR &= ~(1<<WDRF); /* Write logical one to WDCE and WDE */ /* Keep old prescaler setting to prevent unintentional time-out */ WDTCR |= (1<<WDCE) | (1<<WDE); /* Turn off WDT */ WDTCR = 0x00; enable_interrupt; } uint8_t bascule_tone=0; // variable indiquant la fréquence de la tonalité. ISR(TIM0_OVF_vect){ // routine de service pour les interruption sur débordement TCNT0 bascule_tone ^= 1; } int attend_pression_bouton(){ // lecture du bouton avec anti-rebond. Attend que le bouton soit relâché avant de sortir. unsigned int count; count=0; while (count<ANTI_REBOND){ // attend que le bouton soit enfoncé if ((PINB & 1<<BOUTON)==0){ count++; } else{ if (count>0) count--; } _delay_ms(1); } count = 0; while ((count <= DELAIS_3HZ) && ((PINB & 1<<BOUTON)==0)){// attend que le bouton soit relâché count++; _delay_ms(1); } _delay_ms(ANTI_REBOND); return count; } void alarme(){ PORTB|= (1<<AUDIO); if (bascule_tone) _delay_us(TONE_500HZ); else _delay_us(TONE_750HZ); PORTB&=(0XFF - (1<<AUDIO)); if (bascule_tone) _delay_us(TONE_500HZ); else _delay_us(TONE_750HZ); return; } int main(void) { WDT_off(); //désactivation du watch dog timer. enable_interrupt; CLKPR= (1<<CLKPCE); // permet la modification du pre-scale CLKPR = 0 ; // pre-scale mise à zéro. Le MCU fonctionne à la fréquence maximale. DDRB |= (1<<LED | 1<<AUDIO); // met PORTB0 et PORTB1 en sortie DDRB &= (0xFF - (1<<BOUTON)); // met broche BOUTON en entrée PORTB |= (1<<BOUTON); //active le pullup PORTB &= (0xFF - (1<<LED)); // eteint le LED OCR0A=LED_ETEINT; // contrôle de l'intensité de la LED uint8_t rapport_cyclique=0; uint8_t tone_count; unsigned int bouton_enfonce; //combien de msec le bouton est resté enfoncé. while (1) { bouton_enfonce=attend_pression_bouton(); if (bouton_enfonce>=DELAIS_3HZ){ // mode pulsation 3Hz CLKPR=(1<<CLKPCE); CLKPR=FOSC_600KHZ; OCR0A=96; TCCR0A=FAST_PWM2_A; TCCR0B=PS_1024; TIMSK0 |= 1<<TOIE0; // activation de l'interruption sur débordement TCNT0 while (((PINB & 1<<BOUTON)==0)){ alarme(); }; // on attend que le bouton soit relaché _delay_ms(1); // Fosc étant à 600Khz délais * 16 -> 16msec. while (((PINB & 1<<BOUTON)!=0)){ alarme(); }; // sortir de ce mode sitôt que bouton est enfoncé. TIMSK0 &= (0xFF - (1<<TOIE0)); // remettre l'horloge à sa vitesse maximale. CLKPR=(1<<CLKPCE); CLKPR=FOSC_MAX; TCCR0A=0; // désactivation PWM } else{ // mode normal ave contrôle d'intensité if (rapport_cyclique==LED_ETEINT){ rapport_cyclique=LED_MAX; // à ce point ci le PWM est désactivé. PORTB |= 1<<LED; // allume LED pleine intensitée. } else{ rapport_cyclique >>= 1; // diminue l'intensité de moitié. if (rapport_cyclique>15){ OCR0A=rapport_cyclique; TCCR0A=FAST_PWM3_A; // activation PWM TCCR0B=PS_256; } else{ rapport_cyclique=LED_ETEINT; TCCR0A=0; // désactivation PWM TCCR0B=0; PORTB &= (0xFF - (1<<LED)); //éteind LED } } } } } J'ai modifié plusieurs choses par rapport au code d'hier mais on va se concentrer sur la création de la routine de service d'interruption. J'avais besoin de cette routine car lorsque la lumière est en clignotement urgence 3HZ je l'accompagne d'un signal audio double tonalité, 500hz et 750hz. La fréquence bascule en même temps que l'état de la LED. Je devais donc savoir quand la LED change d'état. En mode 3Hz j'ai configuré le PWM en mode bascule. C'est à dire que la sortie change d'état à chaque fois que le comparateur confirme que OCR0A==TCNT0. De plus J'ai configuré le mode 7, c'est à dire que le compteur TCNT0 retombe à zéro en même temps qu'il atteint la valeur de OCR0A. Cette configuration me permet d'obtenir une onde carré à la sortie de PORTB0. Donc lorsque TCNT0 retombe à zéro l'interruption est déclenchée. Cette interruption ne fait que basculer l'indicateur booléen bascule_tone qui est utilisé par la routine alarme() et lui permet de savoir qu'elle fréquence faire entendre.

Si vous regardez au début du code j'ai ajouté la ligne #include <avr/interrupt.h>
Ce fichier défini les macros nécessaires à la création des routines d'interruptions. Plus bas vous apercevez la déclaration de la routine elle-même.
uint8_t bascule_tone=0; // variable indiquant la fréquence de la tonalité. ISR(TIM0_OVF_vect){ // routine de service pour les interruption sur débordement TCNT0 bascule_tone ^= 1; }
La macro ISR sert justement à déclarer les fonctions qui servent de routine de service d'interruption. En argument de la macro on donne un identifiant indiquant de qu'elle interruption il s'agit. Ces identifiants sont définis dans le fichier avr/io.h. Pour voir le contenu d'un fichier inclus, cliquez avec le bouton droit de la souris sur le fichier et choisissez l'item goto implementation dans le menu surgissant.

Comme vous le voyez cette ISR ne fait vraiment pas grand chose. En passant notez que la variable bascule_tone doit-être une variable globale pour être accessible aussi bien par l'ISR que par la fonction alarme().

Autre point à notez dans ce programme, c'est le changement de la fréquence de l'oscillateur système. Pour obtenir une fréquence suffisamment basse pour générer un PWM de 3HZ j'ai du diviser la fréquence de l'oscillateur par 16, ce qui fait que le core du MCU durant le mode alarme fonctionne à 600Khz au lieu de 9,6Mhz. J'en ai tenu compte lorsque j'appelle les fonctions _delay_ms() et _delay_us() en divisant les valeurs de délais par 16. La fréquence de l'oscillateur principal est remise à 9,6Mhz avant de quitter le mode alarme.

Voilà ce sera tout pour cette chronique. Le code prend maintenant 41% de l'espace programme. Et si on ajoutait une nouvelle fonction! Par exemple la lumière pourrait signaler un appel de détresse en envoyant le code morse international S.O.S.: ...---...