Saltar al contenido
Control Automático Educación

Comunicación I2C

En esta entrada vas a aprender todo sobre el protocolo de comunicación I2C, que es, como funciona y adicionalmente veremos como implementarlo en cualquier microcontrolador PIC usando el compilador CCS C. Al final veremos un TUTORIAL I2C con un ejemplo paso a paso de su implementación.

Antes de comenzar, te invito a que veas todas las entradas de nuestro CURSO GRATUITO DE MICROCONTROLADORES PIC.

Y que te suscribas al canal para seguir aprendiendo más sobre estos temas.

Comunicacion I2C Microcontroladores PIC

Vamos a comenzar a entender inicialmente a ver la explicación del protocolo I2C el cual puede ser implementado en cualquier microcontrolador, tanto en el PIC como también se puede implementar una comunicación I2C con Arduino.

¿Que es el I2C?

El bus de comunicaciones I2C (nombrado a veces como I cuadrado C, I^2) es un protocolo que se efectúa por medio de DOS hilos. A través de estos dos hilos pueden conectarse diferentes dispositivos donde algunos de ellos serán MAESTROS en cuanto muchos otros dispositivos serán ESCLAVOS.

¿Como trabaja la comunicación I2C?

Para poder reconocer cada uno de los dispositivos conectados a los DOS hilos del bus I2C, a cada dispositivo se le asigna una dirección.

Así en este tipo de comunicaciones el MAESTRO es el que tiene la iniciativa en la transferencia y este es quien decide con quien se quiere conectar para enviar y recibir datos y también decide cuando finalizar la comunicación.

Los DOS hilos del BUS interfaz de comunicación I2C PIC son lineas de colector abierto donde una de las lineas lleva la señal de reloj y es conocida como (SCL), y la otra linea lleva los datos y es conocida como (SDA).

Los Pines SDA y SDL I2C se encuentran especificados en todos los componentes que usan este tipo de protocolo de comunicación.

Para que la comunicación funcione se deben utilizar unas resistencias PULL UP (resistencias conectadas a positivo) para asegurar un nivel alto cuando NO hay dispositivos conectados al BUS I2C.

La conexión I2C entre un maestro y vários esclavos se muestra a continuación:

i2c conexión
Conexión I2C

El número de dispositivos que pueden conectarse de esta forma y además la longitud del BUS es limitada por la capacidad de direccionamiento (de 7 a 10 bits) y por la máxima carga del BUS (400pF). La velocidad máxima estándar es de 100Kbps.

Videos:

Funcionamiento de la Comunicación I2C PIC

La transmisión de datos se inicia con un bit de inicio (START) y termina con un bit de finalización (STOP). El bit de START se reconoce porque la linea SDA pasa de un estado lógico alto para un estado lógico de bajo cuando la linea SCL esta en nivel alto. El STOP se establece cuando hay una transición de bajo a alto en la linea SDA, cuando SCL está en un nivel alto.

Secuancia de I2C

Cuando comienza la transmisión de datos, el MAESTRO envía la dirección del ESCLAVO con el cual se quiere comunicar, esta dirección puede ser de 7 o 10 bits con formato de byte (uno o dos bits respectivamente) Después de la dirección se adiciona 1 bit, que indica si se desea ESCRIBIR o LEER (R/W).

Cuando el Maestro envía estos DATOS para el esclavo. El ESCLAVO debe responderle al maestro con un bit de confirmación para informarle que escucho la solicitud del maestro y que esta a disposición de lo que él necesite. Este bit de confirmación se conoce como  (ACK).

Si el maestro NO recibe este bit, la comunicación se interrumpe. Por otro lado, se puede dar el caso que un ESCLAVO está mandando alguna información al maestro, entonces el maestro también generará este bit de confirmación hacia el esclavo.

Tramas I2C

Puede darse el caso también de que una vez el MAESTRO se comunica con el ESCLAVO, el MAESTRO no abandone el BUS y continúe comunicándose con el ESCLAVO, para eso el MAESTRO debe generar una nueva condición de START que se conoce en la literatura como START REPETIDA (Sr), idéntica al START anterior solo que con un pulso de reconocimiento.

