L'article précédent j'ai présenté un clap switch fait avec un pro trinket. Mais utilisé une carte qui coûte 10US$ pour faire ça c'est comme vouloir tuer une mouche avec un canon. J'ai fait un autre montage en remplacant le pro trinket par le plus petit des MCU, le PIC10F322 de Micrhochip.

schématique

Pour cette démonstration j'ai dessiné un circuit complet à l'usage de ceux qui voudraient réellement fabriquer la chose pour contrôler une lampe par exemple. Pour ma part je n'ai testé que la partie basse tension (microphone + MCU) en utilisant un LED à la place du relais.

L'entrée analogique est sur RA2 (broche 3 sur format PDIP) et la sortie de contrôle sur RA0 (broche 4 sur PDIP).

code source

Le code source a été écris en mpasm, il ne fait que 128 instructions et utilise 14 octets de RAM, il peut donc être fait avec un PIC10F320 (256i/32RAM). ; NOM: clap-switch ; AUTEUR: Jacques Deschênes ; DATE: 2014-12-16 ; DESCRIPTION: commutateur obéissant au son de 2 claquements de mains rapides ; servant à contrôler une lampe ou autre petit appareil. ; LICENCE: GPLV2 include p10f322.inc __config _WDTE_OFF & _FOSC_INTOSC ;----------- ; constantes ;----------- #define LED RA0 ; sortie de contrôle #define THRESHOLD D'80' ; seuil de détection #define MIN_WIDTH D'5' ; durée minimale #define MAX_WIDTH D'150' ; durée maximale d'un claquement. #define AUDIO_INPUT RA2 ; entrée audio ;----------- ; macros ;----------- ; allume LED ledOn macro bsf LATA, LED endm ; éteint LED ledOff macro bcf LATA, LED endm ; met valeur délais ; dans la variable msec ;setDelay macro n ; movlw n&H'FF' ; movwf msec ; movlw n>>8 ; movwf msec+1 ; endm ; w16=var16 movfw16 macro v16 movfw v16 movwf w16 movfw v16+1 movwf w16+1 endm ; w16=n movlw16 macro n movlw n&H'FF' movwf w16 movlw n>>8 movwf w16+1 endm ; v1=v2 movVar16 macro v1,v2 movfw v2 movwf v1 movfw v2+1 movwf v1+1 endm ; w16=w16-v subVar16 macro v movfw v subwf w16,F skpc decf w16+1,F movfw v+1 subwf w16+1,F endm ; w16=w16+v addVar16 macro v movfw v addwf w16,F skpnc incf w16+1,F movfw v+1 addwf w16+1,F endm ;---------- ; variables ;---------- udata H'40' ; minuterie incrémentée à chaque milliseconde, boucle en 65,536 secondes systick res 2 ; t0,t1 utilisées par main t0 res 2 t1 res 2 ; t3,t4 utilisées par waitClap t3 res 2 t4 res 2 ; msec utilisé par delay ;msec res 2 ; registre de travail 16 bits w16 res 2 ; variable temporaire 16 bits tmp res 2 ;---------- ; code ;---------- org 0 goto init ;ISR mise à jour minuterie système org 4 incf systick,F skpnz incf systick+1,F movlw D'5' addwf TMR0,F bcf INTCON, TMR0IF retfie ;delay: ;délais en millisecondes ; movf msec,F ; skpz ; goto $+4 ; movf msec+1,F ; skpnz ; return ; btfss systick,0 ; goto $-1 ; movlw 1 ; subwf msec,F ; skpc ; decf msec+1,F ; btfsc systick,0 ; goto $-1 ; goto delay ; lecture entrée audio analogRead: ; délais d'acquisition échantillon, 4 µsec. movlw 4 addlw 255 skpz goto $-2 ; conversion A/N bsf ADCON, GO_NOT_DONE btfsc ADCON, GO_NOT_DONE goto $-1 return ; attend un claquement de main waitClap: waitSilence: ; attend bruit de fond < THRESHOLD/2 call analogRead movlw THRESHOLD>>1 subwf ADRES,W skpnc goto waitSilence ; attend dépassement seuil de détection waitClapThreshold: call analogRead movlw THRESHOLD subwf ADRES, W skpc goto waitClapThreshold ;enregistre début événement dans t3 movVar16 t3,systick ;attend niveau redesdence sous 2/3 du niveau seuil détection waitClapDrop: call analogRead movlw THRESHOLD*2/3 ; subwf ADRES, W skpnc goto waitClapDrop movVar16 t4, systick ; fin de l'événement ;contrôle durée de l'événement ; durée minimale movlw16 MIN_WIDTH addVar16 t3 ;w16=t3+MIN_WICTH subVar16 t4 ; w16-t4 < 0 ? ok skpnc goto waitClap ; durée maximale movlw16 MAX_WIDTH ; contrôle durée maximale addVar16 t3 ; w16=t3+MAX_WIDTH subVar16 t4 ; w16-t4 > 0 ? ok skpc goto waitClap ; événement refusé, trop long. return ; évéenement accepté. ; inverse état sortie de contrôle toggleLed: movlw 1<<led xorwf lata f return initialisation mcu init: clrf clkrcon movlw b mhz movwf osccon bcf trisa bsf ansela adcon d tmr0 option_reg intcon tmr0ie gie ledoff boucle principale main: en attente de claquements call waitclap movvar16 t0 t3 temps premier claquement setdelay delay contr intervalle entre les doit- au plus seconde. movlw16 addvar16 subvar16 skpc goto main double-claquement refus trop long chaque claquement. toggleled inverse sortie led si systick approche bouclage on attend apr le subwf skpnc end></led>

idée à explorer

Une modification au logiciel permettrait d'utiliser ce circuit comme verrou électronique qui répondrait à un code rythme. Imaginez qu'on mesure le temps entre chaque claquement et qu'on utilise plusieurs clap on obtiendrais une séquence rythmique pouvant être utilisée comme clé pour dé/verrouiller une porte. Le micro serait collé sur la porte et analyserais les toc-toc au lieu des claquements de mains.

J'aime beaucoup le PIC10F322 car je ne connais aucun autre MCU de cette catégorie qui possède autant de fonctionnalités. Voici un exemple des possibilités offertes par ce MCU . Dans ce démo je fais varié l'intensité d'une LED sans utiliser le moindre cycle CPU en utilisant la richesse des périphériques du PIC10F322. En l'occurrence les périphériques suivants sont utilisés.

1. TIMER2
2. PWM1
3. NCO (Numerically Controlled Oscillator)
4. CLC (Configurable Logic Cell)

Dans ce vidéo on voie la LED pulsée ainsi qu'a l'oscilloscpoe l'onde en sortie PWM1 (tracé bleu) ainsi que l'onde rectangulaire qui alimente la LED (Tracé en jaune).

On voie que le rapport cyclique du signal varie de façon continu selon une fonction triangulaire et pourtant si vous examiner le code source vous ne verrez aucune instruction pour modifier le rapport cyclique du PWM, on voie d'ailleurs à l'oscilloscope qu'il est fixe. En fait une fois les périphériques configurés le programme entre dans une boucle infinie vide.

Code source

programme prnicipal
; NOM: Triangle ; AUTEUR: Jacques Deschênes ; Description: contrôle de l'intensité d'une LED par une fonction triangulaire. ; include p10f322.inc __config _WDTE_OFF & _FOSC_INTOSC radix dec ; constantes PWM_OUT EQU RA0 LED EQU RA1 NCO_OUT EQU RA2 FOSC_SEL EQU 5 FOSC EQU 16000000/(1<<(7-FOSC_SEL)) ; pour FOSC_SEL entre 1-7 TMR2_PRESCALE EQU 4 FREQ_PWM EQU 3200 PR2_COUNT EQU FOSC/(4*TMR2_PRESCALE*FREQ_PWM)-1 FREQ_NCO EQU 3200 NCO_INCRH EQU 2*FREQ_NCO*4096/FOSC NCO_INCRL EQU (2*FREQ_NCO*1049576/FOSC) & 255 NCO_OFFSET EQU 100 ; code org 0 goto init init: ; sélection de la fréquence oscillateur (Fosc) movlw FOSC_SEL<<4 movwf OSCCON ; programmation TIMER2 et PWM1 pour ; générer une onde carrée movlw 5 movwf T2CON movlw PR2_COUNT movwf PR2 movlw PR2_COUNT>>1 movwf PWM1DCH clrf PWM1DCL movlw 3<<6 movwf PWM1CON bcf TRISA, PWM_OUT ; programmation du NCO pour générer une ; onde carrée. movlw NCO_INCRH movwf NCO1INCH movlw NCO_INCRL + NCO_OFFSET movwf NCO1INCL movlw 3<<6 movwf NCO1CON bcf TRISA, NCO_OUT bsf NCO1CLK,0 ; configuration cellule logique include clc.inc bcf TRISA, LED main: goto main end code généré par CLC designer
; File: clc.inc ; Generated by CLC Designer, Version: 1.0.0.4 ; Date: 2014-12-24 16:49 ; Device:PIC10(L)F320/2 BANKSEL CLC1GLS0 movlw H'02' movwf CLC1GLS0 movlw H'00' movwf CLC1GLS1 movlw H'20' movwf CLC1GLS2 movlw H'00' movwf CLC1GLS3 movlw H'03' movwf CLC1SEL0 movlw H'05' movwf CLC1SEL1 movlw H'00' movwf CLC1POL movlw H'C1' movwf CLC1CON

Comment ça fonctionne

Ceci est possible grâce à la Cellule Logique Configurable (CLC). Cette cellule est simplement configurée comme un OU exclusif (XOR gate) qui reçoit en entrés 2 ondes carrées avec un rapport cyclique de 50% à une fréquence d'environ 3200 hertz. L'une de ces ondes est générée par PWM1 et l'autre par le NCO. à l'incrément du NCO est ajouté une valeur appelée NCO_OFFSET de sorte que la fréquence de celui-ci est légèrement différente de celle générée par PWM1. Puisque les fréquences sont différentes la phase des signaux glisse l'un par rapport à l'autre. La fonction XOR fait en sorte que la sortie n'est à 1 que lorsque les 2 signaux sont en opposition de phase.

Elle est où l'onde triangulaire?

Pour ceux qui se demandent quel est le rapport avec une onde triangulaire voici une photo prise à l'oscilloscope en remplaçant la LED par ce filtre passe-basse:

Conclusion

Il y a ce qu'il faut dans ce MCU pour fabriquer une circuit à verrouillage de phase (PLL). Voici un schéma simplifié d'un tel circuit.

Le VCO est un oscillateur dont la fréquence est contrôlée par un voltage (indiqué Vcont. sur le dessin). Ce type de circuit peut-être utilisé entre autre comme démodulateur FM ou encore pour générer une fréquence arbitraire à partir d'un fréquence de référence. Plusieurs MCU utilisent un PLL pour générer la fréquence qui contrôle le CPU. Dans ce type d'application il faut insérer un diviseur de fréquence entre la sortie du VCO et l'entrée du XOR. de sorte que le VCO fonctionne à une fréquence multiple de la référence.

La semaine dernière j'ai découvers l’existence d'un compilateur PASCAL pour les microcontrôleurs PIC 8 bits. Ce compilateur s'appelle PIC micro Pascal ou en abrégé PMP. Lorsque je programme des MCU je le fais en assembleur ou en 'C'. Mais comme j'ai programmé en Turbo Pascal et en Delphi par le passé j'ai décidé de mettre ce compilateur au banc d'essai. Pour ce faire j'ai utilisé la version 2.06 qui est encore en version bêta. J'ai d'ailleurs découvers et rapporté un bug régressif¹ dans cette version. Je reparlerai de ce bug plus loin dans cet article.

Présentation

L'initiateur et auteur principal de PMP est Philippe Paternotte, la contribution des autres membres de l'équipe consiste principalement en des librairies. Il a écris ce compilateur en Delphi, il s'agit d'une application Windows. PMP est disponible gratuitement mais le code source ne l'est cependant pas. Il ne s'agit pas simplement d'un compilateur mais aussi d'un IDE basé sur Scintilla.

PMP est un sous-ensemble de Turbo Pascal, les principales restrictions étant les suivantes.

• Ne supporte pas la programmation par objets.
• Les ARRAY ne peuvent avoir qu'une seule dimension.
• Ne supporte pas les fonctions et procédures imbriquées.
• Ne supporte que les RECORD simple, i.e. sans RECORD imbriqués, ni ARRAY ou CASE.
• Ne supporte qu'un seul niveau d'indirection, i.e. v1^m1^x n'est pas supporté.

PMP ne génère pas de code binaire pour les PIC il génère plutôt un fichier source pour l'assembleur MPASM. Donc MPLAB ou MPLABX doit-être installé avant de procéder à l'installation de PMP. Lors de l'installation PMP recherche mpasm.exe et mplink.exe et doit les trouvés pour fonctionner correctement.

Puisque PMP n'est pas intégré à MPLAB(X), pour flasher le microcontrôleur il faut soit utiliser un outil externe comme Pickit 2 programmer ou ce qui est plus malcommode créer un projet dans MPLAB(X) et y importer le fichier source assembleur généré par PMP. Une autre possibilité est d'utiliser les outils GPUTILS. Dans sa version 2.06 PMP supporte les outils GPUTILS. Pour utiliser GPUTILS sous windows il faut installer mingw32.

