programmateur d'eeprom i2c

Pour un projet sur lequel je travaille j'avais besoin d'un programmateur de mémoire eeprom sériel avec interface I2C mais en regardant sur le site de Microchip et celui de digikey.ca le prix m'a fait reculer. Avec les coûts de transport et les taxes j'aurais du débourser plus de 80$ pour un appareil qui ne me servira probablement que très rarement. J'ai donc entrepris de fabriquer mon propre programmateur. Ce programmateur est conçu pour les mémoires eeprom sérielles avec interface I2C de Microchip. Le projet comprend 2 parties, le montage électronique avec le firmware pour le MCU qui contrôle la programmation eeprom et le logiciel hôte qui tourne sur le PC. Pour le logiciel PC j'ai choisi de l'écrire en python pour qu'il puisse être utilisé aussi bien sous Windows que Linux ou même OSX.

Matériel requis

Qt	No.Pièce	description	prix $CAN	fournisseur
2	A100204-ND	embases DIL-8	0,20	Digikey.ca
1	RB-Ada-30	perma-proto 1/4	8,95/pqt de 3	Robotshop.com/ca
3	P5148-ND	condensateur électrolytique 10uF/25V	0,21	digikey.ca
2	445-8421-ND	condensateur céramique 100nF	0,32	digikey.ca
1	2N3904-APCT-ND	transistor NPN 2N3904	0,45	digikey.ca
1	2N3906-APCT-ND	transistor PNP 2N3906	0,45	digikey.ca
1	PIC12F1822-I/P-ND	Microcontrolleur Micropchip PIC12F1822	1,50	digikey.ca
1	1N4148-TAPCT-ND	diode 1N4148	0,25	digikey.ca
1	P2.0KBACT-ND	resistance 2K/0,25Watt	0,10	digikey.ca
1	CF14JT4K70CT-ND	resistance 4K7/0,25Watt	0,09	digikey.ca
3	CF14JT10K0CT-ND	résistance 10K/0,25Watt	0,09	digikey.ca
5	609-3466-ND	contact pin	0,11	digikey.ca

schéma électronique

Le programmateur communique avec l'ordinateur via un port série à 115200 BAUD, 8bits, pas de parité et 1 stop. La partie à droite du schéma, constituée de Q1 et Q2 est un convertisseur de niveaux de tension pour le RS-232. C'est le même circuit que j'ai déjà présenté sur ce blog. Le MCU PIC12F1822 communique donc avec le PC à travers ce circuit et d'autre part avec l'eeprom via les broches 2,3 et 5. La broche 2 est la sortie SCL et la broche 3 est l'E/S pour SDA du protocole I2C. La broche 5 contrôle le WP de l'eeprom et est gardée au niveau haut sauf pendant l'écriture de données dans l'eeprom. Les eeprom 24LCxxxx ont 3 entrées d'addressage A0-A2, qui servent à sélectionner le circuit intégré sur le bus I2C. Puisqu'il y a 3 bits d'adresse on peut mettre jusqu'à 8 I.C. sur le même bus I2C. Sur le schéma du programmateur j'ai mis A2=A0 à Vdd, l'adresse est donc 0b111. Pour les 24LC1025 il faut que la broche A2 soit à Vdd car le bit de la commande qui correspond à A2 dans les eeprom de plus de 64KB est utilisé pour sélectionner le block de 64K, la mémoire étant divisé en 2 block de 64KB.

montage

Pour le montage j'ai utilisé une platine produite par Adafruit et distribuée par Robotshop.com. C'est la première fois que j'utilise ce produit et je suis très satisfait. La qualité est bonne, les oeillets de soudure sont passant donc on peut soudé du côté composant sans avoir à retourner la platine. Le dessus de la platine est une représentation exacte d'une platine sans soudure. Donc pour faire le montage pas besoin de refaire un schéma de montage il suffit de recopier simplement ce qu'on a fait sur la platine sans soudure. Le montage a été plus rapide que si je l'avais fait sur une platine à grille de points 100mil. C'est un produit intéressant que je recommande.
Côté cuivre de la platine entre les contacts TX et RX j'ai coupé la trace du circuit imprimé pour isoler les contacts l'un de l'autre puisqu'il sont montés sur la même rangée.

firmware PIC12F1822

En ce qui concerne le firmware du PIC12F1822 ça a été assé simple. Pour la communication avec le PC comme le MCU a un périphérique USART incorporé le travail au niveau logiciel a été très simple. Le gros du travail c'est fait au niveau de l'interface I2C avec l'eeprom, mais pas de quoi s'arracher les cheveux.

