Arduino - Circuito Integrado Inter

Circuito Inter-integrado (I2C) é um sistema de troca serial de dados entre os microcontroladores e circuitos integrados especializados de nova geração. É usado quando a distância entre eles é curta (o receptor e o transmissor geralmente estão na mesma placa impressa). A conexão é estabelecida por meio de dois condutores. Um é usado para transferência de dados e o outro é usado para sincronização (sinal de relógio).

Conforme visto na figura a seguir, um dispositivo é sempre um mestre. Ele executa o endereçamento de um chip escravo antes do início da comunicação. Desta forma, um microcontrolador pode se comunicar com 112 dispositivos diferentes. A taxa de transmissão é geralmente de 100 Kb / s (modo padrão) ou 10 Kb / s (modo de taxa de transmissão lenta). Recentemente, surgiram sistemas com taxa de transmissão de 3,4 Mb / s. A distância entre os dispositivos que se comunicam em um barramento I2C é limitada a vários metros.

Pinos I2C da placa

O barramento I2C consiste em dois sinais - SCL e SDA. SCL é o sinal de clock e SDA é o sinal de dados. O barramento mestre atual sempre gera o sinal de clock. Alguns dispositivos escravos podem forçar o clock baixo às vezes para atrasar o envio de mais dados pelo mestre (ou para exigir mais tempo para preparar os dados antes que o mestre tente fazer o clock out). Isso é conhecido como “alongamento do relógio”.

A seguir estão os pinos para diferentes placas Arduino -

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

Arduino I2C

Temos dois modos - código mestre e código escravo - para conectar duas placas Arduino usando I2C. Eles são -

Transmissor Mestre / Receptor Escravo
Receptor mestre / transmissor escravo

Transmissor Mestre / Receptor Escravo

Vamos agora ver o que é transmissor mestre e receptor escravo.

Transmissor Mestre

As funções a seguir são usadas para inicializar a biblioteca Wire e ingressar no barramento I2C como mestre ou escravo. Normalmente é chamado apenas uma vez.

Wire.begin(address) - O endereço é o endereço do escravo de 7 bits em nosso caso, pois o mestre não é especificado e entrará no barramento como mestre.
Wire.beginTransmission(address) - Comece uma transmissão para o dispositivo escravo I2C com o endereço fornecido.
Wire.write(value) - Fila os bytes para transmissão de um dispositivo mestre para o escravo (entre chamadas para beginTransmission () e endTransmission ()).
Wire.endTransmission() - Termina uma transmissão para um dispositivo escravo que foi iniciada por beginTransmission () e transmite os bytes que foram enfileirados 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); 
}

Slave Receiver

As seguintes funções são usadas -

Wire.begin(address) - O endereço é o endereço do escravo de 7 bits.
Wire.onReceive(received data handler) - Função a ser chamada quando um dispositivo escravo recebe dados do mestre.
Wire.available() - Retorna o número de bytes disponíveis para recuperação com Wire.read (). Deve ser chamado dentro do manipulador 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 mestre / transmissor escravo

Vamos agora ver o que é receptor mestre e transmissor escravo.

Receptor Mestre

O Master é programado para solicitar e então ler bytes de dados que são enviados do Slave Arduino endereçado exclusivamente.

A seguinte função é usada -

Wire.requestFrom(address,number of bytes)- Usado pelo mestre para solicitar bytes de um dispositivo escravo. Os bytes podem então ser recuperados com as funções wire.available () e 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); 
}

Transmissor escravo

A seguinte função é usada.

Wire.onRequest(handler) - Uma função é chamada quando um mestre solicita dados deste dispositivo escravo.

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++; 
}