Bonsoir tout le monde...
 
Comme vous pouvez le constater, je n'ai toujours pas réussi a faire ma programmation de PIC...
 
Bon mon programme fonctionne parfaitement en simulation. Seulement, après l'avoir loader dans le pic via MPLAB ICD 2, ça ne marchhhee paaaaaas
 
Le premier gros problème que j'ai, c'est que mon PIC fait des conversions analogiques digitales ANARCHIQUES !!!
 
Il met vraiment ce qu'il veut... Je n'arrive pas à comprendre pourquoi.
 
Peut être que qlqun pourrait m'aider?
 
Merci
 
[CODE]
 LIST      p=18F2525            
 #include <p18F2525.inc>            
 
 CONFIG  OSC  = INTIO67
 CONFIG FCMEN =  OFF
 CONFIG IESO  =  OFF
 CONFIG PWRT  = OFF
 CONFIG BOREN = OFF
 CONFIG WDT  = OFF
 CONFIG MCLRE = OFF
 CONFIG LPT1OSC = OFF
 CONFIG PBADEN = OFF
 CONFIG DEBUG = ON
 
;*********************************************************************
;                                Masques             *
;                                     *
;*********************************************************************
 
MASK_ADCON0   EQU  B'00000000'  ; la conversion analogique n'est pas autorisée
MASK_ADCON1   EQU  B'00001101'  ; Le voltage de référence pour la conversion étant comme VSS et VDD
MASK_ADCON2   EQU  B'10001100'  ; définie la justification par la droite ou gauche
 
MASK_AD1CON0  EQU  B'00000111'  ; la conversion analogique est autorisée et lancée sur le channel 1
 
 
MASK_TRISA   EQU  B'00000011'  ; les pins 2 et 3 sont configurées comme des entrées  
           ; et 4,5,6,7,9 et 10 comme des sorties
MASK_TRISB   EQU  B'00000000'  ; Toutes les pins PORTB sont configurées comme des sorties  
 
MASK_TRISC   EQU  B'01000000'  ; Toutes les pins PORTC sont configurées en sortie sauf RC6 qui sera utilisé
           ; pour l'USART
 
MASK_T2CONOFF  EQU  B'00000011'  ; Le timer2 n'est pas enclenché
MASK_T2CONON  EQU  B'00000111'  ; le timer2 est enclenché
 
MASK_T0CONOFF  EQU  B'00000111'  ; le timer n'est pas enclenché
MASK_T0CONON  EQU  B'10000111'  ; le timer est enclenché
 
MASK_CCP2ON   EQU  B'00001100'  ; configure le registre CCP2 en mode PWM
MASK_CCP2OFF  EQU  B'00000000'  ; désactive le mode PWM du CCP2
 
MASK_PIR1ON   EQU  B'00000010'  ; Autorise l'interruption lorsque TIMER2 dépasse PR2
MASK_PIR1OFF  EQU  B'00000000'  ; interdire l'interruption du timer2
 
MASK_INTCONOFF  EQU  B'00000000'  ; interdire les interruptions du timer0
MASK_INTCONON  EQU  B'10100000'  ; autorise l'interruption du timer 0
 
   
;*********************************************************************
;                            DEFINITION                           *
;*********************************************************************
 
#DEFINE a   PORTB,0   ; Afficheur de la barre a
#DEFINE b   PORTB,1   ; Afficheur de la barre b
#DEFINE c   PORTB,2   ; Afficheur de la barre c
#DEFINE d   PORTB,3   ; Afficheur de la barre d
#DEFINE e   PORTB,4   ; Afficheur de la barre e
#DEFINE f   PORTB,5   ; Afficheur de la barre f
#DEFINE g   PORTB,6   ; Afficheur de la barre g
#DEFINE dp   PORTB,7   ; Afficheur de la barre dp
 
#DEFINE Unites  PORTC,0   ; Allume le 7 segments des unités
#DEFINE Dixaines PORTC,2   ; allume le 7 segments des dixaines
#DEFINE Son   PORTC,1   ; alimente le haut parleur
 
