Oeuf lumineux

Un petit projet qui peut-être mis en œuvre rapidement pour faire la démonstration des possibilités du PIC12F1572. Comme c'est Pâques dimanche prochain un œuf lumineux comme décoration me paraissait pertinent, comme prétexte pour expérimenter avec ce MCU.

PIC12(L)F1572

Voilà un petit MCU disponible en format PDIP-8 qui possède 3 périphériques PWM avec une résolution maximale de 16 bits ce qui est plutôt rare sur les MCU 8 bits. Microchip a conçu ce MCU en pensant plus spécifiquement au contrôle de LED RGB. En effet on peut contrôler directement une LED RGB 20mA/couleur directement à partir des sorties du MCU et ce avec une résolution de 16 bits à une fréquence PWM de 488 hertz. Voici les principales caractéristiques de ce MCU.

• coeur midrange amélioré. 49 Instructions encodées sur 14 bits. Pile des retours de 16 niveaux manipulable à partir du programme.
• Mémoire programme de 2K instructions
• RAM de 256 octets
• 5 E/S RA0,RA1,RA2,RA4,RA5 et RA3 en entrée seulement
• 2 minuteries 8 bits et 4 minuteries 16 bits, 3 utilisées par les PWM
• 1 comparateur analogique
• 1 convertisseur A/N de 10 bits avec 4 entrées
• 1 convertisseur N/A de 5 bits
• 1 EUSART Extended Universal Asynchronous Receiver Transmitter
• 1 CWG générateur d'onde complémentaire
• 3 canaux PWM avec résolution de 16 bits avec compteurs indépendants.

Ce qui rend ce MCU intéressant ce sont ses 3 canaux PWM, le programme démo suivant montre l'utilisation la simple de ces PWM pour piloter une LED RGB. Mais ces canaux PWM ont des modes d'utilisation plus sophistiqués comme contrôle de la phase, synchronisation et impulsion unique.

Programme démo

Le montage est très simple et peut-être réalisé rapidement sur une plaquette de prototypage sans soudure.

code source

