Arduino - Circuito inter integrado

El circuito interintegrado (I2C) es un sistema para el intercambio de datos en serie entre los microcontroladores y los circuitos integrados especializados de una nueva generación. Se utiliza cuando la distancia entre ellos es corta (el receptor y el transmisor suelen estar en la misma placa impresa). La conexión se establece mediante dos conductores. Uno se utiliza para la transferencia de datos y el otro se utiliza para la sincronización (señal de reloj).

Como se ve en la siguiente figura, un dispositivo siempre es un maestro. Realiza el direccionamiento de un chip esclavo antes de que comience la comunicación. De esta forma, un microcontrolador puede comunicarse con 112 dispositivos diferentes. La velocidad en baudios suele ser de 100 Kb / seg (modo estándar) o 10 Kb / seg (modo de velocidad de transmisión lenta). Recientemente han aparecido sistemas con una tasa de baudios de 3,4 Mb / seg. La distancia entre dispositivos que se comunican a través de un bus I2C está limitada a varios metros.

Pines del tablero I2C

El bus I2C consta de dos señales: SCL y SDA. SCL es la señal de reloj y SDA es la señal de datos. El maestro de bus actual siempre genera la señal de reloj. Algunos dispositivos esclavos pueden forzar el reloj bajo a veces para retrasar el envío de más datos por parte del maestro (o para requerir más tiempo para preparar los datos antes de que el maestro intente marcarlos). Esto se conoce como "estiramiento del reloj".

A continuación se muestran los pines para diferentes placas Arduino:

  • Uno, Pro Mini A4 (SDA), A5 (SCL)
  • Mega, debido a 20 (SDA), 21 (SCL)
  • Leonardo, Yun 2 (SDA), 3 (SCL)

Arduino I2C

Tenemos dos modos, código maestro y código esclavo, para conectar dos placas Arduino usando I2C. Ellos son -

  • Transmisor maestro / receptor esclavo
  • Receptor maestro / transmisor esclavo

Transmisor maestro / receptor esclavo

Veamos ahora qué es el transmisor maestro y el receptor esclavo.

Transmisor maestro

Las siguientes funciones se utilizan para inicializar la biblioteca Wire y unirse al bus I2C como maestro o esclavo. Esto normalmente se llama una sola vez.

  • Wire.begin(address) - La dirección es la dirección del esclavo de 7 bits en nuestro caso, ya que el maestro no está especificado y se unirá al bus como maestro.

  • Wire.beginTransmission(address) - Inicie una transmisión al dispositivo esclavo I2C con la dirección dada.

  • Wire.write(value) - Colas de bytes para la transmisión desde un dispositivo maestro a esclavo (llamadas intermedias a beginTransmission () y endTransmission ()).

  • Wire.endTransmission() - Finaliza una transmisión a un dispositivo esclavo que fue iniciada por beginTransmission () y transmite los bytes que fueron puestos en cola por wire.write ().

Example

#include <Wire.h> //include wire library

void setup() //this will run only once { 
   Wire.begin(); // join i2c bus as master
} 

short age = 0; 

void loop() {   
   Wire.beginTransmission(2); 
   // transmit to device #2
   Wire.write("age is = ");
   Wire.write(age); // sends one byte
   Wire.endTransmission(); // stop transmitting
   delay(1000); 
}

Receptor esclavo

Se utilizan las siguientes funciones:

  • Wire.begin(address) - Dirección es la dirección esclava de 7 bits.

  • Wire.onReceive(received data handler) - Función que se llamará cuando un dispositivo esclavo reciba datos del maestro.

  • Wire.available() - Devuelve el número de bytes disponibles para su recuperación con Wire.read (). Se debe llamar dentro del controlador Wire.onReceive ().

Example

#include <Wire.h> //include wire library

void setup() {  //this will run only once
   Wire.begin(2); // join i2c bus with address #2
   Wire.onReceive(receiveEvent); // call receiveEvent when the master send any thing 
   Serial.begin(9600); // start serial for output to print what we receive 
}

void loop() {   
   delay(250); 
}

//-----this function will execute whenever data is received from master-----//

void receiveEvent(int howMany) { 
   while (Wire.available()>1) // loop through all but the last {
      char c = Wire.read(); // receive byte as a character
      Serial.print(c); // print the character
   }
}

Receptor maestro / transmisor esclavo

Veamos ahora qué es el receptor maestro y el transmisor esclavo.

Receptor maestro

El Maestro está programado para solicitar y luego leer bytes de datos que se envían desde el Arduino Esclavo con dirección única.

Se utiliza la siguiente función:

Wire.requestFrom(address,number of bytes)- Utilizado por el maestro para solicitar bytes de un dispositivo esclavo. Los bytes se pueden recuperar con las funciones wire.available () y wire.read ().

Example

#include <Wire.h> //include wire library void setup() { 
   Wire.begin(); // join i2c bus (address optional for master) 
   Serial.begin(9600); // start serial for output
} 

void loop() { 
   Wire.requestFrom(2, 1); // request 1 bytes from slave device #2
   while (Wire.available()) // slave may send less than requested {
      char c = Wire.read(); // receive a byte as character
      Serial.print(c); // print the character
   } 
   delay(500); 
}

Transmisor esclavo

Se utiliza la siguiente función.

Wire.onRequest(handler) - Se llama a una función cuando un maestro solicita datos de este dispositivo esclavo.

Example

#include <Wire.h> 

void setup() { 
   Wire.begin(2); // join i2c bus with address #2
   Wire.onRequest(requestEvent); // register event
} 

Byte x = 0;

void loop() { 
   delay(100); 
} 

// function that executes whenever data is requested by master
// this function is registered as an event, see setup()

void requestEvent() { 
   Wire.write(x); // respond with message of 1 bytes as expected by master
   x++; 
}