SoloCodigo

hola gente del foro, soy nuevo por aca y decidi ingresar ya q observe la seriedad con la cual se manejan Uds. Ademas tengo un problemita ya q deseo leer o grabar una memoria E2prom externa mediante un pic q en lo posible tiene q ser el 16f628 el cual soporta transferencia serie tipo USART, y no se como puedo lograr ello.   Espero q puedan ayudarme

Se conectan al modulo MSSP configurado como I2C o SPI segun lo necesites, responde el tipo de memoria que utilizas y te damos un aventon. Saludos y Bienvenido!

Hola ! Bueno, las rutinas de lectura de puertos, retardos, etc. van en la memoria flash del micro, que no es lo mismo que la EEPROM. Depende para que necesites EEPROM, es decir que cantidad de datos quieres almacenar, el 16F628 tiene 128 bytes de E2 (para abreviar) interna; son muy fáciles de manejar.
Si tienes un LCD, los textos a escribir que no varíen, p.e. títulos, menus, etc. van en la flash.
Hojeando el manual del 628, me doy cuenta ahora de que éste no tiene implementado modulo MSSP; así que perdón por el error de uno de los mensajes anteriores  Viendo esto, vas a tener que implenetar la comunicación por soft... cosa que funciona. Hace poco dejé un poco de código en una discución iniciada por Elisa Marti, fijate, en una de esas te sirve...
Bueno, espero que puedas hacer tu proyecto.
Saludos!

Hola Jonathan! En realidad el error fue mío, pero no importa... Lo bueno es que nos dimos cuenta antes de meter más la pata

Saludos!

Hola, bueno, en primer lugar quiero decirles que me parece impecable este foro, con respecto al debate planteado, pues puedo ayudarle a quien le interese con rutinas I2C, en ASM para usar con cualquier microcontrolador de MicroChip y con algunos cambios otras marcas, de cualquier manera les recomiendo mirar el PIC16F88, que ademas de tener un precio inferior al 16F84 y similar al 16F628, posee el MSSP, conversor A/D de 10 bits de resolucion, 8 mhz de reloj interno de 4  frecuencias seleccionables, USART, ICSP, permite utilizar debug in circuit y ademas tiene 4 KW de memoria, 4 veces mas que el famoso 16F84A, y 256 bytes de memoria eeprom, creo que definitivamente no tiene sentido usar otro micro en caso de necesitar caracteristicas similares, y  es compatible pin a pin, con los sus antecesores, realmente una maravilla, bueno espero que les sirva y a vuestra disposicion.............


Ariel / PikMan

Hola, bueno, aqui dejo el codigo, como esta funciona en un 16F877 u otro que tenga puerto C, por lo tanto hay que modificar esto, tambien debe usarse la instruccion tris para los 16CX (los de 12 bits) en lugar de cargar el registro tris, por lo tanto si se pretende usar un PIC16C55 por ejemplo ( pues este posee port C), se debe reemplazar esto

bsf   STATUS,RP0
   movlw   b'11100111'
   movwf   TRISC
bcf   STATUS,RP0

por

   movlw   b'11100111'
                tris            portc

Y  ademas las direcciones de los registros de RAM, que pueden lelgar a ser posiciones usadas en otros procesos, o bueno si les sobra memoria las dejas solo para esto, pero no olviden este precioso detalle.

Como podran observar mas abajo, cada vez que se realiza una operacion se programa el sentido de los pines, se puede llegar a optimizar, y eliminar algunas
operaciones pero para entender la rutina se las dejo asi, y por supuesto no olviden que el valor binario que cargan al registro debe contener las direcciones fijas de los otro pines, y por ultimo las lineas SDA y SCL deben tener una resistencia de PULL-UP de 100K al +VCC, en algunos circuitos omiten la de SDA, pero les aconsejo porner las dos si no le puede llegar a doler la cabeza.
Es posible, en los micros que lo disponen, activar en el portB los week pullup, con esto se pueden omitir las resistencias internas.
Al final hay dos rutinas una que lee y  otra que escribe un byte determinado de la memoria.
No todas las 24XX son iguales, de la 24C16 en adelante la direccion es de 16 bits, y si se va usar la 24LC16 mucha atencion que su direccionamiento no es igual, de cualquier modo les recomiendo leer la hoja de datos de la memoria que vayan a utilizar, basicamente estas rutinas pueden ser usadas para cualquiera.

saludos y espero que les sirva.

PIKMAN / ARIEL




;====================================================================
; Definicion de registros auxiliares en RAM para manejo de la memoria
; Rutina generica para microcontroladores sin MSSP, totalmente
; FIRMWARE es aplicable en cualquier microcontrolador, de la linea 16c6xx
; para los 16c5x hay que modificar los registros TRIS si no no anda
;====================================================================
ADDR   equ   0x30 ; direccion a escribir
DATAO   equ   0x31 ; dato a escribir
SLAVE   equ   0x32 ; direccion de esclavo
TXBUF   equ   0x33 ; buffer de tx
COUNT   equ   0x34
EEPROM   equ   0x35
RXBUF   equ   0x36 ; buffer de rx
LOOPS   equ   0x37
LOOPS2   equ   0x38
BCOUNT  equ   0x39

