Leitura de temperatura por I2C com o MCP9808

Você fará a prática no seu computador e com seus próprios equipamentos: um Arduino Uno R3, um módulo MCP9808 e cabos. Antes de montar, consulte a documentação do seu módulo e confirme que ele é explicitamente compatível com alimentação e sinais de 5 V.

Módulos podem ter a mesma função, mas pinos em posições, nomes e circuitos auxiliares diferentes. Por isso, siga a função indicada no módulo e na documentação — não uma posição presumida na placa.

No Uno R3, o barramento desta prática usa os pinos analógicos compartilhados:

• SDA → A4
• SCL → A5
• GND do módulo → GND do Uno
• Alimentação do módulo → terminal de alimentação indicado pela documentação, compatível com 5 V

O GND comum é indispensável: ele fornece a referência de tensão para os sinais SDA e SCL. Faça a montagem com o circuito desligado.

SDA e SCL são linhas de dreno aberto. Em vez de alguém forçar nível alto, cada participante do barramento faz apenas uma destas ações:

• puxa a linha para nível baixo;
• libera a linha.

Quando todos a liberam, o resistor de pull-up leva a linha ao nível alto. Assim, vários dispositivos podem compartilhar a mesma linha sem um dispositivo dirigir alto enquanto outro dirige baixo.

No barramento I2C, o Uno é o controlador: ele inicia a comunicação e escolhe com qual dispositivo quer falar. Essa escolha usa um endereço de 7 bits.

O MCP9808 usa uma base fixa, 0x18. Os pinos de endereço do próprio sensor — A2, A1 e A0 — acrescentam um valor de 0 a 7 a essa base. Assim, vários MCP9808 podem compartilhar SDA e SCL quando recebem configurações diferentes.

Atenção: A0, A1 e A2 aqui são pinos de endereço do MCP9808. Eles não são as entradas analógicas A0, A1 e A2 do Uno.

Cada pino A contribui com um bit para o final do endereço. A base 0x18 corresponde ao padrão com A2, A1 e A0 baixos:

0x18 + valor binário A2A1A0

Por exemplo, A2=0, A1=1 e A0=1 formam 011₂, que vale 3. Logo, o endereço é 0x18 + 3 = 0x1B. Consulte a documentação do seu módulo para saber como seus pinos ou resistores definem esses níveis.

Para a montagem deste tutorial, A2, A1 e A0 estão em nível baixo. Complete o valor hexadecimal de sete bits que será passado à Wire.

Não converta 0x18 para um “endereço de leitura” ou “endereço de escrita” ao chamar a Wire. O bit que diferencia leitura e escrita faz parte da transmissão no barramento, mas não deve ser acrescentado manualmente ao argumento da biblioteca.

Portanto, quando chegar o momento de iniciar uma comunicação, o valor será 0x18 — não 0x30 nem 0x31.

Uma transação I2C é delimitada por condições especiais nas duas linhas do barramento:

• START: SDA passa de nível alto para baixo enquanto SCL está alto.
• STOP: SDA passa de nível baixo para alto enquanto SCL está alto.

Entre esses limites, os bits de dados normalmente mudam enquanto SCL está baixo. O receptor observa o valor de SDA enquanto SCL está alto. Essa regra permite distinguir dados das condições que abrem e encerram uma conversa no barramento.

Cada trecho transmitido tem oito bits e mais um nono pulso de clock destinado à confirmação.

Após os oito bits, quem recebeu o byte pode puxar SDA para baixo no nono pulso: isso é ACK. Se SDA permanece em alto, há um NACK.

O sentido importa: quem transmite os oito bits não é necessariamente quem confirma. Por exemplo, ao controlador enviar endereço e dados, o sensor confirma. Ao sensor enviar um byte de leitura, o controlador confirma ou encerra com NACK.