En ce qui concerne la documentation qui viens avec PMP elle existe sous forme de fichier PDF et d'un fichier d'aide Windows CHM pour l'aide en ligne.

Installation

L'installation est si simple qu'elle se passe d'explications. Au premier lancement l'IDE demande si on veut associé les fichiers avec l'extension .pmp et .pas avec celle-ci. Sous Windows 7 l'installation se fait dans C:\Program Files (x86)\PMP\V2.0.6. Ce dossier contient un dossier examples.

Premier programme

Mon objectif principal pour ce banc d'essai était de voir si PMP fait une bonne optimisation du code. Dans ce but j'ai réécris le code de mon article intitulé chandelle électronique. J'ai recréé exactement la même structure de programme en Pascal que celle que j'avais en assembleur.

Ce programme utilise un PIC10F202. Ce MCU n'est pas du tout conçu pour supporter la programmation dans un langage de haut niveau comme PASCAL, ce qui rend l'optimisation encore plus difficile. Voici donc le code source créé dans l'IDE de PMP. program flicker; // My first PMP program! const TMR0_CNT = 221; LFSR_MASK = 0x7FFFF159; var LED :boolean @ GPIO.2 ; pwm_cntr, frame_cntr, pwm_val, next_bright, rand_val: byte; rand: DWORD; procedure lfsr_rand; begin if (not shrb(rand)) then begin rand := rand xor LFSR_MASK; end; rand_val := rand and 0xFF; end; {lfsr_rand} procedure pwm_control; begin inc(pwm_cntr); pwm_cntr := pwm_cntr and 15; if (pwm_cntr<pwm_val then led:="1" else end begin tris loop led :="NOT" tmr0 while>0) do ; pwm_control; if (not pwm_cntr) then begin inc(frame_cntr); frame_cntr := frame_cntr and 31; if (not (frame_cntr and 7)) then begin lfsr_rand; if (7<rand_val then rand_val:="rand_val" div next_bright :="rand_val;" end if begin pwm_val end. flicker>Le compilateur génère le fichier <b>.asm</b> suivant. <textarea readonly rows="15" cols="75" style="color:gray;font-size:11px;">;; 1 program flicker; // My first PMP program! ;; 2 ;; 3 const list p=PIC10F202 ; Target processor device list r=dec ; Use decimal radix include "PROCESSOR.ASM" ; Device specifics include file errorlevel -302 ; Disable bank warnings ;; 4 TMR0_CNT = 221; flicker.TMR0_CNT equ h'DD' ; 221 - b'1101.1101' ;; 5 LFSR_MASK = 0x7FFFF159; flicker.LFSR_MASK equ h'7FFFF159' ; 2147479897 ;; 6 ;; 7 var ;; 8 LED :boolean @ GPIO.2 ; ;; 9 pwm_cntr, ;; 10 frame_cntr, ;; 11 pwm_val, ;; 12 next_bright, ;; 13 rand_val: byte; ;; 14 ;; 15 rand: DWORD; ;; 16 ;; 17 procedure lfsr_rand; __config h'FEB' ; CP=OFF, MCLRE=OFF, WDTE=OFF ; ------------------------------------------------------- ; IDLOCS - idlocs has a bug, so generate them directly. ; ------------------------------------------------------- __flicker._200 code h'200' ; Idlocs section errorlevel -220 ; Disable code address warnings data h'0001' ; h'02' data h'0000' ; h'02' data h'0000' ; h'02' data h'0000' ; h'02' ; --------------- ; RESET VECTOR. ; --------------- __flicker._000 code h'000' ; Reset vector goto __flicker ;; 18 begin __flicker.1 code ; Proc / func section real address flicker.__lfsr_rand: global flicker.__lfsr_rand ;; 19 if (not shrb(rand)) then bcf STATUS, C ; Clear carry rrf flicker.rand+3, F ; Shift right from LSB rrf flicker.rand+2, F ; Shift right from LSB rrf flicker.rand+1, F ; Shift right from LSB rrf flicker.rand, F ; Shift right from LSB btfss STATUS, C ; Test bit bcf __BitStack, 0 ; Into bit acc btfsc STATUS, C ; Test bit bsf __BitStack, 0 ; Into bit acc btfsc __BitStack, 0 ; Test bit acc goto __lfsr_rand.0 ; Branch if true ;; 20 begin ;; 21 rand := rand xor LFSR_MASK; movlw h'59' ; constant 1st byte xorwf flicker.rand, F ; XOR to variable 1st byte (LSB) movlw h'F1' ; constant 2nd byte xorwf flicker.rand+1, F ; XOR to variable 2nd byte movlw h'FF' ; constant 3rd byte xorwf flicker.rand+2, F ; XOR to variable 3rd byte movlw h'7F' ; constant 4th byte xorwf flicker.rand+3, F ; XOR to variable 4th byte (MSB) ;; 22 end; __lfsr_rand.0: ;; 23 rand_val := rand and 0xFF; movf flicker.rand, W ; Get variable in acc movwf flicker.rand_val ; Store to byte ;; 24 end; {lfsr_rand} retlw h'00' ; Normal return ;; 25 ;; 26 ;; 27 procedure pwm_control; ;; 28 begin __flicker.2 code ; Proc / func section real address flicker.__pwm_control: global flicker.__pwm_control ;; 29 inc(pwm_cntr); incf flicker.pwm_cntr, F ; Increment ;; 30 pwm_cntr := pwm_cntr and 15; movlw h'0F' ; constant andwf flicker.pwm_cntr, F ; AND to variable ;; 31 if (pwm_cntr<pwm_val then led:="1" else movf flicker.pwm_cntr w get variable in acc movwf __stack__0 push byte flicker.pwm_val bsf __bitstack prepare bit subwf compare to stack btfsc status c skip if less bcf load false btfss test goto __pwm_control.0 branch gpio flicker.led store true __pwm_control.1 __pwm_control.0: __pwm_control.1: end retlw h normal return begin main program entry point. __flicker.3 code section __flicker: clrf __flags clear general purpose flags flicker.continue: loop tris movlw constant set i direction led :="NOT" __l0: target mask xorwf f flip tmr0 while>0) do ; __L2: movf TMR0, W ; Get variable in acc btfss STATUS, Z ; Skip if zero goto __L2 ; Branch if w is TRUE ;; 41 pwm_control; call flicker.pwm_control ;; 42 if (not pwm_cntr) then movf flicker.pwm_cntr, W ; Get variable in acc btfss STATUS, Z ; Skip if zero goto __L3 ; Branch if w is TRUE ;; 43 begin ;; 44 inc(frame_cntr); incf flicker.frame_cntr, F ; Increment ;; 45 frame_cntr := frame_cntr and 31; movlw h'1F' ; constant andwf flicker.frame_cntr, F ; AND to variable ;; 46 if (not (frame_cntr and 7)) then movf flicker.frame_cntr, W ; Get variable in acc andlw h'07' ; AND btfss STATUS, Z ; Skip if zero goto __L4 ; Branch if w is TRUE ;; 47 begin ;; 48 lfsr_rand; call flicker.lfsr_rand ;; 49 if (7<rand_val then rand_val:="rand_val" div movlw h movwf __stack__0 push byte movf flicker.rand_val w get variable in acc bsf __bitstack prepare bit subwf compare to stack btfsc status c skip if less bcf load false btfss test goto __l5 branch clear carry rrf f shift value __l5: next_bright :="rand_val;" flicker.next_bright store end __l4: flicker.frame_cntr z zero __l6 is true begin pwm_val flicker.pwm_val __l6: __l3: __l0 loop end. flicker flicker.continue flicker.led equ gpio subroutines jump table __flicker._0fe code force absolute section first instructions flicker.lfsr_rand: global flicker.lfsr_rand flicker.__lfsr_rand flicker.pwm_control: flicker.pwm_control flicker.__pwm_control data definitions __data.008 udata_ovr flicker.rand: res __bitstack: flicker.rand_val: flicker.pwm_cntr: __stack__0: flicker.pwm_val: __flags: __flags flicker.frame_cntr: flicker.next_bright: used symbols information boolean sfr gpio.2 flicker.lfsr_mask const longword procedure flicker.pwm_cntr flicker.rand flicker.tmr0_cnt ram usage bad r="Reserved," s="SFR," x="used," m="mirrored," .="free)" a b d e bytes free of gprs compiled by pmp_ide for pic10f202 on pmp team philippe paternotte compilation time: ms generation thanks to: jack w. crenshaw albert graef and berend de boer thomas lemense their good work about how build compilers. mike gore his excellent picfloat fp library ancestor float library. special olivier jauzelon heavy beta tester contributor vasile guta-ciucur breth cosmin koteles the installer program configuration file fred king johan bakker giulio bottini flemming myrup calin raszga willem van pelt bernd koesters testers donators michel burcez my best friend who knows nothing programming pics wise advices. source.>version C compilée avec XC8 free. <textarea readonly rows="15" cols="75" style="color:gray;font-size:11px;">/* * File: xc8_flicker.c * Author: Jacques * * Created on 13 janvier 2015, 08:27 */ #include <pic10f202.h> #define TMR0_CNT 221 #define LFSR_MASK 0x7ffff159 #define LED 2 unsigned char pwm_cntr, frame_cntr, pwm_val, next_bright, rand_val; unsigned long long random; void lfsr_rand(){ random >>= 1; if (! random & 0x10000000u){ random ^= LFSR_MASK; } rand_val = random & 0xFF; } void pwm_control(){ pwm_cntr++; pwm_cntr &= 15; if (pwm_cntr<pwm_val gpio="GPIO" int main argc char argv asm while tmr0="TMR0_CNT;">0) ; pwm_control(); if (!pwm_cntr){ frame_cntr++; frame_cntr &=31; if (!(frame_cntr & 7)){ lfsr_rand(); if (rand_val>7) rand_val >>=1; next_bright = rand_val; } if (frame_cntr==0){ pwm_val = next_bright; } } } return 0; }//main() </pwm_val></pic10f202.h>

Comparaison

• __BitStack, 1 octet, sert à sauvegarder les status bits pour la donnée qui est dans __STACK__0.
• __STACK__0, 1 octet, utilisé comme variable temporaire.
• __FLAGS, 1 octet, est utilisé pour les variables de type boolean définies dans le programme PASCAL.

var
  LED :boolean @ GPIO.2 ;

flicker.LED     equ     2        flicker.LED       ; Bit 2 in GPIO

Bug régressif dans la version 2.06B

A la ligne 49 du code PASCAL on retrouve la ligne:

if (7<rand_val) then rand_val:= rand_val div 2;

if (rand_val>7) then rand_val:= rand_val div 2;

        movf    flicker.rand_val, W     ; Get variable in acc
        bsf     __BitStack, 0           ; Prepare bit ACC (true)
        sublw   h'07'                   ; subtract W to constant

        movlw   h'07'
        movwf   __STACK__0              ; Push byte
        movf    flicker.rand_val, W     ; Get variable in acc
        bsf     __BitStack, 0           ; Prepare bit ACC (true)
        subwf   __STACK__0, W           ; Compare to stack byte

Lorsqu'on étudie le code assembleur généré par PMP on comprends rapidement pourquoi ça prend 16% de plus d'instructions. Il semble que toutes les comparaisons sur les variables passe par __BitStack et __STACK__0.

Conclusion

Bien sur ce banc d'essai est bref et je vais certainement poursuivre d'autres expérimentations avec PMP mais ça m'a quand même permis de me faire une idée du prix a payer en terme d'utilisation de l'espace de code. Le résultat est meilleur que celui obtenu avec XC8 version gratuite. Donc pour ceux qui préfère le PASCAL au 'C'ça peut-être intéresssant. Personnellement pour un programme PIC qui a moins de 512 instructions je préfèrerai toujours programmer en assembleur. Donc pour tous les PIC10F, PIC12F qui disposent de 256/512 instructions de FLASH.

NOTES:
1) un bug régressif est un bug qui a été introduit dans la version courante alors que la même fonctionnalité fonctionnait correctement dans une version antérieure.

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.

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.

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 f_tr_dly call transition btfss f_tr_cmpl goto main_loop bcf random end></f_tr_dly></p10f200.inc>

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() </pic10f200.h>

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 }

Voici un petit programme à tester dans le simulateur de MPLABX en mode pas à pas. Mais avant essayez de deviner le contenu de STATUS après chaque opération suivie du commentaire STATUS=?. Si vous répondez correctement à chaque étape votre compréhension du fonctionnement interne du CPU est excellente.

    include p10f200.inc
    __config _WDTE_OFF
    radix dec
    org 0
main_loop
    bsf STATUS,0   ; set C bit
    bsf STATUS,1   ; set DC bit
    bsf STATUS,2   ; set Z bit
    clrf STATUS    ; Q1, STATUS=?
    bsf STATUS,7   ; Q2, STATUS=?
    movfw STATUS   ; Q3, STATUS=? W=?
    movlw 0x78
    addwf STATUS,F ; Q4, STATUS=?
    movfw STATUS   ; Q5, STATUS=? W=?
    xorwf STATUS,F ; Q6, STATUS=?
    goto main_loop
    end

Réponses et explications

