Autor Tema: leyendo memoria 24cxx  (Leído 5951 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado manongo_123

  • PIC10
  • *
  • Mensajes: 25
leyendo memoria 24cxx
« en: 14 de Septiembre de 2005, 21:37:00 »

Hola amigos, quisiera saber donde podria encontrar ejemplos del pic 16f84 leyendo una memoria 24cxx, o escribiendo, solo de los pic que no tienen la funcion de i2c como el f877 estuve intentando pero no me llego a salir , solo quiero saber si me dan un explicacion que aparte de las rutinas para leer o escribir en i2c como sobrepaso o cambio  de posicion de mem¿ria osea pasando los 255 bytes por ejemplo estoy leyendo en la posicion d"22" y luego quiero saltar la posicion "1500" de una memoria 24c32por ejemplo.
y es que no tengo tiempo pues donde estudio aun no me enseñan estas cosas y los datashets estan muy dificiles de entenderlos gracias

Desconectado fenix_jn

  • PIC18
  • ****
  • Mensajes: 418
RE: leyendo memoria 24cxx
« Respuesta #1 en: 14 de Septiembre de 2005, 22:18:00 »
mmm en q lenguaje?? yo solo tngo disponible las rutinas en ASM, en CCS las rutinas vienen preincluidas y son ejecutables directamente.

Desconectado DannielHP

  • PIC10
  • *
  • Mensajes: 43
RE: leyendo memoria 24cxx
« Respuesta #2 en: 14 de Septiembre de 2005, 23:36:00 »
Mira, en la pagina de Microchip puedes encontrar un tutorial que se llama "I2C Master Mode " En el cual explica muy bien este protocolo y cada uno de los elementos que lo integran (Start, Stop, ACK, etc) Y explica en detalle como desarrollar un codigo para comunicar un PIC con una memoria 24xx01x por medio del módulo MSSP en modo Master.
Todo esto en ensamblador.
Saludos.

Desconectado DannielHP

  • PIC10
  • *
  • Mensajes: 43
RE: leyendo memoria 24cxx
« Respuesta #3 en: 14 de Septiembre de 2005, 23:44:00 »
Tambien puedes bajarte la AN554 "Software Implementation of I²C Bus Master" que como el nombre lo dice, describe la implementacion por software del I2C para la familia PIC16CXXX. Viene con un .zip que incluye el código fuente en ensamblador.


Desconectado manongo_123

  • PIC10
  • *
  • Mensajes: 25
RE: leyendo memoria 24cxx
« Respuesta #4 en: 15 de Septiembre de 2005, 00:01:00 »
hola amigos, miren, he bajado datashes de microchip, si pero lo que no entiendo es porque no me sale el programa. miern lo hice asi en asm.

inicio     movlw     00
             movwf    ADDR        ;direccion
             
             movlw   b"10100000"
             movwf   slave
             call         RDBYTE     ;rutinas de comunicacion i2c
             call        delay_5ms
bucle     slave?            ;pongo de nuevo el slave
             incf      ADDR,f
             call     RDBYTE
             call     delay_5ms
             goto     bucle

amigos, lo que quisiera es saber como como formar el programa y no las rutinas, pues los datashets me toman tiempo poder entenderlos pues estan en un idioma tecnico, solo quiero saber como cambiar de lugar en una memoria por ejemplo estar al inicio y luego dar un salto hasta final (24c32) y que viene a ser el slave b"1010xxx0) que son esos x"s, bueno eso es lo principal pues desearia que me dieran una mano como lo hacen ustedes. ya que estoy estudiando y aun no llegan a esto y me tienen ocupado. el experimento lo estoy haciendo en el pic 16f628  sda=RA7    clk=RA6.   muchas gracias

Desconectado fenix_jn

  • PIC18
  • ****
  • Mensajes: 418
RE: leyendo memoria 24cxx
« Respuesta #5 en: 15 de Septiembre de 2005, 00:26:00 »
bueno en ASM puedes usar ese DS, para saltar de una direccion a otra solo tienes q ejecutar la rutina LoadAddr_8 de nuevo con la nueva direccion, estoy seguro q deben existir al menos 3 registros para el control de dispositivo (en este caso la memoria), una de control, otra de direccion y una de datos (o mas de esta ultima depende si es de 8 o 16 bit), de hecho leyendo el DS tenemos estos registros:

MY_ADDRESS <----- Direccion de dispositivo/control
SlavAddr(Hi) <------- Direccion interna del dispositivo (o direccion de memoria)
DataByte   <------- Datos a leer/escribir

solo es cosa de implementar la rutina y escribir los datos en cada registro, como no se en q memoria estas escribiendo t dire q deberas cargar los registros de esta forma:

MY_ADDRESS  debera ser igual a b"1010MAAA"
M es el modo (lectura escritura)
A es la direccion A2, A1, A0 seleccionada mediante pines externos (y antes de q me cuelguen; esto tb pueden ser slectores de pag B2, B1, B0 si estas usando memorias 24XX16 o mayores)

SlavAddr(Hi) debera ser igual a la direccion de memoria q kieres leer o escribir, nota q estos son 2 registros y es para direccionar hasta 1K de memoria (1024 posiciones de acuerdo al DS a 10 bits, con arreglos adecuados podrias direccionar 64K sin problemas). SlavAddr contiene la direccion baja mientras SlavAddrHi contiene 2 bits para la direccion alta.

DataByte no necesita explicacion, escribe en el si vas a enviar datos, lee si vas a recibir (usando las rutinas necesarias claro!!)

MY_ADDRESS es una constante, por lo q su valor debera ser definido al principo del programa:
 
Codigo:

#define _MY_ADDRESS 0xD6 ; This slave’s address



Los demas los haces con los conocidos movlw K o movf file, 0 y movwf file, las rutinas en el DS estan mas o menos bien explicadas pero si se entiendn por lo q se pueden escribir directament en el programa (teniendo cuidado con las direcciones) incluso algunas macros son eliminables (por ejemplo las de 10bit si no las vas a usar)

Las macros t permiten pasar el valor directamente como argumento asi q es posible q ni necesites los movf y movxx q t escribi arriba, solo llama a la rutina con el valor q necesitas escribir y ya.

Desconectado DannielHP

  • PIC10
  • *
  • Mensajes: 43
RE: leyendo memoria 24cxx
« Respuesta #6 en: 15 de Septiembre de 2005, 00:31:00 »
Por lo que veo, en tu programa estas haciendo una lectura secuencial.

En tu codigo comienzas a leer de la direccion 0:
 inicio movlw 00
 movwf ADDR ;direccion

y luego la vas incrementando. Si tu programa está funcionando, lo unico que deberias hacer es cambiar el valor de la direccion y quitar el  "goto bucle" para que no se cicle.

Desconectado DannielHP

  • PIC10
  • *
  • Mensajes: 43
RE: leyendo memoria 24cxx
« Respuesta #7 en: 15 de Septiembre de 2005, 00:37:00 »
Ah, en b"1010xxx0 las x significa que no importa si es 1 o 0, da igual, no pasa nada.

Desconectado vszener

  • Moderadores
  • PIC24H
  • *****
  • Mensajes: 2395
RE: leyendo memoria 24cxx
« Respuesta #8 en: 15 de Septiembre de 2005, 07:24:00 »
Ke tal!!!bueno, si lo que quieres es ejemplos de como escribir y leer una memoria eeprom externa, en el subforo de c concretamente en el post de ejemplitos en c hay un programa de como leer y escribir en una memoria externa eeprom 24LC256 con un 16F648A e incluso esta la simulacion en PROTEUS......si quieres puedes adaptar el codigo para el 16F84A no es dificil....aqui el enlace:
http://miarroba.com/foros/ver.php?foroid=46840&temaid=4061462&pag=5
Giño
· Nos vemos en los bares!!!!!
· Mi Blog: Aqueronte

Desconectado manongo_123

  • PIC10
  • *
  • Mensajes: 25
RE: leyendo memoria 24cxx
« Respuesta #9 en: 17 de Septiembre de 2005, 21:04:00 »


   gracias amigos, por la ayuda que me dan, me sacan un gran peso de encima pues ahora me dedicare a experimentarlo, y a estudiarlo.
   escribi esta pregunta, pues no entendia, y ya me duele la cabeza leer tantos datashets, y es que deberia a ver un solo ejemplo en "asembler"  de un pic 16f84a y una memoria conectadas y que haga como minimo un secuencial en el puerto b por ejemplo, pues he buscado y no he encontrado. eso solo eso necesito para poder entrarme en esto, pues si alguien me dice donde encontrarlo se lo agradeceria de corazon, y ya muchas gracias pór todo.

Desconectado vszener

  • Moderadores
  • PIC24H
  • *****
  • Mensajes: 2395
RE: leyendo memoria 24cxx
« Respuesta #10 en: 18 de Septiembre de 2005, 04:28:00 »
Hola manongo_123!!!haber, cada vez que tratamos con dispositivos externos al pic(memorias,rtc,...) normalmente lo que se usan son librerias de los mismos ya que estos necesitan inicializarse y demas y por supuesto porque si lo queremos utilizar en otro programa no tendremos que volver a escribir todo el codigo de nuevo, sino solamente incluir la libreria. Los data sheet son necesarios cada vez que uses elementos externos por lo que te he comentado anteriormente, porque necesitan una inicializacion y tienen su "trato" particular, de todas formas hay un libro llamado: Microcontrolador PIC16F84 Desarrollo de proyectos el cual esta muy completo y viene con ejemplo de como escribir eeproms concreamente la 24LC256, aqui te dejo uno de los ejemplos:

Codigo:
;************************************ I2C_EEPROM_01.asm *******************************
;
;   ===================================================================
;     Del libro "MICROCONTROLADOR PIC16F84. DESARROLLO DE PROYECTOS"
;     E. Palacios, F. Remiro y L. López.
;      Editorial Ra-Ma.  www.ra-ma.es
;   ===================================================================
;
; Programa para manejar la escritura y lectura en la memoria EEPROM serie 24LC256.
; Tiene dos partes:
;    1ª   Escribe un mensaje grabado en el programa del PIC16F84A a partir de la posición
;   3B00h dentro de la 24LC256.
;    2ª   Lee el mensaje grabado en la memoria 24LC256 anteriormente y lo visualiza en la
;   pantalla del módulo LCD.
;
; El mensaje tendrá menos de 16 caracteres, que es la máxima longitud de la pantalla.
;
; ZONA DE DATOS **********************************************************************

   __CONFIG   _CP_OFF &  _WDT_OFF & _PWRTE_ON & _XT_OSC
   LIST      P=16F84A
   INCLUDE  <P16F84A.INC>

   CBLOCK   0x0C
   ENDC

Pagina   EQU   0x3B         ; Escribe y lee en esta página, por ejemplo.

; ZONA DE CÓDIGOS ********************************************************************

   ORG    0
Inicio
   call   LCD_Inicializa
Principal
   movlw   Pagina         ; Escribe a partir de la dirección 0 de esta
   call    M24LC256_EscribeMensaje   ; página de la memoria.
   movlw   Pagina         ; Lee a partir de la dirección 0 de esta página
   call   M24LC256_Mensaje_a_LCD   ; de la memoria.
   sleep            ; Pasa a reposo.

; Subrutina "M24LC256_EscribeMensaje" ----------------------------------------------------------------
;
; Escribe la memoria M24LC256 con el mensaje grabado al final de este programa a partir
; de la posición 0 de la página de la memoria 24LC256, señalada por el contenido del
; registro de trabajo W.
; El tamaño de memoria que se puede grabar por este procedimiento es de 64 bytes como máximo.

   CBLOCK
   ValorCaracter         ; Valor ASCII del carácter a escribir.
   ENDC

M24LC256_EscribeMensaje
   movwf   M24LC256_AddressHigh   ; El registro W apunta a la página donde va a
   clrf   M24LC256_AddressLow   ; grabar el mensaje a partir de la dirección 0.
   call   M24LC256_InicializaEscritura
M24LC256_EscribeOtroByte
   movf   M24LC256_AddressLow,W
   call   Mensaje         ; Obtiene el código ASCII del carácter.
   movwf   ValorCaracter      ; Guarda el valor de carácter que ha leído del
   call   I2C_EnviaByte      ; mensaje y lo escribe en la 24LC256.
   call   Retardo_5ms      ; Tiempo de escritura entre byte y byte.
   movf   ValorCaracter,F      ; Lo único que hace es posicionar flag Z. En caso
   btfsc   STATUS,Z      ; de que sea "0x00", que es código indicador final
   goto   FinEscribeMensaje      ; del mensaje sale de la subrutina.
   incf   M24LC256_AddressLow,F
   goto   M24LC256_EscribeOtroByte
FinEscribeMensaje
   call   I2C_EnviaStop      ; Termina la escritura.
   call   Retardo_5ms
   return

Mensaje
   addwf   PCL,F
   DT " Estudia D.P.E.",0x0

   INCLUDE  <BUS_I2C.INC>      ; Subrutinas de control del bus I2C.
   INCLUDE  <M24LC256.INC>   ; Subrutinas de control de la memoria 24LC256.
   INCLUDE  <RETARDOS.INC>
   INCLUDE  <LCD_4BIT.INC>
   END
   
;   ===================================================================
;     Del libro "MICROCONTROLADOR PIC16F84. DESARROLLO DE PROYECTOS"
;     E. Palacios, F. Remiro y L. López.
;      Editorial Ra-Ma.  www.ra-ma.es
;   ===================================================================


Suerte!!!Giño
· Nos vemos en los bares!!!!!
· Mi Blog: Aqueronte

Desconectado vszener

  • Moderadores
  • PIC24H
  • *****
  • Mensajes: 2395
RE: leyendo memoria 24cxx
« Respuesta #11 en: 18 de Septiembre de 2005, 04:33:00 »
Bueno y aqui te dejo la libreria de la memoria eeprom 24lc256:

Codigo:
;**************************** Librería "M24LC256.INC" ***********************************
;
;   ===================================================================
;     Del libro "MICROCONTROLADOR PIC16F84. DESARROLLO DE PROYECTOS"
;     E. Palacios, F. Remiro y L. López.
;      Editorial Ra-Ma.  www.ra-ma.es
;   ===================================================================
;
; Estas subrutinas permiten realizar las tareas de manejo de la memoria EEPROM serie
; 24LC256 que transmite y recibe la información vía serie a través de un bus I2C.
;
; Subrutina "M24LC256_InicializaEscritura" ----------------------------------------------
;
; Prepara la memoria para iniciar su escritura a partir de la posición de memoria fijada
; por los registros:
; - (M24LC256_AddressHigh), indica el número del bloque o página de memoria a escribir.
; - (M24LC256_AddressLow), indica posición a escribir dentro del bloque.

   CBLOCK
   M24LC256_AddressHigh      ; Guarda el valor de la dirección de memoria a
   M24LC256_AddressLow      ; escribir o leer.
   M24LC256_Dato
   ENDC
;
M24LC256_DireccionEscritura    EQU   b"10100000"; Dirección de la memoria 24LC256 para
M24LC256_DireccionLectura    EQU   b"10100001"; escritura y lectura respectivamente.

M24LC256_InicializaEscritura
   call   I2C_EnviaStart      ; Envía condición de Start.
   movlw   M24LC256_DireccionEscritura; Envía dirección de escritura del
   call   I2C_EnviaByte      ; esclavo.
   movf   M24LC256_AddressHigh,W   ; A partir de la dirección apuntada por los
   call   I2C_EnviaByte      ; registros M24LC256_AddressHigh y
   movf   M24LC256_AddressLow,W   ; M24LC256_AddressLow.
   call   I2C_EnviaByte
   return   

; Subrutina "M24LC256_InicializaLectura" ------------------------------------------------
;
; Prepara la memoria para iniciar su lectura a partir de la posición de memoria fijada
; por los registros:
; - (M24LC256_AddressHigh), indica el número del bloque o página de memoria a leer.
; - (M24LC256_AddressLow), indica posición a escribir dentro del bloque.

M24LC256_InicializaLectura
   bcf   I2C_UltimoByteLeer   ; Todavía no ha comenzado a leer ningún dato.
   call   I2C_EnviaStart      ; Envía condición de Start.
   movlw   M24LC256_DireccionEscritura; Envía dirección de escritura del
   call   I2C_EnviaByte      ; esclavo.
   movf   M24LC256_AddressHigh,W   ; A partir de la dirección apuntada por los
   call   I2C_EnviaByte      ; registros M24LC256_AddressHigh y
   movf   M24LC256_AddressLow,W   ; M24LC256_AddressLow.
   call   I2C_EnviaByte
   call   I2C_EnviaStop
;
   call   I2C_EnviaStart      ; Envía condición de Start.
   movlw   M24LC256_DireccionLectura   ; Indica a la memoria 24LC256 que va a
   call   I2C_EnviaByte      ; proceder a la lectura.
   return

; Subrutina "M24LC256_Mensaje_a_LCD" ----------------------------------------------------
;
; Lee el mensaje grabado en la memoria 24LC256 y lo visualiza en la pantalla del módulo LCD.
; En el registro de trabajo W se introduce la página de la memoria a partir de cuya primera
; posición se va a leer. La lectura termina cuando encuentre el código 0x00. Así por ejemplo,
; si (W)=2Fh lee el mensaje que comienza en la posición 0 de la página 2Fh de la memoria,
; que es la posición 2F00h absoluta.
;
   CBLOCK
;   M24LC256_ValorCaracter      ; Valor ASCII del carácter leído.
   ENDC

;M24LC256_Mensaje_a_LCD
   movwf   M24LC256_AddressHigh   ; Apunta al inicio de la página correspondiente.
   clrf   M24LC256_AddressLow
   call   M24LC256_InicializaLectura
M24LC256_LeeOtroByte
   call   I2C_LeeByte      ; Lee la memoria 24LC256.
   movwf   M24LC256_ValorCaracter   ; Guarda el valor de carácter.
   movf   M24LC256_ValorCaracter,F   ; Lo único que hace es posicionar flag Z. En caso
   btfsc   STATUS,Z      ; que sea "0x00", que es código indicador final   
   goto   M24LC256_FinMensaje   ; del mensaje, sale de la subrutina.
   movf   M24LC256_ValorCaracter,W   ; Recupera el valor leído.
   call   LCD_Caracter      ; Lo visualiza en la pantalla del LCD.
   incf   M24LC256_AddressLow,F   ; Apunta a la siguiente posición.
   goto   M24LC256_LeeOtroByte
;M24LC256_FinMensaje
;   call   M24LC_256_FinalizaLectura
;   return

; Subrutina "M24LC256_FinalizaLectura" ------------------------------------------------
;
; Activa el bit I2C_UltimoByteLeer para que la subrutina I2C_LeeByte ponga en alta
; impedancia la línea SDA y pueda ejecutarse posteriormente la condición de Start o Stop
; que fija el protocolo del bus I2C.

M24LC256_FinalizaLectura
   bsf   I2C_UltimoByteLeer   ; Con estas dos instrucciones se pone en
   call   I2C_LeeByte      ; alta impedancia la línea SDA. No importa el
   call   I2C_EnviaStop      ; resultado de la lectura realizada.
   return

; Subrutina "M24LC256_Mensaje_a_LCD" ----------------------------------------------------
;
; Lee un mensaje grabado en la memoria 24LC256 y lo visualiza por el módulo LCD. En caso que
; sea más largo que la longitud de la pantalla se desplaza hacia la izquierda con sensación
; de movimiento. En el registro de trabajo W se introduce la página de la memoria a partir
; de cuya primera posición va a leer. La visualización termina cuando encuentre el código
; 0x00. Así por ejemplo si (W)= 2Fh lee el mensaje que comienza en la posición 0 de la
; página 2Fh de la memoria, que es la posición 2F00h absoluta.
;
   CBLOCK
   M24LC256_ValorCaracter      ; Valor ASCII del carácter leído.
   M24LC256_CursorPosicion
   ENDC
   
M24LC256_Mensaje_a_LCD
   bcf   I2C_UltimoByteLeer
   movwf   M24LC256_AddressHigh   ; Apunta al inicio de la página correspondiente.
   clrf   M24LC256_AddressLow
   call   M24LC256_InicializaLectura
M24LC256_PrimeraPosicion
   clrf   M24LC256_CursorPosicion   ; El cursor en la posición 0 de la línea.
   call   LCD_Borra      ; Se sitúa en la primera posición de la línea 1 y
M24LC256_VisualizaCaracter         ; borra la pantalla.
   movlw   LCD_CaracteresPorLinea   ; ¿Ha llegado a final de línea?
   subwf   M24LC256_CursorPosicion,W
   btfss   STATUS,C
   goto   M24LC256_NoEsFinalLinea
M24LC256_EsFinalLinea
   call   Retardo_200ms      ; Lo mantiene visualizado durante este tiempo.
   call   Retardo_200ms
   call   M24LC256_FinalizaLectura
   incf   M24LC256_AddressLow,F
   call   M24LC256_InicializaLectura
   goto   M24LC256_PrimeraPosicion
M24LC256_NoEsFinalLinea
   call   I2C_LeeByte      ; Obtiene el ASCII del carácter apuntado.
   movwf   M24LC256_ValorCaracter   ; Guarda el valor de carácter.
   movf   M24LC256_ValorCaracter,F   ; Lo único que hace es posicionar flag Z. En caso
   btfsc   STATUS,Z      ; que sea "0x00", que es código indicador final
   goto   M24LC256_FinMensaje   ; de mensaje, sale fuera.
M24LC256_NoUltimoCaracter
   call   LCD_Caracter      ; Visualiza el carácter ASCII leído.
   incf   M24LC256_CursorPosicion,F   ; Contabiliza el incremento de posición del
               ; cursor en la pantalla.
   goto   M24LC256_VisualizaCaracter   ; Vuelve a visualizar el siguiente carácter
M24LC256_FinMensaje         ; de la línea.
   call   M24LC256_FinalizaLectura
   return

;   ===================================================================
;     Del libro "MICROCONTROLADOR PIC16F84. DESARROLLO DE PROYECTOS"
;     E. Palacios, F. Remiro y L. López.
;      Editorial Ra-Ma.  www.ra-ma.es
;   ===================================================================


Por cierto, el libro tiene su propia pagina web donde hay ejemplos y la simulacion en PROTEUS, aqui el enlace:
www.pic16f84a.com
Y aqui el enlace a la pagina de uno de sus autores:
http://www.terra.es/personal/fremiro/home.htm

Suerte!!!Giño
· Nos vemos en los bares!!!!!
· Mi Blog: Aqueronte


 

anything