; "Minuteur longue durée 6 digits (à quartz) " ; (C) Fabrice Sincère, Olivier Flayols ; Février 2011 ; version 1.0.1 ; microcontrôleur PIC 16F628A ; développé avec Microchip MPLAB IDE List p=16F628A ; processeur utilisé #include __config _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC & _LVP_OFF & _DATA_CP_OFF & _BOREN_OFF & _MCLRE_ON ;bits de configuration : ;code protect OFF ;watchdog timer OFF ;power up timer ON ;oscillateur HS (quartz à grande fréquence) ;low voltage program OFF ;data EE read protect OFF ;brown out detect OFF ;master clear enable ON ;xxxxxxxxxxxxx ; Assignations ;xxxxxxxxxxxxx debutRAM EQU H'20' ; adresse de début de la RAM du 16F628A finRAMplus1 EQU H'80' ; adresse de fin + 1 (H'7F'+1 = H'80') ;xxxxxx ; macro ;xxxxxx bank1 macro ; passage en banque 1 bsf STATUS,RP0 bcf STATUS,RP1 endm bank0 macro ; passage en banque 0 bcf STATUS,RP0 bcf STATUS,RP1 endm ;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ; Initialisation de la mémoire EEPROM (facultatif) ; Cela met dans l'EEPROM le message : ; (C) Fabrice Sincere 01/02/2011 (en code ASCII) ; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx org 0x2100 ; début de zone EEPROM du PIC 16F628A DE '(' ; ou DE 0x28 (code ASCII correspondant) DE 'C' DE ')' DE 'F' ,'a' ,'b','r','i','c','e',' ' DE 'S','i','n','c','e','r','e',' ' DE '0','1','/','0','2','/','2','0','1','1' ;xxxxxxxxxxxxxxxxxxxxxxxxx ; déclaration de variables ;xxxxxxxxxxxxxxxxxxxxxxxxx CBLOCK 0x020 ; début de la zone des registres d'usage général du 16F628A digit : 1 ; variable qui indique n° de l'afficheur actif (0 à 5) ; (routine d'affichage) digit_minuteur : 1 ; variable qui indique n° de l'afficheur actif (0 à 5) ; (routines de réglage) STATUS_TEMP : 1 ; sauvegarde du registre STATUS (routine d'interruption) W_TEMP : 1 ; sauvegarde du registre W (routine d'interruption) compteur_1 : 1 ; compteur des 1/514 de seconde (chiffre des unités) compteur_10 : 1 ; (chiffre des dizaines) compteur_100 : 1 ; (chiffre des centaines) compteur_clignotement_digit : 1 ; compteur de la temporisation ; du clignotement du digit actif (en mode réglage) flag_clignotement_digit : 1 ; 0 = digit actif éteint (B'1111' en entrée de 7447) ; (on utilise le bit 0) flag_tempo_digit : 1 ; drapeau mis à 1 au début de la temporisation anti-rebonds ; du bouton poussoir SELECTION DIGIT(on utilise le bit 0) compteur_tempo_digit : 1 ; compteur de la temporisation anti-rebonds ; du bouton poussoir SELECTION DIGIT (on utilise le bit 0) flag_tempo_valeur : 1 ; drapeau mis à 1 au début de la temporisation anti-rebonds ; du bouton poussoir SELECTION VALEUR (on utilise le bit 0) compteur_tempo_valeur : 1 ; compteur de la temporisation anti-rebonds ; du bouton poussoir SELECTION VALEUR (on utilise le bit 0) flag_tempo_start :1 ; drapeau mis à 1 au début de la temporisation ; du bouton poussoir START/STOP (on utilise le bit 0). compteur_tempo_start : 1 ; compteur de la temporisation ; du bouton poussoir START/STOP (on utilise le bit 0) flag_reglage : 1 ; drapeau mis à 1 pendant la phase de réglage (on utilise le bit 0) flag_minuteur : 1 ; drapeau mis à 1 pendant la phase de décompte (on utilise le bit 0) flag_000000 : 1 ; drapeau mis à 1 pour afficher 00.00.00 (on utilise le bit 0) afficheur_0_minuteur : 1 ; contient le chiffre des heures (dizaines) (minuteur) afficheur_1_minuteur : 1 ; contient le chiffre des heures (unités) (minuteur) afficheur_2_minuteur : 1 ; contient le chiffre des minutes (dizaines) (minuteur) afficheur_3_minuteur : 1 ; contient le chiffre des minutes (unités) (minuteur) afficheur_4_minuteur : 1 ; contient le chiffre des secondes (dizaines) (minuteur) afficheur_5_minuteur : 1 ; contient le chiffre des secondes (unités) (minuteur) afficheur_0_horloge : 1 ; contient le chiffre des heures (dizaines) (horloge) afficheur_1_horloge : 1 ; contient le chiffre des heures (unités) (horloge) afficheur_2_horloge : 1 ; contient le chiffre des minutes (dizaines) (horloge) afficheur_3_horloge : 1 ; contient le chiffre des minutes (unités) (horloge) afficheur_4_horloge : 1 ; contient le chiffre des secondes (dizaines) (horloge) afficheur_5_horloge : 1 ; contient le chiffre des secondes (unités) (horloge) afficheur_0 : 1 ; contient le chiffre des heures (unités) à afficher afficheur_1 : 1 ; contient le chiffre des heures (unités) à afficher afficheur_2 : 1 ; contient le chiffre des minutes (dizaines) à afficher afficheur_3 : 1 ; contient le chiffre des minutes (unités) à afficher afficheur_4 : 1 ; contient le chiffre des secondes (dizaines) à afficher afficheur_5 : 1 ; contient le chiffre des secondes (unités) à afficher afficheur : 1 ; contient le chiffre actif à afficher compteur_TMR0 : 1 ; nombre de débordement du TMR0 ENDC ;xxxxxxxxxxxxxxxxxxxx ; démarrage sur reset ;xxxxxxxxxxxxxxxxxxxx org 0x0000 goto initialisation ; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ; Routine d'interruption ; 1 source d'interruption : TMR0 en mode timer ; Toutes les 256*2 = 512 cycles = 102,4 µs (prescaler 1:2) quartz 20 MHz ; Toutes les 256*1 cycles = 102,4 µs (prescaler 1:1) quartz 10 MHz ; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx org 0x0004 ; vecteur d'interruption movwf W_TEMP swapf STATUS,W movwf STATUS_TEMP ; sauvegarde du registre W puis du registre STATUS ;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx decf compteur_TMR0,f ; on décrémente (compteur_TMR0) btfsc STATUS, Z ; (compteur_TMR0)= 0 ? goto testBP ; oui goto restauration ; non testBP movlw D'19' movwf compteur_TMR0 ; On arrive ici toutes les 19*512 = 9728 cycles (quartz 20 MHz) ; ou 19 * 256 = 4864 cycles (quartz 10 MHz) ; = 1,945 6 ms (soit quasiment 1/514 s = 1,945 53 ms) ; (écart de 38 ppm) call BP_digit ; routine de gestion du bouton poussoir SELECTION DIGIT call BP_valeur ; routine de gestion du bouton poussoir SELECTION VALEUR call BP_start ; routine de gestion du bouton poussoir START/STOP ; Routine de gestion du clignotement du digit actif (en mode réglage) ; on teste si on est dans le mode réglage btfss flag_reglage ,0 goto rafr decf compteur_clignotement_digit , f btfss STATUS , Z goto rafr movlw D'100' movwf compteur_clignotement_digit comf flag_clignotement_digit , f ; inversion du flag ; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx rafr call rafraichissement ; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx decf compteur_1 , f ; on décrémente le compteur des 1/514 s movlw 0xFF subwf compteur_1 , W btfss STATUS,Z goto restauration ; non movlw D'9' ; oui movwf compteur_1 decf compteur_10 ,f movlw 0xFF subwf compteur_10 ,W btfss STATUS,Z goto restauration ; non movlw D'9' ; oui movwf compteur_10 decf compteur_100 ,f movlw 0xFF subwf compteur_100 ,W btfss STATUS,Z goto restauration ; non ; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ; oui : on arrive ici toutes les secondes movlw D'3' movwf compteur_1 movlw D'1' movwf compteur_10 movlw D'5' movwf compteur_100 ; initialisation du compteur à 513 ; teste si on est dans le mode minuteur btfsc flag_minuteur,0 call heure_minute_sec_moins_horloge ; oui restauration bcf INTCON,T0IF ; on efface le drapeau T0IF swapf STATUS_TEMP,W ; restauration des registres STATUS puis W movwf STATUS swapf W_TEMP,f swapf W_TEMP,W retfie ; retour d'interruption ; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ; Routine de gestion du bouton poussoir SELECTION DIGIT (broche RB0) ; Quand ce bouton est appuyé, le digit actif est décalé ; 0 -> 1- > 2-> 3-> 4-> 5-> 0 -> 1 ... ; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx BP_digit btfsc flag_tempo_valeur,0 return btfsc flag_tempo_start, 0 return btfsc flag_tempo_digit, 0 ; (flag_tempo_digit) = 0 ? goto label_BP_digit0 btfsc PORTB,0 ; flag_tempo_digit = 0 return ; BP au repos ; BP appuyé bcf flag_000000 , 0 ; drapeau mis à 0 bsf flag_reglage, 0 ; drapeau mis à 1 bcf flag_minuteur, 0 ; drapeau mis à 0 movlw D'250' ; temporisation de 250*(1/514) # 500 ms movwf compteur_tempo_digit bsf flag_tempo_digit, 0 ; drapeau mis à 1 return label_BP_digit0 ; (flag_tempo_digit) = 1 decf compteur_tempo_digit , f btfss STATUS, Z return ; le compteur n'est pas nul ; le compteur est nul bcf flag_tempo_digit , 0 ; drapeau mis à 0 ;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx incf digit_minuteur, f ; on change d'afficheur 0->1->2->3->4->5->0-> etc movlw D'6' subwf digit_minuteur, W btfss STATUS, Z return clrf digit_minuteur return ; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ; Routine de gestion du bouton poussoir SELECTION VALEUR (broche RB1) ; Quand ce bouton est appuyé, la valeur du digit actif est incrémentée ; 0 -> 1- > 2-> 3-> 4-> ... 9 -> 0 ... ; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx BP_valeur btfsc flag_tempo_digit,0 return btfsc flag_tempo_start, 0 return btfsc flag_tempo_valeur, 0 ; (flag_tempo_valeur) = 0 ? goto label_BP_valeur0 btfsc PORTB,1 ; flag_tempo_valeur = 0 return ; BP au repos ; BP appuyé bcf flag_000000 , 0 ; drapeau mis à 0 bsf flag_reglage, 0 ; drapeau mis à 1 bcf flag_minuteur, 0 ; drapeau mis à 0 movlw D'150' ; temporisation de 150*(1/514) # 300 ms movwf compteur_tempo_valeur bsf flag_tempo_valeur, 0 ; drapeau mis à 1 return label_BP_valeur0 ; (flag_tempo_valeur) = 1 decf compteur_tempo_valeur , f btfss STATUS, Z return ; le compteur n'est pas nul ; le compteur est nul bcf flag_tempo_valeur , 0 ; drapeau mis à 0 ;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ; on incrémente la valeur du digit actif movlw D'0' subwf digit_minuteur, W btfss STATUS, Z goto digit_minuteur1 ; (digit_minuteur) différent de 0 incf afficheur_0_minuteur,f movlw D'10' subwf afficheur_0_minuteur, W btfss STATUS, Z return clrf afficheur_0_minuteur return digit_minuteur1 movlw D'1' subwf digit_minuteur, W btfss STATUS, Z goto digit_minuteur2 ; (digit_minuteur) différent de 1 incf afficheur_1_minuteur,f movlw D'10' subwf afficheur_1_minuteur, W btfss STATUS, Z return clrf afficheur_1_minuteur return digit_minuteur2 movlw D'2' subwf digit_minuteur, W btfss STATUS, Z goto digit_minuteur3 ; (digit_minuteur) différent de 2 incf afficheur_2_minuteur,f movlw D'6' subwf afficheur_2_minuteur, W btfss STATUS, Z return clrf afficheur_2_minuteur return digit_minuteur3 movlw D'3' subwf digit_minuteur, W btfss STATUS, Z goto digit_minuteur4 ; (digit_minuteur) différent de 3 incf afficheur_3_minuteur,f movlw D'10' subwf afficheur_3_minuteur, W btfss STATUS, Z return clrf afficheur_3_minuteur return digit_minuteur4 movlw D'4' subwf digit_minuteur, W btfss STATUS, Z goto digit_minuteur5 ; (digit_minuteur) différent de 4 incf afficheur_4_minuteur,f movlw D'6' subwf afficheur_4_minuteur, W btfss STATUS, Z return clrf afficheur_4_minuteur return digit_minuteur5 ; (digit_minuteur) = 5 incf afficheur_5_minuteur,f movlw D'10' subwf afficheur_5_minuteur, W btfss STATUS, Z return clrf afficheur_5_minuteur return ; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ; Routine de gestion du bouton poussoir START/STOP (broche RB7) ; Quand ce bouton est appuyé, le compte à rebours est lancé (START) ; En fin de temporisation, réinitialisation du programme (STOP) ; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx BP_start btfsc flag_tempo_valeur,0 return btfsc flag_tempo_digit, 0 return btfsc flag_tempo_start,0 ; (flag_tempo_start) = 0 ? goto label_BP_start0 ; non (1) btfsc PORTB,7 ; oui (0) return ; BP au repos ; BP appuyé btfss flag_reglage,0 ; teste si on est dans le mode réglage (START) goto BP_start0 ; non movlw D'250' ; temporisation de 250*(1/514) # 500 ms movwf compteur_tempo_start bsf flag_tempo_start, 0 ; drapeau mis à 1 bcf flag_000000 , 0 ; drapeau mis à 0 bcf flag_reglage, 0 ; drapeau mis à 0 bsf flag_minuteur, 0 ; drapeau mis à 1 movf afficheur_0_minuteur , W movwf afficheur_0_horloge movf afficheur_1_minuteur , W movwf afficheur_1_horloge movf afficheur_2_minuteur , W movwf afficheur_2_horloge movf afficheur_3_minuteur , W movwf afficheur_3_horloge movf afficheur_4_minuteur , W movwf afficheur_4_horloge movf afficheur_5_minuteur , W movwf afficheur_5_horloge return BP_start0 movlw D'250' ; temporisation de 250*(1/514) # 500 ms movwf compteur_tempo_start bsf flag_tempo_start, 0 ; drapeau mis à 1 bsf flag_000000 , 0 ; drapeau mis à 1 bcf flag_reglage, 0 ; drapeau mis à 0 bcf flag_minuteur, 0 ; drapeau mis à 0 return label_BP_start0 ; (flag_tempo_digit) = 1 decf compteur_tempo_start , f btfss STATUS, Z return ; le compteur n'est pas nul ; le compteur est nul bcf flag_tempo_start , 0 ; drapeau mis à 0 return ;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ; Routine "heure_minute_sec_moins_horloge" ; Décrémentation d'une seconde de l'horloge ; afficheur_5 -> secondes (unité) ; afficheur_4 -> secondes (dizaine) ; afficheur_3 -> minutes (unité) ; afficheur_2 -> minutes (dizaine) ; afficheur_1 -> heures (unités) ; afficheur_0 -> heures (dizaines) ; 3.10:01->3.10:00->3.09:59 ... ->0.00:00 ;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx heure_minute_sec_moins_horloge decf afficheur_5_horloge,f movlw 0xFF subwf afficheur_5_horloge,W btfss STATUS,Z ; (afficheur_5_horloge) = 0xFF ? goto lab_heure ; non movlw D'9' ; oui movwf afficheur_5_horloge decf afficheur_4_horloge,f movlw 0xFF subwf afficheur_4_horloge,W btfss STATUS,Z ; (afficheur_4_horloge) = 0xFF ? goto lab_heure ; non movlw D'5' ; oui movwf afficheur_4_horloge decf afficheur_3_horloge,f movlw 0xFF subwf afficheur_3_horloge,W btfss STATUS,Z ; (afficheur_3_horloge) = 0xFF ? goto lab_heure ; non movlw D'9' ; oui movwf afficheur_3_horloge decf afficheur_2_horloge,f movlw 0xFF subwf afficheur_2_horloge,W btfss STATUS,Z ; (afficheur_2_horloge) = 0xFF ? goto lab_heure ; non movlw D'5' ; oui movwf afficheur_2_horloge decf afficheur_1_horloge,f movlw 0xFF subwf afficheur_1_horloge,W btfss STATUS,Z ; (afficheur_1_horloge) = 0xFF ? goto lab_heure ; non movlw D'9' ; oui movwf afficheur_1_horloge decf afficheur_0_horloge,f movlw 0xFF subwf afficheur_0_horloge,W btfss STATUS,Z ; (afficheur_0_horloge) = 0xFF ? goto lab_heure ; non ; oui : fin de la temporisation bcf flag_000000 , 0 ; drapeau mis à 0 bcf flag_reglage, 0 ; drapeau mis à 0 bcf flag_minuteur, 0 ; drapeau mis à 0 return lab_heure ; initialisation du minuteur (dans le cas d'un retour au mode réglage) movf afficheur_0_horloge , W movwf afficheur_0_minuteur movf afficheur_1_horloge , W movwf afficheur_1_minuteur movf afficheur_2_horloge , W movwf afficheur_2_minuteur movf afficheur_3_horloge , W movwf afficheur_3_minuteur movf afficheur_4_horloge , W movwf afficheur_4_minuteur movf afficheur_5_horloge , W movwf afficheur_5_minuteur return ; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ; Routine de rafraîchissement de l'affichage ; Les 5 afficheurs sont multiplexés ; On active les afficheurs les uns après les autres (un toutes les 1/514 s) rafraichissement test_000000 ; test du flag_000000 btfss flag_000000 , 0 ; ( flag_000000) = 0 ? goto mode_reglage ; non clear clrf afficheur_0 clrf afficheur_1 ; oui clrf afficheur_2 clrf afficheur_3 clrf afficheur_4 clrf afficheur_5 goto changement mode_reglage ; test du flag_reglage btfss flag_reglage, 0 ; (flag_reglage) = 0 ? goto mode_minuteur ; oui btfss flag_clignotement_digit , 0 goto test_flag_reglage_0 movlw D'0' subwf digit_minuteur, W btfss STATUS, Z goto digit1m ; (digit) différent de 0 movlw B'1111' ; on éteint l'afficheur actif movwf afficheur_0 goto changement digit1m movlw D'1' subwf digit_minuteur, W btfss STATUS, Z goto digit2m ; (digit) différent de 1 movlw B'1111' ; on éteint l'afficheur actif movwf afficheur_1 goto changement digit2m movlw D'2' subwf digit_minuteur, W btfss STATUS, Z goto digit3m ; (digit) différent de 2 movlw B'1111' ; on éteint l'afficheur actif movwf afficheur_2 goto changement digit3m movlw D'3' subwf digit_minuteur, W btfss STATUS, Z goto digit4m ; (digit) différent de 3 movlw B'1111' ; on éteint l'afficheur actif movwf afficheur_3 goto changement digit4m movlw D'4' subwf digit_minuteur, W btfss STATUS, Z goto digit5m ; (digit) différent de 4 movlw B'1111' ; on éteint l'afficheur actif movwf afficheur_4 goto changement digit5m movlw D'5' subwf digit_minuteur, W btfss STATUS, Z goto changement ; (digit) différent de 5 movlw B'1111' ; on éteint l'afficheur actif movwf afficheur_5 goto changement test_flag_reglage_0 movf afficheur_0_minuteur, W ; non movwf afficheur_0 movf afficheur_1_minuteur, W ; non movwf afficheur_1 movf afficheur_2_minuteur, W movwf afficheur_2 movf afficheur_3_minuteur, W movwf afficheur_3 movf afficheur_4_minuteur, W movwf afficheur_4 movf afficheur_5_minuteur, W movwf afficheur_5 goto changement mode_minuteur ; test du flag_minuteur btfss flag_minuteur, 0 goto changement ; =0 movf afficheur_0_horloge, W movwf afficheur_0 movf afficheur_1_horloge, W movwf afficheur_1 movf afficheur_2_horloge, W movwf afficheur_2 movf afficheur_3_horloge, W movwf afficheur_3 movf afficheur_4_horloge, W movwf afficheur_4 movf afficheur_5_horloge, W movwf afficheur_5 goto changement changement decf digit, f ; on change d'afficheur 5->4->3->2->1->0->5-> etc movlw 0xFF subwf digit, W btfss STATUS, Z goto suite movlw D'5' movwf digit suite ; on alimente l'afficheur correspondant movlw D'0' subwf digit, W btfss STATUS, Z goto digit1 ; (digit) différent de 0 movlw B'00011111' movwf PORTA movlw B'10000011' movwf PORTB ; RB6=0 : afficheur0 alimenté movf afficheur_0, W movwf afficheur ; on charge (afficheur_0) dans (afficheur) goto fin digit1 movlw D'1' subwf digit, W btfss STATUS, Z goto digit2 ; (digit) différent de 0 movlw B'11000011' movwf PORTB movlw B'00011110' movwf PORTA ; RA0=0 : afficheur1 alimenté movf afficheur_1, W movwf afficheur ; on charge (afficheur_1) dans (afficheur) goto fin digit2 movlw D'2' subwf digit, W btfss STATUS, Z goto digit3 ; (digit) différent de 1 movlw B'11000011' movwf PORTB movlw B'00011101' movwf PORTA ; RA1=0 : afficheur2 alimenté movf afficheur_2, W movwf afficheur ; on charge (afficheur_2) dans (afficheur) goto fin digit3 movlw D'3' subwf digit, W btfss STATUS, Z goto digit4 ; (digit) différent de 2 movlw B'11000011' movwf PORTB movlw B'00011011' movwf PORTA ; RA2=0 : afficheur3 alimenté movf afficheur_3, W movwf afficheur ; on charge (afficheur_3) dans (afficheur) goto fin digit4 movlw D'4' subwf digit, W btfss STATUS, Z goto digit5 ; (digit) différent de 3 movlw B'11000011' movwf PORTB movlw B'00010111' movwf PORTA ; RA3=0 : afficheur4 alimenté movf afficheur_4, W movwf afficheur ; on charge (afficheur_4) dans (afficheur) goto fin digit5 movlw D'5' subwf digit, W btfss STATUS, Z goto fin ; (digit) différent de 4 movlw B'11000011' movwf PORTB movlw B'00001111' movwf PORTA ; RA4=0 : afficheur5 alimenté movf afficheur_5, W movwf afficheur ; on charge (afficheur_5) dans (afficheur) goto fin fin ; commande de l'afficheur actif movlw D'0' subwf afficheur, W btfss STATUS, Z goto valeur1 ; (afficheur) différent de 0 bcf PORTB, 2 bcf PORTB, 3 bcf PORTB, 4 bcf PORTB, 5 ; on affiche 0 return valeur1 movlw D'1' subwf afficheur, W btfss STATUS, Z goto valeur2 ; (afficheur) différent de 1 bsf PORTB, 2 bcf PORTB, 3 bcf PORTB, 4 bcf PORTB, 5 ; on affiche 1 return valeur2 movlw D'2' subwf afficheur, W btfss STATUS, Z goto valeur3 ; (afficheur) différent de 2 bcf PORTB, 2 bsf PORTB, 3 bcf PORTB, 4 bcf PORTB, 5 ; on affiche 2 return valeur3 movlw D'3' subwf afficheur, W btfss STATUS, Z goto valeur4 ; (afficheur) différent de 3 bsf PORTB, 2 bsf PORTB, 3 bcf PORTB, 4 bcf PORTB, 5 ; on affiche 3 return valeur4 movlw D'4' subwf afficheur, W btfss STATUS, Z goto valeur5 ; (afficheur) différent de 4 bcf PORTB, 2 bcf PORTB, 3 bsf PORTB, 4 bcf PORTB, 5 ; on affiche 4 return valeur5 movlw D'5' subwf afficheur, W btfss STATUS, Z goto valeur6 ; (afficheur) différent de 5 bsf PORTB, 2 bcf PORTB, 3 bsf PORTB, 4 bcf PORTB, 5 ; on affiche 5 return valeur6 movlw D'6' subwf afficheur, W btfss STATUS, Z goto valeur7 ; (afficheur) différent de 6 bcf PORTB, 2 bsf PORTB, 3 bsf PORTB, 4 bcf PORTB, 5 ; on affiche 6 return valeur7 movlw D'7' subwf afficheur, W btfss STATUS, Z goto valeur8 ; (afficheur) différent de 7 bsf PORTB, 2 bsf PORTB, 3 bsf PORTB, 4 bcf PORTB, 5 ; on affiche 7 return valeur8 movlw D'8' subwf afficheur, W btfss STATUS, Z goto valeur9 ; (afficheur) différent de 8 bcf PORTB, 2 bcf PORTB, 3 bcf PORTB, 4 bsf PORTB, 5 ; on affiche 8 return valeur9 movlw D'9' subwf afficheur, W btfss STATUS, Z goto valeur15 bsf PORTB, 2 bcf PORTB, 3 bcf PORTB, 4 bsf PORTB, 5 ; on affiche 9 return valeur15 movlw D'15' subwf afficheur, W btfss STATUS, Z return bsf PORTB, 2 bsf PORTB, 3 bsf PORTB, 4 bsf PORTB, 5 ; on affiche rien return ;xxxxxxxxxxxxxxx ; initialisation ;xxxxxxxxxxxxxxx initialisation bank0 clrf PORTA ; mise à 0 des sorties du port A clrf PORTB ; mise à 0 des sorties du port B movlw B'00000111' movwf CMCON ; inactivation des comparateurs analogiques bank1 movlw B'00000000' movwf OPTION_REG ; bit 7 (/RBPU) = 0 : activation des résistances de pull-up du port B ; bit 6 (INTEDG)= 0 : (non utilisé) ; bit 5 (T0CS) = 0 : TMR0 Clock Source Select = OSC2/CLKOUT (mode timer) ; bit 4 (T0SE) = 0 : (non utilisé) ; bit 3 (PSA) = 0 ; bit 2 (PS2)= 0 ; bit 1 (PS1) = 0 ; bit 0 (PS0) = 0 ; Avec un quartz 10 MHz : prescaler 1:1 (PSA PS2 PS1 PS0) = (1000) ; Avec un quartz 20 MHz : prescaler 1:2 (PSA PS2 PS1 PS0) = (0000) movlw B'00000000' movwf TRISA ; bit 0 du port A (RA0) = 0 : configuration en sortie (afficheur 1) ; bit 1 du port A (RA1) = 0 : configuration en sortie (afficheur 2) ; bit 2 du port A (RA2) = 0 : configuration en sortie (afficheur 3) ; bit 3 du port A (RA3) = 0 : configuration en sortie (afficheur 4) ; bit 4 du port A (RA4) = 0 : configuration en sortie (afficheur 5) movlw B'10000011' movwf TRISB ; bit 0 du port B (RB0) = 1 : configuration en entrée (bouton poussoir SELECTION DIGIT) ; bit 1 du port B (RB1) = 1 : configuration en entrée (bouton poussoir SELECTION VALEUR) ; bit 2 du port B (RB2) = 0 : configuration en sortie (entrée A du 7447) ; bit 3 du port B (RB3) = 0 : configuration en sortie (entrée B du 7447) ; bit 4 du port B (RB4) = 0 : configuration en sortie (entrée C du 7447) ; bit 5 du port B (RB5) = 0 : configuration en sortie (entrée D du 7447) ; bit 6 du port B (RB6) = 0 : configuration en sortie (afficheur 0) ; bit 7 du port B (RB7) = 1 : configuration en entrée (bouton poussoir START/STOP) bank0 deb ; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ;Effacement de la mémoire RAM du PIC 16F628A movlw debutRAM movwf FSR ; on charge l'adresse de début de la RAM debu clrf INDF ; effacement du contenu du registre pointé par FSR incf FSR, f ; on incrémente l'adresse movlw finRAMplus1 ; adresse de fin + 1 subwf FSR, W btfss STATUS, Z ; on teste si (FSR) = adresse de fin + 1 goto debu ; non : on recommence ;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx movlw D'3' movwf compteur_1 movlw D'1' movwf compteur_10 movlw D'5' movwf compteur_100 ; initialisation du compteur à 513 movlw D'19' movwf compteur_TMR0 movlw D'4' movwf digit_minuteur movlw D'250' movwf compteur_tempo_digit ; 250*(1/514) # 500 ms movlw D'150' movwf compteur_tempo_valeur ; 150*(1/514) # 300 ms movlw D'250' movwf compteur_tempo_start movlw D'100' movwf compteur_clignotement_digit ; 100*(1/514) # 200 ms bsf flag_000000 , 0 ; drapeau mis à 1 clrf TMR0 ; mise à zero du timer0 movlw B'10100000' movwf INTCON ; bit 7 (GIE) = 1 : autorisation globale des interruptions ; bit 5 (T0IE) = 1 : autorisation de l'interruption TMR0 ; bit 2 (T0IF)= 0 : on efface le drapeau de l'interruption TMR0 ; les autres bits sont inutilisés (valeur par défaut = 0) goto debut_programme ;xxxxxxxxxxxxxxxxxxxxx ; programme principal ;xxxxxxxxxxxxxxxxxxxxx debut_programme ; on attend le débordement de TMR0 (0xFF -> 0x00) ; ce qui génére une interruption goto debut_programme END