O interface I2C é um protocolo de comunicação série que funciona no paradigma master/slave e foi concebido pela Philips em 1982. Desde então teve algumas evoluções. As mais importantes são em 1992 com a introdução do fast-mode, e a primeira definição publica das especificações. Esta é a implementação que os Arduinos suportam. Em 1995 a Intel introduziu uma variação do I2C chamada de SMBus (System Managment Bus), com um formato mais controlado e que é encontrado nos microcomputadores, como por exemplo no Raspberry Pi.
Do ponto de vista das ligações o interface I2C é simples e facil de implementar. Para além da terra partilhada, para funcionar o I2C apenas precisa de dois fios e duas resistências a fazer de pull up nas linhas. Com esses dois fios podem-se ligar vários dispositivos com interface I2C.
No caso dos Arduinos, como estes já tem os pull up internamente, não é necessário colocar as resistencias entre as linhas e o vcc. No entanto, como todos os Arduinos tem esses pull ups, significa que o número de Arduinos possiveis de ligar é mais limitado que o maximo teórico.
Bus I2C
O bus I2C é composto por dois sinais transportados fisicamente por dois fios, e um protocolo de endereçamento dos nodes.
Os dois fios do bus I2C correspondem aos seguintes dois sinais:
- SDA – o sinal dos dados
- SCL – o sinal de relógio
Sinal SDA do bus I2C
Nesta linha passa o sinal que transmite os dados
Sinal SCL do bus I2C
O sinal de relógio, SCL é sempre gerado pelo master activo. Os nodes slaves nunca podem colocar a linha em HIGH. Apenas os masters o podem fazer, mas alguns nodes slaves podem forçar o sinal SCL em LOW de modo a forçar o master a aguardar antes de enviar mais dados, ou para obter mais tempo para responder ao master antes que o tempo se esgote. Esta técnica do uso do SCL pelos slaves é denominada de alongamento do relógio (clock stretching).
Endereçamento no bus I2C
A quantidade de dispositivos, ou nodes, teoricamente possiveis no bus i2c depende, do numero de bits de endereçamento. Existe uma versão de 7 bits, (usada no Arduino) com 127 nodes, e uma versão de 10 bits, que permitem 1008 dispositivos.
Nodes I2C
Os dispositvos no bus I2C, também chamados de nodes são identificados pelo seu endereço no bus e podem ser de um de dois tipos.
No protocolo da interface I2C estão previstos dois tipos de dispositivos (referidos como nodes):
- Master (estando previstos multiplos masters no protocolo)
- Slave (naturalmente com multiplos slaves)
Cada um dos dispositivos, podem ter ser de um dos dois tipos.
A principal diferença funcional entre os masters I2C e os slaves I2C, é que apenas os masters podem iniciar comunicações.
Neste protocolo existem pelo menos os seguintes tipos de ambientes possiveis (em todos eles podem existir um ou mais nodes slave):
- Apenas um node master
- Com mais de um node master (multiplos master)
A principal diferença entre estes tipos de ambiente é o potencial de existencia de colisões, que provocam pelo menos instabilidade e erros na transmissão dos dados, quando não provocam simplesmente a interrupção do funcionamento normal do microcontrolador.
Apenas um node master
Sem o problema de colisões de acesso ao bus para resolver, é de implementação simples, e costuma funcionar sem problemas
Multiplos masters
Dependendo da situação pode ser viável ou não. Com problemas fáceis de resolver ou dificeis. Neste ambiente com mais que um master no bus i2c existe o problema das eventuais colisões de acesso ao bus para resolver.
Ainda não percebi se nos casos que experimentei e não consegui por a funcionar, seja possivel de os colocar a funcionar com:
- Implementação avançada só por software
- Hardware extra (dois fios) para sinalizar o acesso ao bus entre os vários masters.
Dispositivos com interface I2C
- Microcontroladores (Arduino I2C)
- Módulos de Acelerómetros, giróscópios, magnetómetros, sensores de distancia, relógios de tempo real,memórias epprom, sram e fram
- Modulos conversores ou controladores
Links
https://learn.sparkfun.com/tutorials/i2c/all