LPC810, partie 9, comparateur analogique

Dans cet article je discute du comparateur analogique. Celui-ci possède une référence de voltage programmable sur 32 niveaux. Dans le démo j'utilise cette référence programmable pour créer un convertisseur analogique/numérique avec un résolution de 5 bits. Un potentiomètre est lu et sert à contrôler l'intensité d'une LED par PWM.

Le LPC810 possède 2 entrées analogiques, ACMP0_1 et ACMP0_2. L'entrée ACMP0_1 peut-être reliée à la broche 8 et l'entrée ACMP0_2 peut-être reliée à la broche 5. Cette liaison se fait par le registre LPC_SWM->PINENABLE0. Chacune de ces 2 entrées peut-être connectée soit à l'entrée positive, soit la négative du comparateur. C'est le registre LPC_CMP->CTRL qui sert à effectuer les branchements sur les entrées du comparateur. Dans le démo ci-bas, l'entrée ACMP0_1 est branchée sur l'entrée positive du comparateur. L'entrée négative du comparateur est reliée à la sortie de la référence de voltage programmable (Voltage ladder).

Un comparateur analogique fonctionne de la façon suivante, Il y a 2 entrées, une positive et l'autre négative. Lorsque le voltage sur l'entrée positive est plus élevé que celui sur l'entrée négative la sortie du comparateur est à 1 sinon elle est à 0. Le symbole d'un comparateur est le suivant:

Mais si les 2 voltages sont égaux? Les entrées des comparateurs sont conçues pour avoir ce qu'on appelle de l’hystérésis. L'idée est la suivante, supposons que l'entrée négative est branchée sur une référence de voltage fixe et que la positive est branchée sur un signal variable. Sitôt que l'entrée positive dépasse l'entrée négative la sortie du comparateur passe à 1. Mais à cause du bruit s'il n'y avait pas d'hystérésis la sortie pourrait commuter rapidement entre 0 et 1. Mais l'hystéris fait que l'entrée positive doit redescendre d'une certaine valeur avant que la sortie ne repasse à zéro. Le comparateur du LPC810 a une hystérésis programmable avec 4 valeurs possibles, 0mV, 5mV, 10mV et 20mV. Ces valeurs représentent la variation minimale de voltage entre les 2 entrées pour que la sortie commute à nouveau. Donc si on programme 20mV et que le voltage sur l'entrée positive monte jusqu'à ce que la sortie passe à 1. Ce voltage doit redescendre d'au moins 20mV avant que la sortie ne repasse à zéro.

Si le signal d'entrée est bruyant on utilise une hystérésis forte, s'il est propre on utilise une hystérésis faible. Dans le démo j'ai programmé l'hystérésis à 20mV. Mon calcul est le suivant, le potentiomètre est alimenté à 3 volts, 3/32 donne 94mV donc on peut utiliser l'hystérésis maximale sans perdre de résolution sur le potentiomètre tout en maximisant l'immunité aux interférences.

Un convertisseur A/N improvisé

Le LPC810 n'a pas de convertisseur A/N mais on peut en improviser un en utilisant le comparateur et la référence de voltage programmable. Ce convertisseur n'a qu'un résolution de 5 bits étant limité par la résolution du voltage ladder.

Voici comment fonctionne le convertisseur à 5 bits. On commence par programmer le voltage ladder à sa valeur médiane. Si la sortie du comparateur est à 1 c'est que le voltage sur l'entrée positive est supérieur à 1,5volt, sinon il est inférieur à cette valeur. On change la valeur de référence en fonction de l'état de sortie du comparateur. Si la sortie est à 1, on programme le voltage ladder à la position médiane entre 1,5 volts et 3 volts. Si la sortie du comparateur est à 0 on programme le voltage ladder à la position médiane entre 0 volt et 1,5 volts. On vérifie encore la sortie du comparateur et chaque fois que c'est à 1 on augmente le voltage du voltage ladder de la moitié de l'intervalle restant. Par cette division binaire de l'intervalle restant on obtient un résultat avec 5 comparaisons. Cette technique de conversion A/N s'appelle convertisseur à approximations successives. C'est le type de convertisseur le plus souvent utilisé sur les MCU. Le nombre de comparaisons nécessaires est le nombre de bits de résolution du convertisseur, 8,10 ou 12. Ce type de conversion est plus rapide que le sigma-delta ou les convertisseurs à pente.