;*********************************************************************
;                            TABLE 7 segments         *
;Cette table permet le stockage d'informations concernant l'affichage*
; des 7 segments. Elle contient les adresses qui permettent d'affiher*
;tel ou tel chiffre. Les adresses suivantes sont attribuées    *
;respectivement à 0,1,2,3,4,5,6,7,8,9,10        *
;*********************************************************************
tabl_segment EQU  0x0001000
 
 org  tabl_segment
 
 db  0x3F,0x06,0x5B,0x4F
 db  0x26,0x6D,0x7D,0x07
 db  0x7F,0x6F,0x00
 
;*********************************************************************
;                          VARIABLES                       *
;*********************************************************************
 
 CBLOCK  0x00
  cmptac  : 1    ; Temps nécessaire à la charge du convertisseur pour l'
         ; acquisition
  cmptac50 : 1        
  cmptmoy  : 1    ; compteur permettant d'avoir 8 échantillons et d'en faire  
         ; la moyenne
  accumL  : 1          
  accumH  : 1
 
  moyenneL : 1    ; 8 premiers octets de la moyenne
  moyenneH : 1    ; 8 derniers octets de la moyenne
 
  ones  : 1    ; variables des unités pour 7-segments
  tens  : 1    ; variables des dixaines pour 7-segments
  casel  : 1    ; permet de sélectionner quel cadran allumer
   
  cmptpile : 1    ; registre permettant de tester la pile
  pileL  : 1    ; valeur de la conversion pour vérifier la pile
  pileH  : 1    
 
  onespile : 1    ; unité et dixaine de la conversion
  tenspile : 1    ; pour vérifier la pile
 
  tensson  : 1    ; test des fréquences
 
  ENDC
 
 org  0x000
 bra  init  
 
;*********************************************************************
;                            INTERRUPTION                          *
;*********************************************************************
 
   ;     AFFICHAGE      ;
   ; Cette interruption sert à afficher toutes   ;
   ; les 20ms sur les cadrans 7 segments les     ;
   ; données stockées dans les registres ones    ;
   ; et tens           ;
   ;**********************************************
 
 org  0x08
 
 
 movlw MASK_PIR1OFF
 movwf PIR1,0
 
AFFICHAGE
 
 
 movlw  UPPER(tabl_segment)  ; charger bits 16 à 21 de l’adresse
 movwf  TBLPTRU     ; dans pointeur UPPER
 movlw  HIGH(tabl_segment)   ; charger bits 8 à 15 de l’adresse
 movwf  TBLPTRH     ; dans pointeur HIGH
 movlw  LOW(tabl_segment)   ; charger bits 0 à 7 de l’adresse
 movwf  TBLPTRL     ; dans pointeur LOW
 
 clrf PORTC
 
 BCF  PORTC,0     ; On configure RC0 et RC1 en sortie
 BCF  PORTC,1
 
 movlw 0x01     ; on met 1 dans w
 movwf casel     ; on charge 1 dans casel
 
 cpfseq casel,0     ; comparer casel à w, et sauter s'ils sont égaux
 
 bra  AFITENS     ; si différent alors on va afficher les dixaines
 
 movf ones,w,0    ; mettre le nombre d'unité dans w
 addwf TBLPTRL,1,0    ; ajouter ones dans le pointeur de la table L
 
 tblrd *      ; lire la table à l'adresse du pointeur
 
 movf TABLAT,w    ; mettre le résultat de la table dans w
 movwf PORTB     ; envoyer la valeur de la table vers l'afficheur 7 segments
 
 BSF  PORTC,0,0    ; allumer uniquement le cadran des unités
 
 BRA  NVCASEL     ; aller à NVCASEL de façon à sélectionner un nouveau cadran
 