; Definicion de Bits Para para manejo de la memoria

DI   equ   7    ; bits internos
DO   equ   6    
SDATA   equ   4    ; pines SDA ( datos) y SCL ( clock ) I2C
SCLK   equ   3    ; en este caso programa los pines 3 y 4
                                      ; modificar segun circuito.



;==============RUTINA PARA GENERAR BIT DE START===================

BSTART
   bsf   STATUS,RP0
   movlw   b'11100111'
   movwf   TRISC
   bcf   STATUS,RP0   
   bcf   PORTC,SCLK
   bsf   PORTC,SDATA
   nop
   bsf   PORTC,SCLK
   nop
   nop
   nop
   nop
   nop
   bcf   PORTC,SDATA
   nop
   nop
   nop
   nop
   nop
   bcf   PORTC,SCLK
   nop
   nop
   return

;==============RUTINA PARA GENERAR BIT DE STOP===================

BSTOP
   bsf   STATUS,RP0
   movlw   b'11100111'
   movwf   TRISC
   bcf   STATUS,RP0   
   bcf   PORTC,SCLK
   bcf   PORTC,SDATA
   nop
   nop
   nop
   bsf   PORTC,SCLK
   nop
   nop
   nop
   bsf   PORTC,SDATA
   nop
   nop
   bcf   PORTC,SCLK
   nop
   nop
   nop
   return

;==============RUTINA PARA ENVIAR BIT HACIA LA MEMORIA============

BITOUT
   bsf   STATUS,RP0
   movlw   b'11100111'
   movwf   TRISC
   bcf   STATUS,RP0   
   bcf   PORTC,SCLK
   bsf   PORTC,SDATA
   btfss   EEPROM,DO
   bcf   PORTC,SDATA
   nop
   nop
   bsf   PORTC,SCLK
   nop
   nop
   nop
   nop
   bcf   PORTC,SCLK
   return

;==============RUTINA PARA RECIBIR BIT DESDE LA MEMORIA===========

BITIN
   bsf   EEPROM,DI
   bsf   STATUS,RP0
   movlw   b'11110111'
   movwf   TRISC
   bcf   STATUS,RP0   
   bcf   PORTC,SCLK
   bsf   PORTC,SCLK
   nop
   nop
   nop
   nop
   nop
   nop
   nop
   nop
   btfss   PORTC,SDATA
   bcf   EEPROM,DI
   bcf   PORTC,SCLK
   return

;==============RUTINA TRANSMITIR UN BYTE ===================


TX   
   movlw   .8   
   movwf   COUNT
TXLP   bcf   EEPROM,DO
   btfsc   TXBUF,7
   bsf   EEPROM,DO
   call   BITOUT
   rlf   TXBUF,1
   decfsz   COUNT
   goto   TXLP
   call   BITIN
   return

;==============RUTINA PARA RECIBIR UN BYTE========================


RX
   clrf   RXBUF
   movlw   .8
   movwf   COUNT
   bcf   STATUS,C
RXLP   rlf   RXBUF,F
   call   BITIN
   btfsc   EEPROM,DI
   bsf   RXBUF,0
   decfsz   COUNT
   goto   RXLP
   bsf   EEPROM,DO
   call   BITOUT
   return   

;==============RUTINA PARA LEER UN BYTE DE LA MEMORIA=============

LEER
   call   BSTART         ; Se genera Bit de START
   nop
   nop
   bcf   SLAVE,0         ; Selecciona el modo de escritura
   movfw   SLAVE         ; del dispositivo esclavo
   movwf   TXBUF         ; Tranb   
   call   TX         ;
   movfw   ADDR   
   movwf   TXBUF
   call   TX
   nop
   nop
   call   BSTART   
   nop
   nop
   bsf   SLAVE,0
   movfw   SLAVE
   movwf   TXBUF
   call   TX
   nop
   call   RX
   bsf   EEPROM,DO
   call   BITOUT
   call   BSTOP
   return

;==============RUTINA PARA ESCRIBIR UN BYTE DE LA MEMORIA=============

ESCRIB
   call   BSTART         ; Se genera bit de START
   nop
   nop
   bcf   SLAVE,0         ; Selecciona modo escribir en
   movfw   SLAVE         ; la direccion del esclavo y se pone en W
   movwf   TXBUF         ; Se transfiere W al buffer de TX
   call   TX         ; Se transmite el byte a la memoria
   movfw   ADDR         ; Se carga en W la direccion a escribir
   movwf   TXBUF         ; Se transfiere W al buffer de TX
   call   TX         ; Se transmite el byte a la memoria
   nop
   nop
   movfw   DATAO         ; Se transfiere a W el dato a escribir   
   movwf   TXBUF         ; Se transfiere W al buffer de TX
   call   TX         ; Se transmite el byte a la memoria
   call   BSTOP         ; Se Genera bit de STOP
   movlw   .20         ; Carga 20 milisegundos
   movwf   LOOPS         ; Para esperar que termine
   call   WAIT         ; la escritura en la memoria      
   return            ; Y retorna

   goto   WAIT      