1. STATUS=0x1F. Pensiez-vous que le contenu de STATUS serais mis à zéro? Erreur car certains bits sont en lecture seule : ~TO et ~PD. De plus Z est mis à 1 car l'instruction CLRF affecte ce bit en le mettant à 1. L'ajustement des bits Z,DC et C se fait à la fin de l'opération et l'opération CLRF ne change pas l'état des indicateurs DC et C. Ces deux là était à 1 donc ils le reste. Donc si vous voulez mettre à zéro les 3 indicateurs ne faites pas un CLRF STATUS mais plutôt:

   
     BCF STATUS,Z
     BCF STATUS,DC
     BCF STATUS,C
   

2. STATUS=0x9F. Ce bit est R/W donc il es mis à 1 tel que prévu par l'opération. Les autres bits ne sont pas affectés.
3. STATUS=0x9B et W=0x9F. C'est normal puisque l'instruction MOVFW affecte la valeur de l'indicateur Z. Celui-ci a été mis à zéro puisque la valeur transféré dans W n'était pas nulle.
4. STATUS=0x1B. L'addition a bien donnée le résultat escomptée sauf que les indicateurs Z, DC et C ont été ajusté en conséquence de l'addition. Comme toujours les bit en lecture seule de STATUS n'ont pas été modifiés par le résultat et les 3 indicateurs ont écrasés les bit 0-2 du résultat. Si vous voulez vérifier que l'addition donne le résultat escompté remplacé addwf STATUS, F par addwf STATUS, W et vérifier le résultat dans W.
5. STATUS=0x1B et W=0x1B. Cette fois-ci STATUS n'a pas été modifié par l'opération MOVFW puisque Zétait déjà à zéro.
6. STATUS=0x1F. l'opération XORWF n'affecte que le bit Z. Ici on a fait une opération xor de la valeur de STATUS avec elle-même. Le résultat d'une telle opération est zéro. Donc le bit Z a été mis à 1. les bits DC et C ne sont pas altérés. Encore une fois les 3 indicateurs écrase les bits 0-2 du résultat. Le bit 4 (~PD) était à 1 et le reste puisqu'il est en lecture seule.

Certains microcontrôleurs permettent de configurer les sorties numériques en mode open drain. Dans cet article j'explique ce que ça signifie et je donne des exemples d'utilisation.

configuration d'une sortie numérique

Les sorties numériques des MCU sont composées de 2 transistors MOSFET complémentaires montées entre les 2 rails d'alimentation Vdd et Vss comme ceci.

Les transistors MOSFET ont 3 électrodes. Drain, Source, Gate. Le Gate contrôle le passe du courant entre le Drain et la Source. Lorsque Vin est à 1 le transistor P-MOSFET et bloqué et le N-MOSFET conduit, on a donc zéro à la sortie. À l'inverse si Vin est à 0, le transistor P-MOSFET conduit et le N-MOSFET est bloqué de sorte que la sortie est à 1. Il n'y a qu'un seul transistor qui conduit à un instant donné sinon on aurait un court-circuit entre Vdd et Vss.

Drain ouvert

Maintenant si on désactive le transistor P-MOSFET de sorte qu'il n'y a que le transistor N-MOSFET qui peut entré en conduction alors on a que la sortie sur la broche du MCU est en haute impédance lorsque le N-MOSFET est bloqué ou elle est connecté à Vss lorsque le transistor conduit. C'est ce qu'on appelle une configuration Open Drain

Pour désactiver le P-MOSFET on installe un commutateur analogique (analog switch) comme montré sur le schéma ci-bas. Lorsque le signal open drain et actif SW1a conduit et sw1b est bloqué de sorte que le Gate du P-MOSFET est branché à Vdd le rendant inopérant.

Utilité du Drain ouvert

La configuration Open Drain est utile dans diverses situations, partage du bus entre plusieurs dispositifs, adaptation de niveau de tension, alimentation d'une LED par la cathode.

Par exemple il existe des dispositifs qui utilisent un protocole de bus appelé ONE-WIRE. Ces dispositifs n'utilisent qu'un seul fil pour communiquer avec le microcontrôleur et cette communication se fait dans les 2 sens en semi-duplex.

adaptation de niveau

Toutes les sorties numérique des PIC24FJ64G00x sont configurable en mode open drain. Ces MCU fonctionnent à 3,3 volt. Supposons qu'on veut interfacer un tel MCU avec un affichage LCD qui fonctionne à 5 volt. Pour adapter les niveaux logiques sur le bus de communication il suffit de configurer les sorties du MCU en open-drain et de mettre des résistances pullup sur les lignes du bus. De cette façon lorsque le transistor N-MOSFET à la sortie du MCU est bloqué le niveau à l'entrée du LCD est tiré à 5 volt. Lorsque le transistor N-MOSFET du MCU est en conduction la ligne est tirée à zéro volt. Voici le schéma d'un montage qui utilise cette configuration. Il s'agit du schéma d'un projet dont je parlerai bientôt sur ce blog.

alimentation LED en mode drain ouvert

Lorsqu'une sortie complémentaire commute pendant une fraction de seconde il y a un certain courant qui passe de Vdd à Vss à travers les 2 transistors car la commutation n'est pas instantanée. Cela a 2 effets, une consommation électrique supplémentaire et du bruit sur le bus d'alimentation. Si on alimente des LEDs par la cathode comme dans le schéma ci-bas en configurant les sorties du MCU en open drain on élimine ces 2 problèmes.

J'ai fait plusieurs projets qui généraient un signal vidéo NTSC monochrome. Cette fois ci je voulais expérimenter avec un affichage LCD. PICVisionPortable est une console de jeux rétro monochrome qui utilise un LCD graphique de 128x64. Le MCU est le même que pour le projet PICVision soit un PIC24FJ64GA002. Cependant il n'y a pas que le type d'affichage qui est différent. PVP utilise la même machine virtuelle (avec quelques modifications) que le projet CHIPCON. et supporte aussi la lecture d'une carte SD sur laquelle sont enregistrés les jeux.

caractéristiques

• MCU PIC24FJ64GA002, 64Ko flash, 8Ko RAM.
• Affichage LCD passif à rétro-éclairage Robotshop RB-Dfr-177. 128x64 pixels
• Lecteur de carte SD pour les jeux
• Haut-parleur intégré. Son avec 2 tonalités simultanés ou bruit blanc.
• Espace code disponible 4096 octets. Machine virtuelle Super CHIP étendue.
• Outils disponibles: assembleur, déassembleur et convertisseur vers fichier C pour intégration d'un jeux en mémoire flash
• Alimentation 4 piles AA.

schéma électronique

Il y avait juste le nombre de broches sur le format DIP-28 pour répondre aux besoins du projet. De plus comme ce MCU permet de configurer les sorties binaire en mode drain ouvert il n'a pas été nécessaire d'utiliser des adaptateurs de niveau de tension entre le module LCD qui fonctionne à 5 volts et le MCU qui lui fonctionne à 3,3 volts.

L'interface utilisateur ne comprend que 5 boutons, les 4 directions et le select. au dessus du select il y a un petit bouton pour réinitialiser la console. A gauche de l'affichage il y a le haut-parleur et le commutateur d'alimentation.

Je voulais que le montage soit le plus simple possible il n'y a donc pas de cristal, il n'est pas nécessaire d'avoir une précision d'horloge.

Pour le connecteur de la carte SD j'ai du fabriquer un petit circuit imprimé. l'empreinte est dans le dossier documents.

Adaptation du jeux LEM que j'avais écris pour le projet CHIPCON.

carte MCU dans le boitier

Tous les composants dans le boitier

Prototype complété

description détaillée

L'affichage est un LCD passif STN a rétro-éclairage par LED acheté chez Robotshop.com/ca. Puisqu'il s'agit d'un LCD passif l'affichage a une persistance longue ce qui produit un effet de trainé dans les animations. Les jeux sont néanmoins jouables. Sur le vidéo suivant ça paraît pire que c'est en réalité à cause des réflexions sur l'écran. Désolé pour la mauvaise qualité de ce vidéo mais je ne suis pas vraiment équiper produire de bons vidéos.

Le PIC24FJ64GA002 possède 8Ko de RAM, 1Ko est réservé pour la mémoire d'affichage et 4Ko pour l'espace jeux. Contrairement à l'émulateur CHIP original les 4Ko sont disponibles pour l'espace code. Les jeux doivent-être écris avec le point d'entré à l'adresse zéro. Les jeux superCHIP existants doivent-être adaptés pour cette console pour les raisons suivantes:

1. Le point d'entré doit-être à l'adresse zéro et non 512.
2. Le clavier n'a que 5 boutons, 4 de directionsà gauche et un sélectionà droite.
3. Ce processeur étant plus rapide les jeux doivent-être ralentis en insérant des délais supplémentaire dans le code.

Dans le dossier tools on retrouve l'assembleur pvpasm, le déassembleur pvpdasm et le convertisseur cvt-chip. Il reste de la place dans la mémoire flash pour y intégrer quelques jeux.

J'ai adapté 5 jeux superCHIP pour cette console et les ai intégrés dans la mémoire flash. Il encore près de 32Ko de flash libre, donc de l'espace pour plusieurs autres jeux.

adaptation de jeux superCHIP

Lorsqu'il n'y a pas de carte SD dans la fente la console affiche la liste des jeux en mémoire flash. Vous pouvez écrire vos propre jeux et les utiliser à partir de la carte SD ou les intégrer dans la mémoire flash du MCU.

L'adaptation se fait en 3 étapes:

• désassembler le fichier binaire avec l'utilitaire pvpdasm.exe qui est dans le dossier tools du dépôt github.
  exemple: pvpdasm blinky.ch8 blinky.chp
• Ouvrir dans un éditeur de texte le fichier assembleur .chp. Faire une recherche sur les instructions SKP, SKNP et LD VX, K. remplacer les codes de touches par ceux correspondant aux touches de la console PVP.
  1. UP = 0
  2. DOWN = 1
  3. LEFT = 2
  4. RIGHT = 3
  5. SELECT = 4
  La console PVP est plus rapide qu'une calculatrice HP-48 aussi faut-il introduire des délais aux endroits appropriés. Localiser ces endroits est la partie la plus difficile.
• Une fois les modifications faites dans l'éditeur, il faut assembler le programme avec pvpasm.exe
  exemple: pvpasm.exe blinky.chp blinky.pvp

intégration des jeux dans la mémoire flash

Pour intégrer un jeux dans la mémoire flash du MCU il faut utiliser l'outil cvt-chip.exe qui est dans le dossier tools.
exemple d'utilisation: cvt-chip -pPIC blinky.pvp

le résultat de cette opération est la création de 2 fichiers en langage C. Un fichier blinky.h et un fichier blinky.c. Il faut ajouter ces 2 fichiers au projet MPLABX.

Dans l'exemple donné ici il ajouter dans le fichier main.c
#include "games/BLINKY/blinky.h"

Chaque jeux en mémoire flash a une entrée dans le tableau flash_games[GAMES_COUNT]. Il faut aussi incrémenter la constante GAMES_COUNT.

• Le nom qui apparaît à l'écran.
• la constante définie dans le fichier d'entête qui donne le nombre d'octet occupé par le jeux. Dans l'exemple de blinky cette constante s'appelle BLINKY_SIZE.
• Le nom du tableau (array) contenant le jeux. Celui est aussi défini dans le fichier d'entête créé par cvt-chip.exe
• le nom du tableau xxxx_info. Ceci est une description du jeux qui est affichée avant que le jeux ne démarre. Par défaut le tableau est vide. La constante NULL peut-être utilisée s'il n'y a pas d'info à afficher.

liens

• github du projet.
• http://www.chip8.com
• projet PICVision
• Projet CHIPcon

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.

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 fvr fvrcon="0;" convertisseur a adcon0="0;" unsigned random int i number="0;" for if>>=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-- pwm1dc if done-- pwm2dc-- pwm2dc pwm3dc-- pwm3dc pwm1ldcon="128;" pwm2ldcon="128;" pwm3ldcon="128;" delay_us int main 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;" on ra5 pwm2 ra4 pwm1 led bleu pwm1ph="0;" pwm1pr="0xffff;" pwm1clkcon="0;" pwm1con="(3<<6)|(1<<4);" rouge pwm2ph="0;" pwm2pr="0xffff;" pwm2clkcon="0;" pwm2con="(3<<6)|(1<<4);" pwm3 verte pwm3ph="0;" pwm3pr="0xffff;" pwm3clkcon="0;" pwm3con="(3<<6)|(1<<4);" lata="0;" trisa et en sortie seed initialise le g prng while transition delay_ms return> Dans ce projet les 3 canaux PWM sont utilisés en mode <i>standard</i>. 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 <b>x</b> 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. </pwm1dc></i></xc.h></stdlib.h></stdio.h>

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().

Après avoir observé l’œuf lumineux j'ai décidé que ça pouvait remplacer une chandelle au centre d'une table à dîner. J'en ai donc fait un montage sur un bout de planche de chêne de dimensions 19mm x 110mm x 60mm.

couper un oeuf

L'opération la plus délicate est de couper le bout de l’œuf sans fendre ou fragmenter le rebord du trou. J'ai pris un bouchon de contenant de jus que j'ai appliqué sur le gros bout de l’œuf et j'ai utilisé un marqueur pour en tracé la circonférence. Le meilleur outil que j'ai trouvé pour obtenir un bon résultat est un Dremel avec une petite meule.

Le rebord du trou est très fragile, pour éviter qu'il se forme des fissures j'ai appliqué un filet de colle chaude à l'extérieur juste sur le rebord de l'ouverture. Finalement j'ai vernis l’œuf avec de l'uréthane transparent.

