No tutorial anterior, abordamos como fazer a interface de um módulo GPS NEO-6M com Raspberry Pi (RPi). O módulo se comunica com RPi através do receptor/transmissor assíncrono universal ou Protocolo UART.
O UART é o protocolo de comunicação de dados ponto a ponto mais comum. Mas não é o único protocolo de comunicação serial. Na eletrônica embarcada, os protocolos I2C e SPI também são amplamente utilizados para comunicação serial de dados. Ao contrário do UART, I2C e SPI são padrões de dados seriais síncronos do tipo mestre-escravo.
Neste tutorial, discutiremos os fundamentos do protocolo I2C.
O que é um I2C?
Um circuito interintegrado (I2C) ou interface de dois fios (TWI) é um protocolo serial síncrono originalmente desenvolvido pela Philips Semiconductors (agora NXP). É um barramento serial multimestre e multiescravo para dispositivos de baixa velocidade que requer apenas dois fios para comunicação serial de dados entre vários dispositivos. Pode ser facilmente implementado com dois canais de entrada/saída digital em um dispositivo.
Um barramento I2C possui apenas dois fios através dos quais centenas de dispositivos podem comunicar dados seriais.
Como padrão de comunicação do tipo mestre-escravo, pelo menos um dispositivo conectado ao barramento deve ser o mestre. É o dispositivo mestre que gera um sinal de clock para comunicação serial síncrona.
Os dispositivos escravos podem transferir dados de e para o(s) dispositivo(s) mestre(s), que acessam os dispositivos escravos por meio de seus endereços I2C. O endereço de cada dispositivo escravo em um barramento I2C deve ser único. Entretanto, os dispositivos escravos I2C ainda devem obter seus endereços da NXP.
Existem apenas dois fios no I2C onde os dispositivos podem ser conectados:
1. Dados seriais (SDA) – a linha pela qual os dispositivos mestre e escravo comunicam dados seriais
2. Relógio serial (SCK) – a linha através da qual o(s) dispositivo(s) mestre(s) gera(m) o sinal de relógio.
O I2C é um tipo de comunicação half-duplex. Nota: um dispositivo mestre só pode ler ou gravar dados no escravo por vez. Além disso, o sinal do relógio e as operações de leitura e gravação são todas controladas pelo(s) dispositivo(s) mestre(s).
Embora possa haver um número ilimitado de dispositivos mestres conectados ao barramento I2C, o número máximo de dispositivos escravos pode ser 112 (no endereçamento de 7 bits) ou 1008 (no endereçamento de 10 bits).
Os drivers do barramento I2C são de drenagem aberta, o que significa que os dispositivos podem puxar a linha de sinal I2C para baixo, mas não podem aumentá-la. Por padrão, ambas as linhas são elevadas por resistores pull-up até que o barramento seja acessado por um dispositivo mestre. Isto é útil para evitar contenção de barramento.
Como os dispositivos mestres só podem puxar a linha de sinal para baixo, não pode haver conflito entre vários mestres – como um mestre puxando a linha para baixo enquanto o outro a leva para alto. Se a qualquer momento a linha de sinal estiver baixa, significa que está acessando um dispositivo mestre.
Portanto, apenas um mestre pode acessar o barramento I2C por vez. E o barramento mestre só pode ler ou gravar dados com um escravo por vez.
Os dados seriais comunicados pelo I2C são divididos em pacotes de dados de 8 bits. A taxa de transferência de dados depende da frequência do clock. No modo padrão, a frequência do clock é de 100 a 400 kHz.
A frequência do relógio é:
- 1 MHz em modo rápido I2C
- 3,4 MHz em modo de alta velocidade
- 5 MHz em modo ultrarrápido
Vantagens de um I2C
A UART é a interface serial mais comum, mas apresenta desvantagens. Ao usar o UART, a comunicação de dados só é possível entre dois dispositivos. Esses dispositivos também devem concordar com um protocolo comum e ter quase o mesmo clock.
É possível conectar mais de dois dispositivos às linhas UART, mas isso acarreta um alto risco de contenção de barramento. Praticamente, a taxa de dados máxima alcançável com o UART é de 230.400 bps. E em cada transmissão de dados de 8 bits, há uma sobrecarga de 2 bits.
Também não é fácil implementar o UART em software. Uma comunicação UART viável requer um chip UART externo ou integrado.
Por outro lado, uma interface periférica serial (SPI) permite apenas um dispositivo mestre, mas vários dispositivos escravos. Para conectar um dispositivo escravo, são necessárias quatro linhas. Para cada dispositivo escravo, é necessária uma linha extra para a seleção do chip. Portanto, apesar da alta taxa de dados (de até 10 Mbps) e da comunicação full-duplex, não é prático conectar vários dispositivos escravos através de um SPI devido às linhas extras necessárias para cada escravo. Esta limitação é mais evidente quando todo o circuito é disposto em uma PCB.
Um SPI normalmente só é bom para a comunicação de dados full-duplex de alta velocidade de um dispositivo mestre (como um microcontrolador ou computador incorporado) com um número limitado de periféricos escravos (digamos, dois ou três). No entanto, um SPI é uma alternativa ao UART para comunicação de dados full-duplex de alta velocidade com mais de um dispositivo periférico.
Essencialmente, um I2C representa o melhor do UART e do SPI. Embora permita a comunicação half-duplex, usando um I2C, um número ilimitado de dispositivos mestres pode comunicar dados seriais com centenas de dispositivos escravos em apenas dois fios.
Como os dispositivos mestres só podem acionar as linhas em nível baixo, a contenção de barramento não é uma preocupação. As taxas de dados ficam entre as do UART e do SPI (até 5 Mbps), e há uma sobrecarga de apenas 1 bit (ACK/NACK) para cada byte transmitido através do protocolo I2C.
Um I2C ainda requer algum hardware complexo em comparação com um SPI, mas não é tão complexo quanto o UART. Além disso, a implementação de software de um I2C é bastante viável.
Além disso, um I2C é particularmente útil quando a comunicação de dados em baixa velocidade é necessária com vários dispositivos ou por vários mestres em apenas dois fios. É por isso que é comumente usado por sensores e módulos incorporados. Ao usar um I2C, um microcontrolador (como o Arduino) ou um computador incorporado (como o Raspberry Pi) pode se conectar e se comunicar com centenas de sensores por meio de apenas dois fios, enquanto conecta apenas seus dois canais/pinos.
Desvantagens de um I2C
Um I2C permite a comunicação serial de dados com vários dispositivos e vários mestres usando apenas dois fios, mas possui baixas taxas de transferência de dados e carece de recursos full-duplex. O I2C simplesmente não é uma opção quando a comunicação full-duplex é necessária ou quando é necessária alta velocidade de dados.
Isso significa:
- O UART é bom para comunicação básica full-duplex entre dois dispositivos com clock semelhante.
- Um SPI é bom para comunicação de dados full-duplex e de alta velocidade com dois ou mais periféricos.
- Um I2C é bom para comunicação de dados em baixa velocidade com vários dispositivos, entre vários mestres em um barramento de 2 fios.
O hardware I2C
A implementação de um I2C requer dois drivers de saída open-drain (coletor aberto na terminologia TTL). Ambos os fios em um barramento I2C devem ser puxados para cima com um resistor adequado. Os canais I2C na maioria dos sensores e módulos comunicam dados seriais com sucesso por meio de dois a três metros de fio.
Para transmissão de dados a longas distâncias, são necessárias placas breakout I2C dedicadas.
A maioria dos microcontroladores e computadores embarcados possui hardware I2C dedicado, que pode operar como mestre I2C e escravo I2C. Como escravo I2C significa que eles também possuem um endereço I2C. Com hardware I2C, eles podem gerar condições de início e parada, receber um endereço I2C e enviar e receber dados seriais pelo protocolo.
Se o endereço I2C for implementado pelo software, os bits de dados deverão ser amostrados pelo menos duas vezes por pulso de clock. A maioria dos microcontroladores tem frequência de clock suficiente para que possam facilmente amostrar os dados I2C usando um temporizador/contador interno com ou sem um pré-escalador.
Os níveis de tensão I2C
As tensões típicas usadas para o I2C são +5 e +3,3V. O I2C é flexível, entretanto, e também pode manter comunicação de dados com dispositivos/interfaces com outros níveis de tensão.
Ao conectar um dispositivo de tensão mais alta a outro de tensão mais baixa através de I2C, é necessário cuidado. Às vezes, puxar o barramento I2C para um nível de dispositivo de tensão mais baixa é suficiente. Mas ainda há uma chance de que o dispositivo de tensão mais alta danifique o dispositivo de tensão mais baixa. É recomendado conectar os dois dispositivos com diferentes níveis de tensão no barramento I2C usando uma placa de mudança de nível I2C adequada.
Os endereços I2C
Dispositivos mestres em um barramento I2C não precisam ter endereço, pois geram o sinal de clock em uma linha SCL. Os dispositivos escravos precisam ter endereços exclusivos em um barramento I2C.
Os endereços I2C dos dispositivos escravos podem ser de 7 ou 10 bits. Alguns desses dispositivos possuem endereços fixos, enquanto outros possuem linhas de endereço que podem ser conectadas para definir o endereço do dispositivo por meio de uma interface I2C.
Como há um número limitado de endereços I2C (apenas 112 endereços em 7 bits e 1008 endereços em 10 bits), há uma chance de que dois dispositivos I2C tenham o mesmo. Mais de um dispositivo I2C com o mesmo endereço pode ser conectado a um controlador/computador usando um hub I2C.
O protocolo I2C
Por padrão, ambas as linhas I2C (SDA e SCL) são altas. Pode haver um ou mais dispositivos mestres conectados a um barramento I2C. A comunicação de dados é iniciada por um dispositivo mestre.
Um dispositivo mestre gera uma condição inicial seguida pelo endereço do dispositivo escravo. O endereço do dispositivo escravo deve ser único. No endereçamento de 7 bits, o bit 0 do byte de endereço indica se o mestre lê ou escreve no escravo I2C. Se o bit 0 do byte de endereço for 0, o dispositivo mestre grava os dados no escravo I2C. Se for 1, o dispositivo mestre lê dados do escravo I2C.
Depois de selecionar um dispositivo escravo, os quadros de dados que consistem em dados de 8 bits e bits de confirmação são transferidos entre o mestre e o escravo. Pode haver repetidas condições de inicialização de um mestre para ler e escrever os dados seriais com um ou mais escravos I2C.
Assim que a comunicação de dados for concluída, o dispositivo mestre deve gerar uma condição de parada para encerrar a comunicação pelo barramento I2C.
O barramento I2C também pode ser usado por outros dispositivos mestres. Na verdade, pode haver um número ilimitado de dispositivos mestres conectados a um barramento I2C, desde que a capacitância do barramento não exceda 400 pF.
A condição inicial
Para gerar a condição inicial, um dispositivo mestre precisa puxar um SDA para baixo enquanto deixa o SCL para alto.
Se dois dispositivos mestres tentarem acessar o I2C ao mesmo tempo, o que puxar o SDA para baixo primeiro obterá a propriedade do barramento. Isso é chamado de arbitragem.
Quando há uma transição de alto para baixo em uma linha SDA, os escravos I2C são alertados de que uma transmissão está prestes a começar. Uma vez que o barramento é controlado por um mestre, ele pode ler e gravar dados em um ou mais dispositivos escravos, gerando condições de partida repetidas.
Até que a condição de parada seja gerada pelo barramento mestre atual, outros dispositivos mestres não poderão obter controle do barramento I2C.
Quadros de endereço
Os dados são comunicados pelo barramento I2C em quadros de 8 bits (pacotes de dados). O primeiro quadro após a condição inicial é sempre um quadro de endereço. Este quadro identifica o dispositivo escravo com o qual o barramento mestre I2C deve se comunicar.
Neste quadro, o endereço de 7 bits de um dispositivo escravo é transmitido pelo mestre, começando pelo MSB do endereço I2C. É seguido por um bit R/W, que determina se o mestre irá ler ou escrever dados no escravo. Se o bit R/W for 0, o dispositivo mestre grava dados no escravo I2C. Se for 1, o dispositivo mestre lê dados do escravo I2C.
Após a condição de partida, o barramento mestre deve puxar a linha SCL para baixo. Os bits são amostrados sempre que a linha SCL fica alta. Os dados (bits) na linha SDA devem permanecer estáveis quando o SCL estiver alto, caso contrário, será interpretado como uma condição repetida de início ou parada. Os bits de dados só podem mudar quando o SCL estiver baixo. Após a condição inicial, o SCL é reduzido pelo mestre e os dados são colocados na linha SDA. Depois disso, os dados são amostrados pelo escravo em cada transição de baixo para alto do sinal SCL.
Cada quadro de dados de 8 bits termina com um bit ACK/NACK. Após a transferência de 8 bits, o dispositivo receptor obtém o controle da linha SDA. Se o dispositivo receptor puxar a linha SDA para baixo antes do nono pulso de clock, isso significa que ele recebeu com sucesso o quadro de dados de 8 bits.
Se isso não ocorrer, significa que não foi possível receber o quadro de dados ou não foi possível analisar os dados de acordo com o protocolo I2C. Neste caso, o dispositivo receptor não puxa a linha SDA para baixo, mas cabe ao mestre encerrar a comunicação de dados gerando uma condição de parada ou uma condição de início repetida.
No caso de um quadro de endereço, o dispositivo receptor é sempre um dispositivo escravo.
Quadros de dados
Após enviar um quadro de endereço, o barramento mestre continuará enviando pulsos de clock. Dependendo do bit R/W, os dados são lidos ou escritos pelo dispositivo mestre. Após cada quadro de 8 bits, o dispositivo receptor puxa a linha SDA para baixo no nono pulso de clock.
Pode haver qualquer número de quadros de dados trocados entre um mestre e um escravo – depois que o mestre seleciona um escravo e a operação de leitura/gravação enviando o sinal de início e, em seguida, um quadro de endereço.
A condição de parada
Depois que um mestre ganha o controle do barramento I2C, ele pode ler/gravar dados seriais com qualquer número de escravos, gerando condições de inicialização repetidas.
Para liberar o barramento o mestre deve gerar uma condição de parada. A condição de parada é gerada puxando a linha SDA de alto para baixo, enquanto a linha SCL está alta.
É por isso que os bits de dados nunca devem mudar quando o pulso de clock na linha SCL estiver alto. Caso contrário, será interpretado como uma falsa condição de parada ou uma falsa partida repetida.
Alongamento do relógio
Se um dispositivo escravo não estiver pronto ou não for capaz de processar os dados recebidos, ele poderá puxar a linha SCL para baixo para indicar que precisa de tempo para receber/processar os dados. Quando o dispositivo estiver pronto, ele poderá colocar a linha SCL em nível alto, indicando que o mestre pode reiniciar a comunicação serial. Isso é chamado de alongamento do relógio.
Os bits de dados são sempre amostrados em uma transição de baixo para alto do pulso de clock em uma linha SCL. Os dispositivos escravos só podem puxar a linha SCL para baixo depois que o mestre liberar o barramento I2C. Quando a linha SCL é reduzida por um dispositivo escravo, os dispositivos mestres no barramento I2C evitam gerar pulsos de clock ou colocar dados em uma linha SDA até que a linha SCL seja liberada pelo escravo.
O endereçamento I2C de 10 bits
Dispositivos I2C avançados possuem endereços de 10 bits. Eles podem ser usados com dispositivos de endereço de 7 bits, pois o quadro de endereço para dispositivos de 10 bits sempre começa com a sequência de 5 bits, 11110.
Esta sequência indica um endereço de 10 bits do dispositivo mestre. Para selecionar um escravo I2C com endereço de 10 bits, o dispositivo mestre deve enviar dois quadros de endereço para escrever os dados no escravo, ou três quadros de endereço para ler os dados do escravo.
Quando o mestre precisa gravar dados em um escravo de endereço de 10 bits, ele deve enviar dois quadros de endereço. O primeiro quadro de endereço contém a sequência de 5 bits 11110, seguida por dois bits do endereço escravo e o bit R/W. O bit R/W deve ser 0 neste caso.
Após enviar o primeiro quadro, ele deve aguardar o ACK no nono pulso de clock. Se o bit de confirmação (uma linha SCL puxada para baixo pelo dispositivo receptor) for detectado com sucesso pelo mestre, ele envia os 8 bits restantes do endereço escravo no próximo quadro.
Quando um mestre precisa ler os dados de um escravo de endereço de 10 bits, o bit R/W no primeiro quadro de endereço ainda é 0, mas o segundo quadro de endereço é seguido por uma condição de início repetida.
Após a condição de início repetida, o primeiro quadro de endereço é reenviado ao escravo com o bit R/W definido como 1.
Protocolo I2C avançado
A maioria dos dispositivos I2C possui endereços de 7 bits e usa o modo padrão, onde a taxa de transferência de dados é de 100 Kbps. Dispositivos I2C avançados operam em modo rápido, de alta velocidade ou ultrarrápido e geralmente possuem endereços de 10 bits.
Dispositivos I2C de modo rápido têm compatibilidade com versões anteriores e também podem funcionar com controladores I2C mais lentos. Dispositivos I2C de alta velocidade usam dois estados de clock, SCLH e SCLL, e possuem circuitos de supressão de picos em ambas as linhas do barramento I2C.
Os dispositivos de alta velocidade não usam clock stretching ou arbitragem porque possuem drivers de saída de linha aprimorados.
No próximo tutorial, discutiremos a comunicação serial síncrona ao usar o protocolo I2C no Raspberry Pi.
