Autor Tema: Escribir EEPROM externa 24LC256 directamente desde el programador  (Leído 8295 veces)

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

Desconectado falflores

  • PIC16
  • ***
  • Mensajes: 173
    • Control, electrónica y programación en español
Hola de nuevo amigos, sigo con las matrices de LEDs y ahora he decidido mudarme a una EEPROM externa, ya que en la EEPROM del 16F887 solo me caben de la A a la Z y del 0 al 7, en cambio esta memoria le cabe un mundo!.

La cuestión es la siguiente: ¿Alguien sabe como se puede hacer un programa en CCS para grabar directamente la memoria estando conectada en el programador y sin que medie un PIC?, y ¿Saben si se puede programar como en la EEPROM de los PICs con la directiva #rom?

Les pregunto esto, por que en el menu de dispositivos en el MPlab, me aparece la memoria en cuestión, pero al parecer necesita otro compilador distinto que marca como "no encontrado".

Lo que estoy tratando de hacer en este momento es cargarle los datos a mi EEPROM desde un PIC, al que le he cargado todos los datos en la ROM, pero aqui tambien tengo algunos problemas, ya que si le doy una lista de digamos 100 bytes a guardar, y le doy la direccion 0 para comenzar, solo me graba a partir del 75 en la dirección 0, ya probe a darle más tiempo y tambien a refrescarle la instrucción i2c_start(); ya que la comunicacion la hago por i2c desde el modulo del PIC, pero no hay manera!, siempre me hace lo mismo, alguna idea de que puede ser, o si se puede hacer directo desde el programador?, mi programador es el piickit2 que si tiene soporte para esta memoria.

El codigo que tengo para el grabado desde el PIC es el siguiente:

Código: [Seleccionar]
#include<16F887.h>
//#include<stdlib.h>
#fuses INTRC,MCLR,NOLVP,NOPROTECT,NOWDT
#use delay(clock=4000000)
#use fast_io(C)
#use fast_io(D)
#use i2c(master,SDA=PIN_C4,SCL=PIN_C3) 
#include"flex_lcd.h"

#define READ 0b10100001   // byte para escritura
#define WRITE 0b10100000   // byte para lectura

int8 may_A[7] = { 0x06,0xFC,0x12,0x11,0x11,0x12,0xFC }; //A
int8 may_B[7] = { 0x06,0xFF,0x89,0x89,0x89,0x89,0x76 }; //B
int8 may_C[7] = { 0x06,0x7E,0x81,0x81,0x81,0x81,0x42 }; //C
int8 may_D[7] = { 0x06,0xFF,0X81,0X81,0X81,0X42,0X3C }; //D
int8 may_E[7] = { 0x06,0XFF,0X89,0X89,0X89,0X81,0X81 }; //E
int8 may_F[7] = { 0x06,0XFF,0X09,0X09,0X09,0X01,0X01 }; //F
int8 may_G[7] = { 0x06,0X7E,0X81,0X81,0X91,0X91,0X72 }; //G
int8 may_H[7] = { 0x06,0XFF,0X08,0X08,0X08,0X08,0XFF }; //H

void configure()
{
set_tris_C(0);
set_tris_D(0);
output_C(0);
output_D(0);
lcd_init();
}

void main()
{
configure();
int8 i,x=10;
lcd_putc("\fComienza\nescritura...");
delay_ms(1000);
i2c_start();         // Inicia comunicacion i2c
i2c_write(WRITE);    //Deseo escribir
i2c_write(0x00);     //Direccion de inicio
i2c_write(0x00);
for(i=0;i<7;i++) i2c_write(may_A[i]);   // Todos los bytes a guardar..........
delay_ms(x);
for(i=0;i<7;i++) i2c_write(may_B[i]);
delay_ms(x);
for(i=0;i<7;i++) i2c_write(may_C[i]);
delay_ms(x);
for(i=0;i<7;i++) i2c_write(may_D[i]);
delay_ms(x);
for(i=0;i<7;i++) i2c_write(may_E[i]);
delay_ms(x);
for(i=0;i<7;i++) i2c_write(may_F[i]);
delay_ms(x);
for(i=0;i<7;i++) i2c_write(may_G[i]);
delay_ms(x);
for(i=0;i<7;i++) i2c_write(may_H[i]);
delay_ms(x);
i2c_stop();   // Termina comunicacion i2c

lcd_putc("\fFin de\nescritura...");
}