code source firmware PIC12F1822
; NOM: eeprom-prog.asm ; DESCRIPTION: programmeur pour eeprom i2c Microchip série 24AAxxx/24LCxxx/24FCxxx ; interface PC RS-232, communication semi-duplex. ; format des paquets: ; CNT CMD DATA CHKSUM ; CNT est un octet indiquant le nombre d'octets dans le paquet ; excluant CNT ; CMD indique le type message: ; 00 Débute transaction écriture eeprom, 4 octets ; 1 octet cmd ; 2 octets adresse début, (les nombres sont en format en little indian.) ; 1 octet checksum ; 01 data à envoyer à l'eeprom, maximum 16 octets de données ; 1 octet cmd ; 1-16 octets données ; 1 octet checksum ; 02 commande l'écriture des données reçues. ; 1 octet cmd ; 1 octet checksum ; 03 commande début lecture eeprom ; 1 octet cmd ; 2 octets adresse ; 1 octet checksum ; 04 commande lecture n octets suivants ; 1 octet commande ; 1 octet nombre à lire maximum 16 ; 1 octet checksum ; 05 demande version firmware ; 1 octet cmd ; 1 octet chksum ; 06 met à 1 l'indicateur de block F_BLOCK ; 1 octet cmd ; 1 octet chksum ; 07 remet à zéro l'indicateur de block F_BLOCK ; 1 octet cmd ; 1 octet checksum ; 08 fermeture des transactions, retour à l'état IDLE ; 1 octet cmd ; 1 octet chksum ; ; CHKSUM est le complément de 2, de la somme % 256 de tous les ; octets qui précèdent ; ; protocole: ; au départ le programmeur est IDLE et attend un ENQ du PC ; s'il est prêt à recevoir des paquets il répond par un ACK ; Lorsque le PC envoie un paquet il attend un ACK du programmeur. ; Le programmeur traite le paquet avant de répondre ; si le traitement est sans erreur il envoie un ACK ; sinon il envoie un NAK suivit d'un code d'ereur. ; ; codes d'erreurs: ; 00 pas d'erreur (envoyé à la suite d'un ACK) ; 01 erreur checksum sur le paquet reçu ; 02 erreur de communication avec l'eeprom ; 03 commande inconnue ; ; Le programmeur ne sais rien de l'eeprom avec laquelle il est en ; communication. C'est au programme sur le PC de s'assurrer ; que les paramètres de l'eeprom sont respectés: ; - dimension des pages ; - éviter de tenter d'écrire en chevauchement de 2 pages. ; - respect de la capacité mémoire. ; ; MCU: PIC12F1822 ; DATE: 2012-12-16 ; AUTEUR: Jacques Deschênes #include <P12F1822.INC> #include "..\include\pic12f1822_m.inc" #include "..\include\stack.inc" default_config #define DEBUG ;;;;;;;;; constantes ;;;;;;;;;;;;;;;;;;;;;;;; FOSC4 EQU OSC_FREQ_16M FIRMWARE_VERSION EQU H'10' ; high nibble major, low nibble minor BAUDRATE EQU D'115200' FREQ_CLOCK EQU D'16000000' BUFF_SIZE EQU D'66' ; dimension io_buffer ; type de paquet envoyés par le PC PQT_WRITE EQU 0 ; début de programmation eeprom PQT_DATA EQU 1 ; données à programmer PQT_FLASH EQU 2 ; fermer la transaction écriture, flash la rangée. PQT_READ EQU 3 ; débute la lecture de l'eeprom PQT_RDN EQU 4 ; fait la lecture des n octets suivants PQT_VER EQU 5 ; demande version firmware PQT_SETB EQU 6 ; met à 1 F_BLOCK PQT_CLRB EQU 7 ; met à 0 F_BLOCK PQT_EOT EQU 8 ; fermeture des transactions retour à l'état IDLE ;communication UART PC/programmeur ENQ EQU 5 ; le PC envoie un ENQ et attend un ACK du programmeur ACK EQU 6 ; le programmeur répond qu'il est prêt envoyant ce code NAK EQU D'21' ; le programmeur informe le PC qu'il s'est produit une erreur. ; codes d'erreur renvoyés au PC ERR_NONE EQU 0 ; pas d'erreur ERR_CS EQU 1 ; erreur checksum ERR_EE EQU 2 ; erreur communication eeprom ERR_CMD EQU 3 ; commande inconnue. ERR_SYNC EQU 4 ; l'octet reçu n'est pas synchronisé avec l'état du programmeur. ; commandes eeprom ; les eeprom 24LC102x ont 2 blocks de 64KB ; le block est sélectionné par le bit 3 dans la commande. ; pour les eeprom <=64KB le block B1 est sélectionné par défaut car la broche A2 est à V+. ; pour les eeprom 128KB le block B0 est sélectionné par défaut. EE_CTL_WR_B0 EQU H'A6' ; envoie vers EEPROM commande block 0 EE_CTL_RD_B0 EQU H'A7' ; réception de EEPROM commande block 0 EE_CTL_WR_B1 EQU H'AE' ; envoie vers EEPROM commande block 1 EE_CTL_RD_B1 EQU H'AF' ; récepion de EEPROM commande block 1 ; indicateurs booléens F_BLOCK EQU 1 ; indicateur de block pour eeprom > 64KB F_RCVD EQU 2 ; réception paquet UART complétée F_UIDLE EQU 3 ; uart en état idle, attend ENQ F_URDY EQU 4 ; uart prêt à recevoir un paquet F_UPEND EQU 5 ; réception d'un paquet en cours. F_EERD EQU 6 ; lecture eeprom en cours F_EEWR EQU 7 ; écriture eeprom en cours ;;;;;;;;; macros pré-processeur ;;;;;;;;;;;;; ;interface RS-232 avec PC #define TX_P RA0 #define RX_P RA1 #define TX PORTA, TX_P #define RX PORTA, RX_P ;interface eeprom #define WP_P RA2 #define SCL_P RA5 #define SDA_P RA4 #define EE_WP PORTA, WP_P #define EE_SCL PORTA, SCL_P #define EE_SDA PORTA, SDA_P ;;;;;;;;; macros mpasm ;;;;;;;;;;;;;;;;;;;;;; ee_stop macro ; met l'interface i2c à l'état idle ; bank PORTA doit-être préalablement sélectionnée bcf EE_SDA bsf EE_SCL goto $+1 ;delais minimum 600nsec goto $+1 bsf EE_SDA goto $+1 ; délais minimum 1300nsec goto $+1 nop endm ee_start macro ; signale à l'eeprom le début d'une transaction ; bank PORTA doit-être préalablement sélectionnée bsf EE_SDA bsf EE_SCL goto $+1 bcf EE_SDA goto $+1 ; délais minimum 600nsec nop bcf EE_SCL endm ee_read_cmd macro ; prépare l'eeprom pour une lecture séquentielle ; appellée à la suite de: ; call ee_set_address banksel PORTA ee_start movlw EE_CTL_RD_B1 btfss flags, F_BLOCK movlw EE_CTL_RD_B0 pushw call ee_send_byte endm ee_write_cmd macro ; envoie la commande écriture à l'eeprom banksel PORTA ee_start movlw EE_CTL_WR_B1 btfss flags, F_BLOCK movlw EE_CTL_WR_B0 pushw call ee_send_byte endm ee_wr_enable macro ; désactive la broche WP sur l'eeprom ; bank PORTA préalablement sélectionnée bcf EE_WP goto $+1 nop endm ee_wr_disable macro ; active la broche WP sur l'eeprom ; bank PORTA préalablement sélectionnée bsf EE_WP goto $+1 ; délais hold time minimum 1300nsec goto $+1 nop endm ee_send_bit macro ; envoie un bit sur l'interface i2c de l'eeprom ; le bit à envoyé est dans le Carry du registre STATUS ; bank PORTA préalablement sélectionnée bcf EE_SDA skpnc bsf EE_SDA nop bsf EE_SCL goto $+1 ; délais hold minimum 600nsec. bcf EE_SCL endm ee_rcv_bit macro ; reçoit un bit de l'interface i2c ; en sortie le bit est dans le Carry ee_sda_dir SDA_INP bsf EE_SCL goto $+1 ; délais minimum 900nsec nop bcf STATUS, C btfsc EE_SDA bsf STATUS, C bcf EE_SCL goto $+1 ee_sda_dir SDA_OUT endm constant SDA_OUT=0 constant SDA_INP=1 ee_sda_dir macro dir banksel TRISA if dir==SDA_OUT bcf TRISA, SDA_P else bsf TRISA, SDA_P endif banksel PORTA endm case macro val, target ; si W==val goto target ; remet W à la valeur initiale pour le case suivant xorlw val skpnz goto target xorlw val endm ;;;;;;;;; variables ;;;;;;;;;;;;;;;;;;;;;;;;;; udata io_buffer res BUFF_SIZE ; buffer données RS-232 et I2C udata_shr flags res 1 ; indicateurs booléens ee_adr_start res 2 ; début d'adresse pour l'écriture uart_buffer_ptr res 1 ; pointeur buffer uart uart_bytes_cntr res 1 ; compteur pour les octets à recevoir par UART ;;;;;;;;; segment de code ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; code rst_vector org 0 goto init ;;;;;;;;;;; routine de service des interruptions ;;;;;;;;;;;;;;; isr_vector org 4 banksel PIE1 btfss PIE1, RCIE retfie banksel PIR1 btfss PIR1, RCIF retfie ; interruption sur réception uart btfss flags, F_UIDLE goto test_rdy banksel RCREG movfw RCREG xorlw ENQ skpz goto isr_exit movlw ACK movwf TXREG bcf flags, F_UIDLE bsf flags, F_URDY goto isr_exit test_rdy btfss flags, F_URDY goto receive_byte movlw low io_buffer movwf uart_buffer_ptr movwf FSR1L banksel RCREG movfw RCREG movwf uart_bytes_cntr movwf INDF1 incf uart_buffer_ptr, F bcf flags, F_URDY bsf flags, F_UPEND goto isr_exit receive_byte btfss flags, F_UPEND goto bad_sync clrf FSR1H movfw uart_buffer_ptr movwf FSR1L banksel RCREG movfw RCREG movwf INDF1 incf uart_buffer_ptr, F decfsz uart_bytes_cntr,F goto isr_exit bcf flags, F_UPEND bsf flags, F_RCVD goto isr_exit bad_sync movlw low io_buffer movwf FSR1L movlw NAK movwf INDF1 movlw ERR_SYNC movwi 1[FSR1] movlw 2 pushw call uart_send_buffer ee_stop clrf flags bsf flags, F_UIDLE bsf flags, F_BLOCK isr_exit banksel PIR1 bcf PIR1, RCIF retfie ee_send_byte ; envoie un octet sur le bus i2c ; start condition préalablement activée. ; entrée: (octet -- ) ; sortie: Carry=0 ok, Carry=1 erreur movlw 8 xchg pushw ; (octet, cntr -- ) ee_send_byte02 rlf STKP, F ee_send_bit decarg 1 skpz goto ee_send_byte02 drop 2 ee_rcv_bit ; receive ack return ee_send_buffer ;envoie une série d'octets vers l'eeprom ;ee_set_address déjà appellé. ;start contidion préalablement activée ;commande EE_CTL_WR déjà envoyée. ;entrée: (compte -- ) ; compte nombre d'octets à envoyer. ; FSR1 pointe sur le début du buffer ;sortie: Carry bit, 0=succès, 1=échec movfw INDF1 pushw call ee_send_byte skpc goto ee_send_buffer04 ee_stop drop 1 return ee_send_buffer04 addfsr FSR1, 1 decfsz STKP, F goto ee_send_buffer drop 1 return ee_rcv_byte ; reception d'un octet de l'eeprom ; start condition préalablement établie ; commande EE_CTL_RD préalablement envoyée ; entrée: aucun argument ; sortie: octet dans W ee_sda_dir SDA_INP movlw 8 pushw clrw pushw ; (octet_reçu, compteur -- ) ee_rcv_byte02 bsf EE_SCL goto $+1 nop bcf STATUS, C btfsc EE_SDA bsf STATUS, C rlf STKP, F bcf EE_SCL decarg 1 skpz goto ee_rcv_byte02 ee_sda_dir SDA_OUT bcf STATUS, C ee_send_bit ; send ACK popw drop 1 return ; ee_rcv_byte ee_read_bytes ; lit un certain nombres d'octet de l'eeprom ; préalable: ; ee_set_address déjà appellé ; commande EE_CTL_RD déjà envoyée. ; FSR1 pointe au début du buffer ;entrée (compte -- ) ; compte nombre d'octets à lire ;sortie: Carry -> 0=succès, 1=erreur call ee_rcv_byte skpc goto ee_read_bytes02 ee_stop drop 1 return ee_read_bytes02 movwf INDF1 addfsr FSR1, 1 decfsz STKP, F goto ee_read_bytes drop 1 return ee_set_address ; initialise le registre d'adresse de l'eeprom ; entrée: ( high_byte, low_byte -- ) ; sortie: état opération dans Carry: 0=succès, 1=erreur ; s'il n'y a pas d'erreur l'eeprom est prêt à recevoir des données. ee_write_cmd skpc goto ee_send_high_byte drop 2 goto ee_nack_error ; no ack received ee_send_high_byte call ee_send_byte skpc goto ee_send_low_byte drop 1 goto ee_nack_error ; no ack received ee_send_low_byte call ee_send_byte skpc return ; ack received ee_nack_error ee_stop return ; ee_set_address ee_end_read ; termine une série de lecture ; comme ee_rcv_byte termine toujours par un ACK ; il faut terminer la transaction en lisant un dernier octet ; suivit d'un stop movlw 8 pushw ee_end_read02 ee_rcv_bit decfsz STKP, F goto ee_end_read02 ee_stop drop 1 bcf flags, F_EERD return ee_wait_ready ; attend que l'eeprom est terminé son cycle d'écriture ee_write_cmd skpnc goto ee_wait_ready ee_stop return clear_buffer ; met à zéro tous les octets du buffer ; entrée (compte -- ) ; FSR1 pointe au début du buffer clrf INDF1 addfsr FSR1, 1 decfsz STKP, F goto clear_buffer drop 1 return uart_send_buffer ; envoie le contenu bu buffer au PC ; entrée ( compte -- ) ; FSR pointe au début du buffer ; sortie ( -- ), BSR préservé. movfw BSR xchg pushw ; (compte bsr -- ) banksel TXREG uart_send_buffer02 movfw INDF1 movwf TXREG btfss TXSTA, TRMT goto $-1 addfsr FSR1, 1 decfsz STKP, F goto uart_send_buffer02 drop 1 popw movwf BSR ; restore BSR return compute_checksum ; calcule la somme de contrôle des octets dans io_buffer ; entrée: le premier octet du buffer indique le nombre d'octets dans le buffer ; sortie: FSR1 pointe au début du buffer ; le compte du nombre d'octets a été incrémenté de 1 pour inclure le checksum movlw low io_buffer movwf FSR1L incf INDF1,F ; 1 octet de plus pour include la somme de controle movfw INDF1 pushw ; nombre d'octets dans buffer compute_cs_loop addfsr FSR1, 1 decfsz STKP, F goto $+2 goto compute_cs_exit addwf INDF1, W goto compute_cs_loop compute_cs_exit comf WREG incf WREG ; comlément de 2 movwf INDF1 movlw low io_buffer movwf FSR1L drop 1 return checksum_control ; vérifie si le checksum du message est valide ; sortie: si checksum correcte W=0 clrf FSR1H movlw low io_buffer movwf FSR1L movfw INDF1 pushw ; nombre d'octets reçu incf STKP,F cs_loop addfsr FSR1, 1 decfsz STKP, F goto $+2 goto cs_exit addwf INDF1, W goto cs_loop cs_exit drop 1 return process_msg ; traite le message reçu du PC bcf flags, F_RCVD call checksum_control xorlw 0 skpz goto checksum_error movlw low io_buffer movwf FSR1L moviw 1[FSR1]; id du message case PQT_WRITE, begin_eeprom_write case PQT_DATA, data_msg case PQT_FLASH, flash_msg case PQT_READ, begin_eeprom_read case PQT_RDN, read_next_bytes case PQT_VER, version_msg case PQT_SETB, setblock_msg case PQT_CLRB, clearblock_msg case PQT_EOT, eot_msg unknown_command movlw ERR_CMD pushw movlw NAK pushw goto send_answer checksum_error movlw ERR_CS pushw movlw NAK pushw goto send_answer eeprom_comm_error ee_stop bcf flags, F_EEWR bcf flags, F_EERD movlw ERR_EE pushw movlw NAK pushw goto send_answer send_ack movlw ERR_NONE pushw movlw ACK pushw send_answer ; (ack/nak err_code --) clrf FSR1H movlw low io_buffer movwf FSR1L popw movwf INDF1 popw movwi 1[FSR1] movlw 2 pushw call uart_send_buffer ;(compte -- ) bsf flags, F_URDY return begin_eeprom_write ; 4 octets: cmd, adresse, checksum moviw 2[FSR1] ; low adresse pushw moviw 3[FSR1] ; high adresse pushw call ee_set_address skpnc goto eeprom_comm_error bsf flags, F_EEWR goto send_ack data_msg ; 3-18 octets: cmd, data, checksum btfsc flags, F_EEWR goto data_msg02 data_msg01 movlw ERR_SYNC pushw movlw NAK pushw goto send_answer data_msg02 movlw 2 subwf INDF1, W pushw addfsr FSR1, 2 call ee_send_buffer ; (compte -- ) skpnc goto eeprom_comm_error goto send_ack flash_msg ; 2 octets cmd, checksum btfss flags, F_EEWR goto data_msg01 ee_wr_enable ee_stop call ee_wait_ready ee_wr_disable bcf flags, F_EEWR goto send_ack begin_eeprom_read ; 4 octets: cmd, adresse, checksum moviw 2[FSR1] pushw moviw 3[FSR1] pushw call ee_set_address skpnc goto eeprom_comm_error ee_read_cmd skpnc goto eeprom_comm_error bsf flags, F_EERD goto send_ack read_next_bytes ; 2 octets: cmd, nombre, checksum moviw 2[FSR1] ; nombre d'octets à lire dans l'eeprom movwf INDF1 addfsr FSR1, 1 pushw call ee_read_bytes skpnc goto eeprom_comm_error call compute_checksum incf INDF1, W pushw call uart_send_buffer bsf flags, F_URDY return version_msg ; 2 octets cmd, checksum movlw ACK movwf INDF1 movlw FIRMWARE_VERSION movwi 1[FSR1] movlw 2 pushw call uart_send_buffer bsf flags, F_URDY return setblock_msg ; 2 octets: cmd, checksum bsf flags, F_BLOCK goto send_ack clearblock_msg ; 2 octets: cmd, checksum bcf flags, F_BLOCK goto send_ack eot_msg ; 2 octets: cmd + checksum btfss flags, F_EERD goto eot_02 call ee_end_read goto eot_04 eot_02 ee_stop eot_04 clrf flags bsf flags, F_BLOCK bsf flags, F_UIDLE banksel TXREG movlw ACK movwf TXREG btfss TXSTA, TRMT goto $-1 clrf TXREG btfss TXSTA, TRMT goto $-1 return ;;;;;;;; initialisation MCU ;;;;;;;;;;;;;;;;;; init clear_ram ; et par la même occation initialise le stack pointer FSR0=0xC0 banksel ANSELA clrf ANSELA banksel WPUA bsf WPUA, RA3 ; weak pull sur broche reset set_clock_freq FOSC4 set_io_dir SCL_P, OUT set_io_dir SDA_P, OUT set_io_dir WP_P, OUT banksel PORTA ee_wr_disable ee_stop enable_uart_tx enable_uart_rx set_uart_baudrate FREQ_CLOCK, BAUDRATE bsf flags, F_UIDLE bsf flags, F_BLOCK enable_uart_rx_int enable_periph_int enable_interrupts call ee_wait_ready ;;;;;;;; routine principale ;;;;;;;;;;;;;;;;;; main btfss flags, F_RCVD goto main call process_msg goto main end