AFITENS
 
 movlw 0x02     ; charger 2 dans w
 cpfseq casel,0     ; comparer si casel est égal à deux
         ; si oui alors sauter l'instruction suivante
 bra  NVCASEL     ; sinon aller à NVCASEL
 
 movf tens,w,0    ; charger les tens dans w
 clrf TBLPTRL
 addwf TBLPTRL,1,0    ; Ajouter les tens dans le pointeur de la table
 
 tblrd *      ; lire la table  
 
 movf TABLAT,w    ; charger la valeur de la table pointer dans w
 clrf PORTB
 movwf PORTB     ; envoyer la valeur vers l'afficheur
 
 BSF  PORTC,2,0    ; allumer uniquement le cadran des dixaines
 
NVCASEL
 
 RLNCF casel,1,0    ; faire une rotation de bit vers la gauche
 movlw 0x02     ; si casel > 2 alors le remettre à 1
 cpfsgt casel,0     ; si = à 2 alors retourner pour afficher les dixaines
 bra  AFITENS
 
 bcf  INTCON,TMR0IF   ; enlever le flag de l'interruption
 
 movlw 0x63     ; charger w pour le timer low
 movwf TMR0L     ; charger le registre low du timer
 movlw 0xFF     ; charger w pour le timer high
 movwf TMR0H     ; charger le registre high du timer
 
 
 movlw MASK_PIR1ON    ; Autoriser l'interruption du timer2
 movwf PIR1
 
 retfie FAST
 
;*********************************************************************
;                             INITIALISATION                         *
;*********************************************************************
init
 movlw MASK_ADCON1    ; ANO = entrée analogique. Vref = Vss et Vdd
 movwf ADCON1
 
 movlw MASK_ADCON0    ; AN0 sélectionnée, pas de conversion en cours
 movwf ADCON0
 
 movlw MASK_ADCON2    ; Justification par la droite, Acquisition time = 2Tad
 movwf ADCON2
 
 movlw MASK_TRISA    ; Configurer Pin 2 et 3 comme des entrées
 movwf TRISA          
 
 clrf PORTB
 movlw MASK_TRISB    ; Configurer toutes les pins PORTB comme des sorties
 movwf TRISB
 
 clrf PORTC
 movlw MASK_TRISC    ; configurer les pins 11,12,13,14,15,16,18 en sortie et 17 en entrée
 movwf TRISC
 
 clrf ones
 clrf tens
 clrf accumL
 clrf accumH
 clrf onespile
 clrf tenspile
 clrf pileL
 clrf pileH
 
 movlw MASK_T0CONON   ; Lancer le timer0
 movwf T0CON,0    
 movlw 0x63     ; l'interruption aura lieu toutes les 20msec
 movwf TMR0L
 movlw 0xFF
 movwf TMR0H
 movlw MASK_INTCONON   ; autoriser les interruptions du timer0
 movwf INTCON
 
 
 movlw MASK_CCP2OFF   ; désactiver le mode PWM car pas de moyenne
 movwf CCP2CON
 
 GOTO MAIN
 
;*********************************************************************
;                            Test de la pile                         *
;*********************************************************************
 
 
PILE
 
 movlw MASK_T0CONOFF   ; Arreter le timer0 pendant la conversion
 movwf T0CON,0
 
 movlw MASK_PIR1OFF
 movwf PIR1
 
 movlw MASK_AD1CON0   ; autoriser et lancer la conversion sur ch1
 movwf ADCON0
 
 
BOUCLECONVPILE
 
 btfsc ADCON0,GO/DONE   ; tester si = 0 alors conversion finie
         ; une fois la conversion finie, le résultat  
         ; vient se mettre dans deux registres : ADRESL et ADRESH  
 bra  BOUCLECONVPILE   ; =/0 donc boucle2
 
 movlw MASK_T0CONON   ; Relancer le timer0
 movwf T0CON
 
 movlw MASK_PIR1ON    ; Autoriser l'interruption du timer2
 movwf PIR1
 
 movff ADRESL,pileL
 movff ADRESH,pileH
 
