CodeS-SourceS
Rechercher un code, un tuto, une réponse

Serrure electronique

Soyez le premier à donner votre avis sur cette source.

Snippet vu 23 736 fois - Téléchargée 19 fois

Contenu du snippet

Pour faire une serrure electronique

Source / Exemple :


;*****************************************************************
;
;                TITLE           "CLElock.ASM"
;                LIST           P=16F84
; cr‚er le    :	15/06/2000
; par         : Deaubonne Patrick
; modifier le :	13/08/2001
; par         : Deaubonne Patrick
;*****************************************************************

                opt list
				device pic16f84
				config CP=off,OSC=rc

		1 EQU 1

		IO_PIN  EQU     007H    ;SET INPUT / OUTPUT PIN
		IO_MASK EQU     07FH

		INDIR	EQU	00H	; Indirect pointer
		RTCC	EQU	01H	; Real time clock / counter
		PCL 	EQU	02H	; Program counter low byte
		STATUS	EQU	03H	; Status register
		CY  	EQU	0	; Carry/borrow bit
		DC  	EQU	1	; Digit carry
		Z   	EQU	2	; Zero flag
		PD  	EQU	3	; Power down
		T0  	EQU	4	; Time-out bit
		RP0 	EQU	5	; Register page select bits
		RP1 	EQU	6	; Not used in 16C84
		RP2 	EQU	7	; Not used in 16C84
		FSR 	EQU	04H	; Indirect pointer
		PORTA	EQU	05H	; PORT A
		PORTB	EQU	06H	; PORT B
		EEDATA	EQU	08H	; Eeprom data
		EEADR	EQU	09H	; Eeprom address
		PCLATH	EQU	0AH	; Program counter high byte
		INTCON	EQU	0BH	; Interrupt control
		GIE 	EQU	07H	;  global interrupt enable bit
		RBIE 	EQU	03H	;  Timer 0 interrupt enable bit
		TMR0 	EQU	05H	;  Timer 0 interrupt enable bit

;  if picasm doesn't like 08?H for register addresses (TRISA/B EECON1/2)
;  change to 05H, 06H, 08H and 09H :
		OPTION_REG EQU  01H
		TRISA	EQU	05H	; Data direction port A
		TRISB	EQU	06H	; Data direction port B
		EECON1	EQU	08H	; Eeprom control
		EECON2	EQU	09H	; Eeprom control
		RD  	EQU	0	;  eeprom rd bit
		WR  	EQU	1	;  eeprom wr bit
		WREN	EQU	2	;  eeprom wr enable bit
		WRERR	EQU	3	;  eeprom ....
		EEIF	equ	4	;  eeprom ....
		W   	EQU	0	; W reg. as destination
		F   	EQU	1	; F file as destination

;		TMP		1	equ	0CH	; reg 0ch tmp
		BITCNT  equ	0DH	; bit#
		ADDRL	equ	2CH	; eeprom address
		ADDRH	equ	2dH	; eeprom address
		RCVSTAT	equ	10H	; RCVSTAT bit 0:= last byte to tx
					;         bit 1:= last byte to rx
		ADR		equ 11H
		MYDAT	equ 12H
		tmp		equ 13H

		SDATA   EQU     4       ;SERIAL EEPROM DATA LINE
		SCLK    EQU     5       ;SERIAL EEPROM CLOCK LINE
		CLK		equ		6		; CLK pic
		SDA		equ		7		; SDA pic

		BUF		equ 16h
		BUF2	equ 30h
		tmp1	equ	26h
		tmp2	equ 27h
		tmp3	equ 28h
		tmp4	equ 29h
		tmp5	equ 2ah
		tmp6	equ 2bh

		ORG	000H

;-----------------------------------------------------------------------------
;  Program Start	Send Atr and Read data from decoder
;-----------------------------------------------------------------------------
START
		goto	MyStart
		nop
		nop
		nop
		retfie
		retfie
		retfie
		retfie
GetTyp
		movlw	0
		movwf	tmp
		movlw	0xff
		movwf	PORTA
		bcf		PORTA,3
		btfss	PORTB,7
		bsf		tmp,0
		btfss	PORTB,6
		bsf		tmp,7
		bsf		PORTA,3
		bcf		PORTA,2
		btfss	PORTB,7
		bsf		tmp,1
		btfss	PORTB,6
		bsf		tmp,6
		bsf		PORTA,2
		bcf		PORTA,1
		btfss	PORTB,7
		bsf		tmp,2
		btfss	PORTB,6
		bsf		tmp,5
		bsf		PORTA,1
		bcf		PORTA,0
		btfss	PORTB,7
		bsf		tmp,3
		btfss	PORTB,6
		bsf		tmp,4
		call	SetFlipFlop
		movf	tmp,w
		return
