i2c-protocolo-de-comunicacao

Prévia do material em texto

I2C – PROTOCOLO DE COMUNICAÇÃO MCU 
 
www.meccomeletronica.com página 1 
 
Esse barramento foi criado pela empresa Holandesa (Philips) como Inter IC ou I2C que 
possibilita a utilização de grande quantidade de componentes padronizados, os quais podem 
realizar diversas funções, além de possibilitar a troca eficaz de informações entre eles. O 
conceito do barramento I2C é facilitar a integração de circuitos de caráter final de aplicação 
como por exemplo sensores e conversores, com um sistema de controle, de modo que eles 
possam trabalhar com seus sinais de maneira direta. 
 
Uma característica bastante interessante deste barramento é a possibilidade de utilizar, em um 
mesmo sistema, componentes de tecnologias construtivas diferentes sem que haja 
incompatibilidade e nem conflitos na comunicação. No I2C a transmissão da informação entre 
os dispositivos é feita através de 2 fios (Serial Data DAS e Serial Clock SCL). 
 
Os dispositivos ligados em Inter IC possuem um endereço fixo (cada componente recebe um 
endereço específico), e podemos configurá-los para receber ou transmitir dados, dessa 
maneira eles podem ser classificados de várias formas, como: mestres (MASTER), escravos 
(SLAVE), entre outras. 
O barramento I2C é do tipo multi-mestre, isso significa que mais de um dispositivo de controle 
pode ser conectado a ele. No entanto, durante uma comunicação, somente um dos mestres 
pode estar ativo, ou ocorrerá uma colisão de dados no barramento. 
 
 
 
 
I2C – PROTOCOLO DE COMUNICAÇÃO MCU 
 
www.meccomeletronica.com página 2 
 
Por exemplo: enquanto um microcontrolador envia sinais a um conversor, um outro 
microcontrolador troca informações com uma memória usando o mesmo barramento. Tudo isso 
é possível, graças a uma "arbitragem" que determina qual dos sinais tem prioridade no envio 
dos dados. 
 
 
 
 
 
 
 
 
 
As linhas SDA como SCL são bidirecionais e devem ser ligadas ao positivo da alimentação 
através de uma fonte de corrente ou de um resistor pull-up, para garantir que ambas as linhas 
permaneçam em nível alto, quando o barramento está livre. 
Uma das vantagens do padrão I2C é que ele não fixa a velocidade de transmissão 
(frequência), pois ela será determinada pelo circuito MASTER (transmissão do SCL). 
A comunicação entre os dispositivos mestres e os escravos, conectados ao barramento I2C, é 
iniciada pela condição de start (início) e finalizada pela condição de stop (fim). Acompanhe a 
condição de start e stop na figura seguinte: 
 
 
CONEXÃO UTILIZANDO I2C 
I2C é um protocolo de barramento (ou bus), ou seja, com os mesmo fios conectamos todos os 
dispositivos do nosso setup. Essa característica, barramento, é um dos grandes atrativos do 
I2C, pois reduzimos em muito a necessidade de pinos de conexão no Arduino, pois usaremos 
sempre os mesmo fios para a conexão, não importa se estamos utilizando 1 ou 127 
dispositivos. 
I2C – PROTOCOLO DE COMUNICAÇÃO MCU 
 
www.meccomeletronica.com página 3 
 
 
Um dispositivo conectado ao barramento, atuando como Master, e 3 dispositivos atuando como 
Slave, também conectados ao barramento 
O Arduino vem com pinos próprios para a conexão I2C, no caso do Uno e derivados 
os pinos são sempre o 4 (SDA) e 5(SCL). No caso do Arduino Mega, os pinos 
utilizados são o 20 (SDA) e 21 (SCL). 
DAS - Serial Data SCL - Serial Clock 
SDA é o pino que efetivamente transfere os dados, e SCL serve para temporização entre os 
dispositivos, de modo que a comunicação pela SDA possa ter confiabilidade. Como podem 
observar, tanto o envio quanto a recepção de dados é realizada utilizando a linha SDA, ou seja, 
é uma linha bi-direcional de comunicação, ora estamos enviando dados por este pino, ora 
estamos recebendo dados. 
 
 
 
 
 
 
Existem uma variedade enorme de dispositivos que utilizam o protocolo I2C, como o próprio 
Arduino, Raspberry, memórias externas (EEPROM), I/O expanders, RTC (Real Time Clock), 
Visor (LCD, TFT, etc), sensores diversos (temperatura, acelerômetro, etc). 
Além do SDA e SCL, os dispositivos utilizam o terra(GND) e o Vcc para alimentação. Abaixo 
um exemplo de ligação mais real: 
 