; movlw 0x23     ; simulation de prise d'échantillon pour la pile
; movwf pileL
; movlw 0x0
; movwf pileH
;                               CHIFFRES        
;      pour savoir combien il y a de dixaine                    
;    **********************************************************
CHIFFREPILE
 
 clrf onespile    ; Effacer "ones" et "tens"
 clrf tenspile
 
DIXAINEPILE  
 
 movlw 0xA      ; Charger 10 dans w pour savoir
         ; combien de dixaine il y a dans notre moyenne
 subwf pileL,1,0    ; pour se faire, on soustrait 10 à L et on laisse
         ; le résultat dans accumL jusqu'à obtenir un négatif
 movlw 0x0
 subwfb pileH,1,0    ; sousraire le Report de soustraction si il y en a
 
 bn  NEGATIFPILE    ; si le résultat < 0 alors N du reg status vaut 1
         ; Donc on va direct à NEGATIF. Si > 0
 incf tenspile    ; alors on incrémente de 1 la variable tens
 
 BZ  FIN_CHIFFREPILE   ; si le résultat = 0 alors plus de reste donc terminé
 
 bra  DIXAINEPILE    ; Si le résultat est possitif alors on recommence.
 
NEGATIFPILE
 
 movlw 0xA      ; on rajoute les 10 dans accumL pour retrouver un chiffre positif
 addwf pileL,1,0    ; et les passer dans la variable ones
 
UNITEPILE
 
 movff pileL,onespile
 
 
FIN_CHIFFREPILE
;              AFFICHAGE
;         SI tens = 8 et ones = 8  
;     alors afficher deux lignes sur les cadrans
;      pour dire que la pile est plate
;    ************************************************
 
 movlw 0x9      ; simulation d'une pile HS
 movwf tenspile
 
 movlw 0x9      ; la pile est alors chargé à 99%
 movwf onespile
 
AFFICHAGEPILE
 
 movlw  UPPER(tabl_segment)  ; charger bits 16 à 21 de l’adresse
 movwf  TBLPTRU     ; dans pointeur UPPER
 movlw  HIGH(tabl_segment)   ; charger bits 8 à 15 de l’adresse
 movwf  TBLPTRH     ; dans pointeur HIGH
 movlw  LOW(tabl_segment)   ; charger bits 0 à 7 de l’adresse
 movwf  TBLPTRL     ; dans pointeur LOW
 
 BCF  PORTC,0     ; On configure RC0 et RC1 en sortie
 BCF  PORTC,1
 
 
 
 movlw 0x8
 subwf tenspile
 
 BZ  AFIONESPILE
 BN  ZERO
 
 bra  CHIFFRE_RECHARGEPILE
 
AFIONESPILE
 
 movlw 0x9
 subwf onespile
 
 bz  MAIN
 
ZERO
 
 movlw MASK_INTCONOFF   ; interdire les interruptions
 movwf INTCON,0
 
 movlw 0      ; afficher 0 pour dire que la pile est morte
 addwf TBLPTRL,1,0    ; Ajouter 0 dans le pointeur de la table
 
 tblrd *      ; lire la table  
 
 movf TABLAT,w    ; charger la valeur de la table pointer dans w
 movwf PORTB     ; envoyer la valeur vers l'afficheur
 
 BSF  PORTC,1,0    ; allumer uniquement le cadran des dixaines
 
 bra  ZERO     ; tourner en boucle pour ne pas permettre  
         ; l'utilisation du cadran
 
 
;*********************************************************************
;                         PROGRAMME PRINCIPALE                       *
;*********************************************************************
 
MAIN
 
 movlw MASK_T0CONON   ; Lancer le timer0
 movwf T0CON,0    
 movlw 0x63     ; l'interruption aura lieu toutes les 20msec
 movwf TMR0L
 
 movlw 0xFF
 movwf TMR0H
 
 movlw MASK_INTCONON
 movwf INTCON
 
 movlw 0x32     ; charge le compteur à 50 de façon à ce qu'à 0
 movwf cmptpile    ; il y ait test de la pile
 
