PIC micro Pascal, test #2

J'ai poursuivi mes expérimentations avec PMP. Cette fois ci j'ai repris le programme ambiance pingpong et j'ai retravaillé les versions assembleur et XC8 et créé une version avec PMP. Ces versions cible le PIC10F200 au lieu du PIC10F202, ce qui réduit la mémoire programme à un maigre 256 location et la RAM à 16 octets. J'ai commencé par la version en 'C' et j'ai vraiment du me creuser les méninges pour que ça rentre dans les 16 octets de RAM car le compilateur XC8 utilise plusieurs octets de RAM supplémentaires en plus de celle définis dans le code source. J'ai finalement réussi à faire entrer ça dans les 16 octets de RAM. Pour la mémoire FLASH il n'y a pas vraiment eu de problème. Dans cet article je présente donc les 3 versions de code, et je compare les ressources utilisées ainsi que la vitesse d'exécution.

Méthode de travail améliorée

Finalement j'ai découverts la méthode la plus pratique pour travailler avec PMP en utilisant MPLABX pour la programmation du MCU. Dans MPLABX je crée un projet et j'importe le fichier assembleur généré par PMP. Chaque fois que PMP recompile le nouveau fichier assembleur ce dernier est automatiquement disponible dans le projet MPLABX et je n'ai qu'à cliquer sur le bouton "Make and program device" dans la barre d'outil de MPLABX pour reprogrammer le MCU. C'est en fait plus simple que d'utiliser le programme PICKIT 2 programmer et ce n'est pas limité au MCU supportés par le PICKIT 2.

Comparaison des ressources

Voici un tableau comparatif des ressources utilisées par chaque version du programme. Boucle/min. est le nombre de fois que la boucle principale du programme s'exécute pendant la minute d'activité. Sans surprise le code assembleur est beaucoup plus rapide.

version	assembleur	C (XC8 free)	PIC micro Pascal
RAM	11	16	15
FLASH	101	164	162
boucles/min.	9015	6000	5000

Il semble que les résultats pour XC8 et PMP soient très semblable mais en fait le code assembleur généré par PMP serais de 150 instructions et la RAM utilisée serait de 14 octets si ce n'était pas d'un bug dans la version 2.0.6B du compilateur. le code original de transition était: procedure transition; begin tr_cmpl := 1; if (rnd[red] <> rgb[red]) then begin tr_cmpl := 0; if (rnd[red] > rgb[red]) then inc(rgb[red]) else dec(rgb[red]); end; if (rnd[green] <> rgb[green]) then begin tr_cmpl := 0; if (rnd[green] > rgb[green]) then inc(rgb[green]) else dec(rgb[green]); end; if (rnd[blue] <> rgb[blue]) then begin tr_cmpl := 0; if (rnd[blue] > rgb[blue]) then inc(rgb[blue]) else dec(rgb[blue]); end; end; {transition} Lorsque le bug sera corrigé dans la version finale de PMP 2.0.6 cette version pourra être utilisée. Pour le moment lorsqu'on passe l'élément d'un tableau aux procédures inc() et dec() c'est toujours le premier élément qui est modifié.

Vitesse d'exécution

Si on regarde le code source, on se rends compte que le gros du temps processeur est passé dans la procédure pwm_control. donc plus cette procédure est courte plus la boucle PWM sera rapide. Pour la version écrite en assembleur cette procédure utilise 17 instructions, celle en C est de 28 instructions et finalement pour celle écrite en Pascal est de 32 instructions. Donc même si au total PMP génère un code légèrement plus court que XC8 ce n'est pas le cas pour la procédure pwm_control ce qui explique qu'en terme de vitesse d'exécution ce code est le plus lent des 3.

Code source des 3 version

La constante EXPIRE est choisie en fonction de la vitesse d'exécution de chaque version pour une durée d'activité de 60 secondes. En première approximation EXPIRE = 60/PWM_PERIOD. La période PWM est elle-même en première approximation

PWM_PERIOD= 256*N*Tcy
Tcy = 1µsec
N ~=nombre d'instructions dans la routine pwm_control+
    nombre d'instructions supplémentaires dans la boucle
    lorsque pwm_cntr<>0.

Pour chaque version j'ai chronométrée la durée d'activité et recalculé la valeur de EXPIRE et chronométré à nouveau avec la valeur calculée pour m'assurer d'une activité de 60 secondes.

Code source version assembleur