Schématique du montage

Code source du démo

utilisation des resssources

• La LED est branchée sur PIO0_2 (broche 4).
• Le bras mobile du potentiomètre est branché sur PIO0_0 (broche 8) qui est utilisé en mode analogique.
• Le canal 1 du MRT (Multi Rate Timer) est utilisé pour générer une interruption 50 fois par seconde.
• Le module SCT est utilisé pour générer un signal PWM dont le rapport cyclique est contrôlé par le potentiomètre. La sortie COUT0 du SCT est reliée à PIO0_2 et contrôle l'intensité de la LED.
• Le comparateur analogique avec la référence programmable est utilisé comme convertisseur A/N à 5 bits pour lire le potentiomètre.

/* * hardware.h * * Created on: 2014-06-18 * Author: Jacques */ #ifndef LPC810_H_ #define LPC810_H_ #include <LPC8xx.h> #define LED (2u) // sortie LED PIO0_2 #define POT (0u) // entrée potentiomètre PIO0_0 #define delay_us(n) {int i; for(i=(n*USEC)>>3;i;i--)asm("nop\n nop\n nop\n nop");} #define m_set_output_pin(bit) LPC_GPIO_PORT->DIR0|=(bit) #define SYS_CLOCK (12000000UL) // fréquence SYS_CLOCK 30Mhz #define MSEC (SYS_CLOCK/1000) // Tcy/milliseconde #define USEC (SYS_CLOCK/1000000) // Tcy/µsec // bits dans PINENABLE0 #define DIS_ACMP_I1 (1<<0) // analog compare input 1 on PIO0_0 #define DIS_ACMP_I2 (1<<1) // analog compare input 2 on PIO0_1 #define DIS_SWCLK (1<<2) // single wire debug clock on PIO0_3 #define DIS_SWDIO (1<<3) // single wire debug data i/o on PIO0_2 #define DIS_XTALIN (1<<4) // disable crystal in on PIO0_8 #define DIS_XTALOUT (1<<5) // disable crystal out on PIO0_9 #define DIS_RESET (1<<6) // disable reset on PIO0_5 #define DIS_CLKIN (1<<7) // disable clkin on PIO0_1 #define DIS_VDDCMP (1<<8) // disable Vdd compare on PIO0_6 #define m_disable_pin(pins) LPC_SWM->PINENABLE0 |= (pins) // bits dans SYSAHBCLKCTRL #define CLK_SYS (1<<0) #define CLK_ROM (1<<1) #define CLK_RAM (1<<2) #define CLCK_FLASHREG (1<<3) #define CLK_FLASH (1<<4) #define CLCK_I2C (1<<5) #define CLK_GPIO (1<<6) // bit activation signal clock sur GPIO L #define CLK_SWM (1<<7) #define CLK_SCT (1<<8) // bit activation signal clocks ur SCT #define CLK_WKT (1<<9) #define CLK_MRT (1<<10) // bit activation MRT #define CLK_SPI0 (1<<11) #define CLK_SPI1 (1<<12) #define CLK_CRC (1<<13) #define CLK_UART0 (1<<14) #define CLK_UART1 (1<<15) #define CLK_UART2 (1<<16) #define CLK_WWDT (1<<17) #define CLK_IOCON (1<<18) #define CLK_ACMP (1<<19) // activation AHBCLK sur SWM #define m_swmclk_enable() LPC_SYSCON->SYSAHBCLKCTRL |= (CLK_SWM) // désactivation AHBCLK sur SWM #define m_swmclk_disable() LPC_SYSCON->SYSAHBCLKCTRL &= (~CLK_SWM) // activation du signal clock pour les périphériques utilisés #define m_periph_clock_enable(peripherals) LPC_SYSCON->SYSAHBCLKCTRL |= (peripherals) // désactivation du signal clock pour sur les périphériques sélectionnés #define m_periph_clock_disable(peripherals) LPC_SYSCON->SYSAHBCLKCTRL &= ~(peripherals) // bits dans PRESETCTRL #define RESET_SPI0 (1<<0) #define RESET_SPI1 (1<<1) #define RESET_UARTFRG (1<<2) #define RESET_UART0 (1<<3) #define RESET_UART1 (1<<4) #define RESET_UART2 (1<<5) #define RESET_I2C (1<<6) #define RESET_MRT (1<<7) #define RESET_SCT (1<<8) #define RESET_WKT (1<<9) #define RESET_GPIO (1<<10) #define RESET_FLASH (1<<11) #define RESET_ACMP (1<<12) // réinitialise les périphériques #define m_periph_reset(peripheral) {LPC_SYSCON->PRESETCTRL &=~(peripheral);LPC_SYSCON->PRESETCTRL |= (peripheral);} #endif /* LPC810_H_ */

