[CÓMPUTO INTEGRADO] Ampliar memoria PIC

La 24LC256A de Microchip es una memoria que tiene un tamaño de 32 Kbytes, su estructura está organizada en palabras de 1 byte (8 bits) de longitud, por lo tanto dispondremos en total de 32x8=256 kbits para almacenar información.

La característica principal de esta memoria es que implementa el interfaz I2C para su comunicación serie con otros dispositivos electrónicos.

Características básicas del protocolo I2C

• El bus de comunicación utiliza dos cables. Uno para transmitir los datos (SDA) y otro para la señal de reloj (SCL). Ambas líneas se tienen que conectar a la alimentación (Vcc) a través de resistencias Pull-UP.
• El protocolo de comunicación es del tipo Maestro-Esclavo, aunque el protocolo permite que haya varios maestros, lo normal es que solo haya uno, el dispositivo que hace de maestro es el que gobierna la comunicación y es el que controla la señal de reloj (SCL). Los dispositivos que hacen de esclavos responden a las peticiones del maestro.
• Cada dispositivo conectado al bus se identifica por una única dirección, el protocolo admite utilizar 7 ó 10 bits para el direccionamiento, aunque lo normal es que sean siete.

Los cuatro primeros bits están asignados al fabricante del dispositivo y los tres últimos son configurables por hardware.

La trama de un mensaje simple donde el dispositivo que hace de maestro envía datos para ser escritos en la EEPROM sería el siguiente:

• Se envía el bit de inicio (S)
• Se envía la dirección del esclavo, en este caso la memoria EEPROM
• Se envía un bit más junto con la dirección del esclavo (R/W) para indicar que lo que se quiere es leer o escribir. Si este bit es cero el proceso será de escritura.
• Después el maestro manda un pulso de la señal de reloj, durante el cual el esclavo debe contestar con un ACK (señal de reconocimiento), si el maestro no recibe esta señal interrumpe la comunicación.
• Después se envían los bytes de dirección necesarios para identificar el registro de la EEPROM donde queremos realizar el proceso de escritura.
• Mandamos el dato que se almacenará en la EEPROM
• Y por último se manda el bit de parada para finalizar la comunicación.

CCS dispone de librerías específicas para gestionar la comunicación I2C de determinados componentes, entre ellos algunas memorias EEPROM. Basta con incluir la librería correspondiente por medio de la directiva #include y utilizar sin más las funciones de la librería. Pero si el componente que queremos utilizar no dispone del driver pertinente en CCS, tenemos otra opción, que es desarrollar nuestro propio driver, para ello disponemos como ayuda de una directiva homologa a #use rs232 (options), se trata de #use i2c (options).

Al incluir esta directiva el compilador nos permite utilizar las siguientes funciones para controlar la comunicación serie I2C entre varios dispositivos: 

• i2c_isr_state()
• i2c_poll()
• i2c_read()
• i2c_slaveaddr()
• i2c_start()
• i2c_stop()
• i2c_write()

Además los pics que soportan este tipo de comunicación disponen de modulos y registros específicos para facilitar la comunicación I2C por hardware, lo mismo que teníamos con la comunicación serie RS232. 

Esto da pie a muchos ejemplos, ya que hay bastantes dispositivos (Relojes en tiempo real, convertidores A/D, expansión de puertos de E/S, LCDs, etc) que implementan esta interfaz, también tenemos la posibilidad de comunicar varios PICs entre si, uno haciendo de maestro y los otros de esclavos.

En la imagen anterior as patillas A0, A1 y A2 de la memoria están a masa, por lo que la dirección física del componente en la red será: 1010000. Los pines SDA y SCL son los que se conectan al bus IC2, a través de las resistencias pullup.

Puede que alguien se pregunte que valor hay que poner a estas resistencias (pullup) en un circuito real, pues la verdad es que no existe un valor ideal para todos los casos, dependerá de factores como la velocidad a la que hagamos trabajar el bus (100-400 kbps) y de la carga capacitiva que tenga el circuito (max. 400 pF), un valor que se aconseja como estándar es de 4k7. Pero para que el circuito simule bien en Proteus se deben poner las genéricas pullup.  

El pin 7 de la memoria (WP) es para proteger ó no los datos guardados en la memoria, si está a masa los datos no están protegidos y se puede escribir o sobreescribir los datos ya guardados. Si está a uno (Vcc), no es posible escribir en la EEPROM. 

Otro componente de Proteus incluido en el circuito es el I2C Debugger con el cual podemos ver la trama de datos en tiempo de ejecución. En la figura de abajo se detallan los bits de la trama en un proceso de escritura en la EEPROM.

Un ejemplo de código para la comunicación entre el PIC y la memoria EEPROM 24LC256A mediante el protocolo I2C.

#include <16F877.h>   
//Configuración de los fusibles.   
#FUSES NOWDT, XT, NOPUT, NOPROTECT, NOBROWNOUT, NOLVP, NOCPD, NOWRT, NODEBUG   
#use delay(clock=4000000) //Frecuencia de reloj 4MHz   
#byte  puerto_D = 0x08    // Identificador para el puerto C.    
#include "24256.c" //Incluimos librería 24256 
 
 #int_EXT 
 
 void EXT_isr( void )  
 {  
 
 if ((read_ext_eeprom(0)==0x99)||(read_ext_eeprom(0)==0xFF))  
 {  
 write_ext_eeprom(0,0);  
 puerto_D=read_ext_eeprom(0);  
 }  
 else if ((read_ext_eeprom(0) & 0x0F)<0x09)  
 {      
 write_ext_eeprom(0,(read_ext_eeprom(0))+1);  
 puerto_D=read_ext_eeprom(0);  
 }        
 else if ((read_ext_eeprom(0) & 0x0F)>=0x09)  
 {         
 write_ext_eeprom(0,(read_ext_eeprom(0))+7);  
 puerto_D=read_ext_eeprom(0);  
 }     
 
 }  
 
 void main()  
 {  
 set_tris_b(0xFF); //Puerto B como entrada   
 set_tris_d(0x00);//Puerto D como salida  
 enable_interrupts(GLOBAL);  // Se habilita la interrupción global  
 enable_interrupts(INT_EXT); // Se habilita la  interrupción externa  
 puerto_D =0xFF; //inicializo puerto D  
 
 init_ext_eeprom();//inicializamos memoria EEPROM externa 
 //write_ext_eeprom(0,0xFF);//Resetear registro 00 EEPROM  
 
 while(true)  
 {  
 //Resto del programa    
 
 }  
 }  
 

Proteus nos permite también ver el estado de los registros de está memoria en el proceso de simulación.