I2C – PROTOCOLO DE COMUNICAÇÃO MCU 
 
www.meccomeletronica.com página 4 
 
Arduino e outros dispositivos atuando como Slave de um Raspberry Master. 
Os resistores pull-up nas linhas SDA e SCL, são normalmente utilizados quando há mais de 
um slave no barramento, e o valor do resistor é dependente dos dispositivos. Normalmente 
dispositivos I2C possuem um datasheet, e nele podemos encontrar o valor adequado dos 
resistores pull-up. Se estiver utilizando apenas um dispositivo slave conectado ao Arduino, não 
se preocupe, o Arduino já vem com resistores pull-up internos especializados para a 
comunicação I2C. 
A ordem que conectamos os dispositivos não importa. Podemos ligar os dispositivos como 
quisermos, respeitando a pinagem certa, que o resultado final será o mesmo. 
A distância normal de trabalho no barramento I2C é de aproximadamente 1 metro. Além disso 
podemos ter problemas de impedância. Existem dispositivos que podem estender esta 
distância de trabalho até aproximadamente 50 metros, com teoricamente 127 dispositivos. 
I2C – ENDEREÇAMENTO DE DISPOSITIVOS 
Dispositivos I2C possuem um endereço que os identifica. Esse endereço é composto 
normalmente por 7 bits. Se lembram do limite teórico de 127 dispositivos, pois então, com 7 
bits podemos ter 127 valores diferentes. Aqui temos um pouco de confusão, pois além dos 7 
bits que definem o endereçamento, temos ainda um último bit, totalizando 8 bits, que indicam 
se é uma operação de leitura ou escrita (read/write). Normalmente os dispositivos vem 
indicando o seu endereço no formato hexadecimal, considerando 7 bits. Neste caso o Arduino, 
atuando como master, insere estes 7 bits no início da transmissão, ajusta adequadamente o 
oitavo bit, e tudo funciona muito bem. 
 
 
 
Em alguns casos, o fabricante do dispositivo especifica o endereço do dispositivo utilizando o 
oitavo bit. Nestes casos é comum o datasheet especificar um endereço para escrita e outra 
para leitura. Nesta situação temos que calcular o endereço correto (7 bits), ou dar um shift em 
nosso sketch de modo a desconsiderar o oitavo bit. 
 
Como podem ver no exemplo acima, o dispositivo X possui dois endereços: 
( 0X92 E 0X93) 
Sendo que o valor que realmente nos interessa é o 0x49, que é obtido desconsiderando o 
ultimo bit de qualquer um dos endereços anteriores. 
 
Caso não fique claro pelo datasheet se o seu dispositivo usa 7 ou 8 bits no endereçamento, 
outra forma é verificar se o endereço está na faixa de endereços I2C válidos. 
I2C – PROTOCOLO DE COMUNICAÇÃO MCU 
 
