Proyecto Copiadora autónoma de memorias I2C (En Francés)

Sección dedicada a imágenes de circuitos, diagramas que no requieren explicación previa, Proyectos sencillos.

Area para desarrollo de proyectos, colaboración de toda la comunidad en proyectos. Solución de dudas y aportes.

No publicar manuales, no publicar temas ajenos a los proyectos. de ser necesario, hacer indicación con enlace entre etiquetas CODE
Avatar de Usuario
Enigma
Administrador del Sitio
Administrador del Sitio
Usuario Especial
Usuario Especial
Mensajes: 1029
Registrado: Octubre 20, 2013, 4:26 pm
Es: Mujer
Profesion: Webmaster CEO SEO
Ubicacion: Matrix
Navegador: Chrome

Proyecto Copiadora autónoma de memorias I2C (En Francés)

Mensaje por Enigma » Febrero 16, 2016, 3:26 pm

Copieur autonome de mémoires I2C

Proyecto Copiadora autónoma de memorias I2C (En Francés)

Imagen

Description :

Sur ce site, sont proposés deux programmateurs pour les mémoires I2C de la série 24Cxx, l'un se connectant sur le port série, l'autre prévu pour le port parallèle. Ces deux dispositifs nécessitent d'avoir sous la main un PC, ce qui n'est pas toujours le cas, par exemple dans un atelier de dépannage TV (ou autres) ; dans ce cas de figure, la fonction recherchée consiste plutôt à pouvoir dupliquer le contenu d'une eeprom référence dans une mémoire vierge en vue d'un échange standard ; il suffira alors de se constituer une petite 'bibliothèque' de mémoires servant de modèles, et adaptées aux différents cas de figures rencontrés. Le montage présenté sur cette page permet d'effectuer cette duplication de manière totalement autonome, c'est-à-dire sans PC et avec une alimentation constituée d'une simple pile 9V. Il est conçu pour les 24C01, 24C02, 24C04, 24C08 et 24C16 (ou toute référence compatible, telle que la 24C164, etc.). Les mémoires I2C étendues (24C32 à 512) ne sont pour l'instant pas prises en charge.

se du schéma :
Imagen

Comme vous pouvez le constater, l'ensemble est d'une grande simplicité ; le coeur du système est le microcontrôleur PIC16F84 bien connu, largement disponible à un prix raisonnable, et programmable avec des moyens 'rustiques' ; le recours à ce type de composant programmable s'impose comme une évidence compte tenu de la (relative) complexité du protocole I2C utilisé par les EEPROMs 24Cxx.