WAIT1   movlw   .150
   goto   WAIT
WAIT            ; Retardo de W milisegundos
        movwf   TEMP3      
TOP2    movlw   .110
        movwf   TEMP4        
TOP     nop                     ; sit and wait
        nop
   nop
   nop
   nop
   nop
   decfsz  TEMP4,F    ; inner loop done?
   goto    TOP             ; no, go again
   decfsz  TEMP3,F         ; outer loop done?
   goto    TOP2            ; no, go again
   return
;=================================================================

Buenas a todos! Antes que anda soy nuevo en el foro y la verdad que felicito a esta comunidad por la seriedad con que toman las consultas.
Antes que nada voy a aclarar un poquito mi situacion. Soy estudiante de electronica, mas precisamente estoy en una secundaria con orientacion electronica. Para poder recibirme tengo que realizar un proyecto a modo de prueba final. Mas o menso lo que estoy haciendo, o mejor dicho tratando de hace que un pic conectado a un telefono, guarde en su memoria el numero al que se desea llamar y lo compare con una lista de numeros permitidos previamente almacenados. Uno de los problemas principales es que recien comenzamos a aprender a programar pics hace unos 3 meses, por lo tanto mis conocimientos sobre el tema no son muchos (por suerte desde hace unos años se nos enseña a programar con orientacion a bajo nivel   ). El segundo problema es que sabiendo que lso numeros telefonicos tienen varios numeros y que por cada numero necesito un byte, y si ademas se tiene en cuenta que necesitare almacenar al menos unos 50 numeros telefonicos, la memoria del pic es un gran problema segun me dijieron algunos profesores. Asi mismo me dijieron que iba a tener que usar una memoria externa del tipo 24LCXX.
Bueno hasta aqui la breve situacion xD. Ahora si las consultas:

Leyendo material que fui bajando de varios lugares sobre este tipo de memorias y lso pics, me di cuenta de que funcionan con un protocolo I2C y que estan los masters y los slaves.

1º En mi caso el pic que necesitaria tendria q ser master ya q la memoria es slave, verdad?

2º Que tipo de instrucciones se utilizan para escribir datos en la memoria desde el pic (siendo este el master) y cuales se utilizan para leer datos de la memoria?

3º Cuales son los registros que controlan la comunicacion I2C?

Y por ultimo si alguien fuera tan amable de dejar algun ejemplo de un codigo que utilice estas instrucciones y registros para escribir y leer datos de la memoria se agradeceria muchismo! Desde ya muchas gracias!

Muchas gracias por tu interes!
Te cuento que toda la parte del harware ya la tengo desarrollada y 100% funcionando   . En efecto para la deteccion de tonos uso un simple integrado, en mi caso el CM8870. Este integrado, como todos los otros decodificadores DTMF, posse 5 salidas de datos, 4 que se utilizan para brindar un numero binario correspondiente a la tecla presionada como bien dijiste, y otro que avisa de la presencia de un tono DTMF decodificado en la salida (todo aquel que desee mas informacion sobre el tema no dude en preguntar xD).
Lo que planteas de guardar 2 teclas por byte es muy interesante ya q asi ahorraria bastante espacio... pero al verdad es q nose muy bien como hacerlo. Tendria q ir preguntando bit por bit e ir guardando bit por bit con la instruccion bsf Numero,x (aca va una duda muy de principiante: La x que indicaria el numero del bit que pongo a 1, puede ser un contador que se valla incrementando de a uno? )

Y el tema del pic, tendria q se un pic q traiga el modulo MSSP, o sea q sea master?
Por q encontre por varios lados que hay 2 tipos de pic con I2C, uno q es simplemente I2C, y que hay que armar todo un programa como el que postearon mas arriba, y despues hay otro que es MI2C, que segun lei en varios lados toda la interfaz de software q hay q hacer en el otro caso ya biene integrada en el mismo hardware. Con esto pienso q en el segundo caso el programa deberia ser menos engorroso. Y en lo personal apunto a que si esto es asi utilizar un pic con esta caracteristica para alivianar el programa xD

Estube viendo unas hojas de datos de pic q traen el MSSP pero no encontre en ninguna ejemplos practicos de como serian las lineas de codigo para grabar o leer memorias con esto...  

Si alguien me puede sacar todas estas dudas se agradece! xD

Hola!
Perdón por el error... el 16F873 tiene MSSP.
Aqui dejo una rutina (dice para la memoria 24C02, pero en realidad es para cualquier 24C). Solo paso la rutina de lectura de la memoria; solo es cuestion de tomarla como base para escribir la rutina de escritura. Es fácil, y más con la ayuda de la hoja de datos de la memoria...
Asi tambien, pueden escribirse las rutinas para otros dispositivos I2C.

Saludos

No hay problema!
Mantenenos informado de tu proyecto...
Saludos