CONVERSION
 
 clrf accumL          
 clrf accumH     ; réinitialiser accum à 0
 
 
 bsf  ADCON0,ADON    ; autoriser la conversion analogique
 
 movlw 0xFA     ; charger le registre W à 250  
 movwf cmptac     ; charger la variable cmpt1 pour obtenir un échantillon toutes les 25ms
 
 movlw 0x8      ; charger le w à 8 pour obtenir 8 échantillons
 movwf cmptmoy     ; charger cmptmoy à 8
 
BOUCLE
         ; toutes les 50ms prendre un échantillon
 movlw 0xA      ; charger 10 dans w
 movwf cmptac50            
 
BOUCLE50MS_INTERRUPTIONON
 
 movlw MASK_INTCONON   ; Autorise l'interruption du timer0 pendant la boucle
 movwf INTCON
 
 movlw MASK_PIR1ON    ; Autorise l'interruption du timer2 pendant la boucle
 movwf PIR1
 
BOUCLE50MS
 
 decfsz cmptac     ; décrémenter cmptac
 
 bra  BOUCLE50MS    ; =/ 0 boucle1
 
 decfsz cmptac50
 
 bra  BOUCLE50MS_INTERRUPTIONON
 
 movlw MASK_T0CONOFF   ; Arreter le timer0 pendant la conversion
 movwf T0CON
 
 movlw MASK_PIR1OFF   ; interdire l'interruption du timer2 pendant la conversion
 movwf PIR1
 
 bsf  ADCON0,GO_DONE   ; lancer la conversion analogique/digitale
 
 
BOUCLECONV
 
 btfsc ADCON0,GO/DONE   ; tester si = 0 alors conversion finie
         ; une fois la conversion finie, le résultat  
         ; vient se mettre dans deux registres : ADRESL et ADRESH  
 bra  BOUCLECONV    ; =/0 donc boucle2
 
 movlw MASK_T0CONON   ; Relancer le timer0
 movwf T0CON
 
 movlw MASK_PIR1ON    ; Autoriser l'interruption du timer2
 movwf PIR1
 
; movlw 0x10     ; simuler une acquisition
; movwf ADRESL
 
; movlw 0x00     ; simuler une acquisition
; movwf ADRESH
 
;           STOCKER LES ECHANTILLONS POUR FAIRE LA MOYENNE
;*********************************************************************
 
 movf ADRESL,w    ; charger la conversion ADRESL dans registre w
 addwf accumL     ; additionner la précédente conversion avec la valeur de add8v0  
 
 movf ADRESH,w    ; charger la conversion ADRESH dans registre w
 addwfc accumH     ; additionner  la précédente conversion avec la valeur de add8v1
 
 
;             retour à la prise d'échantillons
;*********************************************************************
 
BOUCLEMOY
 decfsz cmptmoy     ; décrémenter le registre cmptmoy de 1  
 bra  BOUCLE     ; si =/ 0 alors retour à BOUCLE 1
 
 
;              calculer la moyenne
;**********************************************************************
 
MOYENNE
 
 RRCF accumH     ; divise RRNCF et RRCF par 2
 RRNCF accumL        
 RRCF accumH     ; Divise encore par 2  
 RRNCF accumL
 RRCF accumH     ; divise encore par 2 donc finalement on a par 8
 RRNCF accumL
 
 decfsz cmptpile    ; enlever 1 à cmptpile
 bra  CHIFFRE
 
 bra  PILE
 
;                            CHIFFRES                            
;*********************************************************************
 
CHIFFRE_RECHARGEPILE
 movlw 0x32     ; charge le compteur à 50 de façon à ce qu'à 0
 movwf cmptpile    ; il y ait test de la pile
 
CHIFFRE
 
 movlw MASK_INTCONON
 movwf INTCON,0
 
 clrf ones     ; Effacer "ones" et "tens"
 clrf tens
 