programme hôte

Comme je l'ai mentionné en introduction j'ai écris le programme en python. Je ne l'ai pas testé sous Linux mais en principe il devrait fonctionner sans modification. Il s'agit d'une application ligne de commande mais l'utilisation est simple.
i2cprog.py port_série mode fichier nombres_octets [-l opp] [-f32]
port_série est le nom du port utilisé pour la communication avec le programmateur.
Sous windows c'est quelque chose comme com3 alors que sous linux ça ressemble à /dev/ttyS0 ou encore /dev/ttyUSB0.
mode est p pour programmer l'eeprom ou r pour lire le contenu de l'eepom.
fichier est le nom du fichier qui contient les données à programmer ou pour le mode r le fichier dans lequel les données seront enregistrées.
nombres_octets est le nombre d'octets à programmer ou lire.
-l opp n'est utilisé que pour la programmation et indique le nombre d'octets par page de l'eeprom. Ce paramètre est essentiel pour la programmation et se retrouve dans le datasheet de l'eeprom utilisée. Par exemple pour 24LC512 ce paramètre est 128.
-f32 n'est utilisé que pour la lecture et sert produire un fichier au format Intel HEX32 plutôt que d'enregistrer les données en binaire brute.
Notez qu'en mode programmation i2cprog.py reconnais les fichiers Intel HEX32 et peut donc en extraire les données pour la programmation. I2cprog.py reconnait aussi les fichiers audio *.WAV 8 et 16bits non compressés. Donc si le nom du fichier se termine par .wav i2cprog.py en extrait le nombre d'octets contenu dans le segment data et l'inscris au début (4 premier octets little indian) ensuite il inscris tous les echantillons dans l'eeprom. J'ai ajouté cette fonctionnalité car c'est exactement ce que j'ai besoin pour mon projet actuel qui sera plublié bientôt sur ce blog.