Para trabajar con el modulo de comunicación I2C PIC, se deben configurar los siguientes registros: SSPCON, SSPCON2, SSPADD, SSPBUF, SSPSTAT SSPSR.

Protocolo de Comunicación I2C con CCS C

En CCS C PIC C, existen funciones que nos facilitan la implementación de este tipo de comunicación. Comencemos primero viendo el tipo de configuraciones que podemos llevar a cabo:

Para las configuraciones genéricas del i2c declaramos lo siguiente en el encabezado de nuestro programa:

#use i2c (opciones)

Estas opciones pueden ir separadas por comas y pueden ser cualquiera de las siguientes opciones

Comunicacion i2c con PIC C

La directiva (#use i2c) tiene efecto en las funciones: I2C_START, I2C_STOP, I2C_READ. I2C_WRITE y I2C_POLL. Se utilizan funciones de Software a menos que se especifique FORCE_HW.

Como por ejemplo:

#USE I2C(master, sda=PIN_B0, scl=PIN_B1)
#USE I2C(slave, sda=PIN_C4, scl=PIN_C3, address=0XA0, force_hw)
#USE I2C(master, sda=PIN_B0, scl=PIN_B1, fast=450000)

Las funciones asociadas al i2c son:

i2c_start();

Para el modo maestro, esta función inicia la trasmisión. Después de la condición de arranque o START, el reloj es colocado en nivel lógico bajo hasta el momento en que se escriba con la función I2C_WRITE(); Si se llama otra función I2C_START antes que un I2C_STOP quiere decir que se está utilizando un START Repetido (Sr). Esta función depende de la respuesta del esclavo.

i2c_stop();

Finaliza la transmisión.

i2c_write(DATO);

En esta función “DATO” es un entero de 8 bits que se envía por el bus. Cuando un dispositivo que es MAESTRO aplica esta instrucción , se genera una señal de reloj que marca la velocidad de transmisión del dato; Cuando un ESCLAVO aplica esta instrucción se queda esperando la señal de reloj que genere el MAESTRO.

Esta función devuelve el bit de reconocimiento ACK que le envía el receptor cuando la transmisión ha terminado: 0 indica ACK; 1 indica NOACK y 2 indica una colisión en el modo MULTIMASTER.

Para saber la dirección de la transmisión, se observa el bit de menor peso (LSB) del primer dato transmitido tras un START (Si el bit es “0” quiere decir que la información se está transmitiendo de MAESTRO a ESCLAVO)

Dato=i2c_read();
Dato2=i2c_read([ack]);

Dato es un entero de 8 bits leído del BUS. Cuando un dispositivo que es MAESTRO aplica esta instrucción , se genera una señal de reloj que marca la velocidad de transmisión del dato; Cuando un ESCLAVO aplica esta instrucción se queda esperando la señal de reloj que genere el MAESTRO. No hay timeout por lo que esta instrucción se utiliza junto con i2c_poll() para prevenir bloqueos.

Opcionalmente se puede incluir un ACK donde  1 indica ACK; 0 indica NOACK

valor=i2c_poll();

Se utiliza solo si el PIC tiene modulo SSP. Devuelve un TRUE(1) si se ha recibido el dato en el buffer y un FALSE(0) si no se ha recibido. Cuando devuelve el TRUE(1) la función i2c_read() guarda el dato recibido.

estado=i2c_isr_state();

Se utiliza solo si el PIC tiene modulo SSP. Devuelve el estado del bus en modo ESCLAVO después de una interrupción.

Estado es un entero de 8 bits.

i2c_slaveaddr(int8 adr);

Se especifica la dirección del dispositivo en modo esclavo.

Protocolo I2C PIC – Ejemplo

Un proceso de temperatura tiene incorporado una tarjeta electrónica encargada de realizar el monitoramiento de la variable temperatura en el interior del proceso.

Dicha tarjeta electrónica cuenta con PIC16F887, un LCD, un puerto de comunicación serial, un sensor I2C de temperatura (DS1621), cuenta con un reloj calendario de tiempo real I2C (DS1307) y cuenta además con una memoria EEPROM serie I2C (M24512).

Se solicita al ingeniero de control realizar un programa en el PIC16F887, para que por medio de un menu en el computador, el usuario pueda tener la opción de leer la temperatura y la hora de lectura de la misma almacenando estos datos en la memoria EEPROM y que estos datos también se visualicen en el LCD.

El Menú debe tener una segunda opción que le permita al usuario ver por el puerto serial los últimos datos almacenados en la EEPROM.

Circuito Electronico Comunicación I2C Microcontroladores PIC:

En el proteus vamos a necesitar los siguientes componentes: PIC16F887, RES, CAP, CRYSTAL, M24512, DS1621, DS1307 y LM016L.

I2CExample

Código de Implementación de Comunicación I2C PIC:

A continuación se muestra el procedimiento y todo el código de implementación del ejemplo. Recuerda que para poder ver el código es necesario que COMPARTAS el contenido de este post o te SUSCRIBAS con cualquiera de los tres botones que están abajo y automáticamente el Código de implementación queda desbloqueado para que lo pegues y lo copies en tu compilador.

En este ejemplo vamos a hacer la libreria I2C para PIC nosotros mismos, entonces es una práctica muy interesante donde vas a aprender mucho.

Para solucionar este ejemplo vamos a crear tres librerías para manejar cada uno de los 3 esclavos del ejemplo.

EEPROM

En entradas pasadas habíamos utilizado la libreria de la EEPROM del PIC para guardar datos en ella, en este ejemplo vamos a crear nuestra propia  libreria I2C para PIC para entender como programarla por i2c:

La EEPROM M24512 (click para ver datasheet)  tiene tres pines E2, E1, E0 que permiten establecer la dirección de este dispositivo, de esta manera el PIC se comunicara con la Memoria cuando el envíe por el i2c dicha dirección.

Esta dirección es almacenada dentro de la EEPROM en un byte de control donde la parte alta de este byte siempre es fija (1010) y la parte baja corresponde a los estados lógicos de E2, E1, E0, por ultimo viene el bit de escritura/lectura, como puede ser visto en la siguiente figura:

byte de control i2c

Lo que quiere decir que si el PIC envia 0xA0 el PIC estará escribiendo en la memoria, por otro lado si manda 0xA1h el PIC estará leyendo la memoria.

El formato de escritura de la EEPROM es mostrada en la hoja de datos en la pagina 15, donde después de la señal de START, se escribe la palabra de control para seleccionar el dispositivo y el modo de trabajo, dos bytes para la dirección de escritura y el dato a escribir.

A continuación se muestra la función de escritura de nuestra  libreria I2C para PIC que guardaremos en un archivo llamado EEPROM_24512.c

void write_ext_eeprom(long int address, BYTE data)
{
   short int status;
   i2c_start();            //Inicializa la Transmisión
   i2c_write(0xa0);        //Escribe la palabra de control(direccion
                           //0h + 0 para escritura)
   i2c_write(address>>8); //Parte alta de la dirección a escribir en la eeprom
   i2c_write(address);    //Parte baja de la dirección a escribir en la eeprom
   i2c_write(data);     //Dato a escribir
   i2c_stop();          //Finalización de la transmisión
   i2c_start();         //Reinicio
   status=i2c_write(0xa0); //Lectura del bit ACK, para evitar escrituras
                           //incorrectas
   while(status==1)     //Si es "1" se espera para responder al esclavo
   {
      i2c_start();
      status=i2c_write(0xa0);
   }
}

El proceso de escritura puede hacerse de 4 formas como mostrada en la pagina 19 del datasheet, nosotros utilizaremos la segunda forma “leer una dirección cualquiera (Random Address Read)” que es la más común y dicho proceso de lectura es muy similar con el de escritura solo que en este caso al final el MAESTRO debe enviar un NO ACK.

A continuación se muestra la segunda función de nuestra  librería I2C para PIC que colocaremos en nuestra librería de EEPROM_24512.c

BYTE read_ext_eeprom(long int address) {
   BYTE data;
   i2c_start();            //Inicializa la Transmisión
   i2c_write(0xa0);        //Escribe la palabra de control(direccion
                           //0h + 0 para escritura)
   i2c_write(address>>8); //Parte alta de la dirección a escribir en la eeprom
   i2c_write(address);    //Parte baja de la dirección a escribir en la eeprom
   i2c_start();         //Reinicio
   i2c_write(0xa1);        //Escribe la palabra de control(direccion
                           //0h + 1 para escritura)
   data=i2c_read(0);    //Lectura del Dato
   i2c_stop();          //Finalización de la transmisión
   return(data);
}

RELOJ DE TIEMPO REAL DS1307

Datasheet click aca. Este dispositivo es capaz de suministrar los segundos, minutos, horas, dia, mes y año en tiempo real (por medio de un cristal de cuarzo de 32.768Khz).

Este dispositivo posee una serie de registros donde aparecen los datos necesarios (tabla 2 de la pagina 8 del datasheet). Estos datos son suministrados en BCD.

El ciclo de escritura de este dispositivo se inicia con la palabra 0xD0 y la lectura con 0xD1 (pagina 12).

En la escritura el segundo byte es un puntero que indica la dirección del dato que queremos escribir (ver la tabla 2).

En el ciclo de lectura es igual que el de escritura solo que el ultimo byte debe indicar un NACK al Maestro. Con esto tan solo queda convertir los bytes leídos de bcd a binario.

Para el manejo del reloj de tiempo real vamos a crear una libreria I2C para PIC llamada DS1307.c con las siguientes funciones:

int BCDaBIN(BYTE bcd)
{
int varia;
varia=bcd;
varia>>=1;
varia &= 0x78;
return (varia + (varia>>2) + (bcd & 0x0f));
}
void rtc_get_time(BYTE& hr, BYTE& min, BYTE& sec) {
i2c_start(); //Escritura
i2c_write(0xD0); //Codigo de escritura
i2c_write(0x00); //Puntero de la primera dirección
i2c_start(); //Lectura
i2c_write(0xD1); //Codigo de lectura
sec = BCDaBIN(i2c_read()&0x7f); //Lectura de los 7 bit de los segundos
min = BCDaBIN(i2c_read()&0x7f); //Lectura de los 7 bit de los minutos
hr = BCDaBIN(i2c_read(0)&0x3f); //Lectura de los 6 bit de las horas
i2c_stop(); //Finaliza comunicación
}

TERMOMETRO

El termometro digital i2c DS1621 (Clic aca Datasheet) permite medir una temperatura entre -55°C y 125°C como mostrado en la tabla 2 de la pagina 4 del datasheet.

Este valor de temperatura es suministrado en dos Bytes. El byte alto es el valor entero con una resolución de 1°C y el segundo byte es el valor decimal con una resolución de 0.5°C.

El termómetro tiene tres pines los cuales sirven para darle la dirección al dispositivo (A2, A1, A0). En nuestro ejemplo tenemos la dirección (0x03).

Al igual que la memoria EEPROM el termómetro tiene un byte de control donde se almacena la dirección y si se desea escribir o leer. Este byte de control posee en su parte alta un numero fijo (1001) y la parte baja viene dado por los pines de dirección (A2, A1, A0) y el ultimo bit (R/W) es de escritura o lectura.

En la pagina 10 del datasheet se muestran todos los comandos que se pueden usar con este dispositivo y la pagina 9 muestra ejemplos de como debe realizarse el envío de tramas por el i2c.

Los comandos pueden ser 0xAA para lectura de la temperatura, 0xEE para el inicio de conversión.

A continuación se muestran las funciones que vamos a colocar en nuestra librería llamada TEMP_DS1621.c

void init_temp(int address) {
   i2c_start();
   i2c_write(0x90|(address<<1)); //Genera primer byte (1001A2A1A0W)
   i2c_write(0xee); //Inicia conversion
   i2c_stop();
}
float read_full_temp(int address) {  
   float tura;
   BYTE datah;
   BYTE datal;
   int data;
   i2c_start();
   i2c_write(0x90|(address<<1)); //Genera primer byte (1001A2A1A0-W)
   i2c_write(0xaa);        //Lee temperatura
   i2c_start();
   i2c_write(0x91|(address<<1)); //Genera primer byte (1001A2A1A0-R)
   datah=i2c_read();       //Lectura parte alta
   datal=i2c_read(0);      //Lectura parte alta y NACK
   i2c_stop();
   data=datah;
   if (datal==128)  
      tura=data+0.5;
   else
      tura=data;
   return(tura);
}

PRINCIPAL

Dado que la temperatura es un dato tipo FLOAT, no se puede guardar este dato directamente en la EEPROM, por lo tanto vamos a utilizar una librería suministrada por CCS C llamada FLOATEE.c que nos permitirá guardar y leer datos tipo FLOAT en una EEPROM.

A continuación se muestra el programa principal el cual despliega un menú, donde si se digita “1” el pic lee la temperatura y la hora y las almacena en la memoria EEPROM mostrando estos datos en el LCD. Si el usuario presiona “2” el PIC lee la memoria y muestra los últimos 7 datos en el terminal serie.

#INCLUDE <16F887.h>
#DEVICE ADC=10
#USE DELAY(CLOCK=4000000)
#FUSES XT,NOPROTECT,NOWDT,NOBROWNOUT,PUT,NOLVP
//Configura direccion de memoria de los puertos A,B,C,D
#BYTE PORTA= 5
#BYTE PORTB= 6
#BYTE PORTC= 7
#BYTE PORTD= 8
#define EEPROM_SDA  PIN_C4
#define EEPROM_SCL  PIN_C3
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7, bits=8, parity=N)
#use i2c(MASTER,Fast=100000, sda=EEPROM_SDA, scl=EEPROM_SCL,force_sw)
#include <lcd.c>
#include <EEPROM_24512.c>
#include <DS1307.c>
#include <TEMP_DS1621.c>
#include <floatee.c>
int dat_in=0, cnt, hr, min, sec;
int16 address=0;
int dat_serie[7];
float dato=0;
//Interrupción por el puerto serial
#int_rda
void rda_isr(void)
{
   dat_in=getc();    //Lee el puerto Serial
   printf("%c\r",dat_in);
   if (dat_in=='2')  //Pregunta si es "2" para visualizar parametros de la EEPROM
   {
      for(cnt=address-7;cnt<=address;cnt++)  //Lee los primeros 7 bytes de la EEPROM
      {
         dat_serie[cnt]=read_ext_eeprom(cnt);
         printf("Byte %u=%3u \r", cnt, dat_serie[cnt]);
      }
   }
}
void main()
{
   lcd_init();
   set_tris_c(255);
   enable_interrupts(int_rda);
   enable_interrupts(global);
   address=0;
   init_temp(0x03);  //Inicializa el DS1621
   
   //Crea un Menu para mostrar por el Serial
   printf("Pulse 1 para leer los datos\r");
   printf("Pulse 2 para visualizar los datos\r");
   
   while(1)
   {
      if(dat_in=='1') //Si es "1" inicie la lectura y grabado de la EEPROM
      {
         init_temp(0x03);  //Inicializa el DS1621
         rtc_get_time(hr,min,sec);  //Lee el tiempo del DS1307
         dato=read_full_temp(0x03); //Lee temperatura del DS1621
         write_float_ext_eeprom(address,dato);  //Guarda 4 bytes del float
         address=address+4;
         
         write_ext_eeprom(address++,hr); //Guarda byte de Hora
         write_ext_eeprom(address++,min); //Guarda byte de Minuto
         write_ext_eeprom(address++,sec); //Guarda byte de Segundo
         
         lcd_gotoxy(1,1);
         printf(lcd_putc,"Temp=%4.1f C    \n",dato);//Visualiza la temperatura
         printf(lcd_putc,"%2u:%2u:%2u",hr,min,sec);//Visualiza la hora
         if (address==0xffff)
            address=0; //Cuando se termina la EEPROM vuelve al principio
         dat_in=0;
      }
   }
}

