[projet] compteur + totaliseur pic 16f84A reset avec mot de passe, affichage sur des sept segments

[invite9dffade3]

Bonjour, pour mon projet en stage, j'ai choisi de réaliser un compteur avec pic 16f84A qui compte avec appuie sur un bouton et la RAZ est avec
un autre bouton, l'affichage est sur des sept segments, cette partie j'ai pu la réaliser, cependant, je veux ajouter des autres afficheurs sept
segments permettant de calculer la somme de tout le comptage, la RAZ sera avec un code écrit sur un KEYPAD affiché sur des sept segments ou
LCD (d'après ce que j'ai pu voir sur le forum il me faudra un autre pic pour piloter l'afficher)
ci joint à quoi ressemble mon projet (enfin le début )
le programme est le suivant, le problème est que quand je réinitialise le premier compteur, dés que le deuxième arrive a XXX0, le premier aussi
passe à XXX0 (donc le deuxième bit s'incrémente) ex: compteur 15 totaliseur 15 réinitialisation compteur 00 totaliseur 15 après 5 appuies,
compteur 10 totaliseur 20
voilà le programme:

LIST p=16F84 ; Définition de processeur
#include <p16F84.inc> ; Définitions des constantes

__CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC


;***************************** ****************************** **********
; ASSIGNATIONS *
;***************************** ****************************** **********

OPTIONVAL EQU B'00111111' ;interuption RB0 sur fron décendant

INTERMASK EQU B'00010000' ; Interruptions sur RB0


;***************************** ****************************** **********
; DEFINE *
;***************************** ****************************** **********

#DEFINE reset PORTA,4 ;

;***************************** ****************************** **********
; MACRO *
;***************************** ****************************** **********

BANK0 macro
bcf STATUS , RP0 ; passer banque0
endm

BANK1 macro
bsf STATUS , RP0 ; passer banque1
endm

;***************************** ****************************** **********
; DECLARATIONS DE VARIABLES *
;***************************** ****************************** **********

CBLOCK 0x00C ; début de la zone variables
w_temp :1 ; Sauvegarde du registre W
status_temp : 1 ; Sauvegarde du registre STATUS
cmpt :1 ; compteur de passage
c1,c2,c3,U1,U2,U3,U4,D1,D2,V1, V2,V3,V4,V5,V6
ENDC ; Fin de la zone

;***************************** ****************************** ***********
; DEMARRAGE SUR RESET *
;***************************** ****************************** ***********

org 0x000 ; Adresse de départ après reset
goto init ; Adresse 0: initialiser

;***************************** ****************************** ***********
; ROUTINE INTERRUPTION *
;***************************** ****************************** ***********

;sauvegarder registres
;---------------------
org 0x004 ; adresse d'interruption
movwf w_temp ; sauver registre W
swapf STATUS,w ; swap status avec résultat dans w
movwf status_temp ; sauver status swappé

; switch vers différentes interrupts
; inverser ordre pour modifier priorités
;----------------------------------------

btfsc INTCON,T0IE ; tester si interrupt timer autorisée
btfss INTCON,T0IF ; oui, tester si interrupt timer en cours
goto intsw1 ; non test suivant
call inttimer ; oui, traiter interrupt timer
bcf INTCON,T0IF ; effacer flag interrupt timer
goto restorereg ; et fin d'interruption
; SUPPRIMER CETTE LIGNE POUR
; TRAITER PLUSIEURS INTERRUPT
; EN 1 SEULE FOIS

intsw1
btfsc INTCON,INTE ; tester si interrupt RB0 autorisée
btfss INTCON,INTF ; oui, tester si interrupt RB0 en cours
goto intsw2 ; non sauter au test suivant
call intrb0 ; oui, traiter interrupt RB0
bcf INTCON,INTF ; effacer flag interupt RB0
goto restorereg ; et fin d'interruption
; SUPPRIMER CETTE LIGNE POUR
; TRAITER PLUSIEURS INTERRUPT
; EN 1 SEULE FOIS

intsw2
btfsc INTCON,RBIE ; tester si interrupt RB4/7 autorisée
btfss INTCON,RBIF ; oui, tester si interrupt RB4/7 en cours
goto intsw3 ; non sauter
call intrb4 ; oui, traiter interrupt RB4/7
bcf INTCON,RBIF ; effacer flag interupt RB4/7
goto restorereg ; et fin d'interrupt
; SUPPRIMER CETTE LIGNE POUR
; TRAITER PLUSIEURS INTERRUPT
; EN 1 SEULE FOIS

intsw3
BANK1 ; passer banque1
btfsc INTCON,EEIE ; tester si interrupt EEPROM autorisée
btfss EECON1,EEIF ; oui,tester si interrupt EEPROM
goto restorereg ; non sauter
call inteep ; traiter interruption eeprom


;restaurer registres
;-------------------
restorereg
swapf status_temp,w ; swap ancien status, résultat dans w
movwf STATUS ; restaurer status
swapf w_temp,f ; Inversion L et H de l'ancien W
; sans modifier Z
swapf w_temp,w ; Réinversion de L et H dans W
; W restauré sans modifier status
retfie ; return from interrupt

;***************************** ****************************** ***********
; INTERRUPTION TIMER 0 *
;***************************** ****************************** ***********
inttimer
decfsz cmpt , f ; décrémenter compteur de passages
return ; pas 0, on ne fait rien
movlw b'00000100' ; sélectionner bit à inverser
xorwf PORTA , f ; inverser LED
movlw 7 ; pour 7 nouveaux passages
movwf cmpt ; dans compteur de passages
return ; fin d'interruption timer

;***************************** ****************************** ***********
; INTERRUPTION RB0/INT *
;***************************** ****************************** ***********
intrb0
bcf INTCON,GIE
bcf INTCON,INTE
movlw h'02'
movwf D1
movwf D2
incf U1,f
movfw U1
incf V1,f
movfw V1
sublw 0x3A
btfss STATUS,Z
return
movlw 0x30
movwf U1
movwf V1
incf U2,f
movfw U2
incf V2,f
movfw V2
sublw 0x3A
btfss STATUS,Z
return
movlw 0x30
movwf U2
movwf V2
incf U3,f
movfw U3
incf V3,f
movfw V3
sublw 0x3A
btfss STATUS,Z
return
movlw 0x30
movwf U3
movwf V3
incf U4,f
movfw U4
incf V4,f
movfw V4
sublw 0x3A
btfss STATUS,Z
return
movlw 0x30
movwf U4
movwf V4
bcf INTCON,INTF
; fin d'interruption RB0/INT
; peut être remplacé par
; retlw pour retour code d'erreur

;***************************** ****************************** ***********
; INTERRUPTION RB4/RB7 *
;***************************** ****************************** ***********
intrb4

return


;***************************** ****************************** ***********
; INTERRUPTION EEPROM *
;***************************** ****************************** ***********
inteep
return ; fin d'interruption eeprom
; peut être remplacé par
; retlw pour retour code d'erreur


;***************************** ****************************** **********
; INITIALISATIONS *
;***************************** ****************************** **********

init
clrf PORTA ; Sorties portA à 0
clrf PORTB ; sorties portB à 0
BANK1 ; passer banque1
clrf EEADR ; permet de diminuer la consommation
movlw OPTIONVAL ; charger masque
movwf OPTION_REG ; initialiser registre option

movlw 0x01
movwf TRISB
movlw 0x10
movwf TRISA

; Effacer RAM
; ------------
movlw 0x0c ; initialisation pointeur
movwf FSR ; pointeur d'adressage indirect
init1
clrf INDF ; effacer ram
incf FSR,f ; pointer sur suivant
btfss FSR,6 ; tester si fin zone atteinte (>=40)
goto init1 ; non, boucler
btfss FSR,4 ; tester si fin zone atteinte (>=50)
goto init1 ; non, boucler

; initialiser ports
; -----------------

BANK0 ; passer banque0

movlw INTERMASK ; masque interruption
movwf INTCON ; charger interrupt control
clrf PORTA

; initialisations variables
; -------------------------


;***************************** ****************************** **********
; PROGRAMME PRINCIPAL *
;***************************** ****************************** **********

start
movlw 0x30
movwf FSR
movlw 0x80
movwf INDF
incf FSR
movlw 0xF3
movwf INDF
incf FSR
movlw 0x48
movwf INDF
incf FSR
movlw 0x60
movwf INDF
incf FSR
movlw 0x33
movwf INDF
incf FSR
movlw 0x24
movwf INDF
incf FSR
movlw 0x04
movwf INDF
incf FSR
movlw 0xF0
movwf INDF
incf FSR
movlw 0x01
movwf INDF
incf FSR
movlw 0x20
movwf INDF
incf FSR
movlw 0x00
movwf INDF
incf FSR
movlw 0xFF
movwf INDF

goto debut

; allumage de touts les segments

movlw 0x3A
movwf U1
movwf U2
movwf U3
movwf U4
movlw h'12'
movwf D2
bcc
movlw h'02'
movwf D1
movlw h'02'
movwf D2

debut_bc
call affiche
decfsz D1
goto debut_bc
decfsz D2
goto bcc

;extinction de tous les segments

movlw 0x3B
movwf U1
movwf U2
movwf U3
movwf U4
movlw h'12'
movwf D2
bbb
movlw h'02'
movwf D1
movlw h'02'
movwf D2

debut_bb
call affiche
decfsz D1
goto debut_bb
decfsz D2
goto bbb




debut
movlw 0x30
movwf V1
movwf V2
movwf V3
movwf V4
movwf V5
movwf V6
debut1
movlw 0x30
movwf U1
movwf U2
movwf U3
movwf U4



boucle
movfw D1
btfsc STATUS,Z
goto dec_D2
decf D1
goto anul_int

dec_D2
movfw D2
btfsc STATUS,Z
goto valid_int
decf D2
goto anul_int

valid_int
bsf INTCON,GIE
bcf INTCON,INTF
bsf INTCON,INTE
goto suite

anul_int
bcf INTCON,INTF
bcf INTCON,INTE
bcf INTCON,GIE
suite
call affiche
btfsc reset
goto boucle
goto debut1



affiche
movlw 0x00
movwf PORTA

movfw U1
movwf FSR
movfw INDF
movwf PORTB

call tempo

movlw 0x01
movwf PORTA

movfw U2
movwf FSR
movfw INDF
movwf PORTB

call tempo

movlw 0x02
movwf PORTA

movfw U3
movwf FSR
movfw INDF
movwf PORTB

call tempo

movlw 0x03
movwf PORTA

movfw U4
movwf FSR
movfw INDF
movwf PORTB

call tempo

movlw 0x04
movwf PORTA

movfw V1
movwf FSR
movfw INDF
movwf PORTB

call tempo

movlw 0x05
movwf PORTA

movfw V2
movwf FSR
movfw INDF
movwf PORTB

call tempo

movlw 0x06
movwf PORTA

movfw V3
movwf FSR
movfw INDF
movwf PORTB

call tempo

movlw 0x07
movwf PORTA

movfw V4
movwf FSR
movfw INDF
movwf PORTB

call tempo


movlw 0x08
movwf PORTA

movfw V5
movwf FSR
movfw INDF
movwf PORTB

call tempo

movlw 0x09
movwf PORTA

movfw V6
movwf FSR
movfw INDF
movwf PORTB

call tempo
return


tempo
movlw 0x10
movwf c1
b3 movlw 0x10
movwf c2
b2 movlw 0x10
movwf c3
b1 decfsz c3
goto b1
decfsz c2
goto b2
decfsz c1
goto b3
return


END ; directive fin de programme

toute intervention est la bienvenue, si je n'étais pas très claire dans la description de mon projet, vos questions sont les bienvenues (malgré
que je préfère vos réponses )
-----

[umfred]

1ère remarque: ça manque franchement de commentaires, même si pour toi ce que tu écris est évident à l'instant t, si tu dois reprendre ce code quelques mois/années plus tard, pas sûr que ça le soit facilement (alors imagine pour nous)
2ème remarque: dans ta routine d'interruptions, pas besoin de tester le bit "enable", le test du flag suffit. Il est aussi inutile de tester les interruptions que tu n'autorises pas. ça allège le code en supprimant du code inutile et ça le rend du coup plus lisible aussi.

Simplifie au max les routines d'interruptions:
=> détection de l'appui sur le bouton => incrémentation du compteur ou RAZ du compteur ou (selon le bouton) => on efface le flag et on sort de l'interruption

dans le programme principal, une boucle qui s'occupe de traduire la valeur des compteurs en valeurs affichables (à l'aide d'une fonction) et ensuite affiche ses valeurs


Pour les afficheurs, ça dépend de beaucoup de choses:
1) tu comptes jusqu'à combien au maximum (et pour le compteur et pour le totaliseur) => ça va jouer sur la taille de ta variable du compteur et du totaliseur (utilises 2 variables distinctes), et aussi sur le nombre d'afficheurs 7-segments par valeur