DIXAINE  
 
 movlw 0xA      ; Charger 10 dans w pour savoir
         ; combien de dixaine il y a dans notre moyenne
 subwf accumL,1,0    ; pour se faire, on soustrait 10 à accumL et on laisse
         ; le résultat dans accumL jusqu'à obtenir un négatif
 movlw 0x0
 subwfb accumH,1,0    ; sousraire le Report de soustraction si il y en a
 
 bn  NEGATIF     ; si le résultat < 0 alors N du reg status vaut 1
         ; Donc on va direct à NEGATIF. Si > 0
 incf tens     ; alors on incrémente de 1 la variable tens
 
 BZ  FIN_CHIFFRE    ; si le résultat = 0 alors plus de reste donc terminé
 
 bra  DIXAINE     ; Si le résultat est possitif alors on recommence.
 
NEGATIF
 
 movlw 0xA      ; on rajoute les 10 dans accumL pour retrouver un chiffre positif
 addwf accumL,1,0    ; et les passer dans la variable ones
 
UNITE
 
 movff accumL,ones
 
FIN_CHIFFRE
 
;      TEST des unités pour sélectionner la fréquence
;   *********************************************************************
 
TEST_SON
 
 movff tens,tensson   ; charger les dixaines dans tensson pour savoir quelle fréquence charger
 
 
TEST90
 
 movlw 0x9      ; charger 9 dans w  
 subwf tensson     ; tensson > 90?
 
 bn  TEST80     ; NON donc aller au test suivant
 
 bra  FREQUENCE90    ; OUI donc charger le timer1 pour une fréquence à 90
 
TEST80
 
 addwf tensson     ; rajouter 90 dans tensson
 movlw 0x8      ; charger 8 dans w
 subwf tensson     ; 90 > tensson > 80?
 
 bn  TEST70     ; NON donc aller au test suivant
 
 bra  FREQUENCE80    ; OUI donc charger le timer1 pour fréquence à 80
 
TEST70
 
 addwf tensson     ; rajouter 80 dans tensson
 movlw 0x7      ; charger 7 dans w
 subwf tensson     ; 80 > tensson > 70?
 
 bn  TEST60     ; NON donc aller au test suivant
 
 bra  FREQUENCE70
 
TEST60
 
 addwf tensson     ; charger 70 dans tensson
 movlw 0x6      ; charger 6 dans w  
 subwf tensson     ; 70 > tensson > 60?
 
 bn  TEST50     ; NON donc aller au test suivant
 
 bra  FREQUENCE60    ; OUI donc charger le timer1 pour une fréquence à 60
 
TEST50
 
 addwf tensson     ; rajouter 60 dans tensson
 movlw 0x5      ; charger 5 dans w
 subwf tensson     ; 60 > tensson > 50?
 
 bn  TEST40     ; NON donc aller au test suivant
 
 bra  FREQUENCE50    ; OUI donc charger le timer1 pour fréquence à 50
 
TEST40
 
 addwf tensson     ; rajouter 50 dans tensson
 movlw 0x4      ; charger 4 dans w
 subwf tensson     ; 50 > tensson > 40?
 
 bn  TEST30     ; NON donc aller au test suivant
 
 bra  FREQUENCE40    ; OUI donc chager le timer1 pour fréquence à 40
 
TEST30
 
 addwf tensson     ; rajouter 40 dans tensson
 movlw 0x3      ; charger 3 dans w
 subwf tensson     ; 40 > tensson > 30?
 
 bn  TEST20     ; NON donc aller au test suivant
 
 bra  FREQUENCE30    ; OUI donc charger le timer1 pour fréquence à 30
 
TEST20
 
 addwf tensson     ; rajouter 30 dans tensson
 movlw 0x2      ; charger 2 dans w
 subwf tensson     ; 30 > tensson > 20?
 
 bn  TEST10     ; NON donc aller au test suivant
 
 bra  FREQUENCE20    ; OUI donc charger le timer1 pour fréquence à 20
 