L’œuf doit pouvoir entrer par dessus le bouchon qui a été utilisé pour marquer l'ouverture. C'est dans ce bouchon qu'est installé le PIC10F1572 avec la LED. Le bouchon est encastré dans la base en bois mais pas complètement. Il sert à maintenir la coquille en position.

Montage électronique

Tous tiens ensemble avec de la colle chaude mais je l'ai utilisté aussi comme isolant.

J'avais suffisamment d'espace pour installer un connecteur pour le programmeur Pickit au cas ou je voudrais modifier le logiciel.

Voici une découverte intéressante que je viens de faire. Il s'agit de 2 consoles de jeux couleurs réalisées avec des moyens très simples. Le signal de sortie est NTSC/couleurs. Cet article est une brève présentation de ces consoles pour ceux qui ne comprennent pas l'anglais (ou le japonais). Le seul composant actif de ces 2 consoles est le MCU le reste n'est que résistances, condensateurs, connecteurs et un cristal 3,58Mhz ou 14,3Mhz pour la deuxième. Suivez le lien ci-haut pour visionner le vidéo des 2 consoles en action.

La première console peut-être réalisée avec un de ces MCU PIC32MX150F128B, PIC32MX250F128B, PIC32MX170F256B ou PIC32MX270F256B. Cette console peut aussi fonctionner sur des PIC32MX120F032B ou PIC32MX220F032B car les graphiques sont basées sur des tables de caractères, une technique qui réduit la quantité de mémoire RAM nécessaire pour le tampon vidéo. Ces MCUs étant disponibles en format PDIP-28 cette console peut-être montée sur une carte à bande ou à points, nul besoin d'un circuit imprimé spécifique. La console peut fonctionner sur 2 piles AA ou AAA ou encore avec un adapteur en y ajoutant un régulateur de tension. Il est nécessaire que le cristal utilisée soit à 3,5795345Mhz. Cette fréquence correspond au signal chroma du NTSC/COULEUR. Ces consoles ne peuvent-être réalisées pour les formats PAL ou SECAM car les modes de modulation couleur de ces 2 standards sont différents. L'auteur précise qu'il a réussi a obtenir une résolution de 256x224 pixels à 16 couleurs sur un PIC32MX150F128B. Dans ce mode le tampon vidéo utilise 28Ko de RAM. Le projet a été réalisé avec MPLAB IDE v8.80, et MPLAB C32 C Compiler v2.02 mais ça ne devrait pas être trop difficile d'adapter le code source pour MPLABX et XC32.

La deuxième console utilise un PIC32MX370F512H et permet de fonctionner en mode graphique vrai pour des jeux plus complexe. Ce MCU n'est pas disponible en format PDIP donc le montage est plus complexe à réaliser. Une solution existe cependant sans avoir à fabriquer un circuit imprimé dédié, il s'agirait d'utiliser un MCU au format TQFP-64 et un breakout board comme celui-ci. Une fois le MCU soudé sur le breakout board il est simple de relier celui-ci à une plaquette à points sur laquelle les autres composants sont montés.

Cette deuxième console permet une résolution de 256x256 pixels avec 256 couleurs. Le cristal utilisé est à une fréquence de 14,31818Mhz (4x3,579545Mhz). Ce MCU peut fonctionner jusqu'à 100Mhz et comme on le voit dans la deuxième partie du vidéo avec le jeux VELUDDA, le MCU est suffisamment puissant pour effectuer une rotation temps réel du bitmap vidéo.

Cet article décris un tuteur de code morse, c'est à dire un petit circuit qui aide à l'apprentissage du code morse.

code morse

Le code morse est un code à rythme, c'est à dire que l'information est encodée dans la durée relatives des éléments, aussi bien la durée des sons que le silence entre ceux-ci porte une signification. Ainsi un son court appelé DIT est l'unité de base du tempo, tous les temps sont relatif à la durée du DIT.

Il y a deux durées sonores et 3 durées de silence.

• DIT est un son court.
• DAH est un son long dont la durée est 3 fois celle du DIT.
• A l'intérieur d'un caractère le silence entre les sons dure 1 DIT.
• Entre les caractères d'un mot le silence dure 3 DIT.
• Entre chaque mot le silence dure 5 (Amérique) ou 7 (Europe) DIT.

En Amérique du nord l'apprentissage du MORSE n'est plus requis pour obtenir une licence radio-amateur. Mais lorsque c'était requis un appliquant devait-être en mesure de lire et de produire un message en morse à la vitesse de 5 mots par minute pour obtenir la licence de base. Ce tuteur émet et lit à la vitesse correspondant à 5 mots par minute. C'est la constante DIT définie au début du fichier source qui détermine le tempo, en diminuant sa valeur on accélère le tempo.

Le circuit

Le circuit est réalisé avec un PIC10F322. Il utilise une LED bicolore rouge/verte pour signaler différents états et un petit haut-parleur pour émettre les codes. La clé morse est branchée sur l'entrée RA3. Il s'agit d'une clé simple (straight key).

Il y a 4 groupes de caractères et le tuteur passe de l'un à l'autre lorsqu'un groupe est complété.

1. lettres 'A' - 'Z'
2. chiffres '0' - '9'
3. ponctuations '!' - '/'
4. ponctuations ':' - '@'

le code source

; NOM: MorseTutor ; DESCRIPTION: aide à l'apprentissage du code MORSE ; AUTEUR: Jacques Deschênes ; COPYRIGHT 2015 ; LICENCE: GPLV3 ; ;************************************************************************** ; This program is free software: you can redistribute it and/or modify ; it under the terms of the GNU General Public License as published by ; the Free Software Foundation, either version 3 of the License, or ; (at your option) any later version. ; ; This program is distributed in the hope that it will be useful, ; but WITHOUT ANY WARRANTY; without even the implied warranty of ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ; GNU General Public License for more details. ; ; You should have received a copy of the GNU General Public License ; along with this program. If not, see <http:></http:>. ;************************************************************************** ; ;Utilisation des périphériques: ; RA0 sortie son ; RA1 anode LED rouge ; RA2 anode LED verte ; RA3 entrée clé morse ; T0 ticks 1 msec. ; ; alimentation 3 volts, 2 piles AA ou AAA ; ; REF: ; http://fr.wikipedia.org/wiki/Morse_%28alphabet%29 ; http://en.wikipedia.org/wiki/Morse_code ; http://fr.wikipedia.org/wiki/Code_Q ; http://www.qsl.net/w5www/qcode.html radix dec include p10f322.inc __config _FOSC_INTOSC & _WDTE_OFF & _MCLRE_OFF & _LVP_OFF SPKR EQU RA2 RED EQU RA1 GREEN EQU RA0 KEY EQU RA3 ; code symbole SYMB_SPC EQU 0 SYMB_DAH EQU 1 SYMB_DIT EQU 2 ; codes d'erreurs ERR_BAD_LEN EQU 3 ; durée symbole invalide ERR_NOT_CHAR EQU 4 ; caractère non reconnu ; vitesse d'entrainement débutant 5 mot par minutes. ; duré d'un dit 240 msec. wpm=1200/T=1200/120 = 5 wpm (word per minutes) DIT EQU 240 ; durée d'un ti en millisecondes (diminuez cette valeur pour vitesse plus rapide) DAH EQU 3*DIT ; durée d'un taah en millisecondes SYMSPC EQU DIT ; durée silence entre symbole d'un même caractère CHRSPC EQU 3*DIT ; durée silence entre 2 caractères d'un mot WORDSPC EQU 7*DIT ; durée silence entre mots en millisecondes ; constante quie détermine la fréquence de la tonalité INCR_L EQU 0x96 ; incrément pour NCO1 octet faible INCR_H EQU 0x00 ; incrément pour NCO1 octet fort ; indicateurs booléens F_CNTDN EQU 0 ; compte les millisecondes à rebours F_KEYDN EQU 1 ; key status flag, if set the key is down F_TICK EQU 2 ; mis à 1 par interruption TMR0 en mode décodeur F_CODE EQU 3 ; réception code en cours FOSC EQU 4000000 ; fréquence oscillateur interne 4 Mhz TMR0_VAL EQU 5 ; valeur de TMR0 pour Fosc/4=1Mhz et un prescale=4 ; ca donne un intervalle de 1msec. QUEUE_SIZE EQU 16 ; capacité de la file des états de la clé. ;*********** ; macros ;*********** ;active tonalité tone_on macro bsf NCO1CON, N1OE endm ;désactive tonalité tone_off macro bcf NCO1CON, N1OE endm ; attend que la clé morse ; soit relâchée wait_release macro btfss PORTA, KEY goto $-1 endm ; active l'interruption sur ; changement d'état E/S binaire ioc_int_enable macro bsf INTCON, IOCIE bsf IOCAN, IOCAN3 bsf IOCAP, IOCAP3 endm ;désactive l'interruption sur ;changemetn d'état E/S binaire ioc_int_disable macro bcf IOCAN, IOCAN3 bcf IOCAP, IOCAP3 bcf INTCON, IOCIE endm ;démarre le chronomètre start_chrono macro msec movlw msec & 255 movwf msec_count movlw msec>>8 movwf msec_count+1 bsf flags, F_CNTDN endm ;attend la fin du compte à rebours pause macro btfsc flags, F_CNTDN goto $-1 endm udata flags res 1 ; indicateurs booléens msec_count res 2 ; compteur millisecondes W_save res 1 ; sauvegarde de W par l'interruption status_save res 1 ; sauvegarde de STATUS par l'interruption FSR_save res 1 ; sauvegarde FSR par l'interruption W16L res 1 ; registre de travail 16 bits octet faible W16H res 1 ; registre de travail 16 bits octet fort B16L res 1 ; registre de travail 16 bits octet faible B16H res 1 ; registre de travail 16 bits octet fort char res 1 ; caractère morse à transmettre bound res 1 ; dernier caractère de la série à l'étude class res 1 ; groupe à l'étude 0=lettre,1=chiffre,2-3=ponctuations symb_morse res 1 ; symbole morse symb_count res 1 ; nombre de symbole pour le caractère à transmettre len_code res 1 ; code de longueur utilisé par decode_morse head res 1 ; tête de la file tail res 1 ; fin de la file evtcount res 1 ; nombre d'événements table_idx res 1 ; index utilisé par find_char .queue udata 0x60 lapse res 2*QUEUE_SIZE ; tableau des durées d'états de la clé morse code 0 ;*************** ; vecteur reset ;*************** movlw 5<<ircf0 fosc="4Mhz," tcy="4/Fosc=1µsec" movwf osccon clrf clkrcon goto init routine isr des registres w_save swapf status status_save movfw fsr fsr_save source d btfss intcon tmr0if ioc3_int sur tmr0 btfsc flags f_cntdn countdown incr le compteur de millisecondes movlw addwf msec_count skpnc incf tmr0_isr_exit countdown: iorwf skpz bcf subwf skpc decf tmr0_isr_exit: tmr0_val iocif isr_exit interuptiion changement ra3 bit plus significatif indique l la cl ferm ioc3_int: iocaf iocaf3 ioc3_isr_exit f_code ioc3_event bsf iocap iocap3 evtcount tone_on f_keydn ioc3_event: porta key key_opened key_closed: ioc3_store_evt key_opened: tone_off ioc3_store_evt: tail indf lapse ioc3_isr_exit: restauration isr_exit: retfie n w16 negw16 comf w16l w16h return bits les c et z sont repr du r sub16wb b16l b16h incfsz tonalit courte sound_dih start_chrono dit pause longue sound_dah dah g code morse caract input: contient transmettre send_char: v valildit premier table char w non valide ascii>"Z" movlw high morse_codes movwf PCLATH movlw 0x21 ; caractère ASCII "!" subwf char, W call morse_codes ; va chercher la transcription morse du charactère ; décodage de la transcription morse ; les 3 bits les plus significatifs contiennent le nombres de symboles ; les 5 autres bits la liste des symboles à transmettre. movwf W16L andlw B'11100000' movwf symb_count swapf symb_count, F clrc rrf symb_count, F movlw 6 subwf symb_count, W btfss STATUS, C ; il y a 6 symboles goto ppq6 ; moins que 6 symboles movlw 6 andwf symb_count, F ; 6 symboles ppq6: ; moins de 6 symboles movf symb_count, F btfsc STATUS, Z return ;zero symboles, caractère non valide movf W16L, W movwf symb_morse movfw symb_count movlw 8 movwf W16L movfw symb_count subwf W16L, F clrc rlf symb_morse, F decfsz W16L, F goto $-3 ; a ce point le nombre de symbole est dans symb_count ; le codage est dans symb_morse avec le premier symbole ; dans le bit le plus significatif. symbole_suivant: rlf symb_morse, F btfsc STATUS, C goto _dah ; carry = 1 -> dah ; carry = 0 -> dit call sound_dih goto pause_1dih _dah: call sound_dah pause_1dih: start_chrono SYMSPC pause decfsz symb_count goto symbole_suivant start_chrono 2*SYMSPC ; silence supplémentaire entre charactère pause return ;******************* ; vérifie si le code morse ; qui est dans 'symb_morse' ; correspond au caractère dans ; 'char' ; sortie: STATUS Z=1 succès ; STATUS Z=0 échec compare_code: movlw HIGH morse_codes movwf PCLATH movlw '!' subwf char,W call morse_codes xorwf symb_morse,W return ;******************** ; signale erreur ; clignote code erreur ; entrée W==code ;********************* code_error: movwf W16L tone_off code_error_b01: bsf PORTA, RED start_chrono 200 pause bcf PORTA, RED start_chrono 200 pause decfsz W16L goto code_error_b01 return ;***************** ; contrôle la longueur du ; symbole. ; entrée: FSR pointe sur la durée ; sortie: W, 2=DIT, 1=DAH, 3=error ;***************** symb_len ; compare longueur avec DIT movfw INDF movwf B16L incf FSR movlw 127 andwf INDF,W movwf B16H movlw DIT&255 movwf W16L movlw DIT>>8 movwf W16H call sub16wb ; W16=DIT-durée ; évaluation de l'écart avec durée DIT skpc call negw16 ; complément de 2 ; accepte écart < DIT/4 25% d'erreur movlw (DIT>>1)&255 movwf B16L movlw (DIT>>9) movwf B16H call sub16wb ; W16=ecart-DIT/4 skpc goto symb_len_dit ; accepte durée == DIT ; ce n'est pas un DIT ;comparaison avec durée DAH decf FSR movfw INDF movwf B16L incf FSR movlw 127 andwf INDF,W movwf B16H movlw DAH&255 movwf W16L movlw DAH>>8 movwf W16H call sub16wb ; W16=DAH-durée skpc call negw16 ; accepte écart < DAH/4 movlw (DAH>>1)&255 movwf B16L movlw (DAH>>9) movwf B16H call sub16wb ; W16=ecart-DAH/4 skpc goto symb_len_dah ; durée reconnue comme DAH movlw ERR_BAD_LEN ; durée non valide return symb_len_dah: ; dureé == DAH movlw SYMB_DAH return symb_len_dit: ; durée == DIT movlw SYMB_DIT return ;************* ; décode la séquence MORSE ; à partir des durées accumulées dans la file ; sortie: symbole morse dans symb_morse ; STATUS bit Z à 1 si succès ;************* decode_morse: clrf symb_count clrf symb_morse movfw head addlw 255 movwf FSR decode_next_symb: incf FSR,F call symb_len movwf len_code xorlw ERR_BAD_LEN skpz goto $+3 movlw ERR_BAD_LEN goto morse_error btfsc INDF, 7 goto decode_store_symb ; si phase==0 symb_len doit-être==DIT ;***debug*** ; bsf STATUS, Z ; return ;***end debug**** movlw SYMB_DIT xorwf len_code,W skpnz goto $+3 movlw ERR_BAD_LEN goto morse_error decfsz evtcount,F goto decode_next_symb goto decode_check_char decode_store_symb: rrf len_code,F rlf symb_morse,F incf symb_count,F decfsz evtcount,F goto decode_next_symb ;tous les événements ont été traités ;ajout de symb_count dans symb_morse decode_check_char: movlw 6 subwf symb_count,W skpc goto decode_f06 movlw (3<<6) iorwf symb_morse,F goto decode_f07 decode_f06: swapf symb_count,F clrc rlf symb_count,W iorwf symb_morse,F decode_f07: call compare_code skpnz return ; succès movlw ERR_NOT_CHAR morse_error: call code_error bcf STATUS, Z ; échec return ;************** ; recherche d'un code dans la table ; existe dans la table morse_codes ; entrée: caractère dans la variable symb_morse ; sortie: bit Z de STATUS à 1 indique succes ;************** ;find_morse: ; movlw HIGH morse_codes ; movwf PCLATH ; clrf table_idx ;find_morse_b01: ; movfw table_idx ; call morse_codes ; xorwf symb_morse, W ; skpnz ; goto find_morse_f01 ; incf table_idx, F ; movlw table_end-morse_codes ; xorwf table_idx, W ; skpz ; goto find_morse_b01 ; bcf STATUS, Z ; échec ; return ; non trouvé ;find_morse_f01: ; trouvé ; movlw '!' ; addwf table_idx,W ; xorwf char,W ; return ;******************* ; initialisation MCU ;******************* init: ; btfss OSCCON, HFIOFS ; goto $-1 movlw 1 movwf OPTION_REG clrf ANSELA clrf WPUA bsf WPUA, KEY movlw ~((1<<spkr movwf trisa clrf lata du nco pour g la tonalit hertz nco1clk bsf nco1con movlw nco1incl nco1inch activation p des interruptions sur t0 intcon groupes de caract on commence par le groupe lettres group0: class char bound goto main group1: group2: group3: boucle programme principal l doit r entendu si correctement lumi verte s un bref instant sinon c rouge qui clignote code d en cas m est au succ passe suivant. les a-z ensuite et finalement ponctuations main: ioc_int_disable orange allum iorwf f call send_char andwf initialisation variables morse main_b01: wait_release flags msec_count evtcount lapse head tail fsr iocan iocan3 bcf iocif iocie main_b02: movfw b16l b16h w16l>>8 movwf W16H call sub16wb skpnc goto main_b02 ioc_int_disable btfss flags, F_KEYDN goto analyse tone_off bsf LATA,RED wait_release bcf LATA, RED goto next_char analyse: ; fin de caractère, analyse des données movf evtcount,F skpnz goto main_b01 call decode_morse skpz goto main ; succès bsf LATA, GREEN start_chrono 200 pause bcf LATA, GREEN next_char: incf char, F movfw bound xorwf char, W skpz goto main incf class,F movfw class xorlw 1 skpnz goto group1 xorlw 1 xorlw 2 skpnz goto group2 xorlw 2 xorlw 3 skpnz goto group3 goto group0 goto $ ;msg_table: ;qrv: ; addwf PCL,F ; dt "QRV",0 ; je suis prêt ;************************************************************* ; table des codes morse ; les bit 5-7 détermine la longueur du code ; 1-5 les bits 0-4 détermine le code ; 6,7 le code a un longueur de 6 et les bit 0-5 sont utilisés ; 0 = ti (dit), 1= taah (dah) ;************************************************************* morse_codes: addwf PCL, F dt B'11101011' ; ! -.-.-- dt B'11010010' ; " .-..-. dt B'00000000' ; # pas défini dt B'00000000' ; $ ...-..- trop long dt B'00000000' ; % pas défini dt B'10101000' ; & .-... dt B'11011110' ; ' .----. dt B'10110110' ; ( -.--. dt B'11101101' ; ) -.--.- dt B'00000000' ; * pas défini dt B'10101010' ; + .-.-. dt B'11110011' ; , --..-- dt B'11100001' ; - -....- dt B'11010101' ; . .-.-.- dt B'10110010' ; / -..-. dt B'10111111' ; 0 ----- dt B'10101111' ; 1 .---- dt B'10100111' ; 2 ..--- dt B'10100011' ; 3 ...-- dt B'10100001' ; 4 ....- dt B'10100000' ; 5 ..... dt B'10110000' ; 6 -.... dt B'10111000' ; 7 --... dt B'10111100' ; 8 ---.. dt B'10111110' ; 9 ----. dt B'11111000' ; : ---... dt B'11101010' ; ; -.-.-. dt B'00000000' ; < pas défini dt B'10110001' ; = -...- dt B'00000000' ; > pas dinini dt B'11001100' ; ? ..--.. dt B'11011010' ; @ .--.-. dt B'01000001' ; A .- dt B'10001000' ; B -... dt B'10001010' ; C -.-. dt B'01100100' ; D -.. dt B'00100000' ; E . dt B'10000010' ; F ..-. dt B'01100110' ; G --. dt B'10000000' ; H .... dt B'01000000' ; I .. dt B'10000111' ; J .--- dt B'01100101' ; K -.- dt B'10000100' ; L .-.. dt B'01000011' ; M -- dt B'01000010' ; N -. dt B'01100111' ; O --- dt B'10000110' ; P .--. dt B'10001101' ; Q --.- dt B'01100010' ; R .-. dt B'01100000' ; S ... dt B'00100001' ; T - dt B'01100001' ; U ..- dt B'10000001' ; V ...- dt B'01100011' ; W .-- dt B'10001001' ; X -..- dt B'10001011' ; Y -.-- dt B'10001100' ; Z --.. table_end: end </spkr></ircf0>