2) méthode d'affichage (non exhaustif):
=> tu peux utiliser un même ensemble d'afficheur pour afficher alternativement (toutes les 1 ou 2 secondes par exemple) les 2 valeurs en mettant en entête de la valeur affiché un caractère ('c' pour le compteur, 'C' pour le totaliseur par exemple, mais ça peut aussi être autre chose)
=> si tu utilises 2 ou 3 ensembles d'afficheurs, tu peux les multiplexer en utilisant le même bus de données mais en alimentant à tour de rôle, le but étant de faire croire à notre œil que les 3 s'affichent en même temps (principe de la persistance rétinienne): par exemple, j'affiche le 1er pendant 10ms, puis ensuite le 2nd pendant 10ms et le 3ème pendant 10ms


Si tu penses que ton pic16f84A est insuffisant, plutôt que de prendre un 2nd pour piloter de l'affichage, regarde si tu ne peux pas en prendre un "plus gros" qui puisse tout faire, ça évitera de faire un bus de communication entre les 2 (et de multiplier par 2 les sources de problèmes)


Je crois que j'ai bien balayé la problématique (peut-être trop ? )

[invite9dffade3]

tout d'abord je vous remercie pour votre réponse assez rapide, pour tes remarques, je ne suis qu'un débutant de pic, donc au niveau de la
programmation je ne suis pas un grand connaisseur, cependant, le début du programme je l'ai pris du net, ce que j'ai ajouté c'est:

