Autor Tema: Circuito y Driver C para 4 Memorias EEPROM 24AA1025 con un total de 512 Kbytes  (Leído 14512 veces)

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

Desconectado pikman

  • Moderadores
  • PIC24F
  • *****
  • Mensajes: 675
Re: Circuito y Driver C para 4 Memorias EEPROM 24AA1025 con un total de 512 Kbytes
« Respuesta #15 en: 03 de Enero de 2007, 15:38:05 »
Es increible, increible........ademas de ahorrar codigo ahorra RAM y ROM......a veces pienso que nunca voya terminar de aprender a usar la cabeza...!!!! :mrgreen: :mrgreen:
saludos
PikMan

Desconectado pikman

  • Moderadores
  • PIC24F
  • *****
  • Mensajes: 675
Re: Circuito y Driver C para 4 Memorias EEPROM 24AA1025 con un total de 512 Kbytes
« Respuesta #16 en: 03 de Enero de 2007, 19:03:02 »
Bueno Sisco, ademas de darte las gracias por la ayuda te digo que el driver va como viento, funciona perfectamente, con las 24C512 y las 24C515 o 1025, muy economico por cierto :D :D
saludos
PikMan

Desconectado RedPic

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 5427
    • Picmania by Redraven
Re: Circuito y Driver C para 4 Memorias EEPROM 24AA1025 con un total de 512 Kbytes
« Respuesta #17 en: 03 de Enero de 2007, 19:18:38 »
Ufff ... he llegado tarde a la solución de mis propios errores  :mrgreen:

Pikman, ¿te importaría postear el código completo del driver tal como ha quedado?

Sisco, muchas gracias por tu aporte y tu interés en estos inventos.  :D

Contra la estupidez los propios dioses luchan en vano. Schiller
Mi Güeb : Picmania

Desconectado pikman

  • Moderadores
  • PIC24F
  • *****
  • Mensajes: 675
Re: Circuito y Driver C para 4 Memorias EEPROM 24AA1025 con un total de 512 Kbytes
« Respuesta #18 en: 03 de Enero de 2007, 19:54:47 »
Hola, DIEGO, pues como no aca esta, no difiere mucho de lo posteado, yo agregue la lectura, y la inicializacion del bus y los puertos, de cualquier modo no se si miraste la duda que te deje en le codigo tuyo

Código: [Seleccionar]

#use i2c(master, sda=EEPROM_SDA, scl=EEPROM_SCL)

void init_ext_eeprom()
{
   output_float(EEPROM_SCL);
   output_float(EEPROM_SDA);

}


typedef struct  {
     int1 b0:1; int1 b1:1; int1 b2:1;  int1 b3:1;  int1 b4:1;  int1 b5:1;  int1 b6:1;  int1 b7:1;
} Los_bits_de_un_Byte;


typedef struct {
        int8 byte0;
        int8 byte1;
        int8 byte2;

} My_Address;



void writeByte24512(My_Address memAddress, int8 data){

   short int status;

   Los_bits_de_un_Byte temp , ControlByte;

   temp = memAddress.byte2 ;

   ControlByte = 0b10100000; // 0xA0 - bit0 Write = 0

   ControlByte.b1 = temp.b0 ; // Chip Select Bit0
   ControlByte.b2 = temp.b1 ; // Chip Select Bit1
   ControlByte.b3 = temp.b2 ; // Chip Select Bit2

   i2c_start();
   i2c_write((int8)ControlByte);
   i2c_write(memAddress.byte1); // Address High Byte
   i2c_write(memAddress.byte0); // Address Low Byte
   i2c_write(data);
   i2c_stop();
   delay_ms(5);
}




int8 readByte24512(My_Address memAddress){

   int8 data;

   Los_bits_de_un_Byte temp,ControlByte;

   temp = memAddress.byte2 ;

   ControlByte = 0b10100000; // 0xA0 - bit0 Write = 0

   ControlByte.b1 = temp.b0 ; // Chip Select Bit0
   ControlByte.b2 = temp.b1 ; // Chip Select Bit1
   ControlByte.b3 = temp.b2 ; // Chip Select Bit2

   i2c_start();
   i2c_write((int8)ControlByte);
   i2c_write(memAddress.byte1); // Address High Byte
   i2c_write(memAddress.byte0); // Address Low Byte
   i2c_start();
   i2c_write((int8)ControlByte|1);
   data=i2c_read(0);
   i2c_stop();
   return data;

}

saludos
PikMan

Desconectado RedPic

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 5427
    • Picmania by Redraven