www.meccomeletronica.com página 5 
 
 
Como podem ver, a faixa disponível vai de 0x08 a 0x77. Não se esqueça que é em 
hexadecimal, e fazendo as conversões para decimal podemos concluir que o número de 
dispositivos possíveis na prática é 112. 
I2C – ESCRITAS E LEITURAS 
Todo o trabalho com dispositivos I2C se resume a uma operação de leitura ou uma operação 
de escrita. Em nossos sketches, independente do dispositivo, estaremos lendo alguma 
informação ou escrevendo alguma informação em um dispositivo especifico. Será comum 
encontrarmos dispositivos com alguma particularidade nas operações de escrita/leitura, mas 
em geral o datasheet do dispositivo fornece esses detalhes. 
Uma observação importante para trabalharmos com I2C no Arduino, temos que dar um include 
na biblioteca Wire. No início de qualquer sketch inclua a linha #include <Wire.h>. Após 
incluirmos a biblioteca, é necessário inicializá-la dentro de setup() com Wire.begin(). 
I2C – ESCRITA 
A escrita em dispositivos I2C é relativamente simples. O trecho de código abaixo mostra como 
funciona esse processo: 
Wire.beginTransmission(endereço); 
 Wire.write(memória); 
 Wire.write(valor); 
 Wire.endTransmission(); 
WIRE.BEGINTRANSMISSION(ENDEREÇO) - Envia o endereço do dispositivo pela linha SDA, 
sinalizando o dispositivo correspondenteque haverá uma comunicação. Todos os dispositivos 
“escutam” essa informação, mas apenas o dispositivo que possui o endereço informado estará 
apto a se comunicar. 
WIRE.WRITE(MEMÓRIA) - A maioria possui diversos registradores que podem ser gravados, e 
precisamos informar em qual registrador queremos informação. 
WIRE.WRITE(VALOR) - Envia o valor (sempre 1 byte) pela SDA para o dispositivo informado 
anteriormente. O dispositivo possui um registrador (ou memória) aguardando pela informação, 
e os outros dispositivos ignoram esta comunicação. O comum é enviarmos uma informação 
(um byte) em cada operação. 
WIRE.ENDTRANSMISSION() - Após enviarmos a informação, devemos finalizar a operação 
com essa linha, liberando o dispositivo e o barramento I2C para novas operações. 
Se observarmos utilizamos o mesmo comando tanto para informar onde queremos gravar e o 
que queremos gravar. Tudo dependo do datasheet do dispositivo, onde, no caso acima, 
teríamos a instrução de que, numa operação de escrita, o primeiro byte indica a posição de 
memória, e o segundo byte indica o valor a ser gravado. Poderíamos muito bem ter um 
dispositivo com apenas um registrador para gravação, e portanto não seria necessário informar 
em qual posição é para o valor ser gravado 
 
 
I2C – PROTOCOLO DE COMUNICAÇÃO MCU 
 
www.meccomeletronica.com página 6 
 
I2C – LEITURA 
O processo de leitura envolve mais comandos. Normalmente o dispositivo possui diversos 
registradores (ou posições de memória) para armazenar diferentes informações, então temos 
que informar de qual registrador queremos ler informação. Ainda, lembrando que cada 
registrador armazena um byte, podemos especificar o número de bytes que queremos ler. O 
trecho de código abaixo mostra como funciona esse processo: 
 Wire.beginTransmission(endereço); 
 Wire.write(memoria); 
 Wire.endTransmission(); 
 Wire.requestFrom(endereço, 1); 
 byte valor; 
 if (Wire.available()){ 
 valor=Wire.read(); 
 } 
 Wire.endTransmission(); 
As três primeiras linhas foram explicadas anteriormente e, basicamente, posicionam o 
registrador do dispositivo na posição que queremos fazer a leitura. Na sequência temos: 
WIRE.REQUESTFROM(ENDEREÇO, 1) - Este comando informa o dispositivo identificado por 
endereço que queremos ler uma posição de memória(ou byte, ou registrador), a partir da 
posição de memória especificada anteriormente. Esta informação é posta imediatamente na 
linha SDA, e o dispositivo então responde informando também na SDA o valor contido no 
registrador. Neste exemplo estamos pedindo apenas o valor de um registrador, mas 
poderíamos pedir tantos quanto forem necessários. Neste caso o dispositivo iria informar 
sequencialmente, a partir da posição informada pelo write anterior. 
WIRE.AVAILABLE() - Este comando verifica se há informação disponível para leitura. 
O hardware do Arduino armazena em buffer as informações recebidas, e atualmente 
este buffer tem o tamanho de 32 bytes. com isso podemos fazer tranquilamente a 
leitura de 32 bytes sequenciais. 
WIRE.READ() - Esta é bem simples, similar ao Serial.read. Basicamente este 
comando lê um byte de cada vez. 
 