GetUser
		retlw	0

Mystart

		clrf	PORTA
		clrf	PORTB
		bsf 	STATUS,RP0	; bank 1 acces … TRISA
		movlw	0x0
		TRIS    PORTA
INTXX
		bcf 	INTCON,GIE	; disable all interrupts
		clrf	INTCON
		movlw	0xC2
		TRIS	portb	;
		movlw	0x7f
		movwf	OPTION_REG
		bcf 	OPTION_REG,7
		bcf     STATUS,RP0

SLOOP		; read until controlbyte 0xa*  is received

	clrf	ADR			; adress eeprom =0
	clrf	ADDRH		; adress 24C16=0
	Movlw	Buf
	movwf	FSR

	call	Read24c16
	call	SetFlipFlop
;	goto fin

	bsf		portb,3		; Mclr=5 volts => lance le æp carte
	movlw	0	; tempo
	movwf 	tmp2
	movwf 	tmp3
	movwf 	tmp4
	movwf	MyDat
;	call WriteTestNext
	movlw	0x20
	movwf	adr

	movlw 8				; 8 caractŠres
	movwf tmp6			; compteur de caratŠres
	movlw	Buf2
	movwf	FSR

startByte
	; partie haute du start bit 1 temps complet
;	call waitOneBit
;	call waitOneBit

clock
	bcf		portb,2
	btfss	portb,1
	goto	Synchro
	nop
	nop
	bsf		portb,2
	btfsc	portb,1
	goto	clock

Synchro

;	bcf		portb,0

StartBit
	bcf		portb,2
	btfsc	portb,1
	goto	StartBit2
	incf	tmp2,f
	nop
	bsf		portb,2
	btfss	portb,1
	goto	startbit

StartBit2
	; calcul du compteur 1/2 temps
	movf	tmp2,w	; tmp3 = tmp2
	movwf	tmp5
	bcf		status,cy	; raz de la retenue
	rrf		tmp5,f		; /2

	movlw 8				; 8 bits
	movwf tmp1			; compteur de bit du caratŠre
	clrf	tmp4		; raz du caractŠre re‡u

firstBit
	; partie haute du start bit 1 temps complet
	call WaitOneBit

RdBit0
	; bit suivant d‚caler vers la gauche
	rlf		tmp4,f
	; restore le compteur 1/2 temps
	movf	tmp5,w	; valeur 1/2 temps
	movwf	tmp3

	; cibler le cr‚nau au milieu = 1er (1/2 temps)
Rdbit
	bcf		portb,2	; clock=1
	bcf		tmp4,0	; bit =1
	btfsc	portb,1	; test si bit est vraiment … un
	bsf		tmp4,0	; non , alors bit =0
	bsf		portb,2	; clock= 0
	nop
	decfsz	tmp3,f	; tempo = 1/2 temps
	goto	 RdBit

	; restore le compteur 1/2 temps
	movf	tmp5,w
	movwf	tmp3

	; finir le cr‚nau du milieu … la fin = 2em ( 1/2 temps)
Rdbit2
	bcf		portb,2	; clock=1
	bsf		portb,2	; clock=0
	decfsz	tmp3,f	; tempo 1/2 temps
	goto	 RdBit2

	decfsz	tmp1,f	; dernier bit
	goto	rdBit0	; non boucle au suivant

	movlw 8				; 8 bits
	movwf tmp1			; compteur de bit du caratŠre

	movf	tmp4,w		; octet re‡u
	movwf	MyDat
	movwf	INDIR
	incf	FSR,f
	call WriteTestNext ; Ecrit le byte Re‡u dans eeprom pic data

	decfsz	tmp6,f		; dernier caractŠre
	goto	NextByte0
	goto	stop

NextByte0

	movlw	8		; 8 bits
	movwf	tmp1    ; compteur de bits
	clrf	tmp4	; initialiser octet recu
	call waitOneBit ; attent valeur 2 bits
	call waitOneBit

	; Attente d' 0 sur le Data
NextByte
	bcf		portb,2
	bsf		portb,2
	btfsc	portb,1
	goto	NextByte

	; Attente d' 1 sur le Data
