; Mesure avec un capteur de température numérique DS1620
; Affichage de la température sur un module LCD alphanumérique 2x16
; Dialogue via RS232C  
; Utilisation de l'USART du 16F628A avec interruptions
; 9600 bauds/s 
; 8 bits de données     
; Pas de bit de parité
; 1 bit de STOP    
; Pas de contrôle de flux  

; (C) Fabrice Sincère, septembre 2007 
; IUT Nancy-Brabois
; Version 1.01
; http://perso.orange.fr/fabrice.sincere
; Microcontrôleur PIC 16F628A
; Langage : assembleur
; Développé avec Microchip MPLAB IDE

	Errorlevel-302 ; Supprime le message "Ensure that bank bits are correct" 

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

	__config _CP_OFF & _WDT_OFF & _PWRTE_ON & _HS_OSC & _LVP_OFF & _DATA_CP_OFF & _BOREN_ON & _MCLRE_OFF
		;bits de configuration :
		; code protect OFF
		; watchdog timer OFF
		; power up timer ON
		;(72 ms : cela permet l'auto-initialisation de l'afficheur LCD)	
		; oscillateur HS 			(quartz 20 MHz)
		; low voltage program OFF
		; data EE read protect OFF
		; brown out detect ON
		; master clear enable OFF (utilisation de l'entrée RA5) 

;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

;xxxxxxxxxxxxxxxxxxxxxxxxxx
; Déclaration des variables
;xxxxxxxxxxxxxxxxxxxxxxxxxx

	CBLOCK 0x070		; début de la zone des registres d'usage général du 16F628A
						; (banque quelconque : 0,1,2 ou 3)
						; 0x070 - 0x07F : 16 variables

	STATUS_TEMP : 1 	; sauvegarde du registre STATUS (routine d'interruption)
	W_TEMP : 1 			; sauvegarde du registre W		(routine d'interruption)

	octet : 1			; octet reçu (broche RX de l'UART)
	octet1 : 1 			; 1er octet reçu : contient le code instruction 8 bits
	octet2 : 1 			; 2eme octet reçu :
						; (0000000 D8) pour les instructions de type WRITE (DS1620)
						; (00000000) non utilisé pour les instructions de type READ (DS1620)
	octet3 : 1 			; 3eme octet reçu : contient le niveau des bits DB7-DB0 :
						; (D7 ... D0) pour les instructions de type WRITE (DS1620)
						; (00000000) non utilisé pour les instructions de type READ (DS1620)

	nb_octet_recu : 1	; nombre d'octets reçus
						; (valeur initiale : 0)

	octet1_tx : 1	; 1er octet à transmettre vers l'ordinateur (TX)
	octet2_tx : 1	; 2ème octet à transmettre vers l'ordinateur (TX)

	nb_octet_transmis : 1	; nombre d'octets transmis
							; (valeur initiale : 0)

	compteur_timer1 : 1	  	; (valeur initiale : 8)

	data1 : 1 			; contient le niveau des bits RS et R/W (module LCD):
						; (000000 RS R/W)
	data2 : 1 			; contient le niveau des bits DB7-DB0 (module LCD):
						; (DB7 ... DB0)
	busy_flag : 1 		; seul le bit 0 est utilisé (module LCD)

	ENDC

	CBLOCK 0x020	; début de la zone des registres d'usage général du 16F628A
					; de la banque 0 (0x020 - 0x06F : 80 variables)

						; Ecran n°1
	position0x40 : 1 	; contient le code ASCII (2ème ligne 1ère position du module LCD)
						; 2 valeurs possibles : '+' ou '-'		
	position0x41 : 1 	; contient le code ASCII (2ème ligne 2ème position)
						; chiffre des centaines (température)	
	position0x42 : 1 	; contient le code ASCII (2ème ligne 3ème position)
						; chiffre des dizaines (température)
	position0x43 : 1 	; contient le code ASCII (2ème ligne 4ème position)
						; chiffre des unités (température)
	position0x44 : 1 	; contient le code ASCII ','(2ème ligne 5ème position)
	position0x45 : 1 	; contient le code ASCII (2ème ligne 6ème position)
						; chiffre des dixièmes (température) : 0 ou 5
	position0x46 : 1 	; contient le code ASCII ' '(2ème ligne 7ème position)
	position0x47 : 1 	; contient 0xDF '°'(2ème ligne 8ème position)
	position0x48 : 1 	; contient le code ASCII 'C'(2ème ligne 9ème position)
	position0x49 : 1 	; '*' qui clignote (2ème ligne 10ème position)
						; Exemple d'affichage : "+ 24,5 °C*"

						; Ecran n°2 (ligne 1)
	position2_0x00 : 1	; 'M'
	position2_0x01 : 1	; 'a'
	position2_0x02 : 1	; 'x'
	position2_0x03 : 1	; ' '
	position2_0x04 : 1	; '+' ou '-'
	position2_0x05 : 1	; ascii centaine
	position2_0x06 : 1	; ascii dizaine
	position2_0x07 : 1	; ascii unité
	position2_0x08 : 1	; ','
	position2_0x09 : 1	; ascii dizieme
	position2_0x0A : 1	; ' '
	position2_0x0B : 1	; '°' 0xDF
	position2_0x0C : 1	; 'C'

						; Ecran n°2 (ligne 2)
	position2_0x40 : 1	; 'M'
	position2_0x41 : 1	; 'i'
	position2_0x42 : 1	; 'n'
	position2_0x43 : 1	; ' '
	position2_0x44 : 1	; '+' ou '-'
	position2_0x45 : 1	; ascii centaine
	position2_0x46 : 1	; ascii dizaine
	position2_0x47 : 1	; ascii unité
	position2_0x48 : 1	; ','
	position2_0x49 : 1	; ascii dizieme
	position2_0x4A : 1	; ' '
	position2_0x4B : 1	; '°' 0xDF
	position2_0x4C : 1	; 'C'

	ascii_signe : 1 	; routine tempASCII
	ascii_centaine: 1 	; routine tempASCII
	ascii_dizaine : 1 	; routine tempASCII
	ascii_unite : 1 	; routine tempASCII
	ascii_dizieme : 1 	; routine tempASCII

	count : 1			; routine binaire -> BCD
	temp  : 1 			; routine binaire -> BCD
	H_byte : 1			; routine binaire -> BCD
	L_byte : 1			; routine binaire -> BCD
	R0 : 1 				; routine binaire -> BCD                
	R1 : 1   			; routine binaire -> BCD
	R2 : 1     			; routine binaire -> BCD 

	etape : 1			; etape = 0x01 (écran n°1)
						; etape = 0x02 (écran n°2)	
	BPminmax_bak : 1	; état antérieur du bouton poussoir RESET MIN/MAX
 						; 0x00 = fermé (RA5 = 0), 0x01 = ouvert (RA5 = 1)
	BPminmax	: 1 	; état actuel du bouton poussoir RESET MIN/MAX
	flagBPminmax : 1    ; drapeau mis à 0x01 après un front descendant
						; à remettre à 0x00 de façon logicielle
	BPecran_bak : 1		; état antérieur du bouton poussoir SELECTION ECRAN
 						; 0x00 = fermé (RA4 = 0), 0x01 = ouvert (RA4 = 1)
	BPecran	: 1 		; état actuel du bouton poussoir SELECTION ECRAN
	flagBPecran : 1     ; drapeau mis à 0x01 après un front descendant
						; à remettre à 0x00 de façon logicielle

	temperature_H : 1	; température actuelle (9 bits complément à 2
						; (0000000 D8)
	temperature_L : 1	; température actuelle (9 bits complément à 2)
						; (DB7 ... DB0)
	temperatureMAX_H : 1	; température MAX (9 bits complément à 2)
	temperatureMAX_L : 1	; température MAX (9 bits complément à 2)
	temperatureMIN_H : 1	; température MIN (9 bits complément à 2)
	temperatureMIN_L : 1	; température MIN (9 bits complément à 2)

	nombre1_H : 1 			; routine comparaison9bits
	nombre1_L : 1 			; routine comparaison9bits
	nombre2_H : 1 			; routine comparaison9bits
	nombre2_L : 1 			; routine comparaison9bits
					
	ENDC  

;xxxxxxxxxxxxxxxxxxxx 
; Démarrage sur reset
;xxxxxxxxxxxxxxxxxxxx

	org 0x0000
	goto initialisation

; xxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Routine d'interruption 
; 3 sources d'interruption (par ordre de priorité) :
; -> réception (UART)
; -> émission (UART)
; -> Timer1 (16 bits)
; xxxxxxxxxxxxxxxxxxxxxxxxxxxxx

	org 0x0004	 			; vecteur d'interruption

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

    bank1
    btfss PIE1, RCIE
    goto int1				
    bank0
    btfsc PIR1, RCIF
    goto reception 
int1
	bank1
    btfss PIE1, TXIE
    goto int2
    bank0
    btfsc PIR1, TXIF
    goto emission
int2
	bank1
	btfss PIE1, TMR1IE 
	goto int3
	bank0
	btfsc PIR1, TMR1IF
	goto interruption_timer1
int3
	goto restauration
	
	;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; Traitement de l'interruption de réception de l'USART
	;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
reception

    bank0
	incf nb_octet_recu , f	; on incrémente (nb_octet_recu)
    movf RCREG , W ; N.B. le flag RCIF est remis à 0 par une lecture du registre RCREG
    movwf octet ; les 8 bits de données sont transférés dans (octet)

	movlw D'1'
	subwf nb_octet_recu , W
	btfss STATUS , Z
	goto rec2
	; réception du 1er octet
	movf octet , W
	movwf octet1

	; on teste s'il s'agit bien du 1er octet
	; (donc valeur 0xAA ou 0x01 ou 0x02 ou 0xA1 ou 0xA2) 

	movlw 0xAA
	subwf octet1 , W
	btfsc STATUS , Z
	goto overrun

	movlw 0x01
	subwf octet1 , W
	btfsc STATUS , Z
	goto overrun

	movlw 0x02
	subwf octet1 , W
	btfsc STATUS , Z
	goto overrun
	
	movlw 0xA1
	subwf octet1 , W
	btfsc STATUS , Z	
	goto overrun

	movlw 0xA2
	subwf octet1 , W
	btfsc STATUS , Z	
	goto overrun

probleme	; il ne s'agit pas du 1er octet
	clrf nb_octet_recu
	goto overrun

rec2
	movlw D'2'
	subwf nb_octet_recu , W
	btfss STATUS , Z
	goto rec3
	; réception du 2ème octet
	movf octet , W
	movwf octet2
	goto overrun

rec3
	; réception du 3ème octet
	movf octet , W
	movwf octet3
	clrf nb_octet_recu 

	; On arrive ici quand les 3 octets sont reçus

	; Décodage de l'instruction (1er octet : octet1)
	; Read Temperature : code instruction 0xAA
	; Write TH : code instruction 0x01
	; Write TL : code instruction 0x02
	; Read TH : code instruction 0xA1
	; Read TL : code instruction 0xA2	

	movlw 0xAA
	subwf octet1 , W
	btfss STATUS , Z
	goto cas2
	call ReadTemperature
	goto cas_fin

cas2
	movlw 0x01
	subwf octet1 , W
	btfss STATUS , Z
	goto cas3
	call WriteTH
	clrf octet1_tx 
	clrf octet2_tx 
	goto cas_fin

cas3
	movlw 0x02
	subwf octet1 , W
	btfss STATUS , Z
	goto cas4
	call WriteTL
	clrf octet1_tx 
	clrf octet2_tx 
	goto cas_fin
	
cas4
	movlw 0xA1
	subwf octet1 , W
	btfss STATUS , Z
	goto cas5
	call ReadTH
	goto cas_fin

cas5	; c'est donc l'instruction Read TL (0xA2)	
	call ReadTL
	; goto cas_fin

cas_fin

	clrf nb_octet_transmis	
		
	bank1
	bsf PIE1 , TXIE ; autorisation de l'interruption d'émission de l'USART	
	bank0
	
	goto overrun

	;xxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; test d'une erreur d'overrun
overrun	 
 	
	bank0	
	btfss RCSTA , OERR
	goto int3
	; traitement de l'erreur d'overrun
	bcf RCSTA , CREN ; on efface le bit OERR
	bsf RCSTA , CREN ; on relance la réception
	goto int3

	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; Traitement de l'interruption d'émission de l'USART
	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
emission

	; 2 octets à transmettre 
	incf nb_octet_transmis , f	; on incrémente (nb_octet_transmis)	

	movlw D'1'
	subwf nb_octet_transmis , W
	btfss STATUS , Z
	goto emm2
	; émission du 1er octet
	movf octet1_tx  , W	

	;bank0
	movwf TXREG ; transmission
				; N.B. le flag TXIF est remis à 0 par une écriture dans le registre TXREG	
	goto int1  ; pour transmettre le plus rapidement possible le 2ème octet

emm2
	; émission du 2ème octet
	movf octet2_tx  , W	

	;bank0
	movwf TXREG ; transmission
				; N.B. le flag TXIF est remis à 0 par une écriture dans le registre TXREG	
	
	bank1

	bcf PIE1 , TXIE ; interdiction de l'interruption d'émission de l'USART	
	bank0
	clrf nb_octet_transmis
	goto int3

	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; Traitement de l'interruption TIMER1
	; On arrive ici toutes les # 105 ms 
	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
interruption_timer1

	decfsz  compteur_timer1, f	; on décrémente (compteur_timer1)
	goto bp	
	goto lcd

lcd
	; on arrive ici toutes les 8 x 105 ms # 839 ms  
	movlw D'8'
	movwf compteur_timer1	

	; Mise à jour de l'affichage du module LCD
	; Instruction "Display Clear"
	movlw B'00000000'	
	movwf data1
	movlw B'00000001'	
	movwf data2
	call commandeLCD

	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; Lecture de la température (DS1620)
	call ReadTemperature
	; La routine retourne le double de la température (9 bits en complément à 2)
	; octet1_tx = (0000000 DB8) 
	; octet2_tx = (DB7 ... DB0) 
	; exemple : 0 0011 0001 = 49 = +024,5 °C
	; exemple : 1 1100 1110 = -50 = -025,0 °C

	bank0	; variables en bank0

	movf octet1_tx , W
	movwf temperature_H
	movf octet2_tx , W
	movwf temperature_L

	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; si le bouton poussoir RESET MIN/MAX a été activé :
	; réinitialisation de la température min et max
 	btfss flagBPminmax , 0 ; test du drapeau
	goto tempmin	
	bcf flagBPminmax , 0	; on efface le drapeau 
	; temperature Max = (1 0000 0000) = -256 = -128°C
	movlw 0x01
	movwf temperatureMAX_H
	clrf temperatureMAX_L
	; temperature Min = (0 1111 1111) = 255 = +127,5°C
	movlw 0xFF
	movwf temperatureMIN_L
	clrf temperatureMIN_H
	goto tempmin
		
	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; Mise à jour de la température minimum (9 bits complément à 2)
	; si : temperature min > temperature actuelle
	; alors : temperature min = temperature actuelle
tempmin
	; nombre2_H = temperatureMIN_H
	; nombre2_L = temperatureMIN_L
	; nombre1_H = temperature_H
	; nombre1_L = temperature_L
	movf temperatureMIN_H , W
	movwf nombre2_H
	movf temperatureMIN_L , W
	movwf nombre2_L
	movf temperature_H , W
	movwf nombre1_H
	movf temperature_L , W
	movwf nombre1_L

	call comparaison9bits
	sublw 0x01
	btfss STATUS , Z
	goto tempmax
	; température min > température actuelle
	movf temperature_H , W
	movwf temperatureMIN_H
	movf temperature_L , W
	movwf temperatureMIN_L
	goto tempmax

	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; Mise à jour de la température maximum (9 bits complément à 2)
	; si temperature max < temperature actuelle
	; alors temperature max = temperature actuelle
tempmax
	; nombre1_H = temperatureMAX_H
	; nombre1_L = temperatureMAX_L
	; nombre2_H = temperature_H
	; nombre2_L = temperature_L
	movf temperatureMAX_H , W
	movwf nombre1_H
	movf temperatureMAX_L , W
	movwf nombre1_L
	movf temperature_H , W
	movwf nombre2_H
	movf temperature_L , W
	movwf nombre2_L

	call comparaison9bits
	sublw 0x01
	btfss STATUS , Z
	goto convert
	; température max < température actuelle
	movf temperature_H , W
	movwf temperatureMAX_H
	movf temperature_L , W
	movwf temperatureMAX_L
	goto convert
	
	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; Conversion température actuelle en code ASCII pour le module LCD
convert
	movf temperature_H , W
	movwf octet1_tx
	movf temperature_L , W
	movwf octet2_tx
	call tempASCII	

	; ascii_signe 		->  position0x40 (ecran 1)
	; ascii_centaine	->  position0x41 (ecran 1)	
	; ascii_dizaine		->  position0x42 (ecran 1)
	; ascii_unite		->  position0x43 (ecran 1)
	; ascii_dizieme		->  position0x45 (ecran 1)

	movf ascii_signe , W
	movwf position0x40	
	movf ascii_centaine , W
	movwf position0x41	
	movf ascii_dizaine , W
	movwf position0x42	
	movf ascii_unite , W
	movwf position0x43	
	movf ascii_dizieme , W
	movwf position0x45	

	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; Conversion température max en code ASCII pour le module LCD
	movf temperatureMAX_H , W
	movwf octet1_tx
	movf temperatureMAX_L , W
	movwf octet2_tx
	call tempASCII	
	; ascii_signe 		->  position2_0x04 (ecran 2 ligne 1)
	; ascii_centaine	->  position2_0x05 (ecran 2 ligne 1)
	; ascii_dizaine		->  position2_0x06 (ecran 2 ligne 1)
	; ascii_unite		->  position2_0x07 (ecran 2 ligne 1)
	; ascii_dizieme		->  position2_0x09 (ecran 2 ligne 1)

	movf ascii_signe , W
	movwf position2_0x04	
	movf ascii_centaine , W
	movwf position2_0x05	
	movf ascii_dizaine , W
	movwf position2_0x06	
	movf ascii_unite , W
	movwf position2_0x07	
	movf ascii_dizieme , W
	movwf position2_0x09	

	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; Conversion température min en code ASCII pour le module LCD
	movf temperatureMIN_H , W
	movwf octet1_tx
	movf temperatureMIN_L , W
	movwf octet2_tx
	call tempASCII	

	; ascii_signe 		->  position2_0x44 (ecran 2 ligne 2)
	; ascii_centaine	->  position2_0x45 (ecran 2 ligne 2)
	; ascii_dizaine		->  position2_0x46 (ecran 2 ligne 2)
	; ascii_unite		->  position2_0x47 (ecran 2 ligne 2)
	; ascii_dizieme		->  position2_0x49 (ecran 2 ligne 2)

	movf ascii_signe , W
	movwf position2_0x44	
	movf ascii_centaine , W
	movwf position2_0x45	
	movf ascii_dizaine , W
	movwf position2_0x46	
	movf ascii_unite , W
	movwf position2_0x47	
	movf ascii_dizieme , W
	movwf position2_0x49	

	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; Mise à jour de l'affichage du module LCD
	; Ecran n°1	(ecran = 0x01)
	; TEMPERATURE :
	; +024,5 °C *
	; Ecran n°2 (ecran = 0x02)
	; MAX +028,0 °C
	; MIN +017,5 °C
	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

	movlw 0x01
	subwf etape , W
	btfss STATUS , Z
	goto miseàjourecran2
	goto miseàjourecran1

	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; mise à jour module LCD (écran n°1)
miseàjourecran1

	; Affichage "TEMPERATURE :" sur la 1ère ligne du module LCD
	call affichageTEMPERATURE

	; On se positionne sur la deuxième ligne 
	; Instruction Set DDRAM Address
	movlw B'00000000'	
	movwf data1
	movlw B'11000000' ; adresse 0x40	
	movwf data2
	call commandeLCD

	; Affichage 2ème ligne 1ère position
	; Instruction "Write Data into DDRAM" 
	movlw B'00000010'	
	movwf data1	; RS = 1 R/W = 0
	movf position0x40 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position0x41 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position0x42 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position0x43 , W
	movwf data2
	call commandeLCD
	
	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position0x44 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position0x45 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position0x46 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position0x47 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position0x48 , W
	movwf data2
	call commandeLCD

	; movlw B'00000010'	
	; movwf data1	; RS = 1 R/W = 0
	; clignotement de l'étoile (témoin de bon fonctionnement du DS1620)
	movlw '*'
	subwf position0x49 , W
	btfss STATUS , Z
	goto lcd49 
	movlw ' '	
	movwf position0x49	
	goto lcd49_1
lcd49
	movlw '*'	
	movwf position0x49	
lcd49_1
	movf position0x49 , W
	movwf data2
	call commandeLCD

	goto interruption_timer1_fin

	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; mise à jour module LCD (écran n°2)
miseàjourecran2

	; Affichage 1ère ligne 1ère position
	; Instruction "Write Data into DDRAM" 
	movlw B'00000010'	
	movwf data1	; RS = 1 R/W = 0
	movf position2_0x00 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x01 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x02 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x03 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x04 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x05 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x06 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x07 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x08 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x09 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x0A , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x0B , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x0C , W
	movwf data2
	call commandeLCD
	
	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; On se positionne sur la deuxième ligne 
	; Instruction Set DDRAM Address
	movlw B'00000000'	
	movwf data1
	movlw B'11000000' ; adresse 0x40	
	movwf data2
	call commandeLCD

	; Instruction "Write Data into DDRAM" 
	movlw B'00000010'	
	movwf data1	; RS = 1 R/W = 0
	movf position2_0x40 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x41 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x42 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x43 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x44 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x45 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x46 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x47 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x48 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x49 , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x4A , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x4B , W
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1	; RS = 1 R/W = 0
	movf position2_0x4C , W
	movwf data2
	call commandeLCD

	goto interruption_timer1_fin

	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; Gestion bouton poussoir
	; Détection d'un front descendant (RA4 : 1 -> 0)
	; sur le bouton poussoir SELECTION ECRAN (RA4)
	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
bp
	; lecture de l'état actuel du BP (BPecran = RA4)	
	clrf BPecran
	btfsc PORTA, 4	
	bsf BPecran , 0

	btfss BPecran_bak , 0	; on teste l'état antérieur du BP
	goto bpecranfin			; 0 (fermé)
	btfsc BPecran , 0		; 1 (ouvert)
	goto bpecranfin			; 1 (ouvert)
	bsf flagBPecran , 0 	; 0 (fermé) front descendant, drapeau mis à 1

bpecranfin	
	; mise à jour de l'état antérieur
	movf BPecran , W
	movwf BPecran_bak

	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; Gestion bouton poussoir
	; Détection d'un front descendant (RA5 : 1 -> 0)
	; sur le bouton poussoir RESET MIN/MAX (RA5)
	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

	; lecture de l'état actuel du BP (BPminmax = RA5)	
	clrf BPminmax
	btfsc PORTA, 5	
	bsf BPminmax , 0

	btfss BPminmax_bak , 0	; on teste l'état antérieur du BP
	goto bpminmaxfin			; 0 (fermé)
	btfsc BPminmax , 0		; 1 (ouvert)
	goto bpminmaxfin		; 1 (ouvert)
	bsf flagBPminmax , 0 	; 0 (fermé) front descendant, drapeau mis à 1

bpminmaxfin	
	; mise à jour de l'état antérieur
	movf BPminmax , W
	movwf BPminmax_bak

	; xxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; mise à jour de l'étape
	; etape = 0x01 (écran n°1)
	; etape = 0x02 (écran n°2)
	; on passe d'une étape à l'autre sur un front descendant
	; du BP SELECTION ECRAN (=> flagBPecran = 1)

	btfss flagBPecran , 0
	goto interruption_timer1_fin	; drapeau = 0		
	bcf flagBPecran , 0 			;  on efface le drapeau	
	movlw 0x01
	subwf etape , W
	btfss STATUS , Z
	goto etape1
	movlw 0x02
	movwf etape	; écran n°2
	goto interruption_timer1_fin

etape1
	movlw 0x01
	movwf etape	; écran n°1
	goto interruption_timer1_fin

	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

interruption_timer1_fin

	bcf PIR1, TMR1IF ; on efface le drapeau
	goto int3

	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx	
restauration

	swapf STATUS_TEMP,W		; restauration des registres STATUS puis W
	movwf STATUS	
	swapf W_TEMP,f
	swapf W_TEMP,W

	retfie		

; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Routine de Conversion température en code ASCII pour le module LCD
; paramètres d'entrée : nombre 9 bits en complément à 2
; octet1_tx = (0000000 DB8) 
; octet2_tx = (DB7 ... DB0) 
; paramètres de sorties :
; ascii_signe
; ascii_centaine
; ascii_dizaine
; ascii_unite
; ascii_dizieme
	; Exemple :
	; octet1_tx = (00000000)
	; octet2_tx = (00110001)
	; 0 0011 0001 = 49 = +024,5 °C
	; ascii_signe = '+'
	; ascii_centaine ='0'
	; ascii_dizaine ='2'
	; ascii_unité ='4'
	; ascii_dizieme ='5'
; Remarque : les valeurs de octet1_tx et octet2_tx sont modifiées
; par la routine

tempASCII	

	; détermination de la valeur absolue (en binaire naturel)
	; 49 -> 49 (0011 0001)
	; -50 -> 50 (0011 0010)
	; on place le résultat dans (octet2_tx)
	
	; on teste DB8 (bit de signe)
	btfss octet1_tx , 0
	goto positif	; DB8 = 0 nombre positif
	; nombre négatif :
	comf octet2_tx , f ; on complémente
 	incf octet2_tx , f ; on ajoute 1
	movlw '-'
	movwf ascii_signe 
	goto demidegre

positif
	movlw '+'
	movwf ascii_signe 

demidegre
	; on teste le bit 0 de (octet2_tx)
	; DB0 = 1 => température xxx,5 °C
	; DB0 = 0 => température xxx,0 °C

	btfss octet2_tx , 0
	goto entier
	movlw '5'
	movwf ascii_dizieme 	
	goto divisionpardeux

entier
	movlw '0'
	movwf ascii_dizieme 

divisionpardeux
	; décalage à droite
	; exemple : 0011 0001 = 49 => 0001 1000 = 24 °C
	rrf octet2_tx , f
	bcf octet2_tx , 7

	; Conversion d'un nombre 8 bits binaire naturel (octet2_tx) en DCD
	; On s'inspire de la note d'application AN526 de Microchip :
	;************************************************************
	; Binary To BCD Conversion Routine
	; This routine converts a 16 Bit binary Number to a 5 Digit
	; BCD Number.
	; The 16 bit binary number is input in locations H_byte and
	; L_byte with the high byte in H_byte.
	; The 5 digit BCD number is returned in R0, R1 and R2 with R0
	; containing the MSD in its right most nibble.
	; Exemple : H_byte = 0xFF 	L_byte 	= 0xFE
	; R0 = 0x06		R1 = 0x55		R2 = 0x34
	; 0xFFFE = 65534
	;************************************************************

	; initialisation
	clrf H_byte
	movf octet2_tx , W
	movwf L_byte

B2_BCD  
	bcf     STATUS , C      
	movlw   D'16'
	movwf   count
	clrf    R0
	clrf    R1
	clrf    R2
loop16  
	rlf     L_byte , f
	rlf     H_byte , f
	rlf     R2 , f
	rlf     R1 , f
	rlf     R0 , f

	decfsz  count , f
	goto    adjDEC
	goto finconversion

adjDEC  
	movlw   R2
	movwf   FSR
	call    adjBCD

	movlw   R1
	movwf   FSR
	call    adjBCD

	movlw   R0
	movwf   FSR
	call    adjBCD

	goto    loop16

adjBCD  
	movlw   0x03
	addwf   INDF , W	; adressage indirect
	movwf   temp
	btfsc   temp , 3         
	movwf   0x00
	movlw   0x30
	addwf   INDF , W	; adressage indirect
	movwf   temp
	btfsc   temp , 7          
	movwf   0x00               
	retlw   0

finconversion
	; conversion BCD -> ASCII
	; 4 bits de poids faibles de R1 = centaines
	; 4 bits de poids forts de R2 = dizaines 
	; 4 bits de poids faibles de R2 = unités

	movf R1 , W
	movwf ascii_centaine	
	movf R2 , W
	movwf ascii_dizaine	
	movwf ascii_unite	

	swapf ascii_dizaine , f
	movlw 0x0F ; masque
	andwf ascii_dizaine , f
	andwf ascii_unite , f

	movlw 0x30
	addwf ascii_centaine , f ; exemple : 5 devient 0x35 (code ASCII de '5')
	addwf ascii_dizaine , f
	addwf ascii_unite , f

	return

; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Routine "comparaison9bits"
; Comparaison de 2 nombres 9 bits en compléments en 2
; Arguments en entrée :
; 1er nombre 
; 	nombre1_H	(0000000 D8)
; 	nombre1_L (D7 ... D0)
; 2ème nombre 
; 	nombre2_H	(0000000 D8)
; 	nombre2_L (D7 ... D0)
; Argument en sortie :
; 	Si nombre1 >= nombre2 : retlw 0x00
; 	Si nombre1 < nombre2 : retlw 0x01

comparaison9bits
	movlw 0x01
	subwf nombre1_H , W
	btfss STATUS , Z
	goto compa0
	; nombre1_H = 1
	clrw
	subwf nombre2_H , W
	btfss STATUS , Z
	goto compa1		; nombre2_H = 1
	; nombre2_H = 0
	retlw 0x01

compa0	; nombre1_H = 0
	movlw 0x01
	subwf nombre2_H , W
	btfss STATUS , Z
	goto compa1		; nombre2_H = 0
	; nombre2_H = 1
	retlw 0x00

compa1	; nombre1_H = nombre1_L 
	movf nombre2_L , W
	subwf nombre1_L , W
	btfss STATUS , C
	retlw 0x01	; C = 0 nombre1_L < nombre2_L
	retlw 0x00	; C = 1 nombre1_L >= nombre2_L

; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Routine 
; Instruction Read Temperature
; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
ReadTemperature

	; RST = 0
	bcf PORTB , 7 	
	; CLK = 1
	bsf PORTB , 6 	
	; RST = 1 (RB7 = 1)
	bsf PORTB , 7 
	; CLK = 0 (RB6 = 0)
	; pause 200 ns
	bcf PORTB , 6 	
	nop

	; DQ = 0 (bit 0 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 1 (bit 1 du code instruction)
	bsf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 2 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 1 (bit 3 du code instruction)
	bsf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 4 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 1 (bit 5 du code instruction)
	bsf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 6 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 1 (bit 7 du code instruction)
	bsf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; xxxxxxxx Lecture des 9 bits de données (D8...D0)

	; configuration de RB0 en entrée
	bank1
	bsf TRISB , 0
	bank0

	; lecture bit D0
	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	btfsc PORTB , 0
	bsf octet2_tx , 0
	btfss PORTB , 0
	bcf octet2_tx , 0
 
	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; lecture bit D1
	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	btfsc PORTB , 0
	bsf octet2_tx , 1
	btfss PORTB , 0
	bcf octet2_tx , 1
 
	; CLK = 1
	bsf PORTB , 6 
	nop 	; pause 200 ns

	; lecture bit D2
	; CLK = 0	
	bcf PORTB , 6 
	nop 	; pause 200 ns

	btfsc PORTB , 0
	bsf octet2_tx , 2
	btfss PORTB , 0
	bcf octet2_tx , 2
 
	; CLK = 1
	bsf PORTB , 6 
	nop		; pause 200 ns

	; lecture bit D3
	; CLK = 0	
	bcf PORTB , 6 
	nop 	; pause 200 ns

	btfsc PORTB , 0
	bsf octet2_tx , 3
	btfss PORTB , 0
	bcf octet2_tx , 3
 
	; CLK = 1
	bsf PORTB , 6 
	nop		; pause 200 ns

	; lecture bit D4
	; CLK = 0	
	bcf PORTB , 6 
	nop 	; pause 200 ns

	btfsc PORTB , 0
	bsf octet2_tx , 4
	btfss PORTB , 0
	bcf octet2_tx , 4
 
	; CLK = 1
	bsf PORTB , 6 
	nop		; pause 200 ns

	; lecture bit D5
	; CLK = 0	
	bcf PORTB , 6 
	nop 	; pause 200 ns

	btfsc PORTB , 0
	bsf octet2_tx , 5
	btfss PORTB , 0
	bcf octet2_tx , 5
 
	; CLK = 1
	bsf PORTB , 6 
	nop		; pause 200 ns

	; lecture bit D6
	; CLK = 0	
	bcf PORTB , 6 
	nop 	; pause 200 ns

	btfsc PORTB , 0
	bsf octet2_tx , 6
	btfss PORTB , 0
	bcf octet2_tx , 6
 
	; CLK = 1
	bsf PORTB , 6 
	nop		; pause 200 ns

	; lecture bit D7
	; CLK = 0	
	bcf PORTB , 6 
	nop 	; pause 200 ns

	btfsc PORTB , 0
	bsf octet2_tx , 7
	btfss PORTB , 0
	bcf octet2_tx , 7
 
	; CLK = 1
	bsf PORTB , 6 
	nop		; pause 200 ns

	; lecture bit D8
	; CLK = 0	
	bcf PORTB , 6 
	nop 	; pause 200 ns

	clrf octet1_tx

	btfsc PORTB , 0
	bsf octet1_tx , 0
	btfss PORTB , 0
	bcf octet1_tx , 0
 
	; CLK = 1
	bsf PORTB , 6 
	nop		; pause 200 ns

	; RST =0
	bcf PORTB , 7  
	nop			; pause 200 ns

	; configuration de RB0 en sortie
	bank1
	bcf TRISB , 0
	bank0

	return

; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Routine 
; Instruction Write TH
; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

WriteTH

	; (RST = 0)

	; CLK =1 (RB6 = 1)
	bsf PORTB , 6 

	; RST =1 (RB7 = 1)
	bsf PORTB , 7 

	; CLK = 0 (RB6 = 0)
	; pause 200 ns
	bcf PORTB , 6 	
	nop

	; DQ = 1 (bit 0 du code instruction) (RB0 = 0)
	bsf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 1 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 2 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 3 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 4 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 5 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 6 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 7 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; 9 bits de données (D8...D0)
	
	; bit D0
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	btfsc octet3 , 0
	bsf PORTB , 0
	btfss octet3 , 0
	bcf PORTB , 0
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D1
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	btfsc octet3 , 1
	bsf PORTB , 0
	btfss octet3 , 1
	bcf PORTB , 0	
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D2
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	btfsc octet3 , 2
	bsf PORTB , 0
	btfss octet3 , 2
	bcf PORTB , 0
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D3
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	btfsc octet3 , 3
	bsf PORTB , 0
	btfss octet3 , 3
	bcf PORTB , 0
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D4
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	btfsc octet3 , 4
	bsf PORTB , 0
	btfss octet3 , 4
	bcf PORTB , 0
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D5
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	btfsc octet3 , 5
	bsf PORTB , 0
	btfss octet3 , 5
	bcf PORTB , 0
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D6
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	btfsc octet3 , 6
	bsf PORTB , 0
	btfss octet3 , 6
	bcf PORTB , 0	
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D7
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	btfsc octet3 , 7
	bsf PORTB , 0
	btfss octet3 , 7
	bcf PORTB , 0
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D8
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	btfsc octet2 , 0
	bsf PORTB , 0
	btfss octet2 , 0
	bcf PORTB , 0
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; RST =0
	bcf PORTB , 7 

	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; pause de 13 ms (écriture dans l'EEPROM du DS1620
	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	
	clrf TMR0
	bcf INTCON , T0IF ; on efface le drapeau
attente
	btfss INTCON , T0IF 
	goto attente
	return

; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Routine 
; Instruction Write TL
WriteTL

	; (RST = 0)

	; CLK =1 (RB6 = 1)
	bsf PORTB , 6 

	; RST =1 (RB7 = 1)
	bsf PORTB , 7 

	; CLK = 0 (RB6 = 0)
	; pause 200 ns
	bcf PORTB , 6 	
	nop

	; DQ = 0 (bit 0 du code instruction) (RB0 = 0)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 1 (bit 1 du code instruction)
	bsf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 2 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 3 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 4 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 5 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 6 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 7 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; 9 bits de données (D8...D0)
	
	; bit D0
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	btfsc octet3 , 0
	bsf PORTB , 0
	btfss octet3 , 0
	bcf PORTB , 0
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D1
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	btfsc octet3 , 1
	bsf PORTB , 0
	btfss octet3 , 1
	bcf PORTB , 0	
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D2
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	btfsc octet3 , 2
	bsf PORTB , 0
	btfss octet3 , 2
	bcf PORTB , 0
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D3
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	btfsc octet3 , 3
	bsf PORTB , 0
	btfss octet3 , 3
	bcf PORTB , 0
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D4
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	btfsc octet3 , 4
	bsf PORTB , 0
	btfss octet3 , 4
	bcf PORTB , 0
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D5
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	btfsc octet3 , 5
	bsf PORTB , 0
	btfss octet3 , 5
	bcf PORTB , 0
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D6
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	btfsc octet3 , 6
	bsf PORTB , 0
	btfss octet3 , 6
	bcf PORTB , 0	
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D7
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	btfsc octet3 , 7
	bsf PORTB , 0
	btfss octet3 , 7
	bcf PORTB , 0
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D8
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	btfsc octet2 , 0
	bsf PORTB , 0
	btfss octet2 , 0
	bcf PORTB , 0
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; RST =0
	bcf PORTB , 7 

	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; pause de 13 ms (écriture dans l'EEPROM du DS1620
	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	
	clrf TMR0
	bcf INTCON , T0IF ; on efface le drapeau
attente2
	btfss INTCON , T0IF 
	goto attente2

	return

; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Routine 
; Instruction Read TH
; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

ReadTH
	; RST = 0
	; CLK = 1

	; RST =1 (RB7 = 1)
	bsf PORTB , 7 

	; CLK = 0 (RB6 = 0)
	; pause 200 ns
	bcf PORTB , 6 	
	nop

	; DQ = 1 (bit 0 du code instruction)
	bsf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 1 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 2 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 3 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 4 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 1 (bit 5 du code instruction)
	bsf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 6 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 1 (bit 7 du code instruction)
	bsf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; xxxxxxxx Lecture des 9 bits de données (D8...D0)

	; configuration de RB0 en entrée
	bank1
	bsf TRISB , 0
	bank0

	; lecture bit D0
	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	btfsc PORTB , 0
	bsf octet2_tx , 0
	btfss PORTB , 0
	bcf octet2_tx , 0
 
	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; lecture bit D1
	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	btfsc PORTB , 0
	bsf octet2_tx , 1
	btfss PORTB , 0
	bcf octet2_tx , 1
 
	; CLK = 1
	bsf PORTB , 6 
	nop 	; pause 200 ns

	; lecture bit D2
	; CLK = 0	
	bcf PORTB , 6 
	nop 	; pause 200 ns

	btfsc PORTB , 0
	bsf octet2_tx , 2
	btfss PORTB , 0
	bcf octet2_tx , 2
 
	; CLK = 1
	bsf PORTB , 6 
	nop		; pause 200 ns

	; lecture bit D3
	; CLK = 0	
	bcf PORTB , 6 
	nop 	; pause 200 ns

	btfsc PORTB , 0
	bsf octet2_tx , 3
	btfss PORTB , 0
	bcf octet2_tx , 3
 
	; CLK = 1
	bsf PORTB , 6 
	nop		; pause 200 ns

	; lecture bit D4
	; CLK = 0	
	bcf PORTB , 6 
	nop 	; pause 200 ns

	btfsc PORTB , 0
	bsf octet2_tx , 4
	btfss PORTB , 0
	bcf octet2_tx , 4
 
	; CLK = 1
	bsf PORTB , 6 
	nop		; pause 200 ns

	; lecture bit D5
	; CLK = 0	
	bcf PORTB , 6 
	nop 	; pause 200 ns

	btfsc PORTB , 0
	bsf octet2_tx , 5
	btfss PORTB , 0
	bcf octet2_tx , 5
 
	; CLK = 1
	bsf PORTB , 6 
	nop		; pause 200 ns

	; lecture bit D6
	; CLK = 0	
	bcf PORTB , 6 
	nop 	; pause 200 ns

	btfsc PORTB , 0
	bsf octet2_tx , 6
	btfss PORTB , 0
	bcf octet2_tx , 6
 
	; CLK = 1
	bsf PORTB , 6 
	nop		; pause 200 ns

	; lecture bit D7
	; CLK = 0	
	bcf PORTB , 6 
	nop 	; pause 200 ns

	btfsc PORTB , 0
	bsf octet2_tx , 7
	btfss PORTB , 0
	bcf octet2_tx , 7
 
	; CLK = 1
	bsf PORTB , 6 
	nop		; pause 200 ns

	; lecture bit D8
	; CLK = 0	
	bcf PORTB , 6 
	nop 	; pause 200 ns

	clrf octet1_tx

	btfsc PORTB , 0
	bsf octet1_tx , 0
	btfss PORTB , 0
	bcf octet1_tx , 0
 
	; CLK = 1
	bsf PORTB , 6 
	nop		; pause 200 ns

	; RST =0
	bcf PORTB , 7  
	nop			; pause 200 ns

	; configuration de RB0 en sortie
	bank1
	bcf TRISB , 0
	bank0

	return

; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Routine 
; Instruction Read TL
; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

ReadTL
	; RST = 0
	; CLK = 1

	; RST =1 (RB7 = 1)
	bsf PORTB , 7 

	; CLK = 0 (RB6 = 0)
	; pause 200 ns
	bcf PORTB , 6 	
	nop

	; DQ = 0 (bit 0 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 1 (bit 1 du code instruction)
	bsf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 2 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 3 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 4 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 1 (bit 5 du code instruction)
	bsf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 6 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 1 (bit 7 du code instruction)
	bsf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; xxxxxxxx Lecture des 9 bits de données (D8...D0)

	; configuration de RB0 en entrée
	bank1
	bsf TRISB , 0
	bank0

	; lecture bit D0
	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	btfsc PORTB , 0
	bsf octet2_tx , 0
	btfss PORTB , 0
	bcf octet2_tx , 0
 
	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; lecture bit D1
	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	btfsc PORTB , 0
	bsf octet2_tx , 1
	btfss PORTB , 0
	bcf octet2_tx , 1
 
	; CLK = 1
	bsf PORTB , 6 
	nop 	; pause 200 ns

	; lecture bit D2
	; CLK = 0	
	bcf PORTB , 6 
	nop 	; pause 200 ns

	btfsc PORTB , 0
	bsf octet2_tx , 2
	btfss PORTB , 0
	bcf octet2_tx , 2
 
	; CLK = 1
	bsf PORTB , 6 
	nop		; pause 200 ns

	; lecture bit D3
	; CLK = 0	
	bcf PORTB , 6 
	nop 	; pause 200 ns

	btfsc PORTB , 0
	bsf octet2_tx , 3
	btfss PORTB , 0
	bcf octet2_tx , 3
 
	; CLK = 1
	bsf PORTB , 6 
	nop		; pause 200 ns

	; lecture bit D4
	; CLK = 0	
	bcf PORTB , 6 
	nop 	; pause 200 ns

	btfsc PORTB , 0
	bsf octet2_tx , 4
	btfss PORTB , 0
	bcf octet2_tx , 4
 
	; CLK = 1
	bsf PORTB , 6 
	nop		; pause 200 ns

	; lecture bit D5
	; CLK = 0	
	bcf PORTB , 6 
	nop 	; pause 200 ns

	btfsc PORTB , 0
	bsf octet2_tx , 5
	btfss PORTB , 0
	bcf octet2_tx , 5
 
	; CLK = 1
	bsf PORTB , 6 
	nop		; pause 200 ns

	; lecture bit D6
	; CLK = 0	
	bcf PORTB , 6 
	nop 	; pause 200 ns

	btfsc PORTB , 0
	bsf octet2_tx , 6
	btfss PORTB , 0
	bcf octet2_tx , 6
 
	; CLK = 1
	bsf PORTB , 6 
	nop		; pause 200 ns

	; lecture bit D7
	; CLK = 0	
	bcf PORTB , 6 
	nop 	; pause 200 ns

	btfsc PORTB , 0
	bsf octet2_tx , 7
	btfss PORTB , 0
	bcf octet2_tx , 7
 
	; CLK = 1
	bsf PORTB , 6 
	nop		; pause 200 ns

	; lecture bit D8
	; CLK = 0	
	bcf PORTB , 6 
	nop 	; pause 200 ns

	clrf octet1_tx

	btfsc PORTB , 0
	bsf octet1_tx , 0
	btfss PORTB , 0
	bcf octet1_tx , 0
 
	; CLK = 1
	bsf PORTB , 6 
	nop		; pause 200 ns

	; RST =0
	bcf PORTB , 7  
	nop			; pause 200 ns

	; configuration de RB0 en sortie
	bank1
	bcf TRISB , 0
	bank0

	return

; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Routine de commande du module LCD
; On traite ici les instructions d'écriture (R/W = 0)
; - Display clear
; - Entry mode set
; - Display On/Off Control
; - Set function
; - Set DDRAM address
; - Write Data into DDRAM

; Arguments d'entrée de la routine : data1, data2

commandeLCD

	; 1ère étape : RS =0, R/W=0 , E = 0

	bcf PORTB , 5	; E = 0    
	bcf PORTB , 3	; RS = 0
	bcf PORTB , 4	; R/W = 0
	
	; mise à jour RS (RB3)
	btfsc data1 , 1
	bsf PORTB , 3
	btfss data1 , 1
	bcf PORTB , 3		
	
	; mise à jour R/W (RB4)
	btfsc data1 , 0
	bsf PORTB , 4
	btfss data1 , 0
	bcf PORTB , 4		

	; 2ème étape : DB7 DB6 DB5 DB4

	; mise à jour DB7 (RA3)
	btfsc data2 , 7
	bsf PORTA , 3
	btfss data2 , 7
	bcf PORTA , 3	

	; mise à jour DB6 (RA2)
	btfsc data2 , 6
	bsf PORTA , 2
	btfss data2 , 6
	bcf PORTA , 2	

	; mise à jour DB5 (RA1)
	btfsc data2 , 5
	bsf PORTA , 1
	btfss data2 , 5
	bcf PORTA , 1	

	; mise à jour DB4 (RA0)
	btfsc data2 , 4
	bsf PORTA , 0
	btfss data2 , 4
	bcf PORTA , 0

	; 3ème étape	E=1 (RB5)
	bsf PORTB , 5
	nop
	nop
	nop
	nop
	nop	; une pause de 1 µs (220 ns suffisent)
	
	; 4ème étape 	E=0 (RB5)
	bcf PORTB , 5	

	; 5ème étape DB3 DB2 DB1 DB0

	; mise à jour DB3 (RA3)
	btfsc data2 , 3
	bsf PORTA , 3
	btfss data2 , 3
	bcf PORTA , 3	

	; mise à jour DB2 (RA2)
	btfsc data2 , 2
	bsf PORTA , 2
	btfss data2 , 2
	bcf PORTA , 2	

	; mise à jour DB1 (RA1)
	btfsc data2 , 1
	bsf PORTA , 1
	btfss data2 , 1
	bcf PORTA , 1	

	; mise à jour DB0 (RA0)
	btfsc data2 , 0
	bsf PORTA , 0
	btfss data2 , 0
	bcf PORTA , 0

	; 6ème étape	E=1 (RB5)
	bsf PORTB , 5
	nop
	nop
	nop
	nop
	nop	; une pause de 1 µs (220 ns suffisent)
	
	; 7ème étape 	E=0 (RB5)
	bcf PORTB , 5	

	; xxxxxxxxxxxxxxxxxxxxxxxx
	; on teste le drapeau Busy
fin_instruction
	call busy
	btfsc busy_flag , 0
	goto fin_instruction ; drapeau Busy = 1 (instruction en cours)
	; drapeau Busy = 0 : instruction terminée

	return

;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Routine (module LCD)
; Instruction "Read Busy Flag"
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

busy
	; étape initiale : configuration des broches RA0 à RA3 en entrées

	bank1
	bsf TRISA , 0 ; bit 0 du port A (RA0) = 1 : configuration en entrée (DB4)
	bsf TRISA , 1 ; bit 1 du port A (RA1) = 1 : configuration en entrée (DB5)
	bsf TRISA , 2 ; bit 2 du port A (RA2) = 1 : configuration en entrée (DB6)
	bsf TRISA , 3 ; bit 3 du port A (RA3) = 1 : configuration en entrée (DB7)
	bank0

	; 1ère étape : RS= 0, R/W =1 , E = 0

	bcf PORTB , 5	; E = 0    
	bcf PORTB , 3	; RS = 0
	bsf PORTB , 4	; R/W = 1

	; 2ème étape : E = 1
	bsf PORTB , 5
	nop ; une petite pause de 200 ns

	; 3ème étape : lecture DB7 (RA3)(busy flag) 

	btfsc PORTA , 3
	bsf busy_flag , 0
	btfss PORTA , 3
	bcf busy_flag , 0

	;bcf busy_flag , 0 ; à supprimer (test debugger MPLAB SIM)

	; 4ème étape : E = 0
	bcf PORTB , 5
	nop ; une petite pause de 200 ns

	; 5ème étape : E = 1
	bsf PORTB , 5
	nop ; une petite pause de 200 ns

	; 6ème étape :  DB3 DB2 DB1 DB0 
	nop

	; 7ème étape : E = 0
	bcf PORTB , 5
	nop ; une petite pause de 200 ns

	; 8ème étape : R/W = 0
	bcf PORTB , 4	

	; dernière étape : configuration des broches RA0 à RA3 en sorties
	bank1
	bcf TRISA , 0 ; bit 0 du port A (RA0) = 0 : configuration en sortie (DB4)
	bcf TRISA , 1 ; bit 1 du port A (RA1) = 0 : configuration en sortie (DB5)
	bcf TRISA , 2 ; bit 2 du port A (RA2) = 0 : configuration en sortie (DB6)
	bcf TRISA , 3 ; bit 3 du port A (RA3) = 0 : configuration en sortie (DB7)
	bank0

	return 

; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
; Routine d'affichage sur la module LCD
; Texte = "TEMPERATURE :"
; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

affichageTEMPERATURE

	; Affichage 'T' (code 0x54)
	; Instruction "Write Data into DDRAM" 
	movlw B'00000010'	
	movwf data1	; RS = 1 R/W = 0
	movlw 'T'	
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1
	movlw 'E'	
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1
	movlw 'M'	
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1
	movlw 'P'	
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1
	movlw 'E'	
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1
	movlw 'R'	
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1
	movlw 'A'	
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1
	movlw 'T'	
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1
	movlw 'U'	
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1
	movlw 'R'	
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1 
	movlw 'E'	
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1
	movlw ' '	; espace (code 0x20) 
	movwf data2
	call commandeLCD

	;movlw B'00000010'	
	;movwf data1
	movlw ':'	
	movwf data2
	call commandeLCD

	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'11010111'
	movwf OPTION_REG
	; bit 7 (/RBPU) = 1 : valeur par défaut (option non utilisée)
	; bit 6 (INTEDG) = 1 : valeur par défaut (option non utilisée)
	; bit 5 (T0CS) = 0 : l'horloge interne est l'horloge du timer0
	; bit 4 (T0SE) = 1 : valeur par défaut (option non utilisée)

	; bit 3 (PSA) = 0
	; bit 2 (PS2) = 1
	; bit 1 (PS1) = 1
	; bit 0 (PS0) = 1 
	; Prescaler du Timer0 = 1:256
	; Watchdog sans prescaler (1:1)

	; le timer0 déborde toutes les 256*256*0,2 µs # 13 ms 

	movlw B'11110000'
	movwf TRISA
	; bit 0 du port A (RA0) = 0 : configuration en sortie (DB4, module LCD)
	; bit 1 du port A (RA1) = 0 : configuration en sortie (DB5, module LCD)
	; bit 2 du port A (RA2) = 0 : configuration en sortie (DB6, module LCD)
	; bit 3 du port A (RA3) = 0 : configuration en sortie (DB7, module LCD)
	; bit 4 du port A (RA4) = 1 : configuration en entrée (bouton poussoir SELECTION ECRAN)
	; bit 5 du port A (RA5) = 1 : configuration en entrée (bouton poussoir RESET MIN/MAX)
	; bits 6 à 7 du port A (RA6 à RA7) = 1 : configuration en entrée, par exemple

	movlw B'00000110'
	movwf TRISB
	; bit 0 du port B (RB0) = 0 : configuration en sortie (broche DQ, capteur DS1620)
	; bit 1 du port B (RB1) = 1 : configuration en entrée (RX : USART)
	; bit 2 du port B (RB2) = 1 : configuration en entrée (TX : USART)
	; bit 3 du port B (RB3) = 0 : configuration en sortie (RS, module LCD)
	; bit 4 du port B (RB4) = 0 : configuration en sortie (R/W, module LCD)
	; bit 5 du port B (RB5) = 0 : configuration en sortie (E, module LCD)
	; bit 6 du port B (RB6) = 0 : configuration en sortie (broche CLK, capteur DS1620)
	; bit 7 du port B (RB7) = 0 : configuration en sortie (broche RST, capteur DS1620)

    movlw D'129'
    movwf SPBRG ; (SPBRG) = D'129'

	movlw B'00100100'	
	movwf TXSTA
	; bit 7 (CSRC) = 0 (non utilisé : 0 par exemple)
	; bit 6 (TX9) = 0 : 8 bits de transmission
	; bit 5 (TXEN) = 1 : autorise la réception
	; bit 4 (SYNC) = 0 : mode asynchrone
	; bit 3 = 0 (non implémenté)
	; bit 2 (BRGH) = 1 : mode asynchrone haute vitesse
	; bit 1 (TRMT) = 0 (en lecture seule)
	; bit 0 (TX9D) = 0 (non utilisé : 0 par exemple)

	bank0		
	movlw B'10010000'	 
	movwf RCSTA	
	; bit 7 (SPEN) = 1 : utilisation du port série	
	; bit 6 (RX9) = 0 : 8 bits de réception
	; bit 5 (SREN) = 0 (non utilisé : 0 par exemple)	
	; bit 4 (CREN) = 1 : autorise la réception
	; bit 3 (ADEN) = 0 (non utilisé : 0 par exemple)
	; bit 2 (FERR) = 0 (en lecture seule)
	; bit 1 (OERR) = 0 (en lecture seule)
	; bit 0 (RX9D) = 0 (non utilisé : 0 par exemple)
 
	clrf PORTA  	; mise à 0 des sorties du port A
	clrf PORTB 		; mise à 0 des sorties du port B
 
	clrf nb_octet_recu  
	clrf nb_octet_transmis

	; temperature Max = (1 0000 0000) = -256 = -128°C
	movlw 0x01
	movwf temperatureMAX_H
	clrf temperatureMAX_L
	; temperature Min = (0 1111 1111) = 255 = +127,5°C
	movlw 0xFF
	movwf temperatureMIN_L
	clrf temperatureMIN_H

	movlw '+'
	movwf position0x40 	; contient le code ASCII (2ème ligne 1ère position du module LCD)
	movlw ','						
	movwf position0x44 	; 2ème ligne 5ème position
	movlw ' '
	movwf position0x46 	; 2ème ligne 7ème position
	movlw 0xDF			; Caractère '°'
	movwf position0x47 	; 2ème ligne 8ème position
	movlw 'C'
	movwf position0x48 	; 2ème ligne 9ème position
	movlw '*'
	movwf position0x49 	; 2ème ligne 10ème position

	movlw 0x01
	movwf etape 	; écran n°1
	movwf BPminmax_bak 	; BP ouvert
	movwf BPecran_bak 	; BP ouvert
	clrf flagBPminmax	; on efface le drapeau
	clrf flagBPecran	; on efface le drapeau

	; Ecran n°2
	movlw 'M'
	movwf position2_0x00
	movwf position2_0x40
	movlw 'a'
	movwf position2_0x01 
	movlw 'x'
	movwf position2_0x02 
	movlw ' '
	movwf position2_0x03 
	movwf position2_0x0A 
	movwf position2_0x43 
	movwf position2_0x4A 
	movlw ','
	movwf position2_0x08 
	movwf position2_0x48 
	movlw 0xDF	
	movwf position2_0x4B 
	movwf position2_0x0B 
	movlw 'C'	
	movwf position2_0x0C 
	movwf position2_0x4C 
	movlw 'i'
	movwf position2_0x41 
	movlw 'n'
	movwf position2_0x42 
						    
	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; Configuration du DS1620
	; Instruction Write Config
	; Code instruction : 0x0C  = 00001100
	; Données : 0x02 = 00000010 (CPU = 1, 1SHOT = 0)

	; (RST = 0)

	; CLK =1 (RB6 = 1)
	bsf PORTB , 6 

	; RST =1 (RB7 = 1)
	bsf PORTB , 7 

	; CLK = 0 (RB6 = 0)
	; pause 200 ns
	bcf PORTB , 6 	
	nop

	; DQ = 0 (bit 0 du code instruction) (RB0 = 0)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 1 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 1 (bit 2 du code instruction)
	bsf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 1 (bit 3 du code instruction)
	bsf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 4 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 5 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 6 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 7 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; 8 bits de données (D7...D0)
	
	; bit D0
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	; D0 = 0 
	bcf PORTB , 0 	
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D1
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	; D1 = 1 
	bsf PORTB , 0 	
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D2
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	; D2 = 0 
	bcf PORTB , 0 	
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D3
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	; D3 = 0 
	bcf PORTB , 0 	
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D4
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	; D4 = 0 
	bcf PORTB , 0 	
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D5
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	; D5 = 0 
	bcf PORTB , 0 	
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D6
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	; D6 = 0 
	bcf PORTB , 0 	
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; bit D7
	bcf PORTB , 6 		; CLK = 0
	nop					; pause 200 ns

	; D7 = 0 
	bcf PORTB , 0 	
	
	bsf PORTB , 6 		; CLK = 1
	nop					; pause 200 ns

	; RST =0
	bcf PORTB , 7 

	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; pause de 13 ms (écriture dans l'EEPROM du DS1620)
	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	
	clrf TMR0
	bcf INTCON , T0IF ; on efface le drapeau
attente1
	btfss INTCON , T0IF 
	goto attente1

	; fin de l'instruction Write Config

	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; Configuration du DS1620
	; Instruction Start Convert T
	; Code instruction : 0xEE = 1110 1110
  
	; RST = 0
	; (CLK =1) (RB6 = 1)

	; RST =1 (RB7 = 1)
	bsf PORTB , 7 

	; CLK = 0 (RB6 = 0)
	; pause 200 ns
	bcf PORTB , 6 	
	nop

	; DQ = 0 (bit 0 du code instruction) (RB0 = 0)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 1 (bit 1 du code instruction)
	bsf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 1 (bit 2 du code instruction)
	bsf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 1 (bit 3 du code instruction)
	bsf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 0 (bit 4 du code instruction)
	bcf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 1 (bit 5 du code instruction)
	bsf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 1 (bit 6 du code instruction)
	bsf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; CLK = 0
	; pause 200 ns
	bcf PORTB , 6 
	nop

	; DQ = 1 (bit 7 du code instruction)
	bsf PORTB , 0 	

	; CLK = 1
	; pause 200 ns
	bsf PORTB , 6 
	nop

	; RST =0
	; pause 200 ns
	bcf PORTB , 7  
	nop
	; fin de l'instruction Start Convert T 
	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; Initialisation du module LCD (interface 4 bits)
	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

	; Instruction "Set Function"
	; Choix du mode 4 bits (à la mise sous tension : mode 8 bits par défaut)
	; RS R/W DB7 DB6 DB5 DB4
	; 0   0   0   0   1   0 

	bcf PORTB , 5	; E = 0    
	bcf PORTB , 3	; RS = 0
	bcf PORTB , 4	; R/W = 0

	bcf PORTA , 0 	; DB4 = 0
	bsf PORTA , 1 	; DB5 = 1
	bcf PORTA , 2 	; DB6 = 0
	bcf PORTA , 3 	; DB7 = 0

	bsf PORTB , 5	; E = 1
	nop
	nop
	nop
	nop
	nop	; une pause de 1 µs (220 ns suffisent)
	
	bcf PORTB , 5	; E = 0

	; pause de 3 x 256 x 0,2 = 153,6 µs (39 µs suffisent)	
	movlw D'253'
	movwf TMR0
	bcf INTCON , T0IF ; on efface le drapeau
attente3
	btfss INTCON , T0IF 
	goto attente3

	; data1 : contient le niveau des bits RS et R/W (module LCD):
	; (000000 RS R/W)
	; data2 : contient le niveau des bits DB7-DB0 (module LCD):
	; (DB7 ... DB0)

	; Instruction "Set Function" (DL = 0, N = 1, F = 0)
	movlw B'00000000'	
	movwf data1
	movlw B'00101000'	
	movwf data2
	call commandeLCD

	; Instruction "Set Function" (DL = 0, N = 1, F = 0)
	; on recommence pour précaution
	movlw B'00000000'	
	movwf data1
	movlw B'00101000'	
	movwf data2
	call commandeLCD

	; Instruction "Display On/Off" (D = 1 , C = 0 , B = 0)
	movlw B'00000000'	
	movwf data1
	movlw B'00001100'	
	movwf data2
	call commandeLCD

	; Instruction "Entry Mode Set" (I/D = 1 , SH = 0)
	movlw B'00000000'	
	movwf data1
	movlw B'00000110'	
	movwf data2
	call commandeLCD

	; Instruction "Display Clear"
	movlw B'00000000'	
	movwf data1
	movlw B'00000001'	
	movwf data2
	call commandeLCD

	; Affichage "TEMPERATURE :" sur la 1ère ligne du module LCD
	call affichageTEMPERATURE

	bank1
    bsf INTCON, GIE ; autorisation globale des interruptions 
	bsf INTCON , PEIE ; autorisation des interruptions des périphériques
    bsf PIE1 , RCIE ; autorisation de l'interruption de réception de l'USART
	bcf PIE1 , TXIE ; interdiction de l'interruption d'émission de l'USART
	bank0
	;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	; Configuration du TIMER1 (16 bits) en mode timer
	; Utilisation de l'interruption
	; Débordement (0xFFFF -> 0x0000) toutes les
	;  8 (prescaler)x 65536 (16 bits) = 104,8576 ms 
	; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

	bsf T1CON , T1CKPS1
	bsf T1CON , T1CKPS0 	; prescaler 1:8
	bsf T1CON , TMR1ON 		; Enables TIMER1
		
	bank1
	bsf PIE1 , TMR1IE ; autorisation de l'interruption du TIMER1 (16 bits)	
	bank0

	movlw D'8'
	movwf compteur_timer1

	goto debut_programme   

;xxxxxxxxxxxxxxxxxxxxx
; Programme principal
;xxxxxxxxxxxxxxxxxxxxx  

debut_programme 

	goto debut_programme ; on attend une interruption

	END