Re: Circuito y Driver C para 4 Memorias EEPROM 24AA1025 con un total de 512 Kbytes
« Respuesta #19 en: 04 de Enero de 2007, 03:21:32 »
No, amigo pikman, aún no lo he mirado. Estoy de trabajo hasta las orejas y no he tenido tiempo de ponerme con él. (Pero lo haré, vive diós que lo haré ja ja ja  :D :D :D)

Contra la estupidez los propios dioses luchan en vano. Schiller
Mi Güeb : Picmania

Desconectado pikman

  • Moderadores
  • PIC24F
  • *****
  • Mensajes: 675
Re: Circuito y Driver C para 4 Memorias EEPROM 24AA1025 con un total de 512 Kbytes
« Respuesta #20 en: 04 de Enero de 2007, 10:26:36 »
Hola, RED,  mira hice una prueba con el dirver para ver si funcionaba correctamente, escribiendo y leyendo cada posicion de memoria, desde 0 hasta 0x7FFF, y funciono correctamente, ademas la perfomace poco difiere a utilizar una sola memoria, pues en mi caso se almacenan datos que despues se transfieren a una PC con un protocolo propietario de correccion de errores bastante lento, pero con esto va muy bien, gracias a ti y a Sisco por supuesto.
saludos
PikMan

Desconectado pikman

  • Moderadores
  • PIC24F
  • *****
  • Mensajes: 675
Re: Circuito y Driver C para 4 Memorias EEPROM 24AA1025 con un total de 512 Kbytes
« Respuesta #21 en: 08 de Enero de 2007, 01:38:28 »
Por aca de nuevo, con mi version de driver, espero que les guste, claro que no voy a ganar en ahorro a Sispic, pero bueno una alternativa, que funciona tambien correctamente, y aplicable a casi todas las 24xxx que permiten direccionamiento por harware, solo lo he usado con las 24LC512 pero si se fijan como funciona la 1025 creo que funcionaria tambien sin modificaciones pero bueno no lo probe.

suerte.

Código: [Seleccionar]


///////////////////////////////////////////////////////////////////////////////////
////       Libreria para acceso lineal de 8 chips 24LC512                      ////
////                                                                           ////
////         Direccionamiento lineal de 0-0x7FFFF (512KBytes)                  ////
////       Provee la facilidad de usar hasta 8 chips como si fuese 1 solo      ////                                                                         ////
//// init_24512x8();  inicializa el bus                                        ////
////                                                                           ////
//// writeByte24512x8(a,d); escribir el byte d(int8) en la direccion a(int32)  ////
////                                                                           ////
//// d=ReadByte24512x8(a); lee el byte d(int8) desde la direccion a(int32)     ////
////                                                                           ////
////                                                                           ////
///////////////////////////////////////////////////////////////////////////////////



#ifndef EEPROM_SDA

#define EEPROM_SDA  PIN_B1
#define EEPROM_SCL  PIN_B0

#endif

#use i2c(master, sda=EEPROM_SDA, scl=EEPROM_SCL)

#define MULTIPLE_EEPROM_ADDRESS int32
#define EEPROM_SIZE   524288

void init_ext_eeprom()
{
   output_float(EEPROM_SCL);
   output_float(EEPROM_SDA);

}


void writeByte_24512x8(int32 memaddress, int8 data){

   int16 address;
   int8  controlbyte;
   short int status;
   
   address=memaddress;

   controlbyte=(0xa0 | ((make8(memaddress,2))<<1));

   i2c_start();
   i2c_write(controlbyte);
   i2c_write(address>>8);     
   i2c_write(address);         
   i2c_write(data);           
   i2c_stop();
   // AckNolege pooling
   i2c_start();
   status=i2c_write(controlbyte);
   while(status==1)
   {
   i2c_start();
   status=i2c_write(controlbyte);
   }
   i2c_stop();
}



int8 readByte_24512x8(int32 memaddress){

    int16 address;
    int8  controlbyte;
    int8  data;

    address=memaddress;
    controlbyte=(0xa0 | ((make8(memaddress,2))<<1));


    i2c_start();
    i2c_write(controlbyte);
    i2c_write(address>>8);
    i2c_write(address);             
    i2c_start();
    i2c_write(controlbyte|1); 
    data=i2c_read(0);
    i2c_stop();
    return data;
}



saludos
PikMan

Desconectado RedPic

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 5427
    • Picmania by Redraven
Re: Circuito y Driver C para 4 Memorias EEPROM 24AA1025 con un total de 512 Kbytes
« Respuesta #22 en: 08 de Junio de 2007, 07:29:27 »
Versión definitiva (por ahora) del Driver. Está probado y funciona a las mil maravillas.  :mrgreen:

Código: CSS
  1. /** \file Driver_24AA1025.c
  2.  * \brief Este fichero contiene funciones para el uso de las memorias Serial EEPROM mediante el bus I2C.
  3.  *
  4.  * Tiene capacidad para hasta 4 módulos de tipo 24AA1025 de Microchip,
  5.  * direcionadas individualmente mediante las constantes <b>deviceAddressX</b>
  6.  * correspondientes a las direcciones hardware de los chips.
  7.  *
  8.  * <b>¡Atención!</b> No inicia la comuniación I2C que debe ser iniciada externamente.
  9.  *
  10.  * \author Diego RedPic
  11.  */
  12.  
  13. // baseControlByte24AA1025 = 8 bits which mean ...
  14. //
  15. // Fixed (4 bits)            -> 1010
  16. // EE internal Block (1 bit) -> 0 for 0000/FFFF, 1 for 10000/1FFFF
  17. // Dev Hard Address (2 bits) -> 00 or 01 or 10 or 11
  18. // R/W (1 bit)               -> 0 -> Write / 1 -> Read
  19.  
  20. int8 const baseControlByte24AA1025 = 0b10100000;
  21. //                                     ----B10W
  22.  
  23.  
  24. // Aux Function /////////////////////////////////////////////////////////////
  25.  
  26. /** \brief Función para la escritura de un byte dando su valor y su dirección absoluta.
  27.   *
  28.   * Esta función decodifica la Dirección Absoluta de memoria en Dirección Relatiba, Banco y Device en las 24AA1025.
  29.   * \param absAddress Dirección absoluta de 32 bits a escribir (rango de 000000h a 080000h).
  30.   * \param[out] relAddress Direccion interna relativa (rango de 0000h a FFFFh).
  31.   * \param[out] cByte Composición del byte de cabecera que incluye el Banco y el Device.
  32.   * \return void
  33.   *
  34.   */
  35. void absoluteAddress_to_relativeAddressAndControlByte24AA1025(int32 absAddress, int16 &relAddress, int8 &cByte){
  36.  
  37.    int8 i;
  38.  
  39.    // Relative Address (Copiar los primeros 16 bits)
  40.    relAddress = 0;
  41.    for(i=0;i<16;i++){
  42.       if(bit_test(absAddress,i)==1){
  43.          bit_set(relAddress,i);
  44.       }
  45.    }
  46.    // Inicializa Control Byte
  47.    cByte = baseControlByte24AA1025;
  48.    // Bank
  49.    if(bit_test(absAddress,16)==1){
  50.       bit_set(cByte,3);
  51.    }
  52.    // Device A0
  53.    if(bit_test(absAddress,17)==1){
  54.       bit_set(cByte,1);
  55.    }
  56.    // Device A1
  57.    if(bit_test(absAddress,18)==1){
  58.       bit_set(cByte,2);
  59.    }
  60. }
  61.  
  62. // Main Functions /////////////////////////////////////////////////////////////
  63.  
  64.  
  65. /** \brief Función para la escritura de un byte dando su valor y su dirección absoluta en las 24AA1025
  66.   *
  67.   * Esta función incluye \c <b>delay</b> de 5 milisegundos tras su ejecución ¡NO DISMINUIR!.
  68.   * \param Address Dirección absoluta de 32 bits a escribir (rango de 000000h a 080000h).
  69.   * \param data Valor del byte a escribir (rango de 00h a ffh).
  70.   * \return void
  71.   */
  72. void writeByte24AA1025(int32 Address, int8 data){
  73.  
  74.    int8  controlByte;
  75.    int16 relativeAddress;
  76.  
  77.    absoluteAddress_to_relativeAddressAndControlByte24AA1025(Address,relativeAddress,controlByte);
  78.  
  79.    i2c_start();
  80.    i2c_write(controlByte);
  81.    i2c_write(relativeAddress>>8);
  82.    i2c_write(relativeAddress);
  83.    i2c_write(data);
  84.    i2c_stop();
  85.    delay_ms(5);
  86. }
  87.  
  88. /** \brief Función para la lectura de un byte dando su dirección absoluta en las 24AA1025
  89.   *
  90.   * \param Address Dirección absoluta de 32 bits a leer (rango de 000000h a 080000h).
  91.   * \return Devuelve byte (int8) con el contenido de dicha dirección.
  92.   */
  93. int8 readByte24AA1025silent(int32 Address){
  94.  
  95.    int8  returnByte=0;
  96.    int8  controlByte;
  97.    int16 relativeAddress;
  98.  
  99.    absoluteAddress_to_relativeAddressAndControlByte24AA1025(Address,relativeAddress,controlByte);
  100.  
  101.    i2c_start();
  102.    i2c_write(controlByte);
  103.    i2c_write(relativeAddress>>8);
  104.    i2c_write(relativeAddress);
  105.    i2c_start();
  106.    i2c_write(controlByte|1);
  107.    returnByte = i2c_read(0);
  108.    i2c_stop();
  109.    return returnByte;
  110. }
  111.  
  112. /** \brief Función para la lectura de un string en las 24AA1025 dando su dirección absoluta y su longitud.
  113.   *
  114.   * \param Address Dirección absoluta de 32 bits a leer (rango de 000000h a 080000h).
  115.   * \param Len Longitud de 8 bits de datos a leer (rango de 00h a FFh).
  116.   * \param[out] pF Puntero con el contenido de lo leído. Se carga de pF[0] a pF[Len-1] y se fuerza pF[Len] a \\0.
  117.   * \return void
  118.   */
  119. void readString24AA1025(int32 Address, int8 Len, char* pF){
  120.  
  121.    char  c;
  122.    int32 m;
  123.    int8  i;
  124.  
  125.    set_to_i2c_channel();
  126.    for(i=0,m=Address;i<Len;i++,m++){
  127.       c = readByte24AA1025silent(m);
  128.       pf[i]=c;
  129.    }
  130.    pf[Len]='\0';
  131.    set_to_ext_channel();
  132. }
  133.  
  134. /** \brief Función para de escritura de un campo en las 24AA1025 dando su dirección absoluta y su contenido.
  135.   *
  136.   * \param Address Dirección absoluta de 32 bits del primer byte del campo a escribir (rango de 000000h a 080000h).
  137.   * \param Len Longitud de 8 bits de datos a leer (rango de 00h a FFh).
  138.   * \param pF Puntero con el contenido del string que hay que escribir.
  139.   * \return void
  140.   */
  141. void writeString24AA1025(int32 Address, int8 Len, char* pF){
  142.  
  143.    int8  i;
  144.    int32 m;
  145.  
  146.    for(i=0,m=Address;i<Len_string,i<Len;i++,m++){
  147.       writeByte24AA1025silent(m,pF[i]);
  148.    }
  149. }
  150.  
  151. /** \brief Función que rellena las 24AA1025 desde una dirección absoluta de inicio hasta una de final y el carácter de relleno.
  152.   *
  153.   * \param Start_Address Dirección de inicio del volcado de momoria
  154.   * \param End_Address Dirección final del volcado de momoria
  155.   * \param FillChar Valor del Byte de relleno
  156.   *
  157.   * \return void
  158.   */
  159. void FillMemory24AA1025(int32 Start_Address, int32 End_Address, int8 FillChar){
  160.  
  161.    int32 m;
  162.  
  163.    for(m=Start_Address;m<End_Address+1;m++){
  164.       writeByte24AA1025silent(m,FillChar);
  165.    }
  166. }
  167.  
  168. ///////////////////////////////////////////////////////////////////////////////
  169.  