/* * File: OeufLumineux.c * Author: Jacques Deschênes * démo PIC12F1572 * contrôle d'une LED RGB avec 16 bits de résolution par couleur. * Created on 28 mars 2015, 13:31 */ #include <stdio.h> #include <stdlib.h> // PIC12F1572 Configuration Bit Settings // 'C' source line config statements #include <xc.h> // #pragma config statements should precede project file includes. // Use project enums instead of #define for ON and OFF. // CONFIG1 #pragma config FOSC = INTOSC // (ECH, External Clock, High Power Mode (4-32 MHz); device clock supplied to CLKIN pin) #pragma config WDTE = OFF // Watchdog Timer Enable (WDT disabled) #pragma config PWRTE = OFF // Power-up Timer Enable (PWRT disabled) #pragma config MCLRE = ON // MCLR Pin Function Select (MCLR/VPP pin function is MCLR) #pragma config CP = OFF // Flash Program Memory Code Protection (Program memory code protection is disabled) #pragma config BOREN = ON // Brown-out Reset Enable (Brown-out Reset enabled) #pragma config CLKOUTEN = OFF // Clock Out Enable (CLKOUT function is disabled. I/O or oscillator function on the CLKOUT pin) // CONFIG2 #pragma config WRT = OFF // Flash Memory Self-Write Protection (Write protection off) #pragma config PLLEN = ON // PLL Enable (4x PLL enabled) #pragma config STVREN = ON // Stack Overflow/Underflow Reset Enable (Stack Overflow or Underflow will cause a Reset) #pragma config BORV = LO // Brown-out Reset Voltage Selection (Brown-out Reset Voltage (Vbor), low trip point selected.) #pragma config LPBOREN = OFF // Low Power Brown-out Reset enable bit (LPBOR is disabled) #pragma config LVP = ON // Low-Voltage Programming Enable (Low-voltage programming enabled) // registre nombre aléatooire entier 32 bits non signé. unsigned long long rndseed; #define VDD 5 // si Vdd<4 volt #define VDD 3 //initialise le générateur hasard //avec 32 lectures de la sonde de //température interne void seed(){ int i; //configuration référence de voltage interne,activation sonde température #if VDD==5 FVRCON=(3<<4); // sonde active high range #else FVRCON=(1<<5); // sonde active low range #endif //sélection du canal d'entrée du convertisseur ADCON0=(0x1D<<2); // sonde température interne //ADCON1: sélection clock source, référence et alignement du résultat ADCON1= (1<<7)|(2<<4); ADCON2=0; //pas d'autoconversion // activation du convertisseur A/N ADCON0|=1; for (i=0;i<32;i++){ ADCON0|=2; //démarre convertion while (ADCON0&2); // attend fin conversion rndseed<<=1; rndseed|=(ADRESL&1)<<i;// bit moins significatif dans rndseed } //désactivation FVR FVRCON=0; //désaction convertisseur A/N ADCON0=0; }//f() unsigned random(){ int i; unsigned number=0; for (i=0;i<16;i++){ if (rndseed&1) rndseed++; rndseed*=3; rndseed>>=1; number<<=1; number |= rndseed&1; } return number; }//f() void delay_ms(unsigned msec){ // T1CON=(3<<4)+1; OPTION_REG=4; // prescale 1:32 TMR0=0; while (msec--){ TMR0+=5; INTCON &= ~(1<<2); while (!(INTCON&(1<<2))); } OPTION_REG=0; }//f() inline void delay_us(unsigned short usec){ if (!usec) return; OPTION_REG=2; //prescale 1:8 TMR0=256-usec; INTCON &= ~(1<<2); while (!(INTCON&(1<<2))); }//f() #define TRAN_DLY 5 // choix d'une nouvelle couleur au hazard // transition progressive vers la nouvelle couleur void transition(){ unsigned blue,green, red; char done=3; blue=random(); red=random(); green=random(); while (done){ done=3; if (blue==PWM1DC){ done--; }else{ if (blue<PWM1DC){ PWM1DC--; }else{ PWM1DC++; } } if (red==PWM2DC){ done--; }else{ if (red<PWM2DC){ PWM2DC--; }else{ PWM2DC++; } } if (green==PWM3DC){ done--; }else{ if (green<PWM3DC){ PWM3DC--; }else{ PWM3DC++; } } PWM1LDCON=128; PWM2LDCON=128; PWM3LDCON=128; delay_us(TRAN_DLY); } }//f() int main(void) { int i=1; char btn_down=0; unsigned dc1=0,dc2=0,dc3=0; OPTION_REG=0; ANSELA=0; OSCCON=(0xe<<3); // Fosc=8Mhz APFCON=3; //PWM1 on RA5, PWM2 on RA4 //configuration PWM1 LED bleu PWM1PH=0; PWM1PR=0xffff; PWM1CLKCON=0; PWM1CON= (3<<6)|(1<<4); //configuration PWM2 LED rouge PWM2PH=0; PWM2PR=0xffff; PWM2CLKCON=0; PWM2CON= (3<<6)|(1<<4); //configuration PWM3 LED verte PWM3PH=0; PWM3PR=0xffff; PWM3CLKCON=0; PWM3CON= (3<<6)|(1<<4); LATA = 0; TRISA &= ~((1<<2)|(1<<4)|(1<<5)); //RA2,RA4 et RA5 en sortie seed(); // initialise le générateur PRNG while (1){ transition(); delay_ms(10); } return (EXIT_SUCCESS); } Dans ce projet les 3 canaux PWM sont utilisés en mode standard. Dans ce mode le registre PWMxPH détermine quand l'impulsion commence et le registre PWMxDC quand elle se termine. La période est déterminée par le registre PWMxPR. Ici la lettre x représente le canal 1,2 ou 3, tous ces registres sont de 16 bits. On note que les registres PWMxPH sont mis à zéro donc l'impulsion commence dès que le compteur tombe à zéro. Lorsque le compteur arrive à la valeur du registre PWMxDC l'impulsion prend fin. Le cycle PWM se termine lorsque le compteur arrive à la valeur du registre PWMxPR. Les registres PWMxPR sont initialisés pour une période maximale soit à 65535 (0xffff) pour bénéficier de la résolution de 16 bits. Notez que les compteurs peuvent-être alimentés directement avec la fréquence Fosc au lieu de Fosc/4 comme c'est le cas pour les autres PIC12 et PIC16. Donc dans ce démo la fréquence PWM est de 32Mhz/65536 ce qui donne environ 488 hertz. Amplement suffisant pour éviter toute perception de scintillement.

Lorsque les 3 canaux PWM sont configurés le programme entre dans la boucle principale qui appelle successivement la fonction transition() et delay_ms(10) pour une brève pause entre chaque transition.

La fonction transition() choisie 3 nouvelles valeurs pour les composantes rouge,verte et bleue et ensuite emmène progressivement les registres PWMxDC à cette nouvelle valeur. Le résultat est une transition douce d'une couleur à l'autre ce qui est beaucoup plus agréable à l’œil qu'un changement brutal.

La fonction random() donne les nouvelles valeurs pour les composantes. J'ai découvert ce type de générateur aléatoire lors de ma lecture du livre de Stephen Wolfram, a new kind of science. le générateur utilise un entier non signé de 32 bits (unsigned long long). les règles sont les suivantes.

1. Si le nombre actuel est impaire il est incrémenté.
2. On multiplie ce nombre par 3.
3. On divise le résultat par 2 et on ne garde que le bit le moins significatif.
Le générateur produit des entiers de 16 bits donc pour chaque appel de random() les 3 étapes sont répétés 16 fois.

Vidéo démo

Ce projet est similaire à celui du projet ambiance pingpong mais ce MCU est nettement plus performant et permet une résolution PWM de 16 bits au lieu de 8 bits et une fréquence PWM plus de 4 fois supérieure. La coquille d’œuf diffuse la lumière de la LED beaucoup plus efficacement qu'une balle de pingpong. L'effet est plus agréable à l’œil que ce laisse entrevoir la vidéo qui n'a pas un bon rendu des couleurs.

conclusion

Je n'ai pas fait de montage permanent de ce projet mais le circuit incluant une pile au lithium de 3 volt CR2450 entrerais en entier dans la coquille. A 3 volt il faudrait diminuer la valeur des résistances pour conserver la même intensité.

On peut aussi expérimenter en changeant la valeur du délais dans la boucle principale et peut-être aussi introduire un délais de quelques microsecondes à l'intérieur de la boucle dans la fonction transition().