; NOM: PingPongMood ; AUTEUR: Jacques Deschênes ; DATE: 2012-10-09 ; lumière d'ambiance dans un balle de pingpong ; elle fonctionne avec 3 piles LR45 ; elle arrête de fonctionner au bout d'une minute pour économiser les piles ; Il suffit de bouger la balle pour qu'elle reparte. ; ; DATE: 2015-01-15, modifié pour PIC10F200 ; #include <P10F200.INC> __CONFIG _WDTE_OFF & _CP_OFF & _MCLRE_OFF radix dec ;;;;;;;;;;;; macros pré-processor ;;;;;;;;;;;;;;; #define RED GPIO, GP0 #define GREEN GPIO, GP1 #define BLUE GPIO, GP2 #define TILT GPIO, GP3 ;;;;;;;;;;;; constantes ;;;;;;;;;;;;;;;;;;;;;;;;;;; MIN_RAM EQU 16 ; première adresse mémoire RAM TRIS_CONF EQU B'1000' ; GP0,GP1,GP2 en sortie RND_XOR_MASK EQU 0xE1 ; masque xor pour le générateur pseudo hasard. EXPIRE EQU 9015 ; environ 60 secondes pour boucle main de 24µsec*256 F_TR_CMPL EQU 0 ; transition complétée F_TR_DLY EQU 1 ; délais de transition ;;;;;;;;;;;;; variables ;;;;;;;;;;;;;;;;;;;;;;;;;;;;; variables udata MIN_RAM flags res 1 pwm_cntr res 1 rnd res 3 ; registre de déclage utilisé par le générateur PRG pwm_red res 1 ; pwm_green res 1 pwm_blue res 1 off_timer res 2 ; minuterie de mise en veille rgb res 1 org 0 goto init ;;;;;;;;;;;;; sous routines ;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;; random ;;;;;;;;;;;;;;;;;;;;;;;; ;; générateur de pseudo hasard utilisant la technique linear feedback shift register ;; REF: http://en.wikipedia.org/wiki/Linear_feedback_shift_register ;; variables: ;; rand est le registre à décalage 24 bits ;; temps d'exécution maximum 10Tcy ;; 10 tcy random bcf STATUS, C rrf rnd+2,F rrf rnd+1,F rrf rnd,F btfss STATUS , C return movlw RND_XOR_MASK xorwf rnd+2, F return ;;;;;;;;;; transition ;;;;;;;;;;;;;;;;;;;;;; ; transition graduelle vers la nouvelle couleur ; 31 tcy transition bsf flags, F_TR_CMPL movfw rnd subwf pwm_red, W skpnz goto green_transition bcf flags, F_TR_CMPL skpnc goto dec_red incf pwm_red, F goto green_transition dec_red decf pwm_red, F green_transition movfw rnd+1 subwf pwm_green, W skpnz goto blue_transition bcf flags, F_TR_CMPL skpnc goto dec_green incf pwm_green, F goto blue_transition dec_green decf pwm_green, F blue_transition movfw rnd+2 subwf pwm_blue, W skpnz return bcf flags, F_TR_CMPL skpnc goto dec_blue incf pwm_blue, F return dec_blue decf pwm_blue, F return ;;;;;;;;;;;;; pwm_control ;;;;;;;;;;;;;;;;; ; contrôle la modulation d'impulsion pour les DEL. ; 18 tcy pwm_control incf pwm_cntr, F clrf rgb movfw pwm_red subwf pwm_cntr,W btfss STATUS, C bsf rgb, 0 movfw pwm_green subwf pwm_cntr, W btfss STATUS, C bsf rgb,1 movfw pwm_blue subwf pwm_cntr, W btfss STATUS, C bsf rgb,2 movfw rgb movwf GPIO return ;;;;;;;;;;;;; check_timer ;;;;;;;;;;;;;;;;;;; ; vérifie si le temps est expiré, si c'est le cas met le MCU en mode sleep check_off_timer movf off_timer,F skpnz decf off_timer+1,F skpz decf off_timer,F movfw off_timer skpnz xorwf off_timer+1,W skpz return enter_sleep clrf GPIO sleep ;;;;;;;;;;;;; initialisation MCU ;;;;;;;;;;;;;;;;;;;;; init movlw (3<<6) option movlw TRIS_CONF tris GPIO movlw 0x80 xorwf rnd ; on s'assure que rnd n'est jamais nul. clrf flags call random ;initialisation off_timer movlw LOW EXPIRE movwf off_timer movlw HIGH EXPIRE movwf off_timer+1 clrf pwm_control ;;;;;;;;;;;;; boucle principale ;;;;;;;;;;;;;;;;;;; main_loop call pwm_control movf pwm_cntr, W skpz goto main_loop ; boucle de 24 Tcy call check_off_timer movlw 1<<F_TR_DLY xorwf flags, F btfsc flags, F_TR_DLY call transition btfss flags, F_TR_CMPL goto main_loop bcf flags, F_TR_CMPL call random goto main_loop end

Code source version C