TEST10
 
 addwf tensson     ; rajouter 20 dans tensson
 movlw 0x1      ; charger 1 dans w
 subwf tensson     ; 20 > tensson > 10?
 
 bn  FREQUENCE0    ; NON donc retourner à la conversion
 
 bra  FREQUENCE10    ; OUI donc charger le timer1 pour fréquence à 10
 
 
 
;              CONTROLE DE LA FREQUENCE DU HAUT PARLEUR                            
;*********************************************************************
 
FREQUENCE0
 
 movlw MASK_PIR1OFF   ; Arrête l'interruption du timer2 car Moyenne = 0
 movwf PIR1
 
 bra  CONVERSION
 
FREQUENCE90
 
 
 movlw MASK_CCP2ON    ; activer le mode PWM car pas de moyenne
 movwf CCP2CON
 
 movlw MASK_PIR1ON    ; autorise l'interruption du timer2 car Moyenne > 90
 movwf PIR1
 
 movlw MASK_T2CONON   ; lance le timer2
 movwf T2CON
 
 movlw 0x5F     ; Charge 95 dans PR2
 movwf PR2
 
 movlw 0x30     ; charge 192 dans valeur de comparaison BCD, ce qui équivaut à  
 movwf CCPR2L     ; dire que nous chargeons notre valeur de comparaison à 48
         ; car nous avons une précision de 1/4. Les décimales correspondent
 movlw 0x0      ; aux deux bits de poids forts qui se situent dans CCP2X et  CCP2Y
 movwf CCP2CON,5    ; mettre les deux bits faibles dans le bit 4 et 5 dans CCP2  
 movwf CCP2CON,4
 
 bra  CONVERSION
 
FREQUENCE80
 movlw MASK_CCP2ON    ; Activer le mode PWM car pas de moyenne
 movwf CCP2CON
 
 movlw MASK_PIR1ON    ; autorise l'interruption du timer2 car Moyenne > 80
 movwf PIR1
 
 movlw MASK_T2CONON   ; lance le timer2
 movwf T2CON
 
 movlw 0x67     ; charge 103 dans PR2
 movwf PR2
 
 movlw 0x34     ; charge 52 dans les bits forts du BCD
 movwf CCPR2L      
 
 movlw 0x0      ; charge les bits faibles dans CCP2X et Y à 0
 movwf CCP2CON,5
 movwf CCP2CON,4
 
 bra  CONVERSION
 
FREQUENCE70
 movlw MASK_CCP2ON    ; activer le mode PWM car pas de moyenne
 movwf CCP2CON
 
 movlw MASK_PIR1ON    ; autorise l'interruption du timer2 car moyenne > 70
 movwf PIR1
 
 movlw MASK_T2CONON   ; lance le timer2
 movwf T2CON
 
 movlw 0x71     ; charge 113 dans PR2
 movwf PR2
 
 movlw 0x38     ; charge 56 dans les bits forts du BCD
 movwf CCPR2L  
 
 movlw 0x1      ; charge les bits faibles dans CCP2X et Y à 1
 movwf CCP2CON,5
 movwf CCP2CON,4
 
 bra  CONVERSION
 
FREQUENCE60
 movlw MASK_CCP2ON    ; activer le mode PWM car pas de moyenne
 movwf CCP2CON
 
 movlw MASK_PIR1ON    ; autorise l'interruption du timer2 car moyenne > 60
 movwf PIR1
 
 movlw MASK_T2CONON   ; lance le timer2
 movwf T2CON
 
 movlw 0x7C     ; charge 124 dans PR2
 movwf PR2
 
 movlw 0x3E     ; charge 62 dans les bits forts du BCD
 movwf CCPR2L
 
 movlw 0x1
 movwf CCP2CON,5    ; charge le bit faible CCP2X à 1
 movlw 0x0
 movwf CCP2CON,4    ; charge le bit faible CCP2Y à 0
 
 bra  CONVERSION
 