Bibliografia

  1. Compilador C CCS y Simulador Proteus para Microcontroladores PIC, Eduardo Garcia Breijo,

Eso es todo por la entrada del dia de hoy, espero les haya gustado y hayan aprendido algo nuevo. Si te ha servido el contenido de esta entrada, de los videos y los códigos de implementación y deseas apoyar mi trabajo invitandome a un café super barato, puedes hacerlo en el siguiente link:

👉 Invitar a Sergio a un Café ☕️

Que esten muy bien, nos vemos en la siguiente entrada.

Entradas relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.

Comentarios (28)

Hola amigo, muy buen curso, lo estoy siguiendo al pie de la letra y estoy seguro que aprenderé mucho. Gracias por compartirlo y por unas explicaciones muy claras y profundas.

Responder

Gracias Justo por el comentário, espero le puedas sacar provecho a la información que aquí comparto. Éxitos!!

Responder

¡Hola Sergio!
¿Cómo está todo?
No me ha quedado claro la función de “address-7” en este ciclo “for”: for(cnt=address-7;cnt<=address;cnt++).
¿Pudieras explicármelo, por favor?
Gracias.

Responder

Hola Edi, es para comenzar desde la dirección 0 y recorrerla. Pues la temperatura ocupó los 4 primeros espacios de la memoria, y la hora ocupó los otros 3 espacios, entonces inicializamos cnt en el address 0.