Une clé fait maison

Après avoir fait des recherches dans l'internet et constater qu'une clé morse même la plus simple de type Straight key coûte plus de 50US$ j'ai décidé d'en fabriquer une avec les matériaux que j'avais sous la main.

• base: chêne 60mm x 120mm x 20mm
• levier: chêne, longueur 90mm, épaisseur 5mm, hauteur 10mm.
• Un bouton collé avec de la colle chaude à l'extrémité du levier.
• Appui du levier: petit bloc de chêne, hauteur 22mm, largeur 18mm, profondeur 15mm. Découpé en U.
• contacts: 2 boulons chromés. Celui vissé dans la base a la tête limée pour formé une surface plate. Les fils son bobiné 3 tours sur ces boulons et soudés.
• Le ressort de rappel proviens d'un stylo à bille à pointe rétractable. Un trou est percé dans la base pour le maintenir et un petit boulon passe à travers le levier et glisse à l'intérieur du ressort.
• Un autre boulon à l'autre extrémité du levier passant à travers celui-ci permet d'ajuster la distance entre les contacts. Son extrémité est appuyé sur un autre petit bloc de chêne collé à la base.
• 2 petites équerres disponibles dans n'importe quelle quincaillerie servent de support aux prises jack 4mm.
• On ne peut le voir sur la photo mais les points de pivot du levier sont constitués de 2 têtes de vis que j'ai d'abord limé et ensuite rendu concave en utilisant un foret. l'extrémité des vis qui passent à travers le bloc supportant le levier appuient dans la cavité des têtes de vis pour former un pivot stable.

séance d'apprentissage

On ne voit pas correctement les différentes couleurs de la LED indiquant l'état, mais on peut voir que la LED clignote lorsque j'échoue à répéter correctement le code entendu. Au départ j'avais mis une tolérance de 25% sur les durées mais je l'ai augmenter à 50% car c'était trop difficile à 25%. C'est la fonction symb_len qui contrôle la valeur des durées.

références

1. code morse
2. alphabet morse
3. codes Q

De nos jours les circuits intégrés logiques sont fabriqués sur des galettes de silicium monocristallin d'une pureté de 99,999 999 99% en utilisant la technologie appellée CMOS. Dans cette article j'explique ce qu'est la technologie CMOS.

Transistor à effet de champ

Le composant actif de l'électronique moderne est le transistor. Les premiers transistors mis en marché étaient basés sur le germanium et étaient de type bipolaires. Mais rapidement le silicium a remplacé le germanium et les transistors à effet de champ ont remplacé les bipolaires. Plus spécifiquement il s'agit de transistors MOSFET ce qui est un acronyme anglophone pour Metal Oxide Semiconductor Field Eeffect Transistor. Il y a 2 types de transistors MOSFET, P-MOSFET et N-MOSFET. Ensemble ils forment une paire complémentaire d'ou l'acronyme anglophone CMOS qui signifie Complementary Metal Oxide Semiconductor.

Complémentaire

Un transistor MOSFET a 3 électrodes, le Drain, la Source et le Gate. Le G est l'électrode de contrôle, c'est à dire qu'elle permet de contrôler le courant qui circule entre le drain et la source. Le semi-conducteur de silicium situé entre le drain et la source s'appelle Channel (canal). Ce canal est séparé du gate par une mince couche d'oxyde de silicium qui est un isolant électrique. Il n'y a donc pas de courant qui circule entre le gate et la source ou le drain. Le contrôle est assuré par le champ électrique entre le gate et le canal créé par la tension appliquée sur le gate.

structure d'un transistor MOSFET

Les transistors MOSFET utilisés dans les circuits logiques sont de type enrichi. Les transistors à enrichissement ne conduisent pas lorsqu'il n'y a aucun voltage entre le gate et la source. C'est parfait pour les circuits logiques, pas de voltage le courant ne passe pas, on applique un voltage et le courant passe, c'est naturellement binaire.

Dépendant de l'élément chimique utilisé pour enrichir¹ le canal, le transistor sera de type P ou N. les symboles électroniques sont les suivants:

Les transistors N-MOSFET fonctionnent avec le drain à un voltage positif par rapport à la source et il faut appliquer un voltage positif sur le gate par rapport à la source pour les mettre en conduction.

Les transistor P-MOSFET fonctionnent avec le drain à un voltage négatif par rapport à la source et il faut appliquer un voltage négatif sur le gate par rapport à la source pour les faire conduire.

Une paire complémentaire est contruite comme ceci:

Lorsque l'entrée est au voltage Vss le transistor N-MOSFET est bloqué tandis que le P-MOSFET conduit on a donc à la sortie Vdd. L'inverse se produit lorsque l'entrée est à Vdd, on a donc un inverseur. Ce montage complémentaire est la base de toutes les portes logiques qui construisent un microprocesseur. A titre d'exemple voici le montage d'un NOR GATE:

On pourrait très bien construire un ordinateur en utilisant des transistors élémentaires complémentaires comme le 2N700 qui un N-MOSFET et le TP0606N3 qui est un P-MOSFET. Cependant il en faudrait des milliers. James Newman a d'ailleurs entrepris un tel travail, sauf qu'il n'utilise pas de paires complémentaires, seulement des NMOS. Le premiers MCU comme le 6502 du Apple II était construit en NMOS. Mais les 6502 d'ajourd'hui frabriqués par Western Design Center sont en CMOS d'ou le C dans W65C02.