Lo de los 5 milisegundos tras cada escritura es crítico. Poniendo 4 milisegundos se produce un error de cada tres escrituras. Con 3 milisegundos falla el 50% de las escrituras. Con esos 5 milisegundos no he tenido ningún error en miles de escrituras.

Contra la estupidez los propios dioses luchan en vano. Schiller
Mi Güeb : Picmania

Meta

  • Visitante
Re: Circuito y Driver C para 4 Memorias EEPROM 24AA1025 con un total de 512 Kbyt
« Respuesta #23 en: 23 de Enero de 2008, 15:05:08 »
Podrías poner el Data Source del esto:



Me encanta esa interfaz y verla funcionar.

Desconectado RedPic

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 5427
    • Picmania by Redraven
Re: Circuito y Driver C para 4 Memorias EEPROM 24AA1025 con un total de 512 Kbyt
« Respuesta #24 en: 23 de Enero de 2008, 18:07:19 »
No, va ser que no. Esta es una de las miles de utilidades que tengo por mi PC y no se ni de quien es.
Contra la estupidez los propios dioses luchan en vano. Schiller
Mi Güeb : Picmania

Desconectado RedPic

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 5427
    • Picmania by Redraven
Re: Circuito y Driver C para 4 Memorias EEPROM 24AA1025 con un total de 512 Kbytes
« Respuesta #25 en: 26 de Junio de 2009, 18:18:25 »
Actualizados todos los enlaces de imágenes en este hilo (estaban corruptas tras mi último cambio de servidor)  :mrgreen:

Un saludo Manuelo, y gracias por avisar.
Contra la estupidez los propios dioses luchan en vano. Schiller
Mi Güeb : Picmania


 

anything