Responder

Excelente amigo, te felicito. Muchísimas gracias por tu aporte

Responder

Muchas gracias Maximiliano por tu comentário, me alegra saber que te ha sido de utilidad. Saludos y muchos éxitos!

Responder

disculpa, este codigo funsiona al utilizarlo con el pic 12f675??. quiero crear un voltimetro y amperimetro.

Responder

Si, solo debes adaptarlo para ese PIC, cambiando la librería y colocando los pines correspondientes al I2C y a los puertos que pretendas emplear en tu proyecto.

Responder

Hola buen dia
algún tutorial para una conexión i2c bidireccional ?

Responder

Genial la explicación, y el desarrollo de las rutinas,muy útil, muchas gracias , y saludos.

Responder

De nada Omar, que bueno que te ha sido de utilidad. Saludos!!

Responder

Hola, buenas noches. Antes que nada, que grandioso trabajo tienes con tus tutoriales. Me han servido de mucho en los últimos meses, sin embargo me encuentro en un dilema con un proyecto y no lo he podido resolver por más que he visto tus tutoriales, me serviría de mucha ayuda si pudieses responderme para resolver algunas dudas. Con gusto me dispongo a invitarte un café si accedes. Y te lo agradecería mucho en verdad.

Responder

Hola Lizette mi tiempo es bastante limitado, puedes dejar tus dudas siempre y cuando sean puntuales, si conozco la respuesta puedo orientarte al respecto. Saludos.