NextByte2
	bcf		portb,2
	bsf		portb,2
	btfss	portb,1
	goto	NextByte2
NextByte3

	goto	firstbit	; non  c'est pas termin‚ , boucle au suivant

stop
	movlw	0x30	; Sauve a adresse eeprom 0x30
	movwf	adr
	bcf		portb,0

	; termin‚
	;==========================
;	movf	tmp2,w		; le temps bit
;	movwf	MyDat
;	call WriteTestNext

;	movf	tmp3,w		; le compteur bit (normalement 0)
;	movwf	MyDat
;	call WriteTestNext

;	movf	tmp5,w		; le 1/2 temps
;	movwf	MyDat
;	call WriteTestNext ; Ecrit le byte Re‡u dans eeprom pic data

;	bcf		portb,0
;	bcf		portA,4
;ever
;	bcf		portb,2
;	bsf		portb,2
;	goto ever
;goto	clock

	; comparaison du buffer Buf et Buf2 de 8 octets

	movlw	8		;8caractŠre … comparer
	movwf	tmp1	; tmp1 = compteur de caractŠres
	movlw	Buf		; adresse du Buffer 1
	movwf	tmp2	; tmp2 pointeur buf
	Movlw	Buf2	; adresse du Buffer 1
	Movwf	tmp3	; tmp3 pointeur buf2

compare
	movf	tmp2,w	; charge pointeur de Buf
	movwf	FSR		; adressage indirect
	movf	INDIR,w	; charge l'octet de buf point‚
	movwf	tmp4	; sauve l'octet en tmp4
	movf	tmp3,w	; charge pointeur de Buf2
	movwf	FSR 	; adressage indirect
	movf	INDIR,w ; charge l'octet de buf2 point‚ dans W
	subwf	tmp4,w	; Comparaison W et tmp4
	btfss	status,z; egal ?
	goto	forever1; Non sortir
	incf	tmp2,f	; octet Buf suivant
	incf	tmp3,f	; octet Buf2 suivant
	decfsz	tmp1,f	; decompte le compteur de caractŠres
	goto	compare ; si pas fini continuer

;	movlw	0x10
;	movwf	adr
;	call writeBuf
;	movlw	0x30
;	movwf	adr
;	movlw	Buf2
;	call writeBuf3

		; OK kay!
		; ON Ouvre !!

	bsf		portb,0
	call	FlipFlop
	bsf		porta,4

	movlw	10
	movwf	tmp1
	clrf	tmp2
	clrf	tmp3
WAIT
	decfsz	tmp3,f
	goto	wait
	decfsz	tmp2,f
	goto	wait
	decfsz	tmp1,f
	goto	wait
	bcf	portb,0
goto	forever

SetFlipFlop
	bsf		porta,3
	clrf	tmp1
	movlw	0x10
	movwf	adr
	call ReadPicEEPROM
	subwf	tmp1,w
	btfsc	STATUS, Z
	bcf		porta,3
	return

FlipFlop
	clrf	tmp1
	movlw	0x10
	movwf	adr
	call ReadPicEEPROM
	subwf	tmp1,w
	btfss	STATUS, Z
	goto	bascule0b
	movlw	0xff
	bsf		porta,3
	goto bascule1
bascule0b
	clrw
	bcf		porta,3
bascule1
	movwf	MyDat
	goto	writePicEEPROM

Read24C16

	call	GetTyp		; Lit le No du type
;	clrf	ADDRL
	clrf	ADDRH
	movwf	ADDRL	; sauve dans adresse basse
	bcf		status,cy	; efface la retenue
	rlf		ADDRL,f	; x2
	rlf		ADDRH,f
	rlf		ADDRL,f	; x4
	rlf		ADDRH,f
	rlf		ADDRL,f	; x8
	rlf		ADDRH,f
	movlw   BUF
	movwf	FSR
	clrf	adr

NextLine
	call 	BSTOP
	call	ReadLine
	call 	writeBuf
;bsf		portb,0
fin
	call	BSTOP	 ;  send BSTOP
;goto fin
	return

;	movlw	0x4F
;	tris portb
;	goto fin

waitOneBit
	; partie haute du start bit 1 temps complet
	movf	tmp2,w
	movwf	tmp3
	incf	tmp3,f		; +2 cycles de s‚curit‚
	incf	tmp3,f