/* * File: pingPong2.c * Author: Jacques Deschênes * * Created on 13 janvier 2015, 15:17 */ #include <pic10f200.h> #pragma config MCLRE=OFF, CP=OFF, WDTE=OFF //NOTE: les types 'short long' et 'unsigned short long' sont de 24 bits // variables unsigned char pwm_cntr, // compteur PWM pwm_red, // rapport cyclique composante rouge pwm_green, // rapport cyclique composante verte pwm_blue; // rapport cyclique composante bleue union { unsigned short long rnd24; struct{ unsigned char b1; unsigned char b2; unsigned char b3; }; } rnd = 0x800000; // variables booléennes typedef struct { unsigned char leds:3; unsigned char tr_cmpl: 1; // transition complétée unsigned char tr_dly: 1; // délais de transition } flags_t; flags_t flags; // constantes #define TMR0_LIMIT 10 #define EXPIRE 6000U // 60sec cycle 100Hertz #define LFSR_MASK 0xE1 // pseudo générateur de hazard 24 bits // utilise la variable rnd void random(){ unsigned char temp; temp = rnd.rnd24 & 0x1; rnd.rnd24 >>= 1; if (temp) rnd.b3 ^=LFSR_MASK; } // gère la transistion progressive d'une couleur // à l'autre void transition(){ flags.tr_cmpl = 1; if (rnd.b1 != pwm_red){ flags.tr_cmpl = 0; if (rnd.b1 > pwm_red) pwm_red++; else pwm_red--; } if (rnd.b2 != pwm_green){ flags.tr_cmpl = 0; if (rnd.b2 > pwm_green) pwm_green++; else pwm_green--; } if (rnd.b3 != pwm_blue){ flags.tr_cmpl = 0; if (rnd.b3 > pwm_blue) pwm_blue++; else pwm_blue--; } } // génère le signal PWM qui cnotrôle la DEL RGB void pwm_control(){ pwm_cntr++; flags.leds=0; if (pwm_cntr < pwm_red) flags.leds |= 1; if (pwm_cntr < pwm_green) flags.leds |= 2; if (pwm_cntr < pwm_blue) flags.leds |= 4; GPIO = flags.leds; } void main(){ unsigned short off_timer; // délais de mise en sommeil. OPTION = (3<<6); GPIO = 0; TRIS = 0; rnd.b3 |= 0x80; // rnd ne dois jamais être à zéro. flags.tr_dly=0; random(); off_timer=EXPIRE; while (1){ pwm_control(); if (!pwm_cntr){ off_timer--; if (!off_timer){ GPIO = 0; asm("sleep"); } flags.tr_dly ^= 1; if (flags.tr_dly){ transition(); if (flags.tr_cmpl){ flags.tr_cmpl=0; random(); } } } }//while }//main()

Code source version Pascal

{ NOM: Ambiance pingpong AUTEUR: Jacques Deschênes DATE: 2015-01-15 DESCRIPTION: modulation d'une LED RGB au hasard utilisant un PIC10F200. } program PingPong; // Ambiance Pingpong // constantes const TMR0_LIMIT= 10; EXPIRE = 5000; { 60sec cycle PWM dure 12msec} LFSR_MASK = 0xE1; type color=(red,green,blue); var // variables pwm_cntr:byte; // compteur PWM rgb:array[color] of byte; rnd: array[color] of byte; leds: byte; tr_cmpl:boolean; tr_dly: boolean; off_timer:WORD; // délais de mise en sommeil. // pseudo générateur de hazard 24 bits // utilise la variable rnd procedure random; begin if shrb(rnd) then rnd[blue] := rnd[blue] xor LFSR_MASK; end; {random} // gère la transistion progressive d'une couleur // à l'autre procedure transition; var temp:byte; begin tr_cmpl := true; if rnd[red] <> rgb[red] then begin tr_cmpl := false; temp:=rgb[red]; if rnd[red] > temp then inc(temp) else dec(temp); rgb[red]:=temp; end; if rnd[green] <> rgb[green] then begin tr_cmpl := false; temp:=rgb[green]; if (rnd[green] > temp) then inc(temp) else dec(temp); rgb[green]:=temp; end; if rnd[blue] <> rgb[blue] then begin tr_cmpl := false; temp:=rgb[blue]; if rnd[blue] > temp then inc(temp) else dec(temp); rgb[blue]:=temp; end; end; {transition} // génère le signal PWM qui cnotrôle la DEL RGB procedure pwm_control; begin inc(pwm_cntr); leds:=0; if (pwm_cntr < rgb[red]) then leds := leds or 1; if (pwm_cntr < rgb[green]) then leds := leds OR 2; if (pwm_cntr < rgb[blue]) then leds := leds or 4; GPIO := leds; end; {pwm_control} begin OPTION(64+128); GPIO := 0; TRIS(GPIO,0); rnd[blue]:=rnd[blue] or 0x80; tr_dly:=false; random; off_timer:=EXPIRE; repeat pwm_control; if (pwm_cntr=0)then begin dec(off_timer); if (off_timer=0) then begin GPIO := 0; asm sleep; end; end; tr_dly := not tr_dly; if (tr_dly) then begin transition; if (tr_cmpl) then begin tr_cmpl:=false; random; end; end; end; until FALSE; end. { program }