Responder

Claro, entiendo. Me refería al de tu página. Bueno, resulta que estoy trabajando con el sensor MLX90614 y siguiendo este tutorial cree mis librerías etc. Y aunque consulté los puertos en el datasheet propiamente, no he logrado hacerlo funcionar. Cabe destacar que lo único que estoy utilizando son algunos leds además del sensor y mi pic, sin embargo no entiendo si la comunicación I2C aplica solamente para dispositivos con entradas Máster/Slave
O por qué no han de funcionar correctamente?

Responder

SALUDOS.
Soy nuevo en esto, pero EXCELENTE TU CURSO.
Donde puedo encontrar un ejemplo con RTC3231 y solo visualizar la hora y fecha en un LCD 16×2, con PIC16F887?
Se requiere una librería para este RTC tambien?

Responder

Buenas noches Sergio, me es grato dirigirme a usted y comentarle que estoy trabajando con el código de la pagina el cual me parece muy interesante, pero para mi mala suerte no logro compilarlo ya que no tengo una librería adecuada del i2c que sea compatible con su librería del DS1621, que me recomendaría usted.

gracias, cordiales saludos.

Responder

Hola John, es solo usar las propias instrucciones del I2C del compilador, como mostrado en el post. A no se que estés usando otro compilador diferente al CCS C Compiler, las funciones deberían funcionar.