Uma leitura de registrador costuma ter duas fases contínuas. Depois de selecionar um registrador para escrita, o controlador gera um START repetido: uma nova condição START sem STOP intermediário. Assim, a comunicação muda para a fase de leitura sem liberar o barramento entre as fases.

Em uma leitura de dois bytes, o controlador confirma o primeiro byte recebido com ACK. No segundo e último byte, ele responde com NACK e então gera STOP. Esse NACK final informa ao dispositivo que não deve enviar outro byte.

Preparar a Wire com limite de espera

Nesta prática, use a biblioteca Wire fornecida pelo pacote Arduino AVR Boards: não é necessária uma biblioteca específica para o MCP9808. O Uno será configurado para I2C a 100 kHz.

Antes de escrever a leitura do sensor, confirme no seu ambiente local que a versão instalada do pacote Arduino AVR Boards documenta estas funções:

• Wire.setWireTimeout(...)
• Wire.getWireTimeoutFlag()
• Wire.clearWireTimeoutFlag()

Consulte a referência da versão instalada na IDE ou os arquivos locais do pacote. Se essa API não estiver disponível, atualize o pacote antes de continuar. Não remova a proteção de timeout como substituto.

Coloque esta configuração no início de setup(), antes das transações que serão criadas nos próximos passos.

Configuração da Wire para esta prática

O timeout da Wire atua nas esperas internas das chamadas da própria biblioteca. Ele é diferente de medir um tempo fora da chamada.

Se uma chamada bloqueante estiver esperando uma condição no barramento, o código após essa chamada ainda não começou a executar. Por isso, um teste com millis() colocado apenas antes e depois dela não consegue interrompê-la.

A flag de timeout também é persistente: depois de registrada, continua ativa até você limpá-la explicitamente. Nos próximos passos, ela será limpa no começo de cada tentativa e consultada ao longo da transação.

Complete apenas as chamadas de configuração. Considere que Wire.h já foi incluída e que o código é destinado ao Uno R3 com uma versão AVR que oferece a API de timeout.

Há dois endereços diferentes nesta leitura:

• 0x18 é o endereço I2C de sete bits do MCP9808 configurado na montagem. Ele seleciona o dispositivo no barramento.
• 0x05 é o endereço interno do registrador de temperatura. Ele informa qual dado queremos ler no dispositivo já selecionado.

Portanto, não use 0x05 em Wire.beginTransmission(): essa chamada espera o endereço do dispositivo, isto é, 0x18.

A leitura é feita em duas fases contínuas.

1. Apontar o registrador. Wire.beginTransmission(0x18) prepara uma transmissão ao sensor. Wire.write(0x05) coloca no buffer o registrador desejado.

2. Manter o barramento. Wire.endTransmission(false) transmite essa fase, mas o argumento false evita o STOP. Assim, a próxima chamada pode continuar com um START repetido.

O valor retornado por endTransmission() será validado no próximo step. Por enquanto, concentre-se na sequência e no papel de cada chamada.

Fase 1: selecionar o registrador de temperatura

Depois da fase de escrita sem STOP, solicite dois bytes ao mesmo sensor:

uint8_t recebidos = Wire.requestFrom(MCP9808, (uint8_t)2);

A biblioteca inicia a fase de leitura e emite STOP quando ela termina. Durante o recebimento, ela também cuida do protocolo: confirma o primeiro byte com ACK, envia NACK após o segundo e último byte e encerra a transação.

Não controle SDA ou SCL manualmente para produzir esses eventos.

Organize as fases da leitura do registrador 0x05. Pense na ordem que mantém a transação contínua entre o envio do registrador e a solicitação de dados.

Complete a sequência que aponta o registrador de temperatura e solicita seus dois bytes. As lacunas representam valores e argumentos essenciais, não nomes de variáveis arbitrários.

Uma leitura só pode chegar à etapa de interpretação quando todas as verificações de transporte forem aprovadas. Comece cada tentativa limpando a flag persistente de timeout. Depois, confira essa flag após cada operação da Wire que possa aguardar o barramento.

A fase que seleciona o registrador termina em Wire.endTransmission(false). Se ela falhar, encerre a tentativa imediatamente: não solicite os dois bytes e não produza uma temperatura.

Mesmo que o retorno da escrita seja sucesso, um timeout registrado torna a tentativa inválida.

No núcleo Arduino AVR adotado, o retorno de Wire.endTransmission(false) informa o resultado da fase de escrita. O valor 0 é o único sucesso. Os demais valores devem ser tratados como falha e comunicados como tal, sem inventar um valor de temperatura.

Consulte a documentação da versão local do pacote Arduino AVR Boards para confirmar os códigos disponíveis.

Esta função valida o transporte e só entrega dois bytes quando a tentativa está completa. Ela ainda não converte esses bytes em graus Celsius.

A conversão só começa depois de a tentativa ter sido validada: escrita concluída, sem timeout e dois bytes disponíveis. O registrador de temperatura é o 0x05.

O MCP9808 envia primeiro o byte mais significativo (MSB) e depois o menos significativo (LSB). Portanto, se a leitura fornecer msb e lsb, a palavra de 16 bits é formada como MSB:LSB, e não na ordem inversa.

Os bits 15 a 13 trazem indicadores de alerta. Eles fazem parte da palavra recebida, mas não fazem parte do valor numérico da temperatura.

Monte a palavra com uint16_t. A conversão explícita antes do deslocamento faz o deslocamento ocorrer em um tipo sem sinal de 16 bits, em vez de depender do comportamento de int com sinal no AVR.

Depois, use máscaras separadas: 0x0FFF conserva apenas o campo numérico, e 0x1000 testa o bit de sinal. A divisão por 16.0 preserva a fração: cada unidade do campo vale 1/16 °C.

Trecho para usar somente após validar os dois bytes recebidos.

Complete as lacunas para montar a palavra e converter uma leitura negativa. Os alertas devem permanecer fora do valor calculado.

Com a montagem já conferida e o MCP9808 configurado em 0x18, a execução terá dois estados:

• Leitura válida: o Monitor Serial mostra uma temperatura em °C.
• Falha: o programa informa a etapa que falhou e não imprime uma temperatura.

Nas próximas telas, copie os dois blocos para um único sketch, na ordem apresentada. Compile, grave no Uno e abra o Monitor Serial em 9600 baud. A primeira tentativa acontece cerca de um segundo após a placa iniciar; as próximas ocorrem a cada segundo.

A temperatura ambiente não tem um valor predeterminado e pode oscilar um pouco. Não aqueça nem resfrie o sensor para este teste.

Bloco 1 de 2 — coloque este trecho no início do sketch. Ele reúne a leitura validada e a conversão já estudadas.

Bloco 2 de 2 — acrescente este trecho abaixo do bloco anterior. Juntos, os dois blocos formam o sketch completo para compilar e gravar.

Agora teste uma ausência de resposta sem alterar a fiação:

1. Troque somente SENSOR_ADDR = 0x18 por SENSOR_ADDR = 0x19.
2. Compile e grave novamente, mantendo apenas o sensor configurado em 0x18 no barramento.
3. Observe a mensagem Falha I2C: escrita ou endereco sem resposta. Não deve aparecer uma temperatura nessa tentativa.
4. Restaure 0x18, grave o sketch e confirme que a temperatura volta a aparecer.

A alteração seleciona um endereço diferente e produz um teste seguro de NACK de endereço.

Antes de converter, siga sempre esta ordem: montagem compatível → endereço do sensor → registrador 0x05 → transação → validação → conversão.

Uma tentativa só pode virar temperatura quando a escrita do registrador teve sucesso, não houve timeout e chegaram exatamente dois bytes disponíveis. Um valor de 0,00 °C pode ser válido: zero não é sinal automático de falha.

Faça a associação entre o caso e sua conclusão.