FREQUENCE50
 movlw MASK_CCP2ON    ; activer le mode PWM car pas de moyenne
 movwf CCP2CON
 
 movlw MASK_PIR1ON    ; autorise l'interruption du timer2 car moyenne > 50
 movwf PIR1
 
 movlw MASK_T2CONON   ; lance le timer2
 movwf T2CON
 
 movlw 0x8A     ; charge 138 dans PR2
 movwf PR2
 
 movlw 0x45     ; charge 69 dans les bits forts du BCD
 movwf CCPR2L
 
 movlw 0x1
 movwf CCP2CON,5    ; charge le bit faible X du BCD à 1
 
 movlw 0x0
 movwf CCP2CON,4    ; charge le bit faible Y du BCD à 0
 
 bra  CONVERSION
 
FREQUENCE40
 movlw MASK_CCP2ON    ; activer le mode PWM car pas de moyenne
 movwf CCP2CON
 
 movlw MASK_PIR1ON    ; autorise l'interruption du timer2 car moyenne > 40
 movwf PIR1
 
 movlw MASK_T2CONON   ; lance le timer2
 movwf T2CON
 
 movlw 0x9B     ; charge 155 dans PR2
 movwf PR2
 
 movlw 0x4E     ; charge 78 dans les bits forts du BCD
 movwf CCPR2L
 
 movlw 0x0
 movwf CCP2CON,5    ; charge le bit faible X du BCD à 0
 movlw 0x1
 movwf CCP2CON,4    ; charge le bit faible Y du BCD à 1
 
 bra  CONVERSION
 
FREQUENCE30
 movlw MASK_CCP2ON    ; activer le mode PWM car pas de moyenne
 movwf CCP2CON
 
 movlw MASK_PIR1ON    ; autorise l'interruption du timer2 car moyenne > 30
 movwf PIR1
 
 movlw MASK_T2CONON   ; lance le timer2
 movwf T2CON
 
 movlw 0xB2     ; charge 178 dans PR2
 movwf PR2
 
 movlw 0x59     ; charge 89 dans les bits forts du BCD
 movwf CCPR2L
 
 movlw 0x0
 movwf CCP2CON,5    ; charge le bit faible X du BCD à 0
 movlw 0x1
 movwf CCP2CON,4    ; charge le bit faible Y du BCD à 1
 
 bra  CONVERSION
 
FREQUENCE20
 movlw MASK_CCP2ON    ; activer le mode PWM car pas de moyenne
 movwf CCP2CON
 
 movlw MASK_PIR1ON    ; autorise l'interruption du timer2 car moyenne > 20
 movwf PIR1
 
 movlw MASK_T2CONON   ; lance le timer2
 movwf T2CON
 
 movlw 0xCF     ; charge 207 dans PR2
 movwf PR2
 
 movlw 0x68     ; charge 104 dans les bits forts du BCD
 movwf CCPR2L
 
 movlw 0x0
 movwf CCP2CON,5    ; charge le bit faible X du BCD à 0
 movlw 0x1
 movwf CCP2CON,4    ; charge le bit faible Y du BCD à 1
 
 bra  CONVERSION
 
FREQUENCE10
 
 movlw MASK_CCP2ON    ; activer le mode PWM car pas de moyenne
 movwf CCP2CON
 
 movlw MASK_PIR1ON    ; autorise l'interruption du timer2 car moyenne > 10
 movwf PIR1
 
 movlw MASK_T2CONON   ; lance le timer2
 movwf T2CON
 
 movlw 0xF9     ; charge 249 dans PR2
 movwf PR2
 
 movlw 0x7D     ; charge 125 dans les bit forts du BCD
 movwf CCPR2L
 
 movlw 0x0      ; charge les bits faible x et y du BCD à 0
 movwf CCP2CON,5
 movwf CCP2CON,4
 
 bra  CONVERSION
 
 END
[CODE/]