Responder

hola Sergio, eh vistovariios videos y son excelentes sin embargo el video de este proyecto que simulas con proteus y el codigo pic compiler por lo que se ve bastante interesante me puse manos a la obra sin embargo ya terminando lel codigo de la memoria eeprom me arroja un error 12 en 2 lineas donde esta la segunda seccion en el read y la fila es i2c_write(address>>8);
i2c_write(address);
gracias por la ayuda

Responder

Baja los archivos que están en el botón amarillo. Recuerda que debes siempre compilar el programa principal, no puedes compilar directamente la librería porque si no te van a salir errores. Saludos.

Responder

Hola Sergio tengo una inquietud yo puedo conectar po i2c una tarjeta de arduino uno con un pic 16f877 y como se haria.
gracias

Responder

Por el I2C puedes conectar cualquier dispositivo que soporte esta comunicación, por ejemplo puedes tener un PIC y un Arduino perfectamente conectados. Se trabaja exactamente igual que con cualquier periferico, solo que debes programar en ambos un código de comunicación I2C.

Responder

muy bueno, estaba siguiendo el tutorial, y por error borré la librería floatee.c, si alguien me lo proporciona por favor

Responder

me encantan tus videos me han ayudado mucho, justo ahora tengo un proyecto y me gustaria un poco de asesoría necesito comunicar un pic con labview y que el pic reciba datos y conforme esos datos le envía órdenes a otros dos pic, la comunicacion entre el pic y el primer pic es por puerto serial , lo que aun no se es como comunicar los otros dos pic , no se si se pueda implentar comunicacion serial e i2c al mismo tiempo, de antemano gracias

