Comunicación I2C entre 2 PIC.

Se trata de comunicar mediante bus I2C dos pic. Uno será el maestro, que enviará la información al pic esclavo para que la gestione. En concreto, en este ejemplo, el pic maestro toma el valor introducido por un teclado numérico. El valor de la tecla pulsada se enviará vía I2c al pic esclavo que la presentará en una pantalla lcd. Pulsando la tecla del asterisco (*), la información mostrada en la pantalla se borrará.

Para este tipo de comunicación se emplea la directiva...

#use I2C

...en la que se establecen las condiciones de la trasmisión como velocidad, pines del bus en el PIC, dirección del PIC esclavo, etc.

Por ejemplo, en este caso:

#use I2C(SLAVE, SDA=PIN_C4 , SCL=PIN_C3, SLOW, ADDRESS=0xa0)

Se está indicando que se establece al PIC como esclavo (SLAVE) , el pin C4 es la linea SDA del bus , el pin C3 es la linea SCL, se utiliza la velocidad de transmisión baja (SLOW) y  la dirección como esclavo será A0h.

En el caso del PIC maestro, en la directiva se indica MASTER en lugar de SLAVE, y se ignora la opción ADDRESS:

#use I2C(MASTER, SDA=PIN_C4 , SCL=PIN_C3, SLOW)

Para enviar la información con el PIC maestro empleamos este grupo de instrucciones:

i2c_start();        //Comienzo de la comunicación I2C ...
i2c_write(0xa0);    //...con la dirección del PIC esclavo...
i2c_write(tecla);   // Envía dato
i2c_stop();         //Finalización de la transmisión

Para saber cuando el PIC esclavo recibe información utilizamos la función i2c_poll(). Esta función devuelve un "TRUE" (valor 1) cuando se ha recibido el dato en el buffer. Comprobando su estado ciclicamente sabremos cuando hay que procesar la información recibida. El dato recepcionado lo podremos recuperar con la función i2c_read(). 

if(i2c_poll()) {                   // Si se ha recibido información...
   dato=i2c_read();                //...la guarda en la variable "dato"
}

La línea de datos SDA y la línea de señal de reloj SCL del bus, son líneas a colector abierto. Esto implica que se deben utilizar resistencias externas o pull-up que aseguren el estado alto cuando no haya dispositivos conectados al bus. Si no fueran usadas, las líneas podrían encontrarse en un momento dado en un estado indeterminado. Si uno de los componentes del bus intenta poner la línea en estado bajo a la vez que otro en estado alto, esto llevaría a conflicto al bus y podría dañar a los componentes.

Los valores típicos de estas resistencias pueden ser, a modo de orientación, de 4k7 para velocidades del bus inferiores o en torno a 100kbps, de 2k2 para velocidades alrededor de 100kbps y de 1k para velocidades en torno a 400kbs o superiores. 

Haz clic en la imagen para ampliarla           

Los programas de los PIC van a ser dos, uno para el maestro...

[+/-] Ver / Ocultar programa MASTER en C

////////////////////////////////////////////////////////////////////////////////
//                    COMUNICACIÓN I2C EN TRE DOS PIC                         //
//                                                                            //
//                      Aplicación para PIC MAESTRO                           //
//                                                                            //
//       El PIC maestro lee teclado y envía el dato al PIC esclavo via I2C    //
//                      que lo mostrará en un lcd.                            //
//                                                                            //
//                            (c) RobotyPic                                   //
////////////////////////////////////////////////////////////////////////////////

#include <16F876a.h>

#fuses XT,PUT,NOPROTECT,BROWNOUT,NOLVP,NOWDT

#use delay (clock=4000000)                     

#use i2c(MASTER, SDA=PIN_C4, SLOW, SCL=PIN_C3, NOFORCE_SW)

#define use_portb_kbd TRUE       //Configuración puerto b para lectura teclado
#include <kbd.c>                 //Carga archivo para control de teclado

#use standard_io(b)
#use standard_io(c)

int tecla;                       //Dato a transmitir
  
/******************************************************************************/
/***************************** Envío I2C **************************************/
   
void envio_I2C (){
  
      i2c_start();         //Comienzo de la comunicación I2C ...
      i2c_write(0xa0);     //...con la dirección del PIC esclavo...
      i2c_write(tecla);    // Envia dato
      i2c_stop();          //Finalización de la transmisión
  }

/******************************************************************************/
/*************************** FUNCIÓN PRINCIPAL ********************************/

void main(){

   kbd_init();                   //Inicializa función de teclado
   port_b_pullups(TRUE);        
   
   while (true){
     
// Lectura del teclado    
      tecla=kbd_getc();       //En "tecla" valor de la tecla pulsada
      if(tecla!=0){           //Si se pulsa teclado...
            envio_I2C();      //...se envía el dato
            delay_ms(100);
      }
   }
}

...y  otro para el PIC esclavo.

[+/-] Ver / Ocultar programa SLAVE en C

////////////////////////////////////////////////////////////////////////////////
//                    COMUNICACIÓN I2C EN TRE DOS PIC                         //
//                                                                            //
//                      Aplicación para PIC ESCLAVO                           //
//                                                                            //
//       El PIC maestro lee teclado y envía el dato al PIC esclavo via I2C    //
//                      que lo mostrará en un lcd.                            //
//                                                                            //
//                            (c) RobotyPic                                   //
////////////////////////////////////////////////////////////////////////////////

#include <16F876a.h>

#fuses XT

#use delay (clock=4000000)

#use standard_io(c)

#use I2C(SLAVE, SDA=PIN_C4 ,SLOW, SCL=PIN_C3, ADDRESS=0xa0, NOFORCE_SW)

#define use_portb_lcd TRUE
#include <lcd.c>

void main() {

   int dato;
   lcd_init(); 
  
   while (1) {
  
      // Recepción por comunicación I2C    
      if(i2c_poll()) {
         dato=i2c_read();
         lcd_putc(dato);                  //Muestra dato recibido por pantalla
         if (dato=='*') lcd_putc("\f");   //Si es * borra la pantalla lcd
         }
   }
} 

Se puede comprobar el funcionamiento bajo una simulación en proteus en esta animación:

Todos los archivos se pueden descargar en el siguiente enlace:

Descargar archivos Comunicacion I2C 2 PIC

Existen más opciones de comunicación I2C. En el artículo referente a la Comunicación I2C entre 3 PIC, se utiliza la interrupción #INT_SSP como otra alternativa.

El proyecto contenido en el artículo ha sido diseñado y probado utilizando las siguientes versiones de software:
- Windows xp y windows 7
- Proteus V7.7 SP2
- CCS PIC C COMPILER v4.084