Cómo conectar I2C EEPROM 24LC64 externo al microcontrolador PIC

Los microcontroladores son chips autónomos porque tienen memoria y procesador integrados. La memoria integrada de los microcontroladores almacena código integrado y otras variables temporales para la ejecución del programa. CircuitsGallery ha publicado muchos tutoriales de microcontroladores y proyectos de microcontroladores PIC.

En ocasiones utilizamos memoria no volátil (dispositivos i2c) con microcontroladores para almacenar datos de forma permanente. En este artículo explicaré cómo conectamos un microchip i2c de memoria externa a un microcontrolador PIC. Para esto utilicé el 24LC64 de Microchip, una PROM borrable eléctricamente de 64 Kbit, también llamada I2C. Este tutorial de i2c definitivamente lo ayudará a realizar proyectos de i2c.

El módulo LCD se utiliza para mostrar los datos. El programa avanza escribiendo datos en el chip de memoria 24LC64 i2c, luego leyéndolos y mostrándolos en la pantalla LCD.

Diagrama esquemático para la interfaz PIC y EEPROM I2C del microchip

Ahora veamos el diagrama del circuito que muestra cómo usar i2c con PIC.

Componentes necesarios

1. Microcontrolador PIC 16F877
2. chip de memoria 24LC64
3. módulo LCD
4. Condensadores (33 pF x 2)
5. Oscilador de cristal 4MHz
6. Resistencia 10kΩ

Así funciona la interfaz I2C con PIC

• Una pantalla LCD de 16 × 2 está conectada al PORTB del PIC y muestra las operaciones de lectura y escritura al espectador.
• Aquí, se utiliza una interfaz de dos cables (con pines SCL y SDA) para la comunicación entre el dispositivo de almacenamiento y el microcontrolador PIC, también llamado «I-Square-C (I2C)» o «Circuito interintegrado».
• I2C tiene la ventaja de permitir conectar diferentes dispositivos en la misma conexión utilizando la dirección del dispositivo y las señales de inicio y parada.
• En dicha interfaz, el PIC actúa como maestro y el servidor de almacenamiento I2C actúa como esclavo, luego el maestro y el esclavo se comunican entre sí. (Hay situaciones en las que usamos i2c master, pero no aquí)
• SCL (Serial Clock Line) es la línea de reloj. Se utiliza para sincronizar todas las transferencias de datos a través del bus I2C y SDA (Serial Data) es la línea de datos.
• Para iniciar la comunicación el canal debe ser el ideal (es decir, que no sea utilizado por otros dispositivos y esté libre), lo ideal es que tanto el pin SDA como el SCL estén activados aplicando una señal alta.

La siguiente figura muestra el diagrama de tiempos para las señales SDA y SCL.

• Aquí SCL y SDA están en ALTO en el punto (A), lo que se llama condición ideal, en el punto (B) SCL permanece ALTO y luego SDA pasa a BAJO, lo que se llama condición inicial.
• Después de enviar la señal de inicio, envíe la dirección del dispositivo al esclavo con el comando de control (lectura o escritura).
• El comando de control informa al esclavo que se está llevando a cabo una operación de lectura o escritura.
• Después de enviar el comando de control, el esclavo envía una confirmación al maestro.

Proceso de escritura

• Después de enviar la señal de inicio, PIC envía la dirección del dispositivo con un comando de escritura para el chip EEPROM (chip i2c) que es «0xA0».
• El siguiente paso es enviar la dirección registrada, que es la ubicación donde se deben escribir los datos. (Para dispositivos con poca memoria, simplemente puede enviar a través de 8 bits).
• Aquí estamos usando una memoria de 64 KB, por lo que debemos enviar la dirección registrada dos veces (yo usé 0x0000). Esto puede dar como resultado que la dirección registrada se envíe dos veces con 8 bits cada una.
• Después de eso, envíe los datos uno por uno y luego envíe una señal de parada.

Leer el proceso

• Para leer desde una dirección específica, primero envíe la dirección del dispositivo con el comando de escritura.
• Luego envíe la dirección registrada como dos datos de 8 bits.
• Se envía una señal de reinicio (aquí la señal de inicio se envía sin enviar una señal de parada, lo que se denomina señal de reinicio).
• A continuación, los datos se reciben uno tras otro. Los datos recibidos se almacenan en un buffer y se muestran en la pantalla.

Programa para la interfaz externa I2C EEPROM

Habíamos escrito un programa integrado PIC para este tipo de interfaz de memoria. El compilador utilizado es Hola técnico c.

[cc lang=‘c’] #include

#include

/////////////////////////////LCD FUNCTIONS\\\\\\\\

#define RS RB0
#define EN RB1
#define D4 RB2
#define D5 RB3
#define D6 RB4
#define D7 RB5
#define _XTAL_FREQ 4000000
#define _CONFIG 0x3F32

void LCD_OUT(char a, char b, char *n);
void LCD_INIT();
void LCD_CHR(char m);
void LCD_DATA(char m);