Responder

Claro que puedes implementar las comunicaciones al mismo tiempo. Tus otros dos PICs pueden comunicarse por i2c sin problemas. O si lo deseas, también puedes comunicarlos usando el SPI, en el curso de MICROCONTROLADORES hicimos un ejemplo con SPI comunicando 2 PICs. Saludos

Responder

cordial saludo.

Sergio.

la verdad esta muy completa la explicación y el largo del vídeo lo amerita lo explicaste como se debe hacer una tutoria virtual.
tengo un problema pensé que lo podía solucionar pero no he sido capaz al comilar las librerias me pide una un instrucción inicial claro que estoy compilando con pic c 5.059, sera ese mi problema?, en manera de lo posible si me puedes guiar seria algo bueno mira el error que me sale.

*** Error 128 “EEPROM_24512.c” Line 2(50,51): A #DEVICE required before this line
1 Errors, 0 Warnings.
Build Failed.

Att: emerson palacio

Responder

Emerson no se porque te sale ese error, no entiendo que es lo que tienes en la linea 2. Estas seguro de estar compilando el programa principal?? No vaya ser que estes compilando la librería. Por Cierto ahí en la pagina están todos los archivos completos comprimidos en un .rar descargalos y compilalo para ver si te sale el mismo problema.

Responder

no ya me dio el error si era mio pensé que se debía compilar las librerías eran solo guardarlas, pero también poseía una librería hecha por alguien y por ende chocaba con tu librería, el problema era que ambas tenían el mismo nombre, solo borre la otra librería y listo, pero si me corrió perfecto, gracias por tu pronta solución.

Att: emerson palacio.

Responder

Imagine que estabas compilando la libreria. Que bueno que ya te funciono. Saludos.

Responder