; "Réveille-matin (à quartz)"          
; (C) Fabrice Sincère, février 2007
; IUT Nancy-Brabois
; version 1.03 
; microcontrôleur PIC 16F628A
; développé avec Microchip MPLAB IDE

	List p=16F628A	; processeur utilisé 
	#include <p16F628A.inc>

	__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

buzzer_ON macro		; active le buzzer
		bsf PORTB, 6
		endm

buzzer_OFF macro	; désactive le buzzer
		bcf PORTB, 6
		endm

;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Initialisation de la mémoire EEPROM (facultatif)
; Cela met dans l'EEPROM le message :
; (C) Fabrice Sincere 21/02/2007
; (en code ASCII)
; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	org H'2100'		; début de zone EEPROM du PIC 16F628A

	DE '(' ; ou DE H'28' (code ASCII correspondant)
	DE 'C'		
	DE ')'
	DE 'F' ,'a'	,'b','r','i','c','e',' '		
	DE 'S','i','n','c','e','r','e',' '
	DE '2','1','/','0','2','/','2','0','0','7'

;xxxxxxxxxxxxxxxxxxxxxxxxx
; déclaration de variables
;xxxxxxxxxxxxxxxxxxxxxxxxx

	CBLOCK H'020'	; début de la zone des registres d'usage général du 16F628A

	digit :	1			; variable qui indique n° de l'afficheur actif (1 à 4)
	STATUS_TEMP : 1 	; sauvegarde du registre STATUS (routine d'interruption)
	W_TEMP : 1 			; sauvegarde du registre W		(routine d'interruption)

	compteur : 1		; compteur des 1/256 de seconde
	secondes : 1 		; compteur de secondes

	flag_tempo_heure : 1	; drapeau mis à 1 au début de la temporisation anti-rebonds
							; du bouton poussoir HEURE (on utilise le bit 0)
	compteur_tempo_heure : 1 ; compteur de la temporisation anti-rebonds
						; du bouton poussoir HEURE (on utilise le bit 0)	

	flag_tempo_minute : 1	; drapeau mis à 1 au début de la temporisation anti-rebonds
							; du bouton poussoir MINUTE (on utilise le bit 0)
	compteur_tempo_minute : 1 ; compteur de la temporisation anti-rebonds
						; du bouton poussoir MINUTE (on utilise le bit 0)

	flag_tempo_selection   ; drapeau mis à 1 au début de la temporisation 
						; du bouton poussoir SELECTION (on utilise le bit 0).					
	compteur_tempo_selection   ; compteur de la temporisation 
						; du bouton poussoir SELECTION (on utilise le bit 0)
						; Cette temporisation, permet après 3 secondes d'inactivité
						; sur les boutons poussoirs MINUTE et HEURE, de revenir à 
						; l'affichage de l'heure courante

	flag_reveil		; drapeau mis à 1 quand c'est l'heure du réveil (on utilise le bit 0)	

	afficheur_1_reveil : 1	; contient le chiffre des heures (dizaines) (reveil)
	afficheur_2_reveil : 1	; contient le chiffre des heures (unités) (reveil)
	afficheur_3_reveil : 1	; contient le chiffre des minutes (dizaines) (reveil)
	afficheur_4_reveil : 1	; contient le chiffre des minutes (unités) (reveil)

	afficheur_1_horloge : 1	; contient le chiffre des heures (dizaines) (horloge)
	afficheur_2_horloge : 1	; contient le chiffre des heures (unités) (horloge)
	afficheur_3_horloge : 1	; contient le chiffre des minutes (dizaines) (horloge)
	afficheur_4_horloge : 1	; contient le chiffre des minutes (unités) (horloge)

	afficheur_1 : 1		; contient le chiffre des heures (dizaines) à afficher (codage BCD)
	afficheur_2 : 1		; contient le chiffre des heures (unités) à afficher (codage BCD)
	afficheur_3 : 1		; contient le chiffre des minutes (dizaines) à afficher (codage BCD)
	afficheur_4 : 1		; contient le chiffre des minutes (unités) à afficher (codage BCD)

	afficheur : 1		; contient le chiffre actif à afficher (codage BCD)

	ENDC 

;xxxxxxxxxxxxxxxxxxxx 
; démarrage sur reset
;xxxxxxxxxxxxxxxxxxxx

	org H'0000'
		goto initialisation

; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Routine d'interruption 
; 1 source d'interruption
; - TMR0 en mode compteur (broche RA4/T0CKI)
; Cette interruption a lieu toutes les 1/256 seconde exactement
; (quartz 32768 Hz prescaler 1:1 -> 1/128 seconde :
; durée divisée par 2 en ajoutant 128 au TMR0)
; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

	org H'0004'	 			; vecteur d'interruption

	movwf W_TEMP 
	swapf STATUS,W
	movwf STATUS_TEMP		; sauvegarde du registre W puis du registre STATUS

	movlw D'128'
	addwf TMR0,f			; on augmente le TMR0 de D'128'
		
	call BP_selection  ; routine de gestion du bouton poussoir SELECTION
	
	call BP_minute    ; routine de gestion du bouton poussoir REGLAGE MINUTE
	call BP_heure     ; routine de gestion du bouton poussoir REGLAGE HEURE

	incf compteur,f	; on incrémente le compteur des 1/256 seconde
	movf compteur,f
	btfss STATUS,Z 			; compteur = 0 ?
	goto raf				; non	
	incf secondes,f			; la seconde est atteinte : on incrémente

	; xxxxxxxxx Si le mode d'affichage est le mode réglage du réveil :
	; on teste si les BP HEURE ou MINUTE sont inactifs depuis au moins 3 secondes
	; si oui, on repasse en mode d'affichage HORLOGE
	btfss flag_tempo_selection, 0
	goto parla	; flag_tempo_selection = 0
	decf compteur_tempo_selection,f
	btfss STATUS, Z
	goto parla	; 	compteur_tempo_selection <> 0						
	bcf flag_tempo_selection,0	; drapeau remis à 0							
	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
parla
	; xxxxx Si c'est l'heure du reveil :
	btfss flag_reveil,0 
	goto parla1	; flag_reveil = 0
	; flag_reveil = 1  : on inverse l'état du buzzer toutes les secondes
	btfss PORTB,6
	goto parla2
	buzzer_OFF
	goto parla1
parla2
	buzzer_ON
	; xxxxxxxxxxxx
parla1

	movlw D'60'
	subwf secondes,W
	btfss STATUS,Z 		
	goto raf
	clrf secondes			; la minute est atteinte : on incrémente	
	call heure_minute_plus_horloge		; mise à jour de l'heure

	; test si c'est l'heure du réveil
	bcf flag_reveil,0  ; drapeau mis à 0
	buzzer_OFF	
	movf afficheur_1_horloge, W 
	subwf afficheur_1_reveil, W
	btfss STATUS, Z		;afficheur_1_horloge = afficheur_1_reveil  ?
	goto raf ; non	
	;oui
	movf afficheur_2_horloge, W 
	subwf afficheur_2_reveil, W
	btfss STATUS, Z		;afficheur_2_horloge = afficheur_2_reveil  ?
	goto raf ; non	
	;oui		
	movf afficheur_3_horloge, W 
	subwf afficheur_3_reveil, W
	btfss STATUS, Z		;afficheur_3_horloge = afficheur_3_reveil  ?
	goto raf ; non	
	;oui
	movf afficheur_4_horloge, W 
	subwf afficheur_4_reveil, W
	btfss STATUS, Z		;afficheur_4_horloge = afficheur_4_reveil  ?
	goto raf ; non	
	;oui : on active le buzzer (pendant une minute avec un cycle de 2 s)
	buzzer_ON
	bsf flag_reveil,0  ; drapeau mis à 1
	
raf
	call rafraichissement

	bcf INTCON,T0IF			; on efface le drapeau T0IF	
	goto restauration

restauration

	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 (broche RB7)
; Quand ce bouton est appuyé, on passe au réglage de l'heure de réveil.
; On revient automatiquement à l'affichage de l'heure courante après 
; 3 secondes d'inactivité.
; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
BP_selection
	; on teste si le bouton poussoir SELECTION est enfoncé
	btfsc PORTB,7	
	return		; BP au repos
	; BP appuyé
	bsf flag_tempo_selection,0	; drapeau mis à 1
	movlw D'4'	
	movwf compteur_tempo_selection	; 4 secondes	
	return

; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Routine de gestion du bouton poussoir REGLAGE MINUTE (broche RB0)
; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
BP_minute    
	;test du flag_tempo_minute
	btfsc flag_tempo_minute, 0
	goto flag_tempo_minute_1
	; flag_tempo_minute = 0	
	btfsc PORTB,0	
	return		; BP au repos
	; BP appuyé
	bsf flag_tempo_minute, 0	; drapeau mis à 1
	movlw D'50'                 ; temporisation de 50/256 # 200 ms
	movwf compteur_tempo_minute
	return

flag_tempo_minute_1 ; le flag_tempo_minute est égal à 1
	decf compteur_tempo_minute,f
	btfss STATUS, Z
	return		; le compteur n'est pas nul	
	; le compteur est nul
	bcf flag_tempo_minute, 0	; drapeau mis à 0

	;test du flag_tempo_selection
	btfsc flag_tempo_selection, 0
	goto la
	call minute_plus_horloge  	;flag_tempo_selection = 0
	return			
la
	call minute_plus_reveil		;flag_tempo_selection = 1
	movlw D'4'	
	movwf compteur_tempo_selection	; 4 secondes
	return

; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Routine de gestion du bouton poussoir REGLAGE HEURE (broche RB1)
; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
BP_heure    
	;test du flag_tempo_heure
	btfsc flag_tempo_heure, 0
	goto flag_tempo_heure_1
	; flag_tempo_heure = 0	
	btfsc PORTB,1	
	return		; BP au repos
	; BP appuyé
	bsf flag_tempo_heure, 0		; drapeau mis à 1
	movlw D'50'                 ; temporisation de 50/256 # 200 ms
	movwf compteur_tempo_heure
	return

flag_tempo_heure_1 ; le flag_tempo_minute est égal à 1
	decf compteur_tempo_heure,f
	btfss STATUS, Z
	return		; le compteur n'est pas nul	
	; le compteur est nul
	bcf flag_tempo_heure, 0	; drapeau mis à 0

	;test du flag_tempo_selection
	btfsc flag_tempo_selection, 0
	goto ici
	call heure_plus_horloge  	;flag_tempo_selection = 0
	return			
ici
	call heure_plus_reveil		;flag_tempo_selection = 1
	movlw D'4'	
	movwf compteur_tempo_selection	; 4 secondes
	return

;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Routine "heure_minute_plus_horloge"
; Incrémentation d'une minute de l'heure courante
; afficheur_4 -> minute (unité)
; afficheur_3 -> minute (dizaine)
; afficheur_1 -> heure (unité)
; afficheur_2 -> heure (dizaine)
; 10:00->10:01-> ... ->10:59->11:00->11:01 ...->23:59->00:00
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Routine "heure_plus_horloge"
; Incrémentation d'une heure (appuie sur BP "REGLAGE HEURE") de l'horloge
; afficheur_1 -> heure (unité)
; afficheur_2 -> heure (dizaine)
; 10->11-> ... ->23->00->01 ...
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

heure_minute_plus_horloge

	incf afficheur_4_horloge,f
 	; on teste si (afficheur_4)=D'10'
	movlw D'10'
	subwf afficheur_4_horloge,W
	btfss STATUS,Z 		
	return		; (afficheur_4) différent (inférieur à) de D'10'
	; (afficheur_4) égal à D'10'
	clrf afficheur_4_horloge
	incf afficheur_3_horloge,f	
	; on teste si (afficheur_3)=D'6'
	movlw D'6'
	subwf afficheur_3_horloge,W
	btfss STATUS,Z 		
	return		; (afficheur_3) différent de D'6'
	; (afficheur_3) égal à D'6'
	clrf afficheur_3_horloge

heure_plus_horloge
	; on teste s'il est 23 heures
	movlw D'3'
	subwf afficheur_2_horloge,W
	btfss STATUS,Z 		
	goto not23
	movlw D'2'
	subwf afficheur_1_horloge,W
	btfss STATUS,Z 		
	goto not23
	; il est 23 heures donc on passe à 00 heure
	clrf afficheur_2_horloge
	clrf afficheur_1_horloge
	return

not23	
	incf afficheur_2_horloge,f	
	; on teste si (afficheur_2)=D'10'
	movlw D'10'
	subwf afficheur_2_horloge,W
	btfss STATUS,Z 		
	return		; (afficheur_2) différent de D'10'
	; (afficheur_2) égal à D'10'
	clrf afficheur_2_horloge
	incf afficheur_1_horloge,f	
	return

;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Routine "heure_plus_reveil"
; Incrémentation d'une heure (appuie sur BP "REGLAGE HEURE") du reveil
; afficheur_1 -> heure (unité)
; afficheur_2 -> heure (dizaine)
; 10->11-> ... ->23->00->01 ...
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

heure_plus_reveil
	; on teste s'il est 23 heures
	movlw D'3'
	subwf afficheur_2_reveil,W
	btfss STATUS,Z 		
	goto not23b
	movlw D'2'
	subwf afficheur_1_reveil,W
	btfss STATUS,Z 		
	goto not23b
	; il est 23 heures donc on passe à 00 heure
	clrf afficheur_2_reveil
	clrf afficheur_1_reveil
	return

not23b	
	incf afficheur_2_reveil,f	
	; on teste si (afficheur_2)=D'10'
	movlw D'10'
	subwf afficheur_2_reveil,W
	btfss STATUS,Z 		
	return		; (afficheur_2) différent de D'10'
	; (afficheur_2) égal à D'10'
	clrf afficheur_2_reveil
	incf afficheur_1_reveil,f	
	return


;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Routine "minute_plus_horloge"
; Incrémentation d'une minute (appuie sur BP "REGLAGE MINUTE") de l'horloge
; afficheur_4_horloge -> minute (unité)
; afficheur_3_horloge -> minute (dizaine)
; 00->01->02 ... ->59->00->01 ...
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

minute_plus_horloge

	incf afficheur_4_horloge,f
 	; on teste si (afficheur_4)=D'10'
	movlw D'10'
	subwf afficheur_4_horloge,W
	btfss STATUS,Z 		
	return		; (afficheur_4) différent (inférieur à) de D'10'
	; (afficheur_4) égal à D'10'
	clrf afficheur_4_horloge
	incf afficheur_3_horloge,f	
	; on teste si (afficheur_3)=D'6'
	movlw D'6'
	subwf afficheur_3_horloge,W
	btfss STATUS,Z 		
	return		; (afficheur_3) différent de D'6'
	; (afficheur_3) égal à D'6'
	clrf afficheur_3_horloge
	return

;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Routine "minute_plus_reveil"
; Incrémentation d'une minute (appuie sur BP "REGLAGE MINUTE") du reveil
; afficheur_4_horloge -> minute (unité)
; afficheur_3_horloge -> minute (dizaine)
; 00->01->02 ... ->59->00->01 ...
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

minute_plus_reveil

	incf afficheur_4_reveil,f
 	; on teste si (afficheur_4)=D'10'
	movlw D'10'
	subwf afficheur_4_reveil,W
	btfss STATUS,Z 		
	return		; (afficheur_4) différent (inférieur à) de D'10'
	; (afficheur_4) égal à D'10'
	clrf afficheur_4_reveil
	incf afficheur_3_reveil,f	
	; on teste si (afficheur_3)=D'6'
	movlw D'6'
	subwf afficheur_3_reveil,W
	btfss STATUS,Z 		
	return		; (afficheur_3) différent de D'6'
	; (afficheur_10) égal à D'10'
	clrf afficheur_3_reveil
	return


; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Routine de rafraîchissement de l'affichage
; Les 4 afficheurs sont multiplexés
; On active les afficheurs les uns après les autres (un toutes les 1/128 s)

rafraichissement

	;test du flag_tempo_selection
	btfsc flag_tempo_selection, 0
	goto flag_tempo_selection_1

	; flag_tempo_selection = 0	: rafraichissement de l'horloge
	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
	goto changement

flag_tempo_selection_1
	; rafraichissement de l'heure de réveil
	movf afficheur_1_reveil, W
	movwf afficheur_1
	movf afficheur_2_reveil, W
	movwf afficheur_2
	movf afficheur_3_reveil, W
	movwf afficheur_3
	movf afficheur_4_reveil, W
	movwf afficheur_4
	goto changement

changement
	decf digit, f		; on change d'afficheur 4->3->2->1->4-> etc
	btfss STATUS, Z
	goto suite
	movlw D'4'
	movwf digit
suite

	; on alimente l'afficheur correspondant
	movlw D'1'
	subwf digit, W
	btfss STATUS, Z
	goto digit2			; (digit) différent de 1
	movlw B'00001110'
	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 2
	movlw B'00001101'
	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 3
	movlw B'00001011'
	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 fin			; (digit) différent de 4 
	movlw B'00000111'
	movwf PORTA			; RA3=0 : afficheur4 alimenté 
	movf afficheur_4, W
	movwf afficheur		; on charge (afficheur_4) 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
	return					;  (par précaution)
	bsf PORTB, 2
	bcf PORTB, 3
	bcf PORTB, 4
	bsf PORTB, 5			; on affiche 9
	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'00101000'
	movwf OPTION_REG
	; bit 7 (/RBPU) = 0 : activation des résistances de pull-up du port B
	; bit 6 (INTEDG)= 0 : (non utilisée)
	; bit 5 (T0CS) = 1 : TMR0 Clock Source Select = RA4/T0CKI (mode compteur)
	; bit 4 (T0SE) = 0 :  RA4/T0CKI actif sur front montant
	; bit 3 (PSA) = 1  : Prescaler attribué au Watchdog
	; bit 2 (PS2)= 0	  
	; bit 1 (PS1) = 0 
	; bit 0 (PS0) = 0 : Facteur de division du prescaler = 1:1

	movlw B'00010000' 
	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) = 1 : configuration en entrée (quartz 32768 Hz)

	movlw B'10000011'
	movwf TRISB
	; bit 0 du port B (RB0) = 1 : configuration en entrée (bouton poussoir REGLAGE MINUTE) 
	; bit 1 du port B (RB1) = 1 : configuration en entrée (bouton poussoir REGLAGE HEURE) 
	; 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 (commande du Buzzer)
	; bit 7 du port B (RB7) = 1 : configuration en entrée (bouton poussoir SELECTION)

	bank0
	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)	

	clrf PORTA		; sorties du port A au niveau bas
					; les afficheurs sont donc éteints
	
	clrf TMR0			; mise à zero du timer0

	; 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'4'
	movwf digit	
	movlw D'50'	
	movwf compteur_tempo_minute		 ; 50*(1/256) # 200 ms
	movwf compteur_tempo_heure
	movlw D'4'	
	movwf compteur_tempo_selection	; 4 secondes
	buzzer_OFF ; (macro) désactive le buzzer
	goto debut_programme  
		
;xxxxxxxxxxxxxxxxxxxxx 
; programme principal
;xxxxxxxxxxxxxxxxxxxxx

debut_programme

; on attend le débordement de TMR0 (H'FF' -> H'00')
; ce qui génére une interruption toutes les 1/256 s

	goto debut_programme

	END