Rdbit3
	bcf		portb,2	; clock=1
	bsf		portb,2	; clock= 0
	decfsz	tmp3,f	; tempo = 1/2 temps
	goto	 RdBit3
return

forever1
	call	SetFlipFlop
forever
;	BCF 	PORTB,SDA	; set data low for ever
	goto	forever

ReadLine:
		movlw	8
		movwf	tmp

RDNEXT		;                ;do {  /* only max 16 byte page write */
		movf	ADDRL,w
		call	READ_EE ; read from eeprom
		movf	EEDATA,w
		movwf	INDIR
		incf	FSR,f
RDNEXT2
		call	RX ; read from eeprom
		movf	EEDATA,w
		movwf	INDIR
		incf	FSR,f
		decfsz	tmp,f
		goto	RDnext2
		goto	BSTOP	 ;  send BSTOP

; MyDat = data … enregister
; adr = adresse de l'eprom pic data
WriteTest
;movlw	0	 ; mettre … l'adresse 0
movlw	0x10 ; ou mettre … l'adresse 0x10
movwf	adr
WriteTestNext
call	WritePicEEPROM
incf	ADR,f	; adresse suivante si plusieurs octets … sauver
;movf	Indir,w	; s'il s'agit d'un Buffer
;movwf	MyDat	;
;goto fin	; Pour test, alors termin‚ !
return		; ou alors continuer

writeBuf:
	movlw	Buf	; adresse du buffer … sauver

writeBuf3
	movwf	FSR	; pour adressage indirect
	MOVLW	8	; 8 caractŠres … sauver
	movwf	tmp ; tmp = compteur de caractŠres

writeBuf2:
	movf	INDIR,w	; charger le caractŠres … sauver
	movwf	MyDat	; MyDat = octet … sauver pour la routine WritePicEEPROM
	call	WritePicEEPROM ; le sauver
	incf	ADR,f	; eeprom suivante
	incf	FSR,f	; octet buffer suivant
	decfsz	tmp,f	; d‚compte le compteur de caractŠre
	goto	writebuf2	; si = 0 ne pas reboucler … WriteBuf2
	bsf 	3,5         ; Bank 1
	bcf 	0bH, 7      ; Disable INTs.
	bcf 	3,5         ; Bank 0
	return

writePicEEPROM
	bcf 	3, 5        ; Bank 0
	movf	MYDAT,W		; load data
	movwf	8           ; EEDATA=W
	movf	ADR,W		; adress
	movwf	9           ; Address to read
	bsf 	3,5         ; Bank 1
	bcf 	8, 4        ; clear EE int flag
	bcf 	0bH, 7      ; Disable INTs.
	bsf 	8, 2        ; Enable Write
	movlw	055h        ;
	movwf	9           ; Write 55h
	movlw	0AAh        ;
	movwf	9           ; Write AAh
	bsf 	8, 1        ; Set WR bit, Begin Write
	bsf 	0bH, 7      ; Enable INTs
	btfsc	8, 1        ; Test End write
	goto	$-1         ; loop while not end
	bcf 	8, 2        ; Disable Write
	bcf 	3,5         ; Bank 0
	return

ReadPicEEPROM
	movf	adr,w
	movwf	EEADR		; Address to read
	bsf		STATUS,RP0	; Bank 1
	bsf		EECON1, RD	; EE Read
	bcf		STATUS, RP0	; Bank 0
	movf	EEDATA, W	; W = EEDATA
return

;
; following code borrowed from multi215.asm +
; - read modified to do sequential read
;
;######################################################
;	EEPROM READ ROUTINE
;######################################################
;		Used reg: EEADR, EEDATA,RCVSTAT,W
;		IN  : W= READ ADRESS
;		OUT : W= BYTE

READ_EE 	MOVWF	EEADR	       ; store byte in reg EEADR

READ_EE_DIR	CALL	BSTART		; generate start bit
		BCF	STATUS,CY			; WRITE SEQUENCE
		CALL	CONTROL_BYTE	; CALC CONTROL BYTE AND TRANSMIT
		MOVF	EEADR,W 		; get word address....
READ_EE1	CALL	TX			; and send it

READ_CURRENT	CALL	BSTART		; generate start bit
		BSF	STATUS,CY	; READ SEQUENCE
		CALL	CONTROL_BYTE	; CALC CONTROL BYTE AND TRANSMIT
		CALL	RX		; read 1 byte from serial EE
;		btfsc	RCVSTAT,1	; if lastbyte then
;		CALL	BSTOP		;   send stop bit to end transmission
;		MOVF	EEDATA,W	; GET RECEIVED BYTE
		RETURN

;
;**********************************************
;	GENERATE CONTROL BYTE
;**********************************************
CONTROL_BYTE	RLF	ADDRH,W		; => CY=1
		ANDLW	B'00001111'     ;MASK OUT UPPER NIBBLE
		IORLW	B'10100000'     ;COMPLETE BYTE 1010AAAD
					;A=ADRESS D=DIRECTION

					;SEND CONTROL BYTE

;**********************************************
;	TRANSMIT DATA SUBROUTINE
;**********************************************

TX		MOVWF	EEDATA		;STORE BYTE TO TX
		MOVLW	B'11000010'     ; set data,clock as outputs
		TRIS PORTB

		CALL    TX4		;TRANSMIT 8 TIMES
		CALL    TX4
		GOTO 	BITIN

TX4		CALL    TXLP
		CALL    TXLP
		CALL    TXLP
TXLP	 	RLF	EEDATA,F	; ROTATE BIT TO CARRY
                GOTO    BITOUT_R        ; send the bit to serial EE

;**********************************************
;	RECEIVE DATA SUBROUTINE
;**********************************************
RX 		MOVLW	B'11010010'    ; make SDATA an input line/SCLK = OUT
;		Call MyTrisb
		TRIS PORTB
		CALL    RX4
		CALL    RX4
		btfss   RCVSTAT,1      ; if not last byte then
		bcf	STATUS,CY      ;   set Ack=0
		btfsc	RCVSTAT,1      ; else
		BCF     STATUS,CY      ;   SET ACK BIT=1
		GOTO    BITOUT         ; TO FINISH TRANSMISSION

RX4		CALL	RXLP
		CALL 	RXLP
		CALL	RXLP

RXLP    CALL    BITIN_R         ; READ A BIT
	 	RLF	EEDATA,F	; SHIFT CARRY TO BYTE
   		RETURN

;*********************************************
;	START BIT SUBROUTINE
;*********************************************

BSTART		BSF	PORTB,SDATA	; make sure data is high
		MOVLW	B'11000010'
		TRIS PORTB		; set data and clock lines for output
		BSF	PORTB,SCLK	; set clock high
		NOP
		BCF	PORTB,SDATA	; data line goes low during
		NOP
		GOTO	BC_END		; high clock for start bit

;**********************************************
;	STOP BIT SUBROUTINE
;**********************************************

BSTOP		BCF	PORTB,SDATA	; make sure data line is low
		MOVLW	B'11000010'
		TRIS PORTB		; set data/clock lines as outputs
		NOP
		BSF	PORTB,SCLK	; set clock high
			NOP
		BSF	PORTB,SDATA	; data goes high while clock high
					; for stop bit
B_END		NOP
BC_END		BCF	PORTB,SCLK	; set clock low again
		RETURN

;**********************************************
;	BITOUT ROUTINE , SEND BIT WHEN CARRY SET
;**********************************************

BITOUT		MOVLW	B'11000010'     ; set data,clock as outputs
;		Call MyTrisb
		tris PORTB
BITOUT_R	BTFSS	STATUS,CY	; check for state of data bit to xmit
		BcF	PORTB,SDATA	; set data line low
		BTFSc	STATUS,CY
		BsF	PORTB,SDATA	; high? set data line high

CLKOUT		BSF	PORTB,SCLK	; set clock line high
		GOTO	B_END

;**********************************************
;	BITIN ROUTINE
;**********************************************
BITIN		MOVLW	 B'11010010'    ; make SDATA an input line/SCLK = OUT
;		Call MyTrisb
		tris PORTB
		bcf	OPTION_REG,7	; make sure weak pull-up is on
BITIN_R		BSF	 PORTB,SCLK	; set clock line high
		NOP
		BSF	 STATUS,CY	; assume input bit is high
		BTFSS	 PORTB,SDATA	; read the data bit
		BCF	 STATUS,CY	; input bit was low ,clear CARRY
		NOP
		GOTO	 BC_END
MyTrisB
	bsf	3,5
	tris	06
	bcf	3,5
	return

		END

Conclusion :


Sa marche, je l'ai fait c pas mal.
a visiter absolument pour le créateur de se fichier: http://perso.wanadoo.fr/pat.deaubonne/DOWNLOAD/Serrure_A_WaferCard/

A voir également

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.