L'avantage du CMOS est la faible consommation de courant. En effet s'il n'y a pas de charge de branchée à la sortie aucun courant ne passe à travers le transistor qui est en conduction. Le courant ne circule entre les 2 transistors qu'au moment de la commutation. Pendant un bref instant les 2 transistors sont en conduction partielle lorsque le voltage sur le gate est à mi-chemin entre Vss et Vdd. Comme le circuit d'un MCU est construit de portes logiques dont les sorties sont branchées sur des entrées d'autres portes logiques, le seul courant qui circule à l'intérieur du MCU est le courant de transition entre 2 états. C'est pour cette raison que lorsqu'on met un MCU en sommeil profond, c'est à dire lorsque le signal clock est arrêté, il ne consomme que des nanoampères.

Ceci explique aussi pourquoi les manufacturiers nous disent de ne pas laisser les entrées flottantes. En effet ces entrées étant à très haute impédance réagissent à tous les champs électromagnétiques environnant ce qui fait commuter les portent d'entrées rapidement de façon aléatoire d'où une consommation accru du micro-contrôleur.

notes

1. Pour avoir un semi-conducteur de type N on introduit dans le silicium des atomes qui ont 5 électrons de valence comme le phosphore, l'arsenic et l'antimoine. Pour obtenir un semi-conducteur de type P on introduit dans le silicium des atomes qui ont 3 électrons de valence comme le bore et l'indium. Ces éléments sont introduits en très faible quantité .

DEL acronyme de Diode ElectroLuminescente. La plupart du temps j'utilise l'acronyme anglophone LED. Quel est la différence entre une DEL et une diode rectificatrice? Dans le principe de fonctionnement il n'y en a pas, les deux fonctionnent selon le même principe de mécanique quantique. Dans cet article j'explique la similitude et la différence entre ces deux types de diode.

A la jonction de P et N

A la jonction de semi-conducteurs P et N il se passe un phénomène mystérieux décris par la théorie de la mécanique quantique. Lorsque les électrons traversent cette jonction ils tombent dans des trous et émettent à ce moment un photon. Ces trous ne sont pas des "nids de poules" comme on appelle les trous dans l'asphalte au Québec. Pour que vous puissiez comprendre je vais expliquer ce qu'est une jonction bipolaire dans un semi-conducteur.

Commençons par le tableau périodique. Au dessus de chaque colonne il y a un chiffre romain suivit de la lettre A ou B. Ce chiffre romain correspond au nombre d'électrons de valence. Les électrons de valence sont les électron d'un atome qui participe aux liaisons chimiques. Ces électrons sont faiblement liés au noyau de l'atome et peuvent être libérés de l'emprise de celui-ci facilement. Il y a 3 colonnes qui intéressent les ingénieurs qui fabriquent des composants électroniques à base de semi-conducteurs: 13, 14 et 15. Dans la colonne 14 on retrouve le silicium et le germanium. Dans la colonne 13 le gallium et dans la colonne 15 l'arsenic.

Le silicium a 4 électrons de valence et est utilisé pour fabriquer la majorité des composants semi-conducteurs. Le gallium a 3 électrons de valence et l'arsenic en a 5. Si on forme un cristal avec de l'arséniure de gallium GaAs on obtient un semi-conducteur qui a en moyenne 4 électrons de valence. Les diodes rectificatrices sont fabriquées avec du silicium et les LED qui émettent dans le visible avec de l'arséniure de gallium.

Un semi-conducteur de type P est un semi-conducteur dans lequel a été ajouté un élément qui n'a que 3 électrons de valence. Ce qui a pour effet de créé des trous dans le réseau cristallin. C'est à dire qu'il manque des électrons pour assurer les liaisons atomiques. Le bore et l'indium sont souvent utilisés pour ce rôle.

Un semi-conducteur de type N est un semi-conducteur dans lequel a été ajouté un élément qui possède 5 électrons de valence. Dans ce cas on a un réseau cristallin qui a un surplus d'électrons. Le phosphore est souvent utilisé pour ce rôle.

Les semi-conducteurs de type P sont donc des capteurs d'électrons et les type N sont des donneurs d'électrons.

Dans une chambre à vide ou la galette de silicium ou d'arséniure de gallium est installée on bombarde celle-ci avec des atomes d'impureté, mettons des atomes de bore pour créer un semi-conducteur de type P. Ces atomes de bore s'installent dans le réseau cristallin. Ensuite on bombarde la galette avec des atomes de phosphore mais avec moins d'énergie pour qu'ils s'enfoncent moins profondément. On obtient ainsi une jonction bipolaire PN. C'est à dire une diode¹.

Lorsqu'on applique une tension électrique positive sur l'anode par rapport à la cathode les électrons traversent la jonction et viennent combler le manque d'électron. Lorsqu'un électron comble l'absence d'un électron dans le réseau cristallin de type P il perd de l'énergie. En terme quantique il passe à un niveau d'énergie inférieur. Comme l'énergie ne se perd pas cette énergie libérée est émise sous forme de photon, c'est à dire de lumière. La longueur d'onde de ce photon ou si vous préférez sa couleur dépend de la différence d'énergie entre les 2 niveaux.

bandes d'énergie

Dans les conducteurs il y a toujours des électrons dans la bande de conduction. Dans cette bande l'énergie des électrons est plus élevée que dans la bande de valence. dans un semi-conducteur les électrons dans la bande de conduction sont plus rare, c'est pourquoi ils conduisent mal l'électricité. C'est lorsqu'un électron passe de la bande de conduction à la bande de valence qu'il libère le surplus d'énergie sous forme de photon. Dans les diodes au silicium l'énergie est plutôt libérée sous forme de phonon. Un phonon est une vibration qui se propage dan le réseau cristallin.

Barrière de potentiel et niveaux d'énergies

Dans la région à la jonction de la zone P et N il y a une zone appauvrie. Une zone ou l'influence du phosphore et du bore s'annule mutuellement. Cette zone forme une barrière qui empêche le courant de circuler à travers la jonction. Il faut que les électrons possèdent une énergie minimale pour franchir cette barrière. Cette valeur correspond au voltage minimum nécessaire pour que la diode conduise. Pour une diode au silicium c'est environ 0,65 volt. Pour les DEL ça dépend du type de DEL, pour les rouges c'est environ 2,1 volt, 2,4 pour les vertes et 3,4 pour les bleues.

La valeur de cette barrière de potentiel est lié à l'énergie nécessaire pour arracher les électrons au réseau cristallin. Pour les faire sortir de leur trou. L'énergie d'un photon est inversement proportionnel à sa longueur d'onde donc une DEL qui émet de photons bleus a une barrière de potentiel plus élevée qu'une DEL qui émet des photons rouges.

photo-sensibilité

On a dit que lorsqu'un électron tombe dans un trou il émet un photon dont l'énergie égale la différence d'énergie que l'électron dans la bande de conduction avait et celle qu'il a une fois coincé dans le réseau cristallin (bande de valence). Cette différence d'énergie s'appelle bande interdite ou band gap en anglais. Bande interdite parce que l'électron ne peut occupé un niveau d'énergie intermédiaire entre ces 2 niveaux. C'est ça la nature quantique de l'univers subatomique.

Si un électron émet un photon lorsqu'il tombe dans un trou le contraire est aussi vrai. Un photon peut déloger un électron de son trou en lui communiquant son énergie. En conséquence toute DEL est photo-sensible. Connectez un voltmètre aux électrodes d'une DEL et exposez celle-ci à la lumière. vous constaterez qu'il y a un voltage aux bornes de la DEL. couvrez la DEL et le voltage disparait. La jonction absorbe les photons et déloge des électrons du réseau cristallin. Il va sans dire que la DEL est particulièrement sensible à la même longueur d'onde qu'elle émet.

Sens unique

Au fait pourquoi une diode ne conduit que dans un sens? C'est simple les trous n'ont pas de mobilité se sont les électrons qui se déplacent dans le réseau. Si on applique le voltage positif sur la cathode les électrons s'éloignent de la jonction plutôt que de la traverser. la zone appauvrie s'élargie au lieu de se rétrécir. Cependant si le voltage est suffisamment élevé les électrons peuvent-être arrachés du réseau dans la partie P de la diode et traverser la jonction. le voltage ou ce phénomène se produit est la tension de claquage ou breakdown voltage en anglais. Lorsque cette tension est atteinte il se produit un phénomène d'avalanche. C'est à dire que les électrons ainsi délogés du réseau cristallin possèdent suffisamment d'énergie pour à leur tour déloger d'autres électrons. Le courant augmente donc rapidement et si le phénomène n'est pas contrôlé il conduit à la destruction de la diode. Les diodes zener utilisent ce principe d'avalanche.

notes

1. Notez que bien que j'ai indiqué le bore dans le dessin comme impureté pour le côté P de la jonction en ce qui concerne les DEL l'aluminium et l'indium sont plutôt utilisés. Le bore lui est utilisé avec le silicium. Si vous consultez les feuillets de spécifications des DEL vous verrez des compositions du genre InAlGaP, InGaN/GaN ou GaAlAs. In pour indium colonne 13 donc 3 électrons de valence. Al pour Aluminium aussi dans la colonne 13 donc aussi 3 électrons de valence. N pour azote, colonne 15 donc 5 électrons de valence. As pour Arsenic colonne 15. Le choix des éléments dépend du niveau d'énergie entre la bande de conduction et la bande de valence, ce qui détermine la longueur d'onde.

Dans l'article précédent sur les DEL j'expliquais le fonctionnement des DEL par la quantisation des niveaux d'énergies dans les couches électroniques des atomes. Dans cet article je vais expliquer 2 autres phénomènes utilisés en électronique qui sont aussi des phénomènes quantiques. L'ionisation et la fluorescence.

enseigne au néon

Vous connaissez surement ces enseignes lumineuses qu'on appelle communément néon. On peut aussi se procurer sur le marché de petites ampoules au néon servant comme indicateur bien que celles-ci ont largement été remplacées par les DEL. Enseigne ou ampoule le principe de fonctionnement est le même, l'ionisation d'un gaz. Dans une tube ou une ampoule sous vide on introduit un gaz sous faible pression. Dans ce tube il y a 2 électrodes isolées l'une de l'autre. Si on applique un voltage suffisant à ces électrodes il y a production de lumière. Le phénomène est le suivant, le champ électrique arrache les électrons de l'atome. On dit d'un gaz dont les atomes perdu 1 ou plusieurs électrons qu'il est ionisé¹. Mais les lois de la physique font en sorte que la matière cherche à se stabiliser au plus bas niveau d'énergie. Les atomes ionisés possèdent un charge positive qui attire les électrons. Ceux-ci retombent donc dans leur position initiale en émettant un photon. l'énergie de se photon donc sa longueur d'onde dépend de la différence d'énergie entre l'électron libre et l'électron capturé par l'atome. Un gaz ionisé n'émet pas une seule fréquence lumineuse mais plusieurs on appelle ces différentes fréquences lumineuse le spectre. Chaque élément chimique possède son propre spectre lumineux qui l'identifie de façon unique. C'est en faisant cette analyse spectrale que les astronomes parviennent à identifier les éléments chimiques qui composent les étoiles et l'atmosphère des autres planètes. Le néon semble orange ou rouge à l’œil parce que c'est la longueur d'onde dominante de son spectre. Si on remplace le néon par un autre gaz la couleur sera différente. Une enseigne au néon qui n'est pas rouge n'est pas en réalité une enseigne au néon mais contient plutôt un autre gaz et l'intérieur du tube est recouvert d'une substance chimique fluorescente. Les petites ampoules néon émettent une lumière orange mais si on augmente le voltage elle deviennent rouges. Si vous alimenter une ampoule néon en courant direct la luminosité sera centrée autour d'une seule des 2 électrodes, la plus positive car les électrons émis par l'autre électrode doivent avoir suffisamment d'énergie cinétique pour ionizer le gaz. Les électrons gagnent en vitesse en se déplaçant vers l'électrode positive. En courant alternatif la luminosité est centrée autour des 2 électrodes car les électrons se déplacent alternativement dans les 2 directions.

« Neon light ». Sous licence CC BY-SA 3.0 via Wikimedia Commons.

indicateur neon A1A

Fluorescence

La première calculatrice que j'ai acheté dans les années 70 était de marque Rockwell et avait un affichage VFD Vacuum Fluorescent Display. A l'intérieur d'un tube de verre dans lequel on a fait le vide il y a plusieurs électrodes. Une cathode qui émet des électrons et des anodes recouvertes d'une substance chimique fluorescente. Entre la cathode et les anodes il y a aussi une grille. Cet agencement est semblable au tube électronique appelé triode sauf qu'il n'est pas conçu pour amplifier un signal mais pour émettre de la lumière. Donc un voltage positif sur une anode attire les électrons générés par la cathode ces électrons accélérés viennent frapper la substance chimique qui est sur l'anode. L'énergie de ces électrons ce communique aux électrons de la substance chimique qui sautent à un niveau d'énergie supérieur. Mais comme dans le cas d'un gaz ionisé les électrons retombent à leur niveau d'énergie initiale en émettant un photon.