APLICAÇÃO 
Quem precisa conectar um display LCD 16×2 ou 20×4 ao Arduino sabe que vai 
precisar de pelo menos 6 fios para conexão. Em placas com um número menor de 
portas, como o Arduino Uno, isso significa sacrificar algumas portas que poderiam ser 
utilizadas para ligação de outros componentes, como sensores ou motores. Um 
módulo que pode ser utilizado para contornar esse problema é o módulo I2C para 
display LCD com CI PCF8574, disponível em : 
https://www.nxp.com/docs/en/data-sheet/PCF8574_PCF8574A.pdf 
 
 
I2C – PROTOCOLO DE COMUNICAÇÃO MCU 
 
www.meccomeletronica.com página 7 
 
Com esse módulo, você consegue controlar um display LCD, seja ele 16×2 ou 20×4, 
utilizando apenas dois pinos do micro controlador. 
Grupo de pinos que formam a interface de comunicação I2C. 
• Pino analógico 4 (SDA) 
• Pino analógico 5 (SCL) 
 
ESTRUTURA DO MÓDULO I2C 
 
Na lateral esquerda do módulo temos quatro pinos, sendo que dois são para 
alimentação (Vcc e GND), e os outros dois são da interface I2C (SDA e SCL). 
 
Embutido no módulo estão as seguinte funções: 
• Potenciômetro para ajuste do contraste do display. 
• Jumper na lateral oposta permite que a luz de fundo (backlight) seja controlada 
pelo programa ou permaneça apagada. 
 
 
 
Geralmente o módulo vem configurado com o endereço 0x27, podendo ser 
alterado esse endereço utilizando os pinos A0, A1 e A2 como mostrado na 
tabela abaixo: 
 
 
 
 
 
I2C – PROTOCOLO DE COMUNICAÇÃO MCU 
 
www.meccomeletronica.com página 8 
 
LIGAÇÃO DO MÓDULO I2C AO DISPLAY LCD 
 
O módulo possui dezesseis pinos que podem ser ligados diretamente ao 
display, ou no protoboard. O exemplo abaixo baseia-se no display LCD 16×2 
com controlador HD44780. 
 
 
OBS.: Verificar a posição dos pinos SDA e SCL para cada plataforma utilizada. 
 
 
PROGRAMA E BIBLIOTECA LIQUIDCRYSTAL_I2C 
 
Para controlar esse módulo I2C, utilize a biblioteca LiquidCrystal_I2C, disponível: 
 
http://www.meccomeletronica.com/site/data/uploads/newliquidcrystal_1.3.4-1.zip 
 
Os comandos para controle do display são praticamente os mesmos da biblioteca 
LiquidCrystal que utilizamos normalmente, com comandos como lcd.begin(), lcd.print() 
e lcd.setCursor(). Na biblioteca I2C, o comando lcd.setBacklight() liga (HIGH) ou 
desliga (LOW) a luz de fundo do display. 
 
1. #include <Wire.h> 
2. #include <LiquidCrystal_I2C.h> 
3. 
4. // Inicializa o display no endereco 0x27 
5. LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3, POSITIVE); 
6. //PCF8574: 0x20 - 0x27 (up to 8 PCF8574’s per I2C bus) 
7. //PCF8574A: 0x38 - 0x3F (up to 8 PCF8574A’s per I2C bus) 
8. 
9. void setup() { 
10. lcd.begin (16,2); 
11. } 
12. void loop() { 
13. lcd.setBacklight(HIGH); 
14. lcd.setCursor(0,0); 
15. lcd.print("ENGENHARIA"); 
16. lcd.setCursor(0,1); 
17. lcd.print("CONTROLE E AUTOMACAO"); 
18. delay(1000); 
19. lcd.setBacklight(LOW); 
20. delay(1000); 
21. }