Lo corte para no poner todo completo, pero en esencia hago lo mismo con las demás.

Por cierto, saben alguna otra forma de grabarle los datos, en lugar de declarar un arreglo para cada caracter?, recordar que el numero de bytes puede variar. Gracias por su tiempo y ayuda.

Los invito a mi blog "Control, electrónica y programación en español" www.robotnias.blogspot.com

Desconectado MGLSOFT

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 7912
Re: Escribir EEPROM externa 24LC256 directamente desde el programador
« Respuesta #1 en: 28 de Marzo de 2011, 22:19:36 »
Que eeprom externa usas??
Winpic mas el GTP-USB+ graban memorias eeprom si tienes un zocalo listo conectado al icsp del grabador.... :mrgreen: :mrgreen:
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

Desconectado falflores

  • PIC16
  • ***
  • Mensajes: 173
    • Control, electrónica y programación en español
Re: Escribir EEPROM externa 24LC256 directamente desde el programador
« Respuesta #2 en: 28 de Marzo de 2011, 23:08:46 »
Utilizo una 24LC256, el problema no es el software para grabar, ya que el pickit 2 tambien graba las memorias, el problema es que me gustaria grabarla a través de un programa para su fácil modificación.
Los invito a mi blog "Control, electrónica y programación en español" www.robotnias.blogspot.com