Dans un VFD il y a une anode par segment d'affichage. Par exemple s'il s'agit d'une calculatrice on a 8 segments par chiffre en incluant le point pour les décimales. Chaque anode doit-être contrôlée individuellement. En fait l'affichage est multiplexée. C'est à dire qu'il y a une cathode par chiffre et seulement 8 électrodes partagées par tous les chiffres. Un seul chiffre est allumé à la fois. La persistance rétinienne nous fait croire qu'ils sont tous allumés simultanément. La grille elle sert a contrôler l'intensité de l'affichage. Si on applique un voltage négatif sur la grille il y aura moins d'électrons qui passeront de la cathode aux anodes.

Tube fluorescent

Qu'il s'agisse de fluo-compact ou de tube fluorescent le principe est le même et combine 2 principes l'ionisation d'un gaz et la fluorescence/phosphorescence².

« Leuchtstofflampen-chtaube050409 » par Christian Taube. Sous licence CC BY-SA 2.0 de via Wikimedia Commons.

« 02 Spiral CFL Bulb 2010-03-08 (black back) » par Sun Ladder— Travail personnel. Sous licence CC BY-SA 3.0 via Wikimedia Commons.

Dans le tube il y a une faible pression de vapeur de mercure. Le champ électrique ionise le gaz mercure. Le gaz ionisé a un spectre qui émet principalement dans le violet et l'ultraviolet. l'intérieur du tube, comme pour les enseignes au néon de couleur variées, est recouvert d'une substance chimique fluorescente. Cette substance capte les photons ultraviolet et réémet dans le visible. Le spectre lumineux émis dépend de(s) substances utilisé(es). En passant les DEL blanches sont en fait des DEL bleues recouverte elle aussi d'une substance fluorescence. Lorsqu'on achète des tubes fluorescent ou des fluocompacte l'embalage spécifie le spectre d'émission par une température, 2700°, 3000°, etc. Cette température correspond à un autre concept de la mécanique quantique appelé émission du corps noir. Une basse température correspond à un éclaire plus jaune (doux) et une haute température à un éclairage plus bleu (dur). Un éclairage daylight correspond à un spectre d'émission qui se rapproche de celui-du soleil.

notes

1. Lorsqu'un gaz contient suffisamment d'atomes ionisés pour devenir un conducteur électrique on parle alors de plasma. C'est ce qui se produit lors d'un orage électrique.
2. Pour comprendre la différence entre fluorescence et phosphorescence voir l'article wikipédia.

Depuis 10 ans Intel et Micron travaillent conjointement sur un projet commun et voilà qu'ils on annoncés hier la mise en marché prochaine de cette nouvelle technologie. Il s'agit d'une mémoire persistance appellée 3D xpoint qui offre des performances nettement supérieure à la mémoire flash. Pour le moment cette mémoire n'est disponible que pour les manufacturiers pour essais et développement de produits. Mais elle devrais-être disponible chez les distributeurs de composants dès 2016.

De quoi s'agit-il?

Il n'y a pas grand détail mais à la lecture de l'annonce faites par Intel et cet article sur le site de la BBC, je crois comprendre qu'il s'agit d'une technologie de type memristor. Il n'y a pas de transistors ce qui permet une plus grande densité. Chaque bit de mémoire est constitué simplement d'un certain type de cristal dont la résistance varie lorsqu'un courant passe à travers celui-ci. Cette variation de résistance persiste après que le courant a cessé. Il s'agit donc d'une mémoire permanente.

Avantages

Par rapport à la mémoire flash cette mémoire a plusieurs avantages.

• 1000 fois plus rapide que la mémoire flash NAND. Donc un MCU qui utiliserais ce type de mémoire pour stocker son programme ne serait pas limité à 40Mhz comme c'est le cas actuellement. Actuellement les MCU dont le core fonctionne au delà de 40Mhz utilisent des wait state et une forme de mémoire cache pour l'accès programme.
• 1000 fois plus durable que la mémoire flash NAND. Donc un MCU qui utiliserais cette mémoire au lieu de la flash pourrait être reprogrammé un nombre illimité de fois sans crainte d'user la mémoire programme. Donc une application pourrait utiliser la mémoire programme pour stocker des données.

J'ai hâte de voir si les manufacturiers de MCU vont adopter cette technologie sous licence pour leur MCUs. Déjà Texas Instruments offre quelque chose dans le même genre avec sa propre technologie FRAM. La FRAM (Ferro Magnetic RAM) est une technologie différente du 3D xpoint mais qui est elle aussi persistance, plus endurante et plus rapide que la FLASH.

Il reste à voir à quel coût cette technologie sera disponible. Si c'est le même coût que la mémoire FRAM de TI les MCUs l'utilisant seront plus coûteux que ceux utilisant la mémoire NAND FLASH.

Lorsque j'ai appris le langage C il y a longtemps l'un des concepts qui m'a donné le plus de difficulté est celui concernant l'usage des variables pointeurs. Cet article est à l'usage de ceux qui débutent en C est qui auraient la même difficulté.

coup d’œil sur les registres interne d'un MCU

Prenons un MCU quelconque, par exemple un PIC12F1822. Si on regarde le modèle de programmation du cœur de ce MCU on voit ceci.

Les registres FSR0 et FSR1 sont ce qu'on appelle des registres d'index, c'est à dire des variables pointeurs. Supposons qu'on écris un programme en mpasm et qu'on veut initialiser la RAM commune à zéro que fait-on?

;sous-routine pour effacer ram commune 0x70-0x7f
clear_common_ram:
;initialistion du pointeur
    clrf FSR0H
    movlw H'70'
    movwf FSR0
    clrf WREG 
clear_loop:
    movwi, FSR0++ ; adressage indirect avec post-incrément
    btfss FSR0,7
    bra clr_loop
    return ; terminé car FSR0==0x80

;sous-routine pour effacer ram commune 0x70-0x7f
clear_common_ram:
    movlw H'70'
    movwf FSR0
clear_loop:
    clrf FSR0 ; adressage indirect
    incf FSR0,F ; incrémente le pointeur
    btfss FSR0,7
    bra clr_loop
    return ; terminé car FSR0==0x80

la même chose en C

répétons le même programme en C

void clear_common_ram(){
    char *p;
    p=(char*)0x70;
    while(((int)p&0x80)==0){
        *p++=0; 
    }           
}

variable pointeur

Dans tout langage de programmation une variable est une adresse en mémoire dans laquelle une information est conservée. Dans l'exemple ci-haut p ne fait pas exception, c'est une adresse mémoire dans laquelle on va garder une information mais cette information n'est pas un char mais une adresse qui indique un autre endroit en mémoire ou est conservé une donnée de type char. Ça a peut-être l'air plus compliqué que la version mpasm mais c'est presque la même chose. Lorsqu'on déclare la variable p l'étoile * avant le p informe le compilateur que cette variable va contenir une autre adresse et non un char.

l'instruction *p++=0; indique qu'on veut modifier le contenu de l'adresse pointée par p et non le contenu de p lui-même. Ici l'étoile * n'a pas la même signification que lorsqu'on déclare la variable. Elle signifie plutôt un adressage indirect. Dans de nombreux assembleurs l'adressage indirect (par pointeur) est indiqué par le nom du registre qui sert de pointeur entre crochet comme ceci:

    LOAD R0,[R15]

Quand le programme compilé va s'exécuter, il va aller chercher la valeur de p et la mettre dans FSR0 ou FSR1. ensuite il va mettre WREGà zéro et effectuée une boucle très semblable à celle d'écrite ci-haut dans la version mpsasm.

J'ai fait un test dans MPLAPX en compilant avec XC8 free (pas d'optimisation) voici le résultat dans le disassembly listing

11:            void clear_common_ram(){
12:                char *p;
13:                p=(char*)0x70;
07ED  3070     MOVLW 0x70
07EE  00F0     MOVWF __pcstackCOMMON
07EF  3000     MOVLW 0x0
07F0  00F1     MOVWF 0x71
14:                while(((int)p&0x80)==0){
07F1  1BF0     BTFSC __pcstackCOMMON, 0x7
07F2  0008     RETURN
07FC  2FF1     GOTO 0x7F1
15:                    *p++=0;
07F3  0870     MOVF __pcstackCOMMON, W
07F4  0086     MOVWF FSR1
07F5  0871     MOVF 0x71, W
07F6  0087     MOVWF FSR1H
07F7  0181     CLRF INDF1
07F8  3001     MOVLW 0x1
07F9  07F0     ADDWF __pcstackCOMMON, F
07FA  3000     MOVLW 0x0
07FB  3DF1     ADDWFC 0x71, F
16:                }
17:            }

clear_common_ram:
; initialisation du pointeur p
; le compilateur a choisi FSR1 comme pointeur
; les FSR du PIC12F1822 sont de 16 bits
    movlw 0x70
    movwf FSR1L
    movlw 0
    movwf FSR1H
clear_loop:
    btfsc FSR1L,7
    return
    clrf INDF1
    ; fsr1 a 16 bits, incrément par addition de 1
    movlw 1
    addwf FSR1L
    movlw 0
    addwfc FSR1H
    goto clear_loop

Lorsqu'on déclare un tableau en C i.e. char tableau[10];, le compilateur va aussi utiliser un registre d'index pour atteindre les éléments de ce tableau, i.e. b=tableau[2]; se traduis en assembleur par:

;initialise le pointeur
   movlw LOW tableau
   movwf FSR0L
   movlw HIGH tableau
   movwf FSR0H
;va cherché la valeur dans le 3ième élément du tableau.
   moviw 2[FSR0]; WREG=indirection:[FSR0+2]
   movwf  b  ; assigne cette valeur à b

adresse d'une variable ordinaire

Si l'étoile avant le nom d'un pointeur sert à indiquer une indirection,on dit déréférencer, comment fait on pour obtenir l'adresse mémoire où est stocké le contenu d'une variable ordinaire:

int b=0, *p;

   p=&b;
   *p=34; // que contient b?

Que ferais-je sans toi

En effet comment ferait-on sans pointeurs pour adresser un tableau ou n'importe qu'elle étendu de mémoire? J'espère donc que cette présentation a clarifié la question des pointeurs.

Cette Article est une réaction à l'article d'Elliot Williams paru sur Hackaday.com le 28 juillet 2015. La question est la suivante: est-ce qu'un sketch Arduino est un programme C++?

L'argument d'Elliot Williams est que derrière la scène, l'environnement Arduino est basé sur C++ et que la syntaxe des sketch Arduino est la même que la syntaxe de C++. Un sketch Arduino est simplement pré-traité pour y apporter les éléments manquants pour en faire un programme C++ compilable par GCC.

Arduino refence

Jetons un coup d'oeil au manuel de référence du langage Arduino. En effet tous les éléments de la syntaxe sont les même que ceux du C++. Mais est-il question ce classes, objets, etc? non.

Le langage Arduino est un sous-ensemble du langage C++. Un sous-ensemble d'un ensemble n'est pas l'ensemble lui-même.

Si on ajoute des éléments du C++ qui ne sont pas dans la référence du langage Arduino comme par exemple des classes d'objets et des instances d'objets, le script va compiler correctement donc c'est du C++ dit M. Williams.

Personnellement je considère que tout fichier qui a besoin d'être pré-traité avant d'être compiler avec gcc n'est pas du C++ à proprement parler même si les éléments manquant peuvent-être ajoutés manuellement dans le fichier sketch. par exemple les prototypes de fonctions ne sont pas requis dans la référence du langage Arduino mais ils le sont par C/C++. Arduino utilise donc un pré-traitement qui lui est propre et qui sert entre autre à ajouter ces prototypes de fonctions ainsi qu'à ajouter un #include pour la librairie Arduino.

exemple

Voici un exemple d'un sketch Arduino auquel j'ai ajouter une classe C++. * Blinker est une classe qui fait clignoter un LED a une fréquence donnée sur la pin 13 */ // Pin 13 connecté à un LED sur la carte Arduino. int led = 13; // setup est exécuté 1 fois au reset de la carte void setup() { // initialisation broche LED comme sortie digitale pinMode(led, OUTPUT); } // classe blinker class blinker { public: blinker(int dly); int getValue() const { return this->value; } // définition au sein de la classe void setValue(int value); void blink() const; private: int value; // blink rate }; blinker::blinker(int dly){ this->value=dly; } inline void blinker::setValue(int value) // définition en dehors de la classe (inline) { this->value = value; } void blinker::blink() const // définition en dehors de la classe (non inline) { digitalWrite(led, HIGH); // allume LED delay(this->value); // délais déterminé par value digitalWrite(led, LOW); // éteint LED delay(this->value); // délais déterminé par value } // the loop routine runs over and over again forever: void loop() { static blinker blinky(1000); //static que ce soit initialisé 1 seule fois. blinky.blink(); } le pré-traitement Arduino transforme le sketch en fichieer .cpp suivant: #line 1 "sketch_aug05a.ino" /* Blinker est une classe qui fait clignoter un LED a une fr\u00e9quence donn\u00e9e sur la pin 13 */ // Pin 13 connect\u00e9 \u00e0 un LED sur la carte Arduino. #include "Arduino.h" void setup(); void loop(); #line 8 int led = 13; // setup est ex\u00e9cut\u00e9 1 fois au reset de la carte void setup() { // initialisation broche LED comme sortie digitale pinMode(led, OUTPUT); } // classe blinker class blinker { public: blinker(int dly); int getValue() const { return this->value; } // d\u00e9finition au sein de la classe void setValue(int value); void blink() const; private: int value; // blink rate }; blinker::blinker(int dly){ this->value=dly; } inline void blinker::setValue(int value) // d\u00e9finition en dehors de la classe (inline) { this->value = value; } void blinker::blink() const // d\u00e9finition en dehors de la classe (non inline) { digitalWrite(led, HIGH); // allume LED delay(this->value); // d\u00e9lais d\u00e9termin\u00e9 par value digitalWrite(led, LOW); // \u00e9teint LED delay(this->value); // d\u00e9lais d\u00e9termin\u00e9 par value } // the loop routine runs over and over again forever: void loop() { static blinker blinky(1000); //static que ce soit initialis\u00e9 1 seule fois. blinky.blink(); }