code source i2cprog.py
#NOM: i2cprog.py #DESCRIPTION: Ce programme est la partie hôte du programmeur eeprom-prog que j'ai créer dans le but de programmer des eeprom à interface # I2C des séries 24AAxxxx/24LCxxxx/24FCxxxxx de Microchip. Pour en savoir plus sur ces mémoires eeprom à interface sériel # visitez le site: http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2697 # Ce programme permet aussi de lire le contenu de ces mémoires et de le sauvegarder dans un fichier. # Le programmeur lui-même est un dispositif qui se branche sur un port série de l'ordinateur hôte et communique # avec en configuration 115200,8,N,1 (115200 baud, 8 bits, pas de parité, 1 stop bit). Aucun contrôle de flux matériel. # Le contrôle de flux se fait par le dialogue entre ce programme hôte et le firmware du programmeur. # #AUTEUR: Jacques Deschênes #DATE: 2012-12-28 import argparse import serial import time import wave import sys # NOTE: python ne permettant pas de définir des constantes # dans ce qui suis les variables en LETTRES_CAPITALE en tiennent lieu. ENQ=5 ACK=6 NAK=21 ERR_NONE=0 ERR_CS=1 ERR_COMM_EE=2 ERR_CMD=3 ERR_SYNC=4 ERR_FLASH=100 ERR_FWAR=101 ERR_UNKNOWN=-1 EE_WRITE=0 EE_DATA=1 EE_FLASH=2 EE_READ=3 EE_RDN=4 EE_VER=5 EE_SETB=6 EE_CLRB=7 EE_EOT=8 MAX_BYTES=64 # nombre maximum d'octet envoyés/reçus par transaction. ACCEPT_FIRMWARE=0x10 # version du firmware programmeur reconnue par cette application. class ProgError(Exception): #erreur programmeur def __init__(self, code, msg): self.err_code=code self.msg=msg Exception.__init__(self, 'erreur programmeur {0:d}, {1}'.format(code, msg)) def int2hex(i,width): # converti un entier en chaîne hexadécimale h='' while i>0: n=i%16 if n<10: h=chr(ord('0')+n) + h else: h=chr(ord('A')+n-10) + h; i=int(i/16) while len(h)<width: h = '0'+h return h #enddef int2hex def bytes_to_hex(bytes): # transforme une séquence d'octets en chaîne hexadécimale. s='' for i in range(len(bytes)): s+= int2hex(bytes[i],2) return s #enddef bytes_to_hex def int2chr(bytes): # converti une liste d'octets en chaîne de caractères hexadécimal s='' for i in range(len(bytes)): try: s+=chr(bytes[i]) except ValueError: quit() return s #enddef int2chr def check_prog_error(s): #contrôle la réponse du programmeur signale une exception si erreur if len(s)==2 and ord(s[0])==ACK: return True elif len(s)==2 and ord(s[0])==NAK: if ord(s[1])==ERR_CS: raise ProgError(ERR_CS,'Le programmeur signale une erreur somme de contrôle') elif ord(s[1])==ERR_COMM_EE: raise ProgError(ERR_COMM_EE,'le programmeur signale une erreur comminication i2c') elif ord(s[1])==ERR_CMD: raise ProgError(ERR_CMD,'Le programmeur n\'a pas reconnu la commande') elif ord(s[1])==ERR_SYNC: raise ProgError(ERR_SYNC,'le programmeur n\'est pas en phase avec l\'hote') else: raise ProgError(ERR_UNKNOWN,'Une erreur inconnue s\'est produite') else: raise ProgError(ERR_UNKNOWN,'Une erreur inconnue s\'est produite') #enddef check_prog_error def checksum(bytes): # calcule la somme de contrôle d'une sequence d'octets. cs=0 for i in range(len(bytes)): cs += bytes[i] cs = 0xFF & (~cs + 1) return cs #enddef checksum def send_to_eeprom(ser, data): #envoie le data à l'eeprom et attend la réponse if data[0]==EE_RDN: expect=data[1]+2 else: expect=2 l=len(data)+1 data = [l] + data cs=0 for i in range(len(data)): cs += data[i] cs = (~cs+1) & 0xFF data += [cs] ser.write(int2chr(data)) s=ser.read(expect) if len(s)>2: data=[] for i in range(len(s)): #conversion chaine en liste octets data+=[ord(s[i])] return data elif data[1]==EE_VER and len(s)==2 and ord(s[0])==ACK: return ord(s[1]) return check_prog_error(s) #enddef send_to_eeprom def enquery(ser): # initialise une transaction avec le programmeur ser.write(chr(ENQ)) c=ser.read(1) if not (len(c)==1 and ord(c[0])==ACK): raise ProgError(NAK, 'Pas de reponse du programmeur') fversion=send_to_eeprom(ser,[EE_VER]) if fversion==ACCEPT_FIRMWARE: print 'version firmware programmeur: {0:d}.{1:d}\n'.format(fversion>>4 & 0xF, fversion &0xF) return True else: raise ProgError(ERR_FWAR, 'La version firmware {0:d}.{1:d} du programmeur n\'est pas supporte'.format(fversion>>4 & 0xF, fversion &0xF)) #enddef enquery def send_eot(ser): #fermeture de la transaction avec le programmeur ser.write(chr(2)+chr(EE_EOT)+chr(0xF6)) s=ser.read(2) if len(s)==2 and ord(s[0])==ACK: return True else: print len(s) raise ProgError(ERR_COMM_EE,'Pas de reponse du programmeur au message EE_EOT') #enddef send_eot def read_wave_file(file_name): global byte_count try: wf=wave.open(file_name,'r') except IOError: print 'Echec ouverture du fichier', file_name return None params=wf.getparams() print 'file format:' print 'canaux:', params[0] print 'bits:',params[1]*8 print 'bits/sec.:', params[2] print 'nbre echantillons:', params[3] data=wf.readframes(min(byte_count,params[3])) if params[1]>2: print 'n\'accepte que les fichiers 8 ou 16 bits' return None bytes=[params[3]&0xFF,params[3]>>8 &0xFF, params[3]>>16 &0xFF, params[3]>>24 & 0xFF] for i in range(len(data)): bytes+=[ord(data[i])] print len(bytes), 'echantillons lus' wf.close() byte_count=min(byte_count,len(bytes)) return bytes #enddef read_wave_file def hex_to_int(hex): # conversion chaine hexadecimal en entier n=0 for i in range(len(hex)): if hex[i]>'9': n= n*16 + ord(hex[i])-ord('A')+10 else: n= n*16 + ord(hex[i])-ord('0') return n #enddef hex_to_int def parse_line(line): # extrait les données du texte hexadécimal bytes=[] if line[0]!=':': return None # erreur format ligne i=1 while i<len(line)-1: bytes += [hex_to_int(line[i:i+2])] i+=2 if checksum_ok(bytes): return bytes else: return None #enddef parse_line def read_hex_file(file_name): global start_address, byte_count try: hf=open(file_name,'r') except IOError: print 'Echec ouverture du fichier', file_name return None data=[] done=False state=0 while not done: line=hf.readline() if len(line)>0: bytes=parse_line(line) if bytes: addr=bytes[1]+bytes[2]*256 rtype=bytes[3] if state==0: if rtype==4: high_address=bytes[4]+bytes[5]*256 state=1 else: done=True #erreur format fichier hex elif state==1: if rtype==1: done=True elif rtype==0: start_address=addr + high_address<<16 state==2 data += bytes[4:-1] else: done=True # erreur format fihcier hex elif state==2: if rtype==1: done=True elif rtype==0: data += bytes[4:-1] elif rtype==4: continue else: done=True if len(data)>=byte_count: done=True else: done=True else: done=True hf.close() if len(data)>byte_count: data=data[:byte_count] print 'Nombre d\'octets lus:', len(data) return data #enddef read_hex_file def init_eeprom_write(ser,address): global byte_count high_address=0xFFFF & address>>16 low_address=0xFFFF & address if byte_count>65536: if high_address>0: send_to_eeprom(ser,[EE_SETB]) else: send_to_eeprom(ser,[EE_CLRB]) if not (len(c)==2 and c[0]==ACK): ok=False send_to_eeprom(ser,[EE_WRITE,low_address&0xFF,low_address>>8 & 0xFF]) return #enddef init_eeprom_write def program_eeprom(): global byte_count, file_name ok=True file_name=file_name.lower() if file_name[-4:]=='.wav': data=read_wave_file(file_name) if data==None: ok=False elif file_name[-4:]=='.hex': data=read_hex_file(file_name) if data==None: ok=False else: try: fi=open(file_name,"rb") except IOError: print 'echec ouverture du fichier:', file_name ok = False raw=fi.read(byte_count) fi.close() data=[] for i in range(len(raw)): data+= [ord(raw[i])] if ok: if len(data)!=byte_count: print len(data), 'octets lus dans le fichier' else: print 'Echec lors de la lecture du fichier', file_name if not ok: return i=0 address=start_address init_eeprom_write(ser,address) count=0 chunk_size=min(row_size,MAX_BYTES) while i<len(data): count=min(chunk_size,len(data)-i) bytes=[EE_DATA]+data[i:i+count] send_to_eeprom(ser,bytes) i+=count address+=count if i%row_size==0: sys.stdout.write('*') send_to_eeprom(ser,[EE_FLASH]) init_eeprom_write(ser,address) if i+count%row_size!=0: send_to_eeprom(ser,[EE_FLASH]) print '\nverification programmation:' ee_data=read_eeprom() print '\nlecture completee, nombre d\'octets lus: {0:d}'.format(len(ee_data)) for i in range(len(data)): if ee_data[i]!=data[i]: raise ProgError(ERR_FLASH,'Erreur verification eeprom, offset {0:d}'.format(i)) return #enddef program_eeprom def checksum_ok(s): cs=0 for i in range(len(s)): cs+=s[i] cs = 0xFF & cs if cs==0: return True else: return False #enddef checksum_ok def write_hex32(data): #génère un fichier Intel HEX32 little indian try: fo=open(file_name,"wb") except IOError: print 'echec creation du fichier', file_name return fo.write(':') high_address=start_address>>16 & 0xFFFF low_address=start_address & 0xFFFF bytes=[2,0,0,4,high_address&0xFF,high_address>>8 &0xFF] cs=checksum(bytes) bytes += [cs] fo.write(bytes_to_hex(bytes)+'\n') # les 16 bits les plus fort de l'adresse i=0 while i<len(data): count=min(16,len(data)-i) bytes=[int(count),low_address&0xFF,low_address>>8 & 0xFF,0] for j in range(i,i+count): bytes+=[data[j]] fo.write(':') cs=checksum(bytes) bytes += [cs] fo.write(bytes_to_hex(bytes)+'\n') i+=count low_address += count if low_address>65535: fo.write(':') high_address += 1 low_address &= 0xFFFF bytes=[2,0,0,4,high_address&0xFF,high_address>>8 &0xFF] cs=checksum(bytes) bytes += [cs] fo.write(bytes_to_hex(bytes)+'\n') # les 16 bits les plus fort de l'adresse fo.write(':00000001FF') fo.close() return #enddef write_hex32 def init_eeprom_read(ser,address): high_address = address>>16 & 0xFFFF low_address = address & 0xFFFF if byte_count>65536: if high_address>0: send_to_eeprom(ser,[EE_SETB]) else: send_to_eeprom(ser,[EE_CLRB]) return send_to_eeprom(ser,[EE_READ,low_address&0xFF,low_address>>8 & 0xFF]) #enddef init_eeprom_read def read_eeprom(): print 'debute la lecture eeprom\n' data=[] i=0 address=start_address block=0 if address>65535: block=1 #eeprom > 64KB init_eeprom_read(ser,address) ok=True while ok and i<byte_count: count=min(MAX_BYTES,byte_count-i) if block==0 and address+count>65536: count=65536-address if i%128==0: sys.stdout.write('.') c=send_to_eeprom(ser,[EE_RDN,count]) if len(c)==count+2 and checksum_ok(c): data += c[1:-1] else: ok=False break i+=count address+=count if block==0 and i<byte_count and address>65535: block=1 address=0 send_eot(ser) enquery(ser) init_eeprom_read(address+0x10000) send_eot(ser) return data #enddef read_eeprom def read_arguments(): global device, op_mode, out_format, file_name global byte_count, row_size, start_address parser=argparse.ArgumentParser(description='programme hôte pour la programmation des eeproms i2c de Microchip, à l''aide du prorammmeur i2cprog', usage=""" i2cprog.py com_port p|r file size [-l page_size] [-s start_address] -i32 <com_port> Est le nom du port serie. <p> Invoque le mode programmation. <r> Invoque le mode lecture. <file> En mode programmation c'est le nom du fichier contenant les octets a programmer. Le programme reconnait les extensions: .HEX et.WAV Un fichier se terminant par .HEX doit-etre un fichier au format intel HEX32. Un fichier se terminant par .WAV est considere comme un fichier Microsoft RIFF avec enregistrement WAVE non compresse. Dans ce cas toutes les donnees suivant le mot clef 'data' qui se trouve dans l'entête du fichier sont envoyes a l'eeprom incluant le compte des octets qui est un entier non signe de 32 bits suivant le mot clef 'data'. Si le fichier contient plus d'octets que <size> les octets supplémentaires sont ignores. Les autres fichiers sont lu sans interprétation et les donnees envoyees au programmeur sans alteration. En mode lecture c'est le nom du fichier dans lequel seront enregistrees les donnees. <size> Est le nombre d'octets a lire ou programmer. Le suffixe K peut-êre utilisé pour Kilo (1024). <-l page_size> Ce parametre est inutile pour la lecture mais indispensable pour la programmation. Le 'page size' ou encore 'row size' est specifie dans le datasheet du composant. <-s start_adresse> est optionel et determine a quelle adresse la programmation va debutee. Par defaut elle commence a zero. <-f 32> Par defaut les donnees lues sont sauvegardees dans un format binaire (RAW) mais cette option permet de les sauvegarder au format intel HEX32 lisible dans un editeur de texte. exemple 1: Programmation d'une eeprom 24LC512 qui contient 64KB avec un page_size de 128 i2cprog.py com3 p data.raw 64K -l 128 exemple 2: Lecture d'une eeprom 24FC256 qui contient 32KB. Le contenu est envoye dans eeprom.raw i2cprog.py com3 r eeprom.raw 32K """) parser.add_argument('com_port', help='nom du port serie') parser.add_argument('mode', help='mode programmation/lecture') parser.add_argument('file_name',help='nom du fichier lu/ecris.') parser.add_argument('bytes',help='Nombre d\'octets lus/ecris.') parser.add_argument('-l', help='octets par page') parser.add_argument('-s',help='adresse debut') parser.add_argument('-f',help='format de sortie intel hex32') arguments=parser.parse_args() device=arguments.com_port # port série utilisé par le programmeur op_mode=arguments.mode #programmation 'p' ou lecture 'r' #nombre d'octets à lire ou écrire. if arguments.bytes[-1:]=='K' or arguments.bytes[-1:]=='k': byte_count=1024*int(arguments.bytes[:-1]) else: byte_count=int(arguments.bytes) if op_mode=='p' and arguments.l==None: print 'en mode programmation l''argument <-l> est obligatoire' quit() else: if arguments.l: row_size=int(arguments.l) if row_size==0: print 'parametre <-l> incorrect.' quit() file_name=arguments.file_name out_format=arguments.f if arguments.s: start_address=int(arguments.s) return #enddef read_arguments # ************** main ************************* op_mode=None file_name=None out_format=None start_address=0 row_size=-1 byte_count=0 device=None read_arguments() print 'port serie:', device, 'BAUDRATE: 115200, 8 bits, pas de parite, 1 stop\n' if op_mode=='p': print 'programmation eeprom' print 'fichier source: ' , file_name print 'nombre d\'octets a lire: ', byte_count print 'octets par page: ', row_size else: print 'lecture eeprom' print 'fichier en sortie:', file_name print 'Nombre d\'octets a lire: ', byte_count if out_format==None: print 'format du fichier: binaire' else: print 'format du fichier: Intel HEX32' print 'adresse de debut: ' , start_address print '\nouverture du port' try: ser=serial.Serial(device,115200,timeout=2) except IOError: print 'echec ouverture du port serie' quit() try: enquery(ser) except ProgError, exc: print exc.msg ser.close() quit() if op_mode=='p': try: program_eeprom() except ProgError, exc: print 'une erreur c\'est produite lors de la programmation\ncode={0:d}, {1}'.format(exc.err_code, exc.msg) else: try: data=read_eeprom() if out_format==None: fo=open(file_name,"wb") for i in range(len(data)): fo.write(chr(data[i])) fo.close() else: #out_format==Intel 32HEX write_hex32(data) print '\n', len(data), 'octets lus\n' except ProgError, exc: print 'une erreur c\'est produite lors de la lecture\ncode={0:d}, {1}'.format(exc.err_code, exc.msg) ser.close() #endof i2cprog.py

tous les fichiers du projet sont disponibles ici.