Desconectado Suky

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 6758
Re: Escribir EEPROM externa 24LC256 directamente desde el programador
« Respuesta #3 en: 28 de Marzo de 2011, 23:33:49 »
Hola! No existe directiva alguna (Como #rom) que guarde directamente en la memoria externa, y la utilidad que ves en MPLAB es seguramente para modificar los hex de una memoria y grabarla por medio de un programador.

Ahora, por cada bytes que envíes a una memoria eeprom 24XX debes esperar mínimo 5ms, sino también tienes la posibilidad de testear el estado de la misma. Otra posibilidad es enviar por página. Fíjate que CCS tiene librerías para su control


Saludos!
No contesto mensajes privados, las consultas en el foro

Desconectado falflores

  • PIC16
  • ***
  • Mensajes: 173
    • Control, electrónica y programación en español
Re: Escribir EEPROM externa 24LC256 directamente desde el programador
« Respuesta #4 en: 29 de Marzo de 2011, 02:29:00 »
Ahora, por cada bytes que envíes a una memoria eeprom 24XX debes esperar mínimo 5ms, sino también tienes la posibilidad de testear el estado de la misma. Otra posibilidad es enviar por página. Fíjate que CCS tiene librerías para su control

A que te refieres con enviar por página?, y ya intente lo de darle mas de 5ms (le doy 10) entre cada escritura y sigue saltandose muchas grabaciones.

Gracias por las rspuestas.
Los invito a mi blog "Control, electrónica y programación en español" www.robotnias.blogspot.com

Desconectado Suky

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 6758
Re: Escribir EEPROM externa 24LC256 directamente desde el programador
« Respuesta #5 en: 29 de Marzo de 2011, 10:03:47 »
Ahora, por cada bytes que envíes a una memoria eeprom 24XX debes esperar mínimo 5ms, sino también tienes la posibilidad de testear el estado de la misma. Otra posibilidad es enviar por página. Fíjate que CCS tiene librerías para su control

A que te refieres con enviar por página?, y ya intente lo de darle mas de 5ms (le doy 10) entre cada escritura y sigue saltandose muchas grabaciones.

Gracias por las rspuestas.

Puedes leer el datasheet de la memoria, el tamaño de la página depende de su capacidad. Y al hacer...

Código: [Seleccionar]
for(i=0;i<7;i++) i2c_write(may_A[i]);   // Todos los bytes a guardar..........
delay_ms(x);
for(i=0;i<7;i++) i2c_write(may_B[i]);

NO estas esperando 10ms por cada escritura.


Saludos!

No contesto mensajes privados, las consultas en el foro

Desconectado falflores

  • PIC16
  • ***
  • Mensajes: 173
    • Control, electrónica y programación en español
Re: Escribir EEPROM externa 24LC256 directamente desde el programador
« Respuesta #6 en: 29 de Marzo de 2011, 13:56:32 »
Jejeje, bueno, la verdad es que modifique el código, para que entre cada grabacion fueran 10 ms, poniendo un delay_ms(x), donde x=10, dentro de cada ciclo for, aunque se me paso postearlo, pero de todas formas sigue ocurriendo.

Me canse de tratar por ese medio, y segui tu el consejo de Suky, ahora estoy utilizando una libreria para leer la eeprom, es la 24256.c, y se resolvieron algunas cuestiones, pero todavia siguen grabandose solo algunos datos.

De esta forma se graban bien hasta la W, pero si el programa lo hago para que grabe más alla de W, entonces me comienza a escribir incoherencias en todo el principio de la memoria, y los datos que ya tenia los sobre escribe.

Ahora tengo asi mi programa:

Código: [Seleccionar]
#include<16F887.h>
//#include<stdlib.h>
#fuses INTRC,MCLR,NOLVP,NOPROTECT,NOWDT
#use delay(clock=4000000)
#use fast_io(C)
#use fast_io(D)
#use i2c(master,SDA=PIN_C4,SCL=PIN_C3) 
#include"flex_lcd.h"
#include"24256.h"
/*********************************************************************************************
ETIQUETAS
*********************************************************************************************/
//Direcciones
#define MAY_A_ADD 0x0000
#define MAY_B_ADD 0x0007
#define MAY_C_ADD 0x000E
#define MAY_D_ADD 0x0015
#define MAY_E_ADD 0x001C
#define MAY_F_ADD 0x0023
#define MAY_G_ADD 0x002A
#define MAY_H_ADD 0x0031
#define MAY_I_ADD 0x0038
#define MAY_J_ADD 0x003E
#define MAY_K_ADD 0x0045
#define MAY_L_ADD 0x004C
#define MAY_M_ADD 0x0053
#define MAY_N_ADD 0x005C
#define MAY_NN_ADD 0x0063
#define MAY_O_ADD 0x006A
#define MAY_P_ADD 0x0071
#define MAY_Q_ADD 0x0078
#define MAY_R_ADD 0x007F
#define MAY_S_ADD 0x0086
#define MAY_T_ADD 0x008D
#define MAY_U_ADD 0x0093
#define MAY_V_ADD 0x009A
#define MAY_W_ADD 0x00A1
#define MAY_X_ADD 0x00AA
#define MAY_Y_ADD 0x00B1
#define MAY_Z_ADD 0x00B7

#define cero_ADD 0x00BE
#define uno_ADD 0x00C5
#define dos_ADD 0x00C9
#define tres_ADD 0x00D0
#define cuatro_ADD 0x00D7
#define cinco_ADD 0x00DE
#define seis_ADD 0x00E5
#define siete_ADD 0x00EC
#define space_ADD 0x00F3

// Tabla de caracteres en EEPROM interna ****************************************************
// El primer byte de cada letra indica el numero de bytes que componen el caracter
int8 may_A[7] = { 0x06,0xFC,0x12,0x11,0x11,0x12,0xFC }; //A
int8 may_B[7] = { 0x06,0xFF,0x89,0x89,0x89,0x89,0x76 }; //B
int8 may_C[7] = { 0x06,0x7E,0x81,0x81,0x81,0x81,0x42 }; //C
int8 may_D[7] = { 0x06,0xFF,0X81,0X81,0X81,0X42,0X3C }; //D
int8 may_E[7] = { 0x06,0XFF,0X89,0X89,0X89,0X81,0X81 }; //E
int8 may_F[7] = { 0x06,0XFF,0X09,0X09,0X09,0X01,0X01 }; //F
int8 may_G[7] = { 0x06,0X7E,0X81,0X81,0X91,0X91,0X72 }; //G
int8 may_H[7] = { 0x06,0XFF,0X08,0X08,0X08,0X08,0XFF }; //H
int8 may_I[6] = { 0x05,0X81,0X81,0XFF,0X81,0X81 }; //I
int8 may_J[7] = { 0x06,0X60,0X80,0X80,0X80,0X80,0X7F }; //J
int8 may_K[7] = { 0x06,0XFF,0X08,0X14,0X22,0X41,0X80 }; //K
int8 may_L[7] = { 0x06,0XFF,0X80,0X80,0X80,0X80,0X80 }; //L
int8 may_M[9] = { 0x08,0XFF,0X02,0X04,0X08,0X08,0X04,0X02,0xFF };         //M
int8 may_N[7] = { 0x06,0XFF,0X02,0X0C,0X30,0X40,0XFF }; //N
int8 may_NN[7] = { 0x06,0XFD,0X09,0X11,0X21,0X41,0XFD }; //Ñ
int8 may_O[7] = { 0x06,0X7E,0X81,0X81,0X81,0X81,0X7E }; //O
int8 may_P[7] = { 0x06,0XFF,0X11,0X11,0X11,0X11,0X0E }; //P
int8 may_Q[7] = { 0x06,0X7E,0X81,0X81,0XA1,0X41,0XBE }; //Q
int8 may_R[7] = { 0x06,0XFF,0X11,0X11,0X31,0X51,0X8E }; //R
int8 may_S[7] = { 0x06,0X46,0X89,0X89,0X89,0X89,0X72 }; //S
int8 may_T[6] = { 0x05,0x01,0x01,0xFF,0x01,0x01 }; //T
int8 may_U[7] = { 0x06,0x7F,0x80,0x80,0x80,0x80,0x7F }; //U
int8 may_V[7] = { 0x06,0x3F,0x40,0x80,0x80,0x40,0x3F }; //V
int8 may_W[9] = { 0x08,0x7F,0x80,0x40,0x20,0x20,0x40,0x80,0x7F };         //W
int8 may_X[7] = { 0x06,0xC3,0x24,0x18,0x18,0x24,0xC3 }; //X
int8 may_Y[6] = { 0x05,0x07,0x08,0xF0,0x08,0x07 }; //Y
int8 may_Z[7] = { 0x06,0xC1,0xA1,0x91,0x89,0x85,0x83 }; //Z

int8 cero[7] = { 0X06,0X7E,0X85,0X89,0X91,0XA1,0X7E }; //0
int8 uno[4] = { 0X03,0X04,0X02,0XFF }; //1
int8 dos[7] = { 0X06,0X86,0XC1,0XA1,0X91,0X89,0X86 }; //2
int8 tres[7] = { 0X06,0X41,0X81,0X81,0X89,0X95,0X63 }; //3
int8 cuatro[7] ={ 0X06,0X18,0X14,0X12,0X11,0XFF,0X10 }; //4
int8 cinco[7] = { 0X06,0X4F,0X89,0X89,0X89,0X89,0X71 }; //5
int8 seis[7] = { 0X06,0X7E,0X89,0X89,0X89,0X89,0X72 }; //6
int8 siete[7] = { 0X06,0X01,0X01,0XF1,0X09,0X05,0X03 }; //7
int8 space[9] = { 0X08,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00 };         //ESPACIO
//********************************************************************************************

void configure()
{
set_tris_C(0);
set_tris_D(0);
output_C(0);
output_D(0);
init_ext_eeprom();
lcd_init();
}

// Esta funcion escribe los bytes de un solo caracter, proporcionando un direccion inicial y los bytes,
//donde la direccion inicial posee el numero de bytes que contiene dicho caracter
void write2ext_eeprom(int8 address, int8 character)
{
int8 i;
int8 *lim;
lim=*character;
for(i=0;i<=lim;i++)
{
write_ext_eeprom(address,*character);
character++;
address++;
}
}

void main()
{
configure();
lcd_putc("\fEscribiendo...");

write2ext_eeprom(MAY_A_ADD,may_A);
write2ext_eeprom(MAY_B_ADD,may_B);
write2ext_eeprom(MAY_C_ADD,may_C);
write2ext_eeprom(MAY_D_ADD,may_D);
write2ext_eeprom(MAY_E_ADD,may_E);
write2ext_eeprom(MAY_F_ADD,may_F);
write2ext_eeprom(MAY_G_ADD,may_G);
write2ext_eeprom(MAY_H_ADD,may_H);
write2ext_eeprom(MAY_I_ADD,may_I);
write2ext_eeprom(MAY_J_ADD,may_J);
write2ext_eeprom(MAY_K_ADD,may_K);
write2ext_eeprom(MAY_L_ADD,may_L);
write2ext_eeprom(MAY_M_ADD,may_M);
write2ext_eeprom(MAY_N_ADD,may_N);
write2ext_eeprom(MAY_NN_ADD,may_NN);
write2ext_eeprom(MAY_O_ADD,may_O);
write2ext_eeprom(MAY_P_ADD,may_P);
write2ext_eeprom(MAY_Q_ADD,may_Q);
write2ext_eeprom(MAY_R_ADD,may_R);
write2ext_eeprom(MAY_S_ADD,may_S);
write2ext_eeprom(MAY_T_ADD,may_T);
write2ext_eeprom(MAY_U_ADD,may_U);
write2ext_eeprom(MAY_V_ADD,may_V);
write2ext_eeprom(MAY_W_ADD,may_W);
write2ext_eeprom(MAY_X_ADD,may_X);
write2ext_eeprom(MAY_Y_ADD,may_Y);
write2ext_eeprom(MAY_Z_ADD,may_Z);
write2ext_eeprom(cero_ADD,cero);
write2ext_eeprom(uno_ADD,uno);
write2ext_eeprom(dos_ADD,dos);
write2ext_eeprom(tres_ADD,tres);
write2ext_eeprom(cuatro_ADD,cuatro);
write2ext_eeprom(cinco_ADD,cinco);
write2ext_eeprom(seis_ADD,seis);
write2ext_eeprom(siete_ADD,siete);
write2ext_eeprom(space_ADD,space);

lcd_putc("\fFin de\nescritura...");
}

Tengo otra duda, se supone que con el uso de esta libreria ya no es necesario darle los 5ms de espera entre escrituras?
Los invito a mi blog "Control, electrónica y programación en español" www.robotnias.blogspot.com

Desconectado Suky

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 6758
Re: Escribir EEPROM externa 24LC256 directamente desde el programador
« Respuesta #7 en: 29 de Marzo de 2011, 15:17:14 »
Veo que lim es un puntero, y que le asignas el valor que apunta character  :? Puedes ingresar como parámetro a la función la dirección del buffer del carácter a escribir y eso lo haces mediante un puntero, pero la cantidad de caracteres debes determinarlo de otra manera. O es fijo o debes usar un carácter nulo para determinar el tamaño del buffer.

Revisa el siguiente tutorial de punteros en ANSI C: http://www.mediafire.com/?yntgemnokti

Contenido:

Capítulo 1: ¿Qué es un Apuntador? ................................................................ 4
Capítulo 2: Tipos de Apuntadores y Arreglos................................................. 9
Capítulo 3: Apuntadores y Cadenas. ............................................................... 13
Capítulo 4: Más sobre Cadenas. ...................................................................... 17
Capítulo 5: Apuntadores y Estructuras. .......................................................... 19
Capítulo 6: Más sobre Cadenas y Arreglos de Cadenas. ................................ 23
Capítulo 7: Más sobre Arreglos Multidimensionales...................................... 27
Capítulo 8: Apuntadores a Arreglos................................................................ 29
Capítulo 9: Apuntadores y Gestión Dinámica de Memoria. ........................... 31
Capítulo 10: Apuntadores a Funciones ............................................................. 38



Y si usas la librería ya no necesitas la demora de 5ms, si la estudias te darás cuenta que la librería testea el estado de la memoria antes de salir de la función de escritura.


Saludos!
No contesto mensajes privados, las consultas en el foro

Desconectado falflores

  • PIC16
  • ***
  • Mensajes: 173
    • Control, electrónica y programación en español
Re: Escribir EEPROM externa 24LC256 directamente desde el programador
« Respuesta #8 en: 31 de Marzo de 2011, 13:57:02 »
Veo que lim es un puntero, y que le asignas el valor que apunta character  :? Puedes ingresar como parámetro a la función la dirección del buffer del carácter a escribir y eso lo haces mediante un puntero, pero la cantidad de caracteres debes determinarlo de otra manera. O es fijo o debes usar un carácter nulo para determinar el tamaño del buffer.

Y si usas la librería ya no necesitas la demora de 5ms, si la estudias te darás cuenta que la librería testea el estado de la memoria antes de salir de la función de escritura.

Es cirto Suky, ahora veo que la demora no es necesaria.

Muchas gracias por el link, la verdad está muy completo, al realizar mi programa todavia me confundía un poco con lo de los apuntadores, y en el texto lo explican muy bien, voy a revisar para ver si es algún error de programacion y lo comento.

Gracias.
Los invito a mi blog "Control, electrónica y programación en español" www.robotnias.blogspot.com

Desconectado jamasari

  • PIC10
  • *
  • Mensajes: 32
Re: Escribir EEPROM externa 24LC256 directamente desde el programador
« Respuesta #9 en: 12 de Noviembre de 2011, 22:38:58 »
Amigo Falflorez me interesa mucho este tema y veo que pudiste minimizar las demoras.

podrias subir el codigo para mirarlo un poco es que tengo algo de problemas con este tema y deseo aprender un poco mas


Gracias

Desconectado falflores

  • PIC16
  • ***
  • Mensajes: 173
    • Control, electrónica y programación en español
Re: Escribir EEPROM externa 24LC256 directamente desde el programador
« Respuesta #10 en: 12 de Noviembre de 2011, 23:57:46 »
Amigo Falflorez me interesa mucho este tema y veo que pudiste minimizar las demoras.

podrias subir el codigo para mirarlo un poco es que tengo algo de problemas con este tema y deseo aprender un poco mas

Claro, este es el que ocupe:

Código: [Seleccionar]
#include<16F887.h>
//#include<stdlib.h>
#fuses HS,MCLR,NOLVP,NOPROTECT,NOWDT
#use delay(clock=20MHz)
#use fast_io(C)
#use i2c(master,SDA=PIN_C4,SCL=PIN_C3)  
#include"24256.h"

#define MAY_A_ADD 0x0000
#define MAY_B_ADD 0x0007
#define MAY_C_ADD 0x000E
#define MAY_D_ADD 0x0015
#define MAY_E_ADD 0x001C

int8 may_A[7] = { 0x06,0xFC,0x12,0x11,0x11,0x12,0xFC }; //A - direccion: 0x0000
int8 may_B[7] = { 0x06,0xFF,0x89,0x89,0x89,0x89,0x76 }; //B - direccion: 0x0007
int8 may_C[7] = { 0x06,0x7E,0x81,0x81,0x81,0x81,0x42 }; //C - direccion: 0x000E
int8 may_D[7] = { 0x06,0xFF,0X81,0X81,0X81,0X42,0X3C }; //D - direccion: 0x0015
int8 may_E[7] = { 0x06,0XFF,0X89,0X89,0X89,0X81,0X81 }; //E - direccion: 0x001C

void write2ext_eeprom(int16 address, int8 *character)
{
int8 i;
int8 *lim;
lim=*character;
for(i=0;i<=lim;i++)
{
write_ext_eeprom(address,*character);
character++;
address++;
}
}

void main()
{
init_ext_eeprom();

write2ext_eeprom(MAY_A_ADD,may_A);
write2ext_eeprom(MAY_B_ADD,may_B);
write2ext_eeprom(MAY_C_ADD,may_C);
write2ext_eeprom(MAY_D_ADD,may_D);
write2ext_eeprom(MAY_E_ADD,may_E);
}

y la libreria la puedes encontrar en el CCS
« Última modificación: 13 de Noviembre de 2011, 15:00:46 por falflores »
Los invito a mi blog "Control, electrónica y programación en español" www.robotnias.blogspot.com