Pourquoi est-ce que j'insiste sur ces détails? A cause de la philosophie d'Arduino. Arduino a été créé pour simplifier l'utilisation des microcontrôleurs pour les rendre accessibles aux non spécialistes. C'est ce qui fait tout l'intérêt d'Arduino. Les spécialistes n'utilisent généralement pas Arduino, car ils n'en ont tout simplement bas besoin et pour eux l'IDE Arduino est d'une utilisation frustrante car cet environnement simplifié n'offre pas les outils auxquels ils sont habituer.

Donc lorsque certains comme M. Williams, veulent expliquer aux utilisateurs d'Arduino qu'en fait ceci c'est du C++ alors moi je dis qu'ils non pas compris l'objet du projet Arduino: garder ça le plus simple possible pour que les amateurs puisse utiliser la plateforme avec une difficulté d'apprentissage minimisée. Si éventuellement ces amateurs deviennent des professionnels ils n'auront plus besoin d'Arduino.

Combien coûtait un disque dur de 26Mo en 1980?

réponse: 4995US$

Cette information me viens d'une publicité parue à la page 53 de BYTEédition du mois d'août 1980¹. La publicité qualifie ce prix de HARD BARGAIN. Toute une aubaine! Et ce sont des dollars de 1980. Si on tiens compte de l'inflation en me fiant à l'information trouvé ici, ça ferais en dollars d'aujourd'hui 14 350US$².

notes

1. Cette édition de BYTE consacré à FORTH peut-être téléchargée à partir de ce lien.
2. Pour l'année 1980 j'ai utilisé le ratio <inflation ajusted $>/<nominal $> * 4995

J'ai conçu plusieurs projets générant un signal NTSC monochrome et les ai branchés sur 3 téléviseurs différents avec succès. Mais voilà que dernièrement j'ai du remplacé mon téléviseur par un de modèle RCA. Comme cette semaine j'ai repris le projet CHIPcon dans le but de remplacer le clavier hexadécimal par un joystick Atari 2600. Je branche CHIPcon v2 sur mon téléviseur RCA... pas de vidéo! Pourtant il fonctionne très bien sur mon petit moniteur de développement. Je n'ai pas été long à figurer d'où provenait le problème.

Standard NTSC

En fait la sortie NTSC que j'utilise n'est pas conforme au standard. Il s'agit d'une version simplifiée appellée balayage progressif sans alternance de champ (field). De plus la synchronisation verticale est aussi simplifiée et consiste à simplement rallonger l'impulsion de synchronisation pour les lignes 1 à 3.

Le standard NTSC lui définie une alternance de field pair et impair. Chaque field ayant chacun 262,5 lignes pour un total de 525 lignes par image puisque les lignes des champs pair et impaire sont inter-lacées. Ceci a pour but d'éviter le scintillement de l'image tout en réduisant la bande passante requise par le signal vidéo puisqu'il n'y a que 262,5 lignes de transmise par champ. Chaque champ n'est affiché que 30 fois par seconde en alternance pair/impair même si le balayage vertical est à la fréquence de 60 fois par seconde. Astucieux!

Dans la version que j'utilise il n'y a que 262 lignes répétées 60 fois par secondes sans inter-lacement.

Solution au problème

Heureusement la solution à ce problème était simple et consistait à une modification de la routine d'interruption vidéo ISR(TIMER1_COMPB_vect) située dans le fichier tvout.c Voici la version originale présentée dans CHIPcon et la version conforme à NTSC corrigée pour CHIPcon v2.

NTSC balayage progressif

#define HTIME (1015) #define HPULSE (74) #define VPULSE (HTIME-2*HPULSE) #define HRES (128) volatile uint8_t frame_delay=0; volatile uint8_t tone_length=0; volatile uint8_t speed_delay=0; static volatile uint16_t line_count=0; static volatile uint8_t video=0; // interruption à la fin de // chaque pulse de synchronisation ISR(TIMER1_COMPB_vect){ register unsigned i; register unsigned char *buff; line_count++; switch(line_count){ case 1: if (frame_delay) frame_delay--; break; case 2: if (tone_length){ tone_length--; if (!tone_length) tone_off(); } break; case 3: NTSC_SYNC_OCRB=HPULSE; break; case 4: if (speed_delay) speed_delay--; break; case 5: ADCSRA |= (1<<adsc break case first_visible: video="1;" last_visible: line_count="0;" ntsc_sync_ocrb="VPULSE;" default: if buff="video_buffer+(((line_count-FIRST_VISIBLE)">>1)*HBYTES); NTSC_VIDEO_UBRR=0; NTSC_VIDEO_UCSRB=(1<<txen0 ntsc_video_ubrr="2;" ntsc_video_udr="0x0;" for while ucsr0a ntsc_video_ucsrb break></txen0></adsc>

NTSC conforme

#define HTIME (1015) #define HALFLINE (HTIME>>1) #define HPULSE (74) #define SERATION (HPULSE>>1) volatile uint8_t frame_delay=0; volatile uint8_t tone_length=0; static volatile int16_t line_count=-1; static volatile uint8_t video=0; static volatile bool even=true; // interruption à la fin de // chaque pulse de synchronisation ISR(TIMER1_COMPB_vect){ register unsigned i; register unsigned char *buff; line_count++; switch(line_count){ case 0: NTSC_SYNC_OCRA=HALFLINE; //period NTSC_SYNC_OCRB=SERATION; //pulse width break; case 6: NTSC_SYNC_OCRB=HALFLINE-SERATION; break; case 12: NTSC_SYNC_OCRB=SERATION; break; case 18: NTSC_SYNC_OCRA=HTIME; NTSC_SYNC_OCRB=HPULSE; break; case 19: if (frame_delay) frame_delay--; break; case 20: if (tone_length){ tone_length--; if (!tone_length) tone_off(); } break; case FIRST_VISIBLE: video=1; break; case LAST_VISIBLE: video=0; break; case 271: if (even){ line_count=-1; even=false; } break; case 272: if (!even){ line_count=-1; even=true; } default: if (video){ buff=video_buffer+(((line_count-FIRST_VISIBLE)>>1)*HBYTES); NTSC_VIDEO_UBRR=0; NTSC_VIDEO_UCSRB=(1<<txen0 ntsc_video_ubrr="2;" ntsc_video_udr="0x0;" for while ucsr0a ntsc_video_ucsrb break></txen0>

Notez que ceci n'augmente pas la résolution verticale qui demeure à 262¹ lignes puisque le même video_buffer est utilisé pour les 2 champs pair et impair.

conclusion

La morale de cette histoire est que si vous voulez que votre projet fonctionne sur tous les téléviseurs il vaut mieux qu'il se conforme au standard NTSC, car on ne sais jamais quand on aura affaire à un téléviseur pointilleux.

NOTES:

1. Les 262 lignes ne sont pas toutes visibles, 21 de ces lignes font partie du vertical retrace. De plus sur les téléviseurs que j'ai essayé il y a environ 230 lignes visibles en balayage progressif. En respectant le standard et en utilisant l'entre-lacement on obtiendrait donc 460 lignes au coup d'un buffer vidéo 2 fois plus grand.

Dans l'article précédent intitulé téléviseur conformiste je présentait un problème et sa solution concernant la génération d'un signal NTSC sur ATmega328P. Mais la solution présentée n'était pas optimum, il y avait un tremblement dans l'image. Aujourd'hui j'ai réglé ce problème et dans cet article j'explique la cause de ce tremblement et la solution que j'ai apportée.

Vidéo avant la correction du problème on voit le tremblement de l'image surtout apparent sur la ligne verticale à droite de l'écran.

Vidéo après correction du problème. Maintenant l'image est très stable. Il n'y a plus de Parkinson.

La gigue d'interruption

J'ai tapé dans google search: traduire: interrupt jitter et c'est la traduction que j'ai obtenu!

Le générateur de signal NTSC utilise une interruption pour modifier les paramètres du signal PWM qui génère la synchronisation mais aussi pour déterminer quand il est temps d'envoyer les pixels vidéo pour chaque ligne visible à l'écran. En ce qui concerne la synchronisation l'interrupt jitter n'affecte pas son fonctionnement puisque cette synchronisation utilise le compteur TCNT1 dont le fonctionnement est indépendant des interruptions. Par contre pour l'envoie des pixels vidéo il y a une influence. Il est primordial que l'envoie du signal vidéo débute toujours au même instant à chaque ligne ainsi qu'à chaque répétion de frame.

Le problème est que le temps de réponse de l'interruption est variable car il est influencé par la durée de l'exécution de l'instruction machine en cours au moment où se produit l'interruption. En effet le MCU doit attendre la fin de l'instruction en cours avant de répondre à l'interruption. Hors sur les AVR le temps d'exécution d'une instruction varie entre 1 et 4 cycles. La durée d'un pixel dans ce générateur vidéo est de 6 cycles machines. Donc une fluctuation de 4 cycles sur le départ de la ligne vidéo c'est 2/3 de pixel en largeur. C'est cette fluctuation qu'on perçoit dans l'image.

Comment régler ce problème

Comme je l'ai dit le fonctionnement du compteur TCNT1 est indépendant des interruptions on peut donc se fier à son fonctionnement pour avoir l'heure juste, si je peut dire. Dans cette application le compteur est cadencé à la même fréquence que le coeur du MCU. Donc lorsqu'il est temps de générer les pixels vidéo d'une ligne sa valeur est toujours la même à 4 cycles près. Le code assembleur que j'ai ajouté lit l'octet faible de TCNT1 qui est un compteur de 16 bits et ne garde que les 2 bits les plus faibles, donc cette valeur peut variée de 0 à 3 du au jitter. Je prends pour cible la valeur 3 et si le compte est inférieur à 3 on ajoute autant d'instruction NOP que nécessaire pour que lorsque le programme arrive au code qui génère le vidéo le compte de TCNT1 soit toujours le même. Puisque c'est TCNT1 qui détermine le début de la ligne vidéo, à compte égal de celui-ci on est à la même position sur la ligne vidéo.

Pour obtenir un timing précis j'ai du écrire le code en embedded assembly. Voici le code ajouté à la routine d'interruption vidéo TIMER1_COMPB_vect dans tvout.c.

 asm(// élimination de la gigue d'interuption (jitter)
"ldi r30,lo8(jit)\n"
"ldi r31,hi8(jit)\n"
"clc\n"
"ror r31\n"
"ror r30\n"
"lds r24,0x84\n"
"andi r24,3\n"
"add r30,r24\n"
"adc r31,r1\n"
"ijmp\n"
"jit:"
"nop\n"
"nop\n"
"nop\n"
"nop\n"
 );

Au bout du compte lorsque le PC arrive à l'instruction qui suis le dernier NOP, le compteur TNCT1 a toujours la même valeur puisqu'il est incrémenté au même rythme que le compteur ordinal (pointeur d'instruction).

routine TIMER1_COMPB_vect

Voici la routine d'interruption au complet. Je rappelle que ceci fait parti du projet open sourde CHIPcon v2. volatile uint8_t frame_delay=0; volatile uint8_t tone_length=0; // interruption à la fin de // chaque pulse de synchronisation ISR(TIMER1_COMPB_vect){ static int16_t line_count=-1; static uint8_t video=0; static bool even=true; register unsigned i; register unsigned char *video_line; line_count++; switch(line_count){ case 0: NTSC_SYNC_OCRA=HALFLINE; //period NTSC_SYNC_OCRB=SERATION; //pulse width break; case 6: NTSC_SYNC_OCRB=HALFLINE-SERATION; break; case 12: NTSC_SYNC_OCRB=SERATION; break; case 18: NTSC_SYNC_OCRA=HTIME; NTSC_SYNC_OCRB=HPULSE; break; case 19: if (frame_delay) frame_delay--; break; case 20: if (tone_length){ tone_length--; if (!tone_length) tone_off(); } break; case FIRST_VISIBLE: video=1; break; case LAST_VISIBLE: video=0; break; case 271: if (even){ line_count=-1; even=false; } break; case 272: line_count=-1; even=true; break; default: if (video){ asm(// élimination de la gigue d'interuption (jitter) "ldi r30,lo8(jit)\n""ldi r31,hi8(jit)\n""clc\n""ror r31\n""ror r30\n""lds r24,0x84\n""andi r24,3\n""add r30,r24\n""adc r31,r1\n""ijmp\n""jit:""nop\n""nop\n""nop\n""nop\n" ); NTSC_VIDEO_UDR=0x0; NTSC_VIDEO_UCSRB=(1<<txen0 video_line="video_buffer+(((line_count-FIRST_VISIBLE)">>1)*HBYTES); for (i=HBYTES;i;i--){ while ( !( NTSC_VIDEO_UCSRA & (1<<udre0 ntsc_video_udr="*video_line++;" while ntsc_video_ucsrb break></udre0></txen0>