/* =============================================================================== Name : main.c Author : $(author) Version : Copyright : $(copyright) Description : démonstration de l'utilisation du comparateur analogique la référence de voltage à 32 niveaux est utilisée en conjonction avec le comparateur analogique pour créé un convertisseur A/N de 5 bits Le potientiomètre est branché sur ACMP0_I1 La lecture du potentiomètre sert à contrôler l'intensité de la LED branchée sur PIO0_2. Le périphérique SCT est utilisé pour générer un signal PWM pour contrôler l'intensité de la LED. le MCU est en mode sleep et s'éveille 50 fois par secondes pour faire la lecture du potentiomètre. =============================================================================== */ #ifdef __USE_CMSIS #include "LPC8xx.h" #endif #include <cr_section_macros.h> #include "hardware.h" /* * utilisation du comparateur analogique avec la référence de * voltage à 32 niveaux pour créer un convertisseur A/N à 5 bits * la lecture se fait par approximation successive en divisant * l'intervalle en 2 à chaque test. Cette division binaire * permet d'obtenir un résultat en 5 comparaisons. */ int read_pot(){ int min,max,test,count,last,current; min=0; max=31; test=15; while ((test<max) && (test>min)){ LPC_CMP->LAD&=~(1|(31<<1u)); LPC_CMP->LAD|=1|(test<<1u); // délais pour laisser le temps à la nouvelle valeur de se stabiliser. delay_us(5); count=0; last=1; while (count<5){ current=LPC_CMP->CTRL&(1u<<21u); if (current==last){ count++; }else{ last=current; count=0; } delay_us(1); } if (last){ min=test; test=test+((max-test)>>1); }else{ max=test; test=test-((test-min)>>1); } } return test; }//f() // lecture du potentiomètre // recharge du registre MATCHREL // avec la valeur lue. // le facteur 1875 correspond au // compte du registre MATCH[0]/32 void MRT_IRQHandler(){ if (LPC_MRT->Channel[1].STAT&1){ LPC_SCT->MATCHREL[1].L=read_pot()*1875; LPC_MRT->Channel[1].STAT=1; } }//SCT_IRQHandler // configuration du SCT pour produire le PWM 16 bits qui contrôle la LED void config_pwm(){ LPC_SCT->CONFIG = (1u<<17); // compteur 16 autolimit sur MATH[0].L LPC_SCT->STATE_L=0; // état machine reste à zéro LPC_SCT->REGMODE_L=0; // mode match. LPC_SCT->MATCH[0].L = (SYS_CLOCK/200); // fréquence 200Hz LPC_SCT->MATCHREL[0].L=(SYS_CLOCK/200); LPC_SCT->MATCH[1].L = (SYS_CLOCK/200>>1); // rapport cyclique 50% LPC_SCT->MATCHREL[1].L=(SYS_CLOCK/200>>1); // événement 0 allume la LED LPC_SCT->EVENT[0].CTRL=(1u<<5)|(1u<<12); //contrôle CTOUT_0, condition CTR_L==MATCH[0].L LPC_SCT->EVENT[0].STATE=(1u<<0); // événement actif lorsque STATE_L==0 LPC_SCT->OUT[0].SET=(1u<<0); // contrôlé par événement 0 // événement 1 éteint la LED LPC_SCT->EVENT[1].CTRL=1u|(1u<<5)|(1u<<12); // contrôle CTOUT_0, condition CTR_L==MATCH[1].L LPC_SCT->EVENT[1].STATE=(1u<<0); // événement actif lorsque STATE_L==0 LPC_SCT->OUT[0].CLR=(1u<<1); // contrôlé par événement 1 //démarre le PWM LPC_SCT->CTRL_L = (LPC_SCT->CTRL_L & ~(3u << 1))|(1u<<3); }//f() // Le ou les bits qui contrôle la fonction dans le registre sont indiqué // entre parenthèse dans le commentaire après le nom de la fonction. int main(void) { // activation du AHBCLK pour les périphériques SWM(7), ACMP(19), MRT(10) et SCT(8) m_periph_clock_enable(CLK_SWM|CLK_ACMP|CLK_MRT|CLK_SCT); // désactivation des fonctons SWCLK(2), SWDIO(3), CLKIN(7) LPC_SWM->PINENABLE0 |=(1u<<2)|(1u<<3)|(1u<<7); // réinitialise les périphériques MRT(7), SCT(8), ACMP(12) de l'état "RESET" m_periph_reset(RESET_MRT|RESET_SCT|RESET_ACMP); // branchement de l'entrée du comparateur ACMP0_I1(0) sur PIO0_0 LPC_SWM->PINENABLE0 &= ~(1u<<0); // COUT_0(31:24) sur PIO0_LED LPC_SWM->PINASSIGN6 = 0x00ffffff|(LED<<24); // désactivaton du AHBLCK sur SWM(7) m_swmclk_disable(); // activation activation du comparateur analogique (15) LPC_SYSCON->PDRUNCFG &= ~(1u<<15); // branchement de ACMP0_I1(10:8) sur l'entrée positive du comparateur //hystérésie du comparateur 20mV (26:25). LPC_CMP->CTRL=(1u<<8)|(3u<<25); // activation de la référence de voltage programmable 32 niveaux, LADEN(0) LPC_CMP->LAD |=1u; // contrôle de l'intensité de la LED par PWM config_pwm(); // délais pour laisser le temps à la référence de voltage de se stabiliser. delay_us(200); // programmation du canal 1 du MRT pour delais lecture pot. LPC_MRT->Channel[1].CTRL=1u|(0u<<1); // mode "repeat interrupt" LPC_MRT->Channel[1].INTVAL=(SYS_CLOCK/50); // interruption 50 fois par seconde // configuration de l'interrption MRT // niveau de priorité 3 NVIC_SetPriority(MRT_IRQn,3); // plus basse priorité //activation de l'interrption MRT NVIC_EnableIRQ(MRT_IRQn); // au lieu d'utiliser une boucle while on met le MCU en mode SLEEP SCB->SCR |= (1u<<1); // retourne au mode SLEEP à la sortie de l'interruption __WFI(); // entre en mode sleep et attend pour une interruption. // si tout fonctionne comme prévu le programme ne devrait pas arrivé ici. return 0 ; }

C'est la fonction read_pot() qui implémente le convertisseur A/N. La fonction main() ne fait qu'initialiser les périphériques.

Une fois que le module SCT est configuré pour généner un signal PWM à une fréquence 200 hertz le MCU est mis en mode sleep. En mode sleep le PWM continu à fonctionner mais le core M0+ est arrêté. Le module MRT est utilisé pour générer une interruption 50 fois par seconde. Le gestionnaire d'interruption MRT_IRQHandler() fait une lecture du potientiomètre et ajuste le rapport cyclique du PWM en fonction de cette lecture. A la sortie du gestionnaire d'interruption le MCU retourne en mode sleep. l'instruction __WFI() est une macro pour l'instruction en assembleur wfi Wait For Interrupt. Cette instruction suspend le core jusqu'à ce qu'il y est une interruption.

---

Liens vers les articles précédents:

1. Introduction au LPC810 (ARM M0+)
2. LPC810, partie 2, anatomie
3. LPC810, création d'un projet
4. LPC810, partie 4, programmation
5. LPC810, partie 5, module SCT et PWM
6. LPC810, partie 8, pong