Répondre à la discussion
Affichage des résultats 1 à 25 sur 25

programmer une carte à puce



  1. #1
    bouchtarat

    Smile programmer une carte à puce


    ------

    je dois réaliser un programmateur premettant d'ecrire des données sur une carte a puce et de pouvoir les lire par la suite.
    L'application doit se lancer a l'insertion de la carte dans le lecteur.
    Comment detecter l'insertion de la carte?
    Comment recuperer les données de la carte pour les mettre dans les champs correspondant(interface C ou C++) ?
    si quelqu'un s'y connait sur le sujet n'hesitez pas a repondre!

    -----

  2. Publicité
  3. #2
    Evernice

    Re : programmer une carte à puce

    Bonjour,

    Je suppose que c'est sous windows.
    le plus simple : utilisation d'un lecteur PC/SC. Utilisation des primitives PC/SC et lancement du scardserver (de tête). Pour dialoguer avec la carte, les ordres sont décrits dans la spec. Sinon, il y a également les normes ISO7816-4 qui décrivent des ordres pour les cartes qui les respectent.
    Il faut formater ces ordres et utiliser les functions idoines de PC/SC pour établir le dialogue. Beaucoup de choses sont disponibles sur la toile à ce sujet.
    A+
    Le chaînon manquant entre le singe et l'homme, c'est nous (Pierre Dac)

  4. #3
    bouchtarat

    Re : programmer une carte à puce

    exusez moi mais je n'ai rien compris pouvez vous m'expliquer PC/SC ?
    et me guider car je ne sais meme d'ou debuter mon projet merci

  5. #4
    billygregoire

    Re : programmer une carte à puce

    bonjour,

    j'ai exactement lemême soucis, on me file du matos et on me dit démerde toi....sympa....

    en fait, j'ai des cartes à puces qui doivent contenir les infos des membres de notre association, genre adresse, en ordre de coti, fiche médicale etc.... mais la programation, c'est pas mon truc. Donc existe-il des programme tout fait, modulables, permettant ce genre d'utilisations....?

  6. A voir en vidéo sur Futura
  7. #5
    freepicbasic

    Re : programmer une carte à puce

    La serrure à carte Gold avec source ,hex, et explications
    http://pagesperso-orange.fr/pat.deau...Gold/INDEX.HTM
    A+, pat

  8. #6
    bouchtarat

    Re : programmer une carte à puce

    ca site est pour réaliser une serrure c'est pour le control d'acces moi je veux seulement quelqu'un qui peut m'aider ou plutot me ghuider en me donnant les étapes par laqueele je dois passer pour pouvoir réaliser mon projet svp aidez moi

  9. Publicité
  10. #7
    bouchtarat

    Re : programmer une carte à puce

    pour billygregoire quels types de carte t'as pour stcker ces données?

  11. #8
    billygregoire

    Re : programmer une carte à puce

    carte GOLD intégrant un microcontrôleur PIC16F84A et une mémoire 24C16, c'est tout ce que je sais....

  12. #9
    freepicbasic

    Re : programmer une carte à puce

    Citation Envoyé par bouchtarat Voir le message
    ca site est pour réaliser une serrure c'est pour le control d'acces moi je veux seulement quelqu'un qui peut m'aider ou plutot me ghuider en me donnant les étapes par laqueele je dois passer pour pouvoir réaliser mon projet svp aidez moi
    Je te donne des programmes avec sources et explications , je pense que tu n'as pas lu ou essayer de comprendre , il suffit de modifier peu de chose pour faire ton projet , encore faut il s'en donner la peine.

    Si tu cherche quelqu'un pour faire ton boulot ce n'est pas la bonne méthode.

    Pose des questions techniques précises , et tu auras des réponses.
    A+, pat

  13. #10
    bouchtarat

    Re : programmer une carte à puce

    bnj
    ou est ce programme que je peux tout simplement modifier ?????

  14. #11
    freepicbasic

    Re : programmer une carte à puce

    Code:
    ;*****************************************************************
    ;
    ;                TITLE           "CLECARD.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=xt
    
    		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	3EH	; eeprom address
    		ADDRH	equ	3FH	; eeprom address
    		RCVSTAT	equ	10H	; RCVSTAT bit 0:= last byte to tx
    					;         bit 1:= last byte to rx
    		ADR		equ 11H
    		tmp		equ 15H
    		MYDAT		equ 12H
    
    		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
    		tmp1	equ	37h
    		tmp2	equ 38h
    
    
    		ORG	000H
    
    
    
    ;-----------------------------------------------------------------------------
    ;  Program Start	Send Atr and Read data from decoder
    ;-----------------------------------------------------------------------------
    START
    		goto	MyStart
    		nop
    		nop
    		nop
    		retfie
    		retfie
    		retfie
    		retfie
    GetTyp
    		retlw	2
    GetUser
    		retlw	0
    
    Mystart
    
    		clrf	PORTA
    		clrf	PORTB
    		bsf 	STATUS,RP0	; bank 1 acces … TRISA
    		movlw	0x10
    		TRIS    PORTA
    INTXX
    		bcf 	INTCON,GIE	; disable all interrupts
    ;		bcf 	INTCON,TMR0	; disable Timer interrupts
    ;		bcf 	INTCON,RBIE	; disable Timer interrupts
    		clrf	INTCON
    		movlw	0xcf
    		TRIS	portb	;
    		movlw	0x7f
    		movwf	OPTION_REG
    		bcf 	OPTION_REG,7
    		bcf     STATUS,RP0
    
    SLOOP		; read until controlbyte 0xa*  is received
    
    	clrf	ADDRH
    	call	GetTyp		; Lit le No du type
    	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
    	call	Nextline
    	goto	fin
    
    
    NextLine
    
    	call 	BSTOP
    	call	ReadLine
    	call 	writeBuf
    fin
    	call	BSTOP	 ;  send BSTOP
    	movlw	0x4F
    	tris portb
    
    
    SendKey
    SendLoop3
    	movlw	128 ; tempo 128 boucle
    	movwf	tmp1
    
    	BSF 	PORTB,SDA	; set data
    SendLoop3a
    	; tempo Data haut de 128 boucles
    	decfsz	tmp1,f
    	goto	SendLoop3a
    
    	; Adresse buffer
    	movlw	BUF
    	; adressage indirect
    	movwf	FSR
    	; 8 caractŠres … transmettres
    	movlw	8
    	movwf	tmp
    
    SendLoop1
    	movlw	32
    	movwf	tmp1
    	BSF 	PORTB,SDA	; set data
    SendLoop1a
    	; tempo Data haut de 32 boucles
    	decfsz	tmp1,f
    	goto	SendLoop1a
    
    	; 8 bits par caractŠres
    	movlw	8
    	movwf	tmp1
    	movf	indir,w
    	movwf	tmp2
    	incf	FSR,f
    
    	; stzrt bit
    
    	BCF 	PORTB,SDA	; set data low  for this bit
    	nop
    	nop
    	nop
    	nop
    	nop
    	nop
    	nop
    	BSF 	PORTB,SDA	; set data low  for this bit
    	nop
    	nop
    	nop
    	nop
    	nop
    	nop
    	nop
    SendLoop2
    	rlf		tmp2,f
    	btfsc	status,cy
    	BSF 	PORTB,SDA	; set data high for this bit
    	btfss	status,cy
    	BCF 	PORTB,SDA	; set data low  for this bit
    	decfsz	tmp1,f
    	goto	SendLoop2
    
    	decfsz	tmp,f
    	goto	SendLoop1
    goto SendKey
    
    forever
    	BCF 	PORTB,SDA	; set data low for ever
    	goto	forever
    
    
    ReadLine:
    
    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
    
    
    
    
    
    
    ;movf	EEDATA,w
    ;movwf	MyDat
    ;clrf	ADR
    ;call	WritePicEEPROM
    ;incf	ADR,f
    ;movf	Indir,w
    ;movwf	MyDat
    ;call	WritePicEEPROM
    ;goto fin
    
    writeBuf:
    
    	movlw	Buf
    writeBuf3
    	movwf	FSR
    	MOVLW	8
    	movwf	tmp
    
    writeBuf2:
    	movf	INDIR,w
    	movwf	MyDat
    	call	WritePicEEPROM
    	incf	ADR,f
    	incf	FSR,f
    	decfsz	tmp,f
    	goto	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
    	movwf	8           ; EEDATA=W
    	movf	ADR,W
    	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
    
    
    
    
    
    ;
    ; 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'11001111'     ; 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'11011111'    ; 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'11001111'
    		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'11001111'
    		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'11001111'     ; 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'11011111'    ; 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
    
    
    
    A+, pat

  15. #12
    freepicbasic

    Re : programmer une carte à puce

    Code:
    ;*****************************************************************
    ;
    ;                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
    
    
    
    A+, pat

  16. Publicité
  17. #13
    freepicbasic

    Re : programmer une carte à puce

    Générateur de fichier aléatoire
    Compiler en TC2
    Code:
    #include "stdio.h"
    #include "stdlib.h"
    
    void crc(char *);
    unsigned int Htoi(char *);
    
    
    main()
    {
    FILE *f1;
    int rnd,i,adr,l,ct;
    char lin[80];
    char Buf[2049];
    
    	rnd=0;
    	printf("\r\nGenŠre un fichier (24C16.HEX) pseudo-al‚atoire !\r\n");
    
    	f1 = fopen("24C16.hex","wb+");
    	if (f1==NULL) {
    		printf("\r\nNe peut pas ouvrir 24C16.HEX !\r\n");
    		exit(1);
    		}
    
    	printf("Appuyer sur une touche !\r\n");
    	while (kbhit()==0) rnd++;
    
    	for (i=0; i<2048; i++)
    		Buf[i] = random( rnd );
    
    
    	adr=i=ct=0;
    	sprintf(lin,":00%04x00",adr);
    	while (i<2048) {
    		i++;
    		ct++;
    		adr++;
    		if ( ct==16) {
    			l=strlen(lin);
    			sprintf(lin+l,"%02x", Buf[i] & 0x0ff);
    			crc( lin );
    			fprintf(f1,"%s\r\n",lin);
    			sprintf(lin,":00%04x00",adr);
    			ct=0;
    			}
    		else {
    			l=strlen(lin);
    			sprintf(lin+l,"%02x", Buf[i] & 0x0ff);
    			}
    		}
    	crc( lin );
    
    	fprintf(f1,":00000001FF\r\n");
    
    
    	fclose(f1);
    }
    
    void crc(char *str)
    {
    unsigned int i,chk;
    int nb;
    char hex[3];
    
    	chk=nb=0;
    	hex[2]='\0';
    	for (i=3;i<strlen(str); i+=2) {
    		hex[0] = str[i];
    		hex[1] = str[i+1];
    		chk += Htoi(hex);
    		nb++;
    		}
    	nb-=3;
    	if (nb<0) nb=0;
    	sprintf(hex,"%02x",nb);
    	memcpy(str+1,hex,2);
    	chk += nb;
    	chk = ( 0x100 - (chk & 0x0ff) & 0x0ff);
    	sprintf(hex,"%02x",chk);
    	strcat(str,hex);
    	strupr(str);
    }
    
    unsigned int Htoi(char *str)
    {
    int i,s;
    unsigned v;
    
    	strupr(str);
    	v=s=0;
    	if (strncmp(str,"0X",2)==0) s=2;
    	for (i=s; i<(strlen(str)); i++) {
    		v *= 16;
    		if ( (str[i]>='0') && (str[i]<='9'))
    		v+=str[i] - '0';
    	else
    		if ( (str[i]>='A') && (str[i]<='F'))
    			v+=str[i] - 'A'+10;
    		else {
    			v /=16;
    			break;
    			}
    		}
    	return( v);
    }
    A+, pat

  18. #14
    freepicbasic

    Re : programmer une carte à puce

    Clelock.hex
    Code:
    :10000000272800000000000009000900090009007D
    :1000100000309300FF3085008511861F1314061FE2
    :10002000931785150511861F9314061F13170515C1
    :100030008510861F1315061F931685140510861F3D
    :100040009315061F1316AF2013080800003485010E
    :1000500086018316003065008B138B01C230660069
    :100060007F308100811383129101AD01163084002D
    :10007000C620AF2086150030A700A800A900920076
    :10008000203091000830AB00303084000611861C0F
    :100090004E2800000000061586184628061186180E
    :1000A0005628A70A00000615861C4E282708AA0015
    :1000B0000310AA0C0830A600A901D820A90D2A080F
    :1000C000A800061129108618291406150000A80B8F
    :1000D00061282A08A80006110615A80B6B28A60B94
    :1000E0005E280830A600290892008000840AF320C8
    :1000F000AB0B7B2889280830A600A901D820D8207E
    :10010000061106158618802806110615861C8428F7
    :100110005D283030910006100830A6001630A70088
    :100120003030A800270884000008A90028088400AF
    :1001300000082902031DE128A70AA80AA60B922895
    :100140000614B82005160A30A600A701A801A80BBE
    :10015000A728A70BA728A60BA7280610E228851515
    :10016000A6011030910019212602031985110800FB
    :10017000A6011030910019212602031DC228FF306C
    :100180008515C42800018511920005290820AD01BC
    :10019000AC000310AC0DAD0DAC0DAD0DAC0DAD0D47
    :1001A0001630840091015021E320F62050210800F0
    :1001B0002708A800A80AA80A06110615A80BDC281B
    :1001C0000800AF20E228083093002C0820210808FE
    :1001D0008000840A392108088000840A930BEA28E9
    :1001E0005029103091000521910A08001630840032
    :1001F00008309300000892000521910A840A930BAD
    :10020000FA2883168B1383120800831212088800C1
    :1002100011088900831608128B13081555308900C0
    :10022000AA30890088148B178818142908118312A2
    :1002300008001108890083160814831208080800B2
    :100240008900482103102B2109082E21482103147D
    :100250002B21392108002D0D0F39A0388800C2301C
    :100260006600342134216229372137213721880D56
    :100270005C29D230660042214221901C0310901864
    :1002800003105A294521452145216521880D080083
    :100290000616C230660086160000061200005829B5
    :1002A0000612C23066000000861600000616000026
    :1002B00086120800C2306600031C061203180616D8
    :1002C00086165729D2306600811386160000031463
    :1002D000061E0310000058298316660083120800CA
    :02400E00F93F78
    :00000001FF
    A+, pat

  19. #15
    bouchtarat

    Re : programmer une carte à puce

    bnj
    svp , j'ai bien essaye à comprendre ce programme mais je vois que je n'ai pas assez de competence
    je vous pris de m'indiquer la partie ou je dois modifier car je veux seulement programmer ma carte en chargent un nom ou un code sur l'eeprom externe de la carte gold
    comment ecrire mon nom et le transfere à la carte
    svvvvpppp
    merci

  20. #16
    freepicbasic

    Re : programmer une carte à puce

    Il y a rien de mystérieux, il suffit que le fichier 24C16 soit identique sur la clé et le verrou, on met ce qu'on veut dedans , j'ai juste fourni un programme qui génére des datas aléatoires si on ne sait pas quoi metttre.
    A+, pat

  21. #17
    freepicbasic

    Re : programmer une carte à puce

    En 2 minutes sur Google 2 utilitaires freeware; (pas testés)

    Pour transformé un fichier binaire en hex;
    http://www.programmersheaven.com/dow.../download.aspx

    Un éditeur de fichier binaire;
    http://www.febooti.com/products/file...rs/hex-editor/
    A+, pat

  22. #18
    bouchtarat

    Re : programmer une carte à puce

    bnj
    pouvez vous m'indiquer sur le programme .asm la ligne qui génére des datas aléatoires si on ne sait pas quoi metttre.pour que je mais à la place mon nom
    svp
    merci

  23. Publicité
  24. #19
    freepicbasic

    Re : programmer une carte à puce

    1) installer hexEditor
    http://www.febooti.com/products/file...rs/hex-editor/

    2) avec Explorer ou "poste de travail" afficher le fichier 24C16.hex
    3) faire propiété
    4) selectionner Hex Editor
    5) le fichier s'affiche en format hex
    6) aller sur la partie droite (zone ASCII)
    7) ne pas modifier le 9 premiers caractères à partir des début de lignes qui commence toutes par ":" et les OD OA qui se trouve avant le ":"
    voir la première image
    8) Saisir les textes
    voir seconde image

    9)
    http://pagesperso-orange.fr/pat.deau...ld/hex2hex.exe
    passer le fichier par ce programme pour recalculer les CRC.
    Images attachées Images attachées
    A+, pat

  25. #20
    bouchtarat

    Re : programmer une carte à puce

    j pas compris ces 2 etapes
    2) avec Explorer ou "poste de travail" afficher le fichier 24C16.hex
    3) faire propiété

    et le deuxieme site n'existe pas impossible d'afficher la page

  26. #21
    freepicbasic

    Re : programmer une carte à puce

    faire
    demarrer
    taper "explorer"
    aller dans le répertoire ou se trouve 24C16.hex


    essayez ici;
    http://www.darkwire.com.au/IC%20Card%20Programmer.html
    A+, pat

  27. #22
    bouchtarat

    Re : programmer une carte à puce

    le 24lc16 c'est celui que vous m'avez donné avant en hex???
    merci

  28. #23
    freepicbasic

    Re : programmer une carte à puce

    Citation Envoyé par bouchtarat Voir le message
    le 24lc16 c'est celui que vous m'avez donné avant en hex???
    merci
    c'est celui que tu modifie pour mettre ton nom, qui sera dans l'eeprom 24c16 de la glodcard (smartcard)
    A+, pat

  29. #24
    bouchtarat

    Re : programmer une carte à puce

    ou je dois modidier ?

  30. Publicité
  31. #25
    bouchtarat

    Re : programmer une carte à puce

    svp j'ai fait mon mieux
    repondez
    si quelqu'un a un programme fait qu'il me l'envoie
    pllllllzzzzzzzz
    merci

Discussions similaires

  1. Communication avec une carte à puce
    Par jeremy34000 dans le forum Électronique
    Réponses: 0
    Dernier message: 29/11/2007, 19h01
  2. programmer une carte mère
    Par aurélien10 dans le forum Logiciel - Software - Open Source
    Réponses: 0
    Dernier message: 15/03/2007, 20h53
  3. comment débuter avec une carte à puce
    Par alainav1 dans le forum Électronique
    Réponses: 4
    Dernier message: 17/10/2006, 20h26
  4. comment programmer une carte gold?
    Par fatus dans le forum Électronique
    Réponses: 1
    Dernier message: 27/07/2006, 19h09
  5. Programmation sur une carte à puce
    Par roi dans le forum Électronique
    Réponses: 8
    Dernier message: 06/05/2005, 23h44
Découvrez nos comparatifs produits sur l'informatique et les technologies.