void LCD_DATA(char m) 
{ 
    if(m & 1)D4 = 1;
    else D4 = 0;

    if(m & 2)D5 = 1;
    else D5 = 0;

    if(m & 4)D6 = 1;
    else D6 = 0;

    if(m & 8)D7 = 1;
    else D7 = 0; 
}

void LCD_CMD(char m) 
{
    RS = 0;
    LCD_DATA(m);
    EN = 1;
    __delay_ms(4);
    EN = 0; }
    LCD_CLEAR() {
    LCD_CMD(0);
    LCD_CMD(1);
}

void LCD_OUT(char a, char b, char *n) 
{
    char p,q,r;
    if(a == 1) 
    {
        p = 0x80 + b;
        r = p>>4;
        q = (0x80+b) & 0x0F;
        LCD_CMD(r);
        LCD_CMD(q);
    }

    else if(a == 2) 
    { 
        p = 0xC0 + b;
        r = p>>4;
        q = (0xC0+b) & 0x0F;
        LCD_CMD(r);
        LCD_CMD(q);
    }

int i;
for(i=0;n[i]!=’′;i++)
LCD_CHR(n[i]);
}

void LCD_INIT() 
{ 
    LCD_DATA(0x00);
    __delay_ms(20);

    LCD_CMD(0x03);
    __delay_ms(5);

    LCD_CMD(0x03);
    __delay_ms(11);

    LCD_CMD(0x03);
    LCD_CMD(0x02);
    LCD_CMD(0x02);
    LCD_CMD(0x08);
    LCD_CMD(0x00);
    LCD_CMD(0x0C);
    LCD_CMD(0x00);
    LCD_CMD(0x06); 
}

void LCD_CHR(char m) 
{ 
    char T1,T2;
    T1 = m&0x0F;
    T2 = m&0xF0;
    RS = 1;
    LCD_DATA(T2>>4);
    EN = 1;
    __delay_ms(5);
    EN = 0;
    LCD_DATA(T1);
    EN = 1;
    __delay_ms(5);
    EN = 0; 
}

//////////////////////I2C Functions\\\\\\

void I2CInit();
void I2CStart();
void I2CStop();
void I2CRestart();
void I2CAck();
void I2CNak();
void I2CWait();
void I2CSend(unsigned char dat);
char I2CInitval[10];
char rcdata[30];
double rdaddr=0x00;
unsigned char I2CRead();
unsigned char I2CData[] = {“i-St@r”};
unsigned char i,j;

void I2CInit(void) 
{
    TRISC3 = 1;
    TRISC4 = 1;
    SSPSTAT |= 0x80; // Slew rate disabled
    SSPCON = 0x28;
    SSPADD = 0x28; /* 100Khz @ 4Mhz Fosc */ 
}

void I2CStart() 
{
    SEN = 1;
    while(SEN);
}

void I2CStop() 
{
    PEN = 1;
    while(PEN);
}

void I2CRestart() 
{
    RSEN = 1;
    while(RSEN);
}

void I2CAck() 
{
    ACKDT = 0;
    ACKEN = 1;
    while(ACKEN);
}

void I2CNak() 
{
    ACKDT = 1;
    ACKEN = 1;
    while(ACKEN);
}

void I2CWait() 
{
    while ((SSPCON2 & 0x1F ) || ( SSPSTAT & 0x04 ) );
}

void I2CSend(unsigned char dat)
{
    SSPBUF = dat;
    while(BF);
    I2CWait();
}

unsigned char I2CRead() 
{
    unsigned char temp;
    RCEN = 1;
    while(!BF);
    temp = SSPBUF;
    I2CWait();
    return temp;
}

//////////////////MAIN FUNCTION\\\\\\\

void main() 
{ 
    int i;
    TRISB = 0x00; // Set PORTB as Output
    LCD_INIT(); // Initilise LCD
    LCD_CLEAR(); // Clear LCD
    LCD_OUT(1,1,”WRITE:”);//Print “WRITE” on LCD 1st row 1st colum
    LCD_OUT(2,1,”READ :”);//Print “READ” on LCD 2nd row 1st colum
    LCD_OUT(1,7,I2CData);

////////////////EEPROM READ and WRITE\\\\

    I2CInit();
    I2CStart();
    I2CSend(0xA0);
    I2CSend(0x00);
    I2CSend(0x00);

    for(j=0;j<6;j++) 
    {
        I2CSend(I2CData[j]); 
    } 

    I2CStop(); __delay_ms(100); I2CStart(); I2CSend(0xA0); I2CSend(0x00); I2CSend(0x00); I2CRestart(); I2CSend(0xA1); 

    for(j=0;j<6;j++) 
    { 
        rcdata[j]= I2CRead(); 
        I2CAck(); 
    } 
    if (i - 1) 
        I2CAck(); 
    else 
        I2CNak();
 
    I2CStop(); 
    LCD_OUT(2,7,rcdata); 

    while(1); 
} 
[/cc]

Que sigue

Para cargar este programa integrado necesita un programador PIC ya que sabemos que la mayoría de las computadoras portátiles de nueva generación no tienen puerto serie RS232. Puede visitar Circuitsgallery con regularidad para obtener nuevos circuitos, tutoriales de microcontroladores y proyectos.