La déclaration des 10 variable que j'utilise (pour les 10 sept segments) "déclaration de variables"
L'initialisation des codes binaires pour afficher 0-1-...-9 "programme principale"
Incrémenter à chaque appuie sur le bouton compter " INTERRUPTION RB0/INT"
L'anti-rebondissement "tempo" (à la fin du programme)
La réinitialisation du compteur principale

Bon si vous pouvez m'orienter encore plus, en me disant quelle partie dois je la supprimer... et si par hasard vous connaissez un bon site qui me
permettra de me comprendre le fonctionnement du keypad

Merci d'avance ^^

[invitee05a3fcc]

Sur le plan hard, ton schéma ne tient pas la route
Tu multiplexes avec un ratio de 1/12 (de ce j'ai pu comprendre)

• Donc, pour un courant moyen de 10mA dans un segment, il faut pulser avec un courant de 10*12= 120 mA ..... je ne pense pas que le PIC va apprécier la plaisanterie !
• Je ne sais pas ce que c'est que U2, mais il pilote les chiffres. Donc il doit supporter le courant de 7 segments pulsés. Soit 120*7=840 mA ! U2 peut le faire ????????

[A voir en vidéo sur Futura]

[invite9dffade3]

bah U2 comme U1, U3, U4, V1... V6 sont des variables chacune correspond à un seul segment, cependant, si mon schéma est faux, pourriez vous me donner un schéma plus correcte, en utilisant un pic plus grand pour pouvoir Contrôler tous les segments sans avoir à multiplexer, et ainsi pouvoir intégré le keypad phone pour le mot de passe et merci!

[invitee05a3fcc]

Tu poses tes questions sur le forum ...... pas en M.P. !

Tu multiplexes avec un ratio de 1/12

Sorry, c'est 1/10
Il faut que tes interfaces avec le PIC puissent piloter les LEDs avec le courant recalculé avec 1/10

[invite9dffade3]

vous pouviez répondre à la deuxième partie de ma question au même temps donc je repose la question:
est ce que le courant sortant de mon pic alimentant le circuit 74145 est 4*25mA = 100mA ?? (25mA courant max fourni par le pic)

[invitee05a3fcc]

est ce que le courant sortant de mon pic alimentant le circuit 74145 est 4*25mA = 100mA ?? (25mA courant max fourni par le pic)

Excuse moi, mais je comprend rien à ta question !

• Depuis quand un 74145 bouffe 25mA en entrée?
• Depuis quand un PIC peut fournir 25mA ?

en utilisant un pic plus grand pour pouvoir Contrôler tous les segments sans avoir à multiplexer,

Ben voyons .... 70 broches rien que pour piloter des LEDS. Une idée comme ça dans mon labo, le gars ne terminait pas sa période d'essais !

PS : Pour info, le 74145 accepte (de mémoire ) 40 ou 80 mA . Dans ton montage, il se prend 10x7x10= 700 mA . Il va faire la gueule !

[invite9dffade3]

bah c'est ce que j'ai lu sur des sites et sur ce forum, un pic peut fournir comme courant max 25mA, excusez ma connaissance réduite, je n'ai que 19ans, et ça fait qu'un an que j'étudie l’électronique, donc mes connaissances sont réduites, et c'est d'ailleurs pour ces inconvénients que je demandes de l'aide
Donc premièrement, je n'utilise pas 70 broches mais 28 et ceci pour pouvoir insérer un clavier 4*4 pour pouvoir programmer la RAZ du totalisateur avec un mot de passe (alors le gars aura une deuxième chance? ), cependant j'ai retardé cette partie, vue que vous m'aviez dit qu'il existe un problème hard sur mon schéma...
deuxièmement, j'ai lu un peu les DATASHEET j'ai trouvé qu'un 74145 peut fournir 20mA a la sortie niveau bas, donc je devrai ajouter 10 transistors emetteur commun pour amplifier le courant?

[invitee05a3fcc]

bah c'est ce que j'ai lu sur des sites et sur ce forum, un pic peut fournir comme courant max 25mA,

Ce que tu lis ou vois à droite ou à gauche, c'est à mettre à la poubelle !
Il n'y a qu'un seul document que tu peux croire, c'est la spécification du produit.
Oui, je sais, c'est volumineux ! Alors tu cherches pour quel Iol et Ioh ,tu as un Vol et Voh garantie . Et c'est aux environs de 5mA . Toute autre affirmation, c'est de la poudre de perlimpinpin .

je n'utilise pas 70 broches mais 28

70, c'est si tu ne veux pas multiplexer.

PS : Tu peux utiliser les 4 sorties qui vont au 74145 pour multiplexer tes 4x4 touches . I suffit alors de rajouter 4 entrées .

[invite9dffade3]

bah en parlant de mon 4x4, pourriez vous me dire un peu comment ça fonctionne, j'ai vu que l'idée général était de mettre soit les lignes (ou les colonnes) à un et attendre l'appuie pour savoir quelle colonnes on a choisi, avec cette méthode nous aurons 4 variable vu que tous les éléments de la ligne sont à 1.... comment savoir la quelle d'entre elles, est celle qu'on veut?

[invitee05a3fcc]

ON multiplexe !
Tu mets 0001 en ligne (affichage du chiffre LED numéro 1)
->Tu regardes si les colonnes sont à 0000 (non, il y a des touches appuyées 0 à 3)
Tu mets 0010 en ligne (affichage du chiffre LED numéro 2)
->Tu regardes si les colonnes sont à 0000 (non, il y a des touches appuyées 4 à 7)
Tu mets 0100 en ligne (affichage du chiffre LED numéro 4)
->Tu regardes si les colonnes sont à 0000 (non, il y a des touches appuyées 8 à 11)
Tu mets 1000 en ligne (affichage du chiffre LED numéro 8)
->Tu regardes si les colonnes sont à 0000 (non, il y a des touches appuyées 12 à 15)
CQFD
PS : il faut rajouter quelques composants pour que ça marche .... je te laisse chercher !

[invite9dffade3]

oki merci Daudet pour tes réponses rapides et efficaces!