La pile 9V, associée à un classique régulateur 7805, fournit le +5v nécessaire aux alimentations du PIC et des mémoires ; la diode protège des inversions de polarité ; le PIC est, comme presque toujours, accompagné de son circuit d'horloge (quartz 4 MHz et condensateurs 15 pF), et de RESET (touche + 22k + 2,2µF, ces valeurs étant peu critiques). On trouve également trois leds (rouge, verte et jaune) indiquant l'état des opérations, ainsi que cinq touches pour lancer le cycle tout en indiquant au montage le modèle de mémoires présentes. Les résistances de 330 ohms limitent le courant dans les leds à un peu moins d'une dizaine de mA. Les résistances de 10 k ohms sont des résistances de tirage, servant à assurer un niveau logique "1" lorsque la touche sur l'entrée considérée est relachée (ou l'inter non passant, dans le cas de RA3). Bas de page (retour)

Les mémoires I2C partagent une ligne SDA commune, qui est la broche RA4 : cette sortie est du type "à collecteur ouvert", ce qui convient bien à la structure du bus I2C, contrairement aux autres sorties du PIC (RB0 à RB7 et RA0 à RA3) qui sont des sorties TTL. La résistance de tirage sur RA4 est donc absolument indispensable, contrairement à celles présentes sur RA0 et RA2 commandant les entrées SCL des mémoires ; je les ai mises afin de fixer les états des broches SCL lors du RESET, les sorties du PIC étant alors en haute impédance.

Je ne reprendrai pas ici la description du bus I2C et des échanges avec les mémoires 24Cxx : le visiteur intéressé se reportera à la rubrique "Protocole I2C" du programmateur I2C pour port parallèle, présenté sur ce même site.

Circuit imprimé
Imagen

Ceux d'entre-vous qui possèdent le logiciel ARES Lite (ou même la version de démo disponible sur le web ?) pourront directement charger le fichier "COP-Ares.LYT" fourni et l'imprimer sur papier à l'échelle 1. Pour les autres, pas de problème : le dessin du circuit est également fourni ci-dessus au format GIF, avec une résolution de 600 DPI ; vous pourrez donc l'imprimer, par exemple avec Paint Shop Pro V3.11, en indiquant les dimensions : 7,20 cm x 5,93 cm (ou 2,83 pouces x 2,33 pouces). Avec les marges, une plaque de 6 cm x 7 cm suffit.

Il reste alors à réaliser une photocopie de bonne qualité (laser) sur un transparent. Une alternative consiste à rendre la feuille de papier transparente aux UV en vaporisant un produit comme le "Diaphane", de KF : j'ai utilisé cette méthode avec satisfaction, mais il est préférable de prolonger un peu l'insolation aux UV (dans mon cas, 5 mn au lieu de 3). Pour terminer, gravez, puis percez, selon votre méthode habituelle.

Liste des composants : Bas de page (retour)

3 résistances de 330 ohms.
9 résistances de 10 k ohms.
1 résistance de 22 k ohms.
2 condensateurs de 15 pF (céramique).
1 condensateur de 2,2 µF (tantale).
1 condensateur de 10 µF (électrolytique, radial).
1 diode 1N4001.
2 supports 'tulipe' 8 broches (2 x 4).
1 support 'tulipe' 18 broches (2 x 9).
1 quartz 4 MHz.
1 PIC 16F84 (ou 16F84A, ou 16C84).
1 régulateur 7805.
6 touches (voir description).
1 led rouge, diamètre 5 mm.
1 led verte, diamètre 5 mm.
1 led jaune, diamètre 5 mm.
1 double bornier à vis
1 triple bornier à vis
1 clip pour pile 9v.
1 pile 9v.
divers : soudure, époxy, perchlo, mèches, etc.
en option :
- 2 inters à bascule (pile et Mode),
- un bouton poussoir (RESET externe).

Remarques :
Utilisez impérativement des supports 'tulipe', en particulier pour les mémoires I2C, car ils seront appelés à supporter de nombreux retraits et insertions.

Un mot concernant les touches : ce modèle de touche (carrée, de 6 mm de côté) est assez courant, on le trouve dans les souris d'ordinateurs, en façade de magnétoscopes, lecteurs de CD et autres appareils audio ou vidéo en tous genres :

Imagen

Imagen

Comme le montrent le schéma et les photos ci-dessus, les touches possèdent quatre connexions, mais qui sont en fait reliées deux à deux de manière interne : ce sont les extrémités de deux bandes parallèles (bandes mises en contact lors de l'appui sur la touche) ; dans le doute, contrôlez le contact à l'ohmmètre. Cette structure permet de réaliser facilement des claviers matricés, sans avoir à ajouter de strap pour faire se croiser les lignes et les colonnes. Vous pouvez choisir un modèle de touche différent pour la touche RESET, ou vous abstenir de la câbler si vous préférez utiliser un bouton poussoir externe (relié au bornier triple).

Implantation des composants :
Câblage :

Imagen

Commencez par souder les résistances et le strap (constitué d'une patte de résistance), puis la diode, puis les six touches, puis les trois supports de CI, les condensateurs 'céramique', chimiques, les leds, le quartz, et enfin les borniers. Connectez le clip de pile 9v au bornier double, avec éventuellement un interrupteur en série.

Imagen

Si vous n'utilisez ni le poussoir RESET externe, ni l'interrupteur "Mode" (voir Mise en service), il n'est pas vraiment nécessaire de souder le bornier triple.

Comme vous le constatez sur la photo ci-dessus, il reste un peu de place sous les touches pour coller des étiquettes indiquant le type de mémoire auquel est associée chaque touche ; de gauche à droite : 24C01, 24C02, 24C04, 24C08 et 24C16. La touche RESET (blanche, à côté du régulateur) permet de se remettre en attente d'un cycle de programmation.

Programmation du PIC :

Personnellement, j'utilise le programmateur JDM ; sa structure est simple, et il tire son alimentation directement du port série auquel il est connecté.

Le programme :

Vous pouvez indifféremment utiliser un PIC16C84, un PIC16F84, ou un PIC16F84A, à condition de l'indiquer à PicCheap. Voici le fichier Cop10.HEX (version 1.0) à programmer dans le PIC. Exceptionnellement, j'ai décidé de fournir le fichier 'source' du programme si vous souhaitez y apporter des modifications ; téléchargez pour cela l'archive ASM-PIC.ZIP (80 ko) ; elle contient les quatre fichiers suivants :
COP10.ASM : le fichier source, éventuellement à éditer.
MPASM.EXE : l'assembleur fourni gracieusement par Microchip.
P16F84.INC : le fichier inclus contenant les définitions des registres du PIC16F84.
ASM.BAT : le fichier à lancer, qui appelle l'assembleur avec les bonnes options.
Lorsque vous lancez le fichier ASM.BAT, l'assemblage se produit, et génère quatre nouveaux fichiers :
COP10.COD, qui n'a pas d'intérêt pour nous.
COP10.ERR : la liste des erreurs rencontrées à la compilation ; il est vide (0 octet) si tout s'est bien déroulé.
COP10.HEX : le fichier au format Intel / Hexa contenant les codes 'machine' à charger dans le PIC grâce à PicCheap.
COP10.LST : le listing contenant toutes les informations obtenues à la compilation (programme source, codes 'machine', messages et nombre d'erreurs, etc.).

Mise en service :
Utilisation :


La pile est branchée, les mémoires ayant été insérées sur les supports 8 broches (l'original du côté du bornier triple, et la mémoire vierge du côté du quartz).
À la mise sous tension, les deux leds rouge et verte clignotent alternativement, pour indiquer que le montage est prêt à effectuer une copie.

Appuyez sur la touche correspondant au type de mémoires présentes :
[24C01], [24C02], [24C04], [24C08] ou [24C16]

Le cycle est lancé : les leds rouge et verte s'éteignent ; la led jaune se met à clignoter.

Si tout se passe normalement, la led jaune va clignoter :
1 fois dans le cas d'une 24C01.
2 fois dans le cas d'une 24C02.
4 fois dans le cas d'une 24C04.
8 fois dans le cas d'une 24C08.
16 fois dans le cas d'une 24C16.

Puis la programmation s'achève et la led verte s'allume pour indiquer que tout est terminé, et qu'aucune erreur n'a été détectée (leds jaune et rouge éteintes).

Si un problème survient (mémoire absente, erreur d'écriture...), la programmation s'interrompt aussitôt, et la led rouge s'allume (leds jaune et verte éteintes).

Lorsque tout est terminé, que la programmation ait réussi ou non, il suffit d'appuyer sur la touche RESET (Remise à zéro) pour repasser en mode 'Attente' (clignotement rouge / vert) ; on peut alors lancer une autre programmation en appuyant sur l'une des cinq touches.

L'appui sur la touche RESET en cours de programmation abrège l'opération. La copie n'est alors que partielle, il faudra par conséquent relancer la duplication.

Bas de page (retour)
La programmation dure environ :


1 seconde dans le cas d'une 24C01,
2 secondes dans le cas d'une 24C02,
4 secondes dans le cas d'une 24C04,
8 secondes dans le cas d'une 24C08,
16 secondes dans le cas d'une 24C16.

Cette durée peut paraître longue, notamment à ceux qui utilisent le programmateur pour PC (sur port série ou parallèle) dont l'action est presque instantanée, mais l'algorithme a été renforcé de manière à détecter pour ainsi dire à coup sûr (presque) toute erreur ; la fiabilité est à ce prix...
L'interrupteur 'Mode', lorsqu'il est passant, permet d'éviter une phase de vérification et de réduire ainsi la durée de la programmation d'environ un tiers (ainsi, pour une 24C16, elle passe à environ 11 secondes). Mais il est dommage de limiter de la sorte la fiabilité du système, et je n'exclus pas d'attribuer à l'interrupteur une autre fonction, dans une version ultérieure du système.

cop10.hex

Código: Seleccionar todo

:020000001728BF
:020008000900ED
:04000C0043346F34D6
:100010007034693465347534723420346434653432
:100020002034323434344334783478340034831612
:10003000083085001F308600FF3081008312FF30BA
:10004000850086008D0197018320970A971D2B2834
:10005000061786122D280613861606091F399600E4
:100060009301940110301606031D382893154F286C
:1000700008301606031D3E2813154F2804301606B7
:10008000031D442893144F2802301606031D4A28E6
:1000900013144F2801301606031D242894178617C1
:1000A00006178616851D0D158F019001101F8613EA
:1000B000101B8617051E8028051D8028051C80281A
:1000C000142197200E0895000D1C80281621A320CE
:1000D0000D1C80280D19732897200D1C80281508E9
:1000E0000E06031D8028900A03198F0A14081006B3
:1000F000031D562813080F06031D56288612812853
:10010000061386178228193091008828FA3091004A
:10011000C830920000000000000000000000000055
:1001200000000000920B8A28910B88280800B2205A
:10013000BE200F0D0E39A138CF20F120E0208E0017
:100140000321C7200800B2200E08CF20F120C720CD
:100150000D1CB128BE20A030CF20F120C7200D1CDF
:10016000AA280800BE200F0D0E39A038CF20F1209C
:100170000D1CBD281008CF20F12008000A2105160B
:100180001821051218210F211821051608000F212A
:10019000051218210A2118210516182108009100BE
:1001A000083092000F21911F0512911B051618218E
:1001B0000A2118210F21910D920BD2280516080053
:1001C0000830920091010F21051618210A211821EB
:1001D000910D1110051A1114920BE3280F2111082B
:1001E000080005160F2118210A2118210D10051EDF
:1001F0000D140F2108000F21051218210A211821C2
:100200000F21051608000F21051618210A211821B3
:100210000F2108008D1C05158D18051408008D1C74
:1002200005118D18051008008D1008008D140800A8
:0402300000000800C2
:084000000200000000000000B6
:02400E00F13F80
:10420000280063002900200050006900650072004A
:1042100072006500200043004F004C002C0020007D
:104220006D00610072007300200032003000300029
:1042300031002C0020005600200031002E003000FC
:10424000530069007400650020007700650062007B
:104250003A00200068007400740070003A002F00DB
:104260002F007700770077002E0063006F006C004E
:1042700032003000300030002E006F007200670006
:00000001FF
cop10.asm

Código: Seleccionar todo

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                      ;;
;;               Copieur autonome de memoires I2C                       ;;
;;            'cop10.ASM' : (c) Pierre COL, mars 2001.                  ;;
;;                                                                      ;;
;;       Programme du PIC16C84, 16F84 ou 16F84A avec quartz 4 MHz       ;;
;;                                                                      ;;
;; - v03 : 1ere modification avec RA4.                                  ;;
;; - v04 : 2eme modification avec un SDA entierement commun sur RA4.    ;;
;; - v05 : un seul jeu d'instructions + aiguillage avec bit CANAL.      ;;
;; - v06 : copie la 24C16 'reference' vers la 24C16 'copie'.            ;;
;; - v07 : + verification de la programmation.                          ;;
;; - v08 : + verification absence court circuit entrees a la masse.     ;;
;; - v09 : clignotement led jaune pour patienter pendant programmation. ;;
;; - v10 : inversion des touches + suppression verif si inter passant.  ;;
;;                                                                      ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;**********************************************************************;

;;;; Definition et parametres (utiles a l'assembleur) : ;;;;

              LIST P=16F84, R=DEC

#include      "P16F84.INC"

              __CONFIG  _CP_OFF & _PWRTE_ON & _WDT_OFF & _XT_OSC
              __IDLOCS  2000h

;**********************************************************************;

;;;; Etiquettes : ;;;;

;;; Adresses programme :
DEBUT         equ       000h ; Debut de la memoire physique.
INT           equ       004h ; Routine d'interruption (pas utilisee).
MEM           equ       006h ; Endroit ou stocker des constantes.

;;; Adresses RAM :
DebutRAM      equ       00Ch
BOOLEEN       equ       (DebutRAM+1)    ; - 8 bits = 8 variables booleennes.
I2C_data      equ       (BOOLEEN+1)     ; - Octet de donnee.
I2C_adrHIGH   equ       (I2C_data+1)    ; - Adresse : octet de poids faible.
I2C_adrLOW    equ       (I2C_adrHIGH+1) ; - Adresse : octet de poids fort.
VAR1          equ       (I2C_adrLOW+1)  ; - 3 variables temporaires :
VAR2          equ       (VAR1+1)        ;   sauvegarde de W, compteurs, etc.
MSBfin        equ       (VAR2+1)        ;
LSBfin        equ       (MSBfin+1)      ;
VerifDATA     equ       (LSBfin+1)      ;
Touche        equ       (VerifDATA+1)   ;
EtatLeds      equ       (Touche+1)      ;

;;; Bits du Port A :
RA0           equ       0 ;  SCL copie.
RA1           equ       1 ;  non connectee.
RA2           equ       2 ;  SCL reference.
RA3           equ       3 ;  Inter "Mode".
RA4           equ       4 ;  SDA commun copie et reference.

;;; Bits du Port B :
RB0           equ       0 ;  Bouton poussoir pour copie 24C01.
RB1           equ       1 ;  Bouton poussoir pour copie 24C02.
RB2           equ       2 ;  Bouton poussoir pour copie 24C04.
RB3           equ       3 ;  Bouton poussoir pour copie 24C08.
RB4           equ       4 ;  Bouton poussoir pour copie 24C16.
RB5           equ       5 ;  Led verte.
RB6           equ       6 ;  Led rouge.
RB7           equ       7 ;  Led jaune.

;;; Entrees / sorties :

SCLcop        equ       RA0
SCLref        equ       RA2
Inter         equ       RA3
SDA           equ       RA4

BP24C01       equ       RB0
BP24C02       equ       RB1
BP24C04       equ       RB2
BP24C08       equ       RB3
BP24C16       equ       RB4
LedVerte      equ       RB5
LedRouge      equ       RB6
LedJaune      equ       RB7

;;; BOOLEEN :
I2CACK        equ       0 ; verifie si l'acces au bus I2C est correct.
CANAL         equ       1 ; 'Reference' : CANAL=0 / 'Copie' : CANAL=1.
NoVer         equ       2 ; mis a 1 si inter passant : alors sauter verif.

;;; Constantes :
I2C_WR        equ       00000000b
I2C_RD        equ       00000001b
I2C_EEPROM    equ       10100000b

;**************************************************************************;

;;;; Donnees EEPROM interne du PIC : ;;;;

EEPROM_DATA   equ       2100h

              ORG       EEPROM_DATA ; Contenu de l'EEPROM (64 octets).

              DE        "(c) Pierre COL, mars 2001, V 1.0"
              DE        "Site web: http://www.col2000.org"

;**************************************************************************;

;; Divers actions, non utiles dans ce cas precis :

              ORG       DEBUT
              GOTO      PROG

              ORG       INT    ; Retour d'interruption (mais
              RETFIE           ; celle-ci n'est pas utilisee).

              ORG       MEM    ; Constantes ou textes divers a stocker :
Message       DT        "Copieur de 24Cxx",0

;; Debut du programme : ;;;;

PROG          BSF       STATUS,RP0 ; Pour acceder aux registres $80 a $AF.

                        ; Configuration des ports A et B (0=S / 1=E) :
              MOVLW     01000b            ; - OUT : SCLref/SCLcop/SDA/RA1.
              MOVWF     TRISA & 01111111b ; - IN  : RA3 = Inter.
              MOVLW     00011111b         ; - OUT : RB5 a RB7 (= Les 3 leds).
              MOVWF     TRISB & 01111111b ; - IN  : RB0 a RB4 (poussoirs).
              MOVLW     11111111b              ; Registres d'options : B7=1,
              MOVWF     OPTION_REG & 01111111b ; resist. de tirage non actives.

              BCF       STATUS,RP0 ; Pour acceder aux registres $00 a $2F,
                                   ; notamment les Ports A et B.

              MOVLW     11111111b
              MOVWF     PORTA      ; Ports I2C initialises (a "1").
              MOVWF     PORTB      ; Leds eteintes : [PB4]-[330]-(led)-[+5V].

              CLRF      BOOLEEN    ; Initialiser d'un coup a '0' les
                                   ; 8 bits de la variable booleenne ;
                                   ; en fait, seul le bit 0 est utilise.

;************************* Partie principale : ************************;


;; Les trois leds sont eteintes. ;;

              CLRF      EtatLeds        ;
AttendTouche  CALL      Tempo50ms       ;
              INCF      EtatLeds,F      ;
              BTFSS     EtatLeds,3      ; tous les 400 ms :
              GOTO      LedRONVOFF      ; ou bien :
              BSF       PORTB,LedRouge  ;;; Led rouge eteinte
              BCF       PORTB,LedVerte  ;;; et led verte allumee.
              GOTO      LireClavier     ; ou bien :
LedRONVOFF    BCF       PORTB,LedRouge  ;;; Led rouge allumee
              BSF       PORTB,LedVerte  ;;; et led verte eteinte.

LireClavier   COMF      PORTB,W         ; Lire le clavier,
              ANDLW     00011111b       ; filtrer les 5 touches,
              MOVWF     Touche          ; et stocker dans la variable 'Touche'.

              CLRF      MSBfin          ; Initialiser a $00 les variables
              CLRF      LSBfin          ; reprentant le depassement d'adresse.

TestBP24C16   MOVLW     00010000b     ; Touche BP 24C16 (et seulement...) ?
              XORWF     Touche,W      ;
              BTFSS     STATUS,Z      ;
              GOTO      TestBP24C08   ; - si non : tester le BP 24C08.
              BSF       MSBfin,3      ; - si oui : Arret a l'adresse $800.
              GOTO      DebutCopie    ;            et on y va...

TestBP24C08   MOVLW     00001000b     ; Touche BP 24C08 ?
              XORWF     Touche,W      ;
              BTFSS     STATUS,Z      ;
              GOTO      TestBP24C04   ; - si non : tester le BP 24C04.
              BSF       MSBfin,2      ; - si oui : Arret a l'adresse $400.
              GOTO      DebutCopie    ;            et on y va...

TestBP24C04   MOVLW     00000100b     ; Touche BP 24C04 ?
              XORWF     Touche,W      ;
              BTFSS     STATUS,Z      ;
              GOTO      TestBP24C02   ; - si non : tester le BP 24C02.
              BSF       MSBfin,1      ; - si oui : Arret a l'adresse $200.
              GOTO      DebutCopie    ;            et on y va...

TestBP24C02   MOVLW     00000010b     ; Touche BP 24C02 ?
              XORWF     Touche,W      ;
              BTFSS     STATUS,Z      ;
              GOTO      TestBP24C01   ; - si non : tester le BP 24C01.
              BSF       MSBfin,0      ; - si oui : Arret a l'adresse $100.
              GOTO      DebutCopie    ;            et on y va...

TestBP24C01   MOVLW     00000001b     ; Touche BP 24C01 ?
              XORWF     Touche,W      ;
              BTFSS     STATUS,Z      ;
              GOTO      AttendTouche  ; - si non : retourner lire la touche.
              BSF       LSBfin,7      ; - si oui : Arret a l'adresse $080.
              ;GOTO     DebutCopie    ;            et on y va...

;; Eteindre les trois leds : ;;

DebutCopie    BSF       PORTB,LedJaune  ; Led jaune...
              BSF       PORTB,LedRouge  ; Led rouge...
              BSF       PORTB,LedVerte  ; Led verte...

;; Tester l'etat de l'inter

              BTFSS     PORTA,Inter      ; L'inter est-il passant (RA3=0) ?
              BSF       BOOLEEN,NoVer    ; Si oui, bit NoVer de BOOLEEN a 1.

;; Lancer la copie : ;;

              CLRF      I2C_adrHIGH      ; - La premiere adresse
              CLRF      I2C_adrLOW       ;   est l'adresse $000.

AdrSuivante1  BTFSS     I2C_adrLOW,6     ; - toutes les 64 adresses,
              BCF       PORTB,LedJaune   ;   allumer ou eteindre la
              BTFSC     I2C_adrLOW,6     ;   led jaune. Le clignotement
              BSF       PORTB,LedJaune   ;   fera patienter l'utilisateur.

              BTFSS     PORTA,SDA        ; - On verifie que SDA est bien a 1,
              GOTO      ErreurCopie      ;
              BTFSS     PORTA,SCLref     ; - et que SCL reference est bien a 1,
              GOTO      ErreurCopie      ;
              BTFSS     PORTA,SCLcop     ; - et que SCL copie est bien a 1.
              GOTO      ErreurCopie      ;

              CALL      CANALreference   ; La memoire pointee est la reference.
              CALL      Read24C16        ; - On lit l'octet de donnee,
              MOVF      I2C_data,W       ; - qu'on stocke pour comparaison
              MOVWF     VerifDATA        ;   ulterieure.
              BTFSS     BOOLEEN,I2CACK   ; - Si erreur de lecture,
              GOTO      ErreurCopie      ;   on abrege...

              CALL      CANALcopie       ; La memoire pointee est la copie.
              CALL      Write24C16       ; - On ecrit l'octet de connee.
              BTFSS     BOOLEEN,I2CACK   ; - Si erreur d'ecriture,
              GOTO      ErreurCopie      ;   on abrege...

              BTFSC     BOOLEEN,NoVer    ; Si l'inter est passant,
              GOTO      ApresVerif       ; sauter la verification.

              CALL      Read24C16        ; - On relit l'octet ecrit.
              BTFSS     BOOLEEN,I2CACK   ; - Si erreur de relecture,
              GOTO      ErreurCopie      ;   on abrege...
              MOVF      VerifDATA,W      ; - On compare avec la donnee
              XORWF     I2C_data,W       ;   que l'on avait stockee.
              BTFSS     STATUS,Z         ; - Si elle est differente,
              GOTO      ErreurCopie      ;   alors erreur : on abrege...

ApresVerif    INCF      I2C_adrLOW,F     ; - On incremente l'adresse : d'abord
              BTFSC     STATUS,Z         ;   l'octet de poids faible, et si
              INCF      I2C_adrHIGH,F    ;   retenue, l'octet de poids fort.
              MOVF      LSBfin,W         ; - Adresse courante = Adresse fin ?
              XORWF     I2C_adrLOW,W     ;   -> on compare les LSB...
              BTFSS     STATUS,Z         ;   - Si differents, adresse suivante.
              GOTO      AdrSuivante1     ;
              MOVF      MSBfin,W         ;   - Si egaux, on compare les MSB...
              XORWF     I2C_adrHIGH,W    ;     - si differents, adr. suivante.
              BTFSS     STATUS,Z         ;     - si egaux,
              GOTO      AdrSuivante1     ;       alors termine avec succes :

              BCF       PORTB,LedVerte   ;       on allume la led verte et fin.
              GOTO      FinCopie         ;

ErreurCopie   BCF       PORTB,LedRouge   ; Erreur ? on a abrege ?
                                         ; allumer la led rouge, puis fin.

FinCopie      BSF       PORTB,LedJaune   ; On eteint la led jaune.
Fin           GOTO      Fin              ; Fin des operations...
                                         ; On reboucle eternellement,
;; Fin du programme.                     ; en attendant un RESET.


;************************* Routines du programme : ************************;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Temporisation de 0,05 seconde : ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Tempo50ms     MOVLW     25
              MOVWF     VAR1
              GOTO      Boucle1TP

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Temporisation de 0,5 seconde : ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Tempo500ms    MOVLW     250  ; N1  ; 1            **
              MOVWF     VAR1       ; 1            ** 4+
Boucle1TP     MOVLW     200  ; N2  ; 1  *         ;;
              MOVWF     VAR2       ; 1  *         ;; 250x
Boucle2TP     NOP                  ; 1  ;         ;; (200x10+2+2)
              NOP                  ; 1  ;         ;;
              NOP                  ; 1  ; 2+      ;;
              NOP                  ; 1  ; 200x10  ;;
              NOP                  ; 1  ; =2002   ;;
              NOP                  ; 1  ;         ;;
              NOP                  ; 1  ;         ;;
              NOP                  ; 1  ;         ;; T(us) = 4+N1x[N2x10+4].
              DECFSZ    VAR2,F     ; 2  ;         ;; avec N1=250 et N2=200 :
              GOTO      Boucle2TP  ;    ;         ;; T = 501004 us
              DECFSZ    VAR1,F     ; 2            ;; T = 0,5 s
              GOTO      Boucle1TP  ;              ;;
              RETURN               ; 2            **

;**************************************************************************;

;--------------------------------------------------------------------------;
;        Fonctions principales pour ecrire et lire dans l'EEPROM           ;
;        I2C, octet par octet (pour les modeles 24C01 a 24C16).            ;
;--------------------------------------------------------------------------;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Lit l'octet situe dans l'EEPROM I2C et met le contenu dans [I2C_data]. ;;
;; Pour indiquer l'adresse a lire :                                       ;;
;; les 3 bits de poids fort de l'adresse sont mis dans [I2C_adrHIGH].     ;;
;; les 8 bits de poids faible de l'adresse sont mis dans [I2C_adrLOW].    ;;
;; (attention, cela modifie les variables VAR1, VAR2 et BOOLEEN)          ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Read24C16        CALL      Set_Adr_I2C         ; - Pointer l'adresse.
                 CALL      I2CSTART            ; - Envoyer un ordre de
                 RLF       I2C_adrHIGH,W       ;   lecture a l'EEPROM I2C.
                 ANDLW     00001110b           ;
                 IORLW     (I2C_EEPROM+I2C_RD) ;    (octet : 1010xxx1b
                 CALL      WtoI2C              ;    xxx = MSB adresse)
                 CALL      I2CgetACK           ; - Confirme par un ACK.
                 CALL      I2CtoW              ; - Lire l'octet.
                 MOVWF     I2C_data            ; - Le mettre dans [I2C_data]
                 CALL      I2CsetNoACK         ; - Terminer l'operation
                 CALL      I2CSTOP             ;   (pas d'ACK, mais un STOP).
                 RETURN                        ; - C'est fini !

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Ecrit l'octet situe dans [I2C_data] dans l'EEPROM I2C.              ;;
;; Pour indiquer l'adresse ou ecrire :                                 ;;
;; les 3 bits de poids fort de l'adresse sont mis dans [I2C_adrHIGH].  ;;
;; les 8 bits de poids faible de l'adresse sont mis dans [I2C_adrLOW]. ;;
;; (attention, cela modifie les variables VAR1, VAR2 et BOOLEEN)       ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Write24C16       CALL      Set_Adr_I2C       ; Pointer l'adresse
                 MOVF      I2C_data,W        ; Lire l'octet I2C_data a envoyer
                 CALL      WtoI2C            ; Envoyer l'octet
                 CALL      I2CgetACK         ; Acquerir l'ACK
                 CALL      I2CSTOP           ; STOP
                 BTFSS     BOOLEEN,I2CACK    ; Tester l'ACK :
                 GOTO      MemNonDispo1        ; - Si PB : tant pis, abreger !
ProgPasFinie     CALL      I2CSTART            ; - Sinon :
                 MOVLW     (I2C_EEPROM+I2C_WR) ; attendre que la programmation
                 CALL      WtoI2C              ; soit terminee en essayant
                 CALL      I2CgetACK           ; d'acceder a la memoire.
                 CALL      I2CSTOP             ; Quand celle-ci repond (ACK),
                 BTFSS     BOOLEEN,I2CACK      ; c'est qu'elle est enfin dispo
                 GOTO      ProgPasFinie        ; et qu'elle a fini le boulot.
MemNonDispo1     RETURN                        ; La, c'est fini !

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Dans l'EEPROM I2C, pointe l'adresse memoire voulue :                ;;
;; les 3 bits de poids fort de l'adresse sont mis dans [I2C_adrHIGH].  ;;
;; les 8 bits de poids faible de l'adresse sont mis dans [I2C_adrLOW]. ;;
;; ex pour l'adresse $5BC: $05 dans I2C_adrHIGH et $BC dans I2C_adrLOW ;;
;; (attention, cela modifie les variables VAR1, VAR2 et BOOLEEN)       ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Set_Adr_I2C      CALL      I2CSTART            ; - 'Start' : debut sequence.
                 RLF       I2C_adrHIGH,W       ; - on cree le premier octet :
                 ANDLW     00001110b           ;  B3 a B1 : les 3 bits de poids
                 IORLW     (I2C_EEPROM+I2C_WR) ;  fort de l'adresse ; B7 a B4 =
                 CALL      WtoI2C              ;  [1010] et B0 = 0 (write).
                 CALL      I2CgetACK           ; - on verifie si l'octet a bien
                 BTFSS     BOOLEEN,I2CACK      ;   ete recu :
                 GOTO      MemNonDispo2        ;  .si non, tant pis, on quitte.
                 MOVF      I2C_adrLOW,W        ;  .si oui, on envoie l'octet de
                 CALL      WtoI2C              ;   poids faible de l'adresse en
                 CALL      I2CgetACK           ;   verifiant qu'il est recu.
MemNonDispo2     RETURN    ;; Si PB : I2CACK=0 dans "BOOLEEN".

;**************************************************************************;


;--------------------------------------------------------------------------;
;                  sous-fonctions permettant de realiser                   ;
;                 les chronogrammes d'acces a la memoire :                 ;
;--------------------------------------------------------------------------;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Envoie une sequence 'START' au peripherique I2C ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

I2CSTART         CALL      SetSCL         ; Au debut, SCL
                 BSF       PORTA,SDA      ; et SDA sont a '1'.
                 CALL      Tempo5us       ; On attend 5 us,
                 BCF       PORTA,SDA      ; puis SDA passe a '0',
                 CALL      Tempo5us       ; puis on attend 5 us,
                 CALL      ClearSCL       ; puis SCL passe a '0',
                 CALL      Tempo5us       ; puis on attend 5 us.
                 BSF       PORTA,SDA      ; SDA doit etre remis a '1'
                 RETURN                   ; pour pouvoir voir les donnees
                                          ; venant de la memoire.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Envoie une sequence STOP au peripherique I2C ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

I2CSTOP          CALL      ClearSCL     ; Au debut, SCL
                 BCF       PORTA,SDA    ; et SDA sont a '0'.
                 CALL      Tempo5us     ; On attend 5 us,
                 CALL      SetSCL       ; puis SCL passe a '1',
                 CALL      Tempo5us     ; puis on attend 5 us,
                 BSF       PORTA,SDA    ; puis SDA passe a '1',
                 CALL      Tempo5us     ; on attend 5 us...
                 RETURN                 ; Fin de la routine.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Envoie un octet contenu dans W au peripherique I2C en 'serie' : ;;
;; (attention, cela modifie les variables VAR1 et VAR2)            ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; L'octet a envoyer est mis dans VAR1 ; on va alors faire subir 8 fois
; a cet octet un decalage vers la gauche, en recopiant a chaque fois au
; prealable le bit B7 sur la broche SDA (avant d'appliquer une impulsion
; d'horloge sur SCL). La variable VAR2 sert de compteur : elle part de 8
; et est decrementee 8 fois jusqu'a 0 afin de compter le nombre de
; decalages :

WtoI2C           MOVWF     VAR1             ; - Octet a envoyer mis dans VAR1.
                 MOVLW     8                ; - 8 (nb de decalages) dans VAR2.
                 MOVWF     VAR2             ;
NextBitI2Cout    CALL      ClearSCL         ; - SCL mis a 0.
                 BTFSS     VAR1,7           ; - Bit B7 de VAR1 a 1 ?
                 BCF       PORTA,SDA        ;   si non : mettre SDA a 0.
                 BTFSC     VAR1,7           ; - Bit B7 de VAR1 a 0 ?
                 BSF       PORTA,SDA        ;   si non : mettre SDA a 1.
                 CALL      Tempo5us         ; - Appliquer impulsion sur SCL :
                 CALL      SetSCL           ; attente 5 us, SCL passe a 1,
                 CALL      Tempo5us         ; attente 5 us, SCL repasse a 0.
                 CALL      ClearSCL         ;
                 RLF       VAR1,F           ; - Decaler VAR1 un coup a gauche.
                 DECFSZ    VAR2,F           ; - Decrementer VAR2 ; si ce n'est
                 GOTO      NextBitI2Cout    ;   pas la 8ieme fois, reboucler.
                 BSF       PORTA,SDA        ; - On remet SDA a '1' (permet
                 RETURN                     ;   de lire SDA comme 1 entree).

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;     Lit un octet depuis le peripherique I2C et le met dans W :     ;;
;;     (attention, cela modifie les variables VAR1 et VAR2)           ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Cette routine ressemble beaucoup a la precedente ; mais au lieu
; de recopier le bit B7 sur SDA et de decaler l'octet vers la gauche
; et ce huit fois de suite, on commence par decaler l'octet, puis on
; recopie SDA sur B0, toujours huit fois de suite. Les bits ne sont
; plus retires un a un, mais au contraire empiles les uns apres les
; autres dans VAR1 :

I2CtoW           MOVLW     8               ;- VAR2=8, variable compteur qui va
                 MOVWF     VAR2            ;  comptabiliser les 8 decalages.
                 CLRF      VAR1            ;- VAR1 initialisee a 00000000b.
NextBitI2Cin     CALL      ClearSCL        ;- SCL mis a 0.
                 BSF       PORTA,SDA       ;- SDA mis a 1 pour etre lisible.
                 CALL      Tempo5us        ;- attente de 5 us.
                 CALL      SetSCL          ;- SCL passe a '1'.
                 CALL      Tempo5us        ;- attente de 5 us.
                 RLF       VAR1,F          ;- decalage un coup vers la gauche.
                 BCF       VAR1,0          ;- bit B0 initialise a 0.
                 BTFSC     PORTA,SDA       ;- on teste SDA : vaut-il 0 ?
                 BSF       VAR1,0          ;  si non (SDA=1), on met B0 a 1.
                 DECFSZ    VAR2,F          ;- huitieme cycle ?
                 GOTO      NextBitI2Cin    ;  si non, reboucler cycle suivant.
                 CALL      ClearSCL        ;- apres dernier cycle : SCL a 0.
                 MOVF      VAR1,W          ;- L'octet lu VAR1 est copie dans W.
                 RETURN                    ; Fin de la routine

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Verifie si le peripherique I2C renvoie un 'Acknowledge' ; si celui-ci ;;
;; est present, le bit I2CACK est mis a '1', sinon il est mis a '0'.     ;;
;; (la seule variable modifiee est 'BOOLEEN')                            ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

I2CgetACK        BSF       PORTA,SDA          ; On s'assure que SDA est a 1.
                 CALL      ClearSCL           ; On genere l'impulsion positive
                 CALL      Tempo5us           ; sur SCL : SCL=0, attendre
                 CALL      SetSCL             ; 5 us, SCL a '1', attendre 5
                 CALL      Tempo5us           ; us. La, lire l'etat de SDA :
                 BCF       BOOLEEN,I2CACK     ; - On met le bit I2CACK a 0.
                 BTFSS     PORTA,SDA          ; - On verifie l'ACK : SDA=0 ?
                 BSF       BOOLEEN,I2CACK     ; oui ? OK, on met I2CACK a 1.
                 CALL      ClearSCL           ; Puis SCL repasse a '0'.
                 RETURN                       ; Et la routine est terminee...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Envoie un bit 'Acknowledge' au peripherique I2C. ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

I2CsetACK        CALL      ClearSCL     ; au debut, SCL est a 0.
                 BCF       PORTA,SDA    ; SDA est mis a 0 (on applique ACK).
                 CALL      Tempo5us     ; on attend 5 us.
                 CALL      SetSCL       ; Impulsion positive sur SCL :
                 CALL      Tempo5us     ; SCL passe a '1' pendant
                 CALL      ClearSCL     ; 5 us, puis repasse a '0'.
                 BSF       PORTA,SDA    ; Il faut penser a remettre SDA a 1.
                 RETURN    ; Fin de la routine, retour au programme principal.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Envoie un 'No Acknowledge' au peripherique I2C. ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

I2CsetNoACK      CALL      ClearSCL    ; Au debut, SCL est a '0'.
                 BSF       PORTA,SDA   ; et SDAref a '1' (car pas d'ACK).
                 CALL      Tempo5us    ; on attend 5 us.
                 CALL      SetSCL      ; Impulsion positive sur SCL :
                 CALL      Tempo5us    ; SCL passe a '1' pendant
                 CALL      ClearSCL    ; 5 us, puis repasse a '0'.
                 RETURN    ; Fin de la routine, retour au programme principal.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Les deux routines suivantes mettent respectivement a          ;;
;; '1' et a '0' la broche SCL ; le choix de la sortie SCL        ;;
;; depend du canal actif :                                       ;;
;; - Si le bit CANAL de BOOLEEN vaut 0 : SCL 'reference' active. ;;
;; - Si le bit CANAL de BOOLEEN vaut 1 : SCL 'copie' active.     ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

SetSCL           BTFSS     BOOLEEN,CANAL ; Si bit CANAL = 0 :
                 BSF       PORTA,SCLref  ; SCLref est mis a '1'.
                 BTFSC     BOOLEEN,CANAL ; Si bit CANAL = 1 :
                 BSF       PORTA,SCLcop  ; SCLcop est mis a '1'
                 RETURN

ClearSCL         BTFSS     BOOLEEN,CANAL ; Si bit CANAL = 0 :
                 BCF       PORTA,SCLref  ; SCLref est mis a '0'.
                 BTFSC     BOOLEEN,CANAL ; Si bit CANAL = 1 :
                 BCF       PORTA,SCLcop  ; SCLcop est mis a '0'
                 RETURN

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;  Selection du canal (memoire) actif :                                   ;;
;;  - Si bit CANAL de BOOLEEN vaut 0 : SCL = SCLref (memoire 'reference'). ;;
;;  - Si bit CANAL de BOOLEEN vaut 1 : SCL = SCLcop (memoire 'copie').     ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

CANALreference   BCF       BOOLEEN,CANAL ; bit mis a '0'.
                 RETURN

CANALcopie       BSF       BOOLEEN,CANAL ; bit mis a '1'.
                 RETURN

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Temporisation de 5 micro-secondes pour respecter ;;
;; les temps d'acces aux peripheriques I2C.         ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Tempo5us         NOP       ; La tempo dure 5 us, avec le "CALL Tempo5us".
                 RETURN    ; (CALL=2us) + (NOP=1us) + (RETURN=2us) = 5 us.

                 END ; L'assembleur peut maintenant aller faire dodo !


;********************** Fin generale du programme. ***************************;


P16F84.INC

Código: Seleccionar todo

       NOLIST

; This header file defines configurations, registers, and other useful bits of
; information for the PIC16F84 microcontroller.  These names are taken to match
; the data sheets as closely as possible.

; Note that the processor must be selected before this file is
; included.  The processor may be selected the following ways:

;       1. Command line switch:
;               C:\ MPASM MYFILE.ASM /PIC16F84
;       2. LIST directive in the source file
;               LIST   P=PIC16F84
;       3. Processor Type entry in the MPASM full-screen interface

;==========================================================================
;
;       Revision History
;
;==========================================================================

;Rev:   Date:    Reason:

;2.00   07/24/96 Renamed to reflect the name change to PIC16F84.
;1.01   05/17/96 Corrected BADRAM map
;1.00   10/31/95 Initial Release

;==========================================================================
;
;       Verify Processor
;
;==========================================================================

        IFNDEF __16F84
           MESSG "Processor-header file mismatch.  Verify selected processor."
        ENDIF

;==========================================================================
;
;       Register Definitions
;
;==========================================================================

W                            EQU     H'0000'
F                            EQU     H'0001'

;----- Register Files------------------------------------------------------

INDF                         EQU     H'0000'
TMR0                         EQU     H'0001'
PCL                          EQU     H'0002'
STATUS                       EQU     H'0003'
FSR                          EQU     H'0004'
PORTA                        EQU     H'0005'
PORTB                        EQU     H'0006'
EEDATA                       EQU     H'0008'
EEADR                        EQU     H'0009'
PCLATH                       EQU     H'000A'
INTCON                       EQU     H'000B'

OPTION_REG                   EQU     H'0081'
TRISA                        EQU     H'0085'
TRISB                        EQU     H'0086'
EECON1                       EQU     H'0088'
EECON2                       EQU     H'0089'

;----- STATUS Bits --------------------------------------------------------

IRP                          EQU     H'0007'
RP1                          EQU     H'0006'
RP0                          EQU     H'0005'
NOT_TO                       EQU     H'0004'
NOT_PD                       EQU     H'0003'
Z                            EQU     H'0002'
DC                           EQU     H'0001'
C                            EQU     H'0000'

;----- INTCON Bits --------------------------------------------------------

GIE                          EQU     H'0007'
EEIE                         EQU     H'0006'
T0IE                         EQU     H'0005'
INTE                         EQU     H'0004'
RBIE                         EQU     H'0003'
T0IF                         EQU     H'0002'
INTF                         EQU     H'0001'
RBIF                         EQU     H'0000'

;----- OPTION Bits --------------------------------------------------------

NOT_RBPU                     EQU     H'0007'
INTEDG                       EQU     H'0006'
T0CS                         EQU     H'0005'
T0SE                         EQU     H'0004'
PSA                          EQU     H'0003'
PS2                          EQU     H'0002'
PS1                          EQU     H'0001'
PS0                          EQU     H'0000'

;----- EECON1 Bits --------------------------------------------------------

EEIF                         EQU     H'0004'
WRERR                        EQU     H'0003'
WREN                         EQU     H'0002'
WR                           EQU     H'0001'
RD                           EQU     H'0000'

;==========================================================================
;
;       RAM Definition
;
;==========================================================================

        __MAXRAM H'CF'
        __BADRAM H'07', H'50'-H'7F', H'87'

;==========================================================================
;
;       Configuration Bits
;
;==========================================================================

_CP_ON                       EQU     H'000F'
_CP_OFF                      EQU     H'3FFF'
_PWRTE_ON                    EQU     H'3FF7'
_PWRTE_OFF                   EQU     H'3FFF'
_WDT_ON                      EQU     H'3FFF'
_WDT_OFF                     EQU     H'3FFB'
_LP_OSC                      EQU     H'3FFC'
_XT_OSC                      EQU     H'3FFD'
_HS_OSC                      EQU     H'3FFE'
_RC_OSC                      EQU     H'3FFF'

           LIST

Compile con MPASM.EXE:
ASM.bat

Código: Seleccionar todo

@echo off
mpasm /q+ /P16F84 /e+ cop10.asm
Adjuntos
asm-pic.zip
No tienes los permisos requeridos para ver los archivos adjuntos a este mensaje.



Avatar de Usuario
Enigma
Administrador del Sitio
Administrador del Sitio
Usuario Especial
Usuario Especial
Mensajes: 1029
Registrado: Octubre 20, 2013, 4:26 pm
Es: Mujer
Profesion: Webmaster CEO SEO
Ubicacion: Matrix
Navegador: Chrome

Re: Proyecto Copiadora autónoma de memorias I2C (En Francés)

Mensaje por Enigma » Septiembre 28, 2018, 2:39 pm

El programa:
puede usar un PIC16C84, un PIC16F84 o un PIC16F84A / PIC16LF84A, siempre que lo indique al software de su programador. Aquí está el archivo Cop10.HEX (versión 1.0) a programar en el PIC. Excepcionalmente, decidí proporcionar el archivo fuente del programa si desea hacer cambios; descargue el archivo ASM-PIC.ZIP (80 KB) para este propósito; contiene los siguientes cuatro archivos:
COP10.ASM: el archivo fuente, posiblemente para editar.
MPASM.EXE: el ensamblador proporcionado gratuitamente por Microchip.
P16F84.INC: el archivo incluido que contiene las definiciones de registro PIC16F84.
ASM.BAT: el archivo para iniciar, que llama al ensamblador con las opciones correctas.
Cuando ejecuta el archivo ASM.BAT, se produce el ensamblado y genera cuatro archivos nuevos:
COP10.COD, que no tiene ningún interés para nosotros.
COP10.ERR: la lista de errores encontrados en la compilación; está vacío (0 bytes) si todo transcurrió sin problemas.
COP10.HEX: el archivo en formato Intel / Hexa que contiene los códigos de 'máquina' para cargar en el PIC, gracias al programador.
COP10.LST: la lista que contiene toda la información obtenida en la compilación (programa fuente, códigos de máquina, mensajes y número de errores, etc.).
Parte inferior de la página (regreso)
Dependiendo del programador utilizado, puede ser necesario configurar manualmente los bits de configuración de PIC en las opciones de programación; en este caso, aquí está la información correspondiente que necesitará (cualquiera que sea el tipo de PIC):


Imagen

Puesta en servicio :

La batería está conectada, las memorias se han insertado en los soportes de 8 pines (el original del lado del bloque de terminales triple y la memoria en blanco del lado de cuarzo).

Al encenderse, los LED rojos y verdes parpadean alternativamente para indicar que la edición está lista para hacer una copia.

Presione la tecla correspondiente al tipo de memorias presentes:
[24C01], [24C02], [24C04], [24C08] o [24C16]

El ciclo se inicia: los leds rojos y verdes se apagan; el led amarillo parpadea.

Si todo va bien, el led amarillo parpadeará:
1 vez en el caso de un 24C01.
2 veces en el caso de un 24C02.
4 veces en el caso de un 24C04.
8 veces en el caso de un 24C08.
16 veces en el caso de un 24C16.
Luego se completa la programación y el led verde se enciende para indicar que todo está terminado y que no se ha detectado ningún error (LED amarillo y rojo apagados).

Si ocurre un problema (memoria no presente, error de escritura ...), la programación se detiene inmediatamente, y el LED rojo se enciende (LEDs amarillo y verde apagados).

Cuando todo está hecho, ya sea que la programación sea exitosa o no, simplemente presione el botón RESET para volver al modo de espera (rojo / verde intermitente); luego puede iniciar otra programación presionando una de las cinco teclas.

Al presionar la tecla RESET durante la programación se cancela la operación. La copia solo es parcial, por lo tanto, reiniciará la duplicación.

Parte inferior de la página (regreso)
La programación dura aproximadamente:

1 segundo en el caso de un 24C01,
2 segundos en el caso de un 24C02,
4 segundos en el caso de un 24C04,
8 segundos en el caso de un 24C08,
16 segundos en el caso de un 24C16.
Esta vez puede parecer larga, especialmente para aquellos que usan el programador para PC (en puerto serial o paralelo) cuya acción es casi instantánea, pero el algoritmo ha sido reforzado para detectarlo por así decirlo (casi) cualquier error; la fiabilidad es a este precio ...
El interruptor 'Modo', cuando se enciende, evita una fase de verificación y, por lo tanto, reduce el tiempo de programación en aproximadamente un tercio (por lo tanto, para un 24C16, pasa a unos 11 segundos). Pero es desafortunado limitar la confiabilidad del sistema, y ​​no excluyo asignarle al interruptor otra función, en una versión posterior del sistema.

Responder

Volver a “Proyectos y Circuitos Didacticos”