Ampliando as portas analógicas do NodeMCU 3

Não é mais segredo para ninguém que o uso de sensores e dispositivos inteligentes deixou de ser algo de filmes e desenhos de ficção científica e se tornou uma realidade bastante palpável e, para muitos, cotidiana. Cidades inteligentes, equipamentos das áreas de saúde e segurança só aumentam sua popularidade ao passo que as tecnologias que as habilitam custam cada vez menos e ficam cada vez mais acessíveis. A Internet das Coisas (IoT) e suas áreas relacionadas, como Big Data, por exemplo, ampliam seu alcance diariamente, tomando conta até mesmo dos lares mais comuns.

Este foi exatamente o meu caso, por exemplo. Sou profissional de computação e atuo, dentre outras coisas, com Big Data e Business Analytics, mas adicionei a IoT a meu portfólio há um tempo. O motivo? A incapacidade de pensar nos mundos contemporâneo e do porvir sem sua existência, mesmo em situações simples como controlar a temperatura de uma sala de servidores, manter a equipe de manutenção ciente, em tempo real, do estado das lâmpadas de um condomínio e coisas desse tipo.

Depois de alguns trabalhos, acabei criando um dispositivo para monitoramento de dados do quarto de meu filho autista durante sua noite de sono, com o intuito de ajudá-lo a dormir melhor. Inicialmente, decidi coletar as variações sonoras e de luminosidade dentro do ambiente, para depois cruzar os dados com os registros feitos por uma smart band que ele usa também durante a noite. Coisa simples, só para testar algumas hipóteses e, quem sabe, aumentar o número de sensores para avançar um pouco mais no assunto. Como bom usuário de NodeMCU que sou, me deparei com um problema básico: eu precisava de duas entradas analógicas, mas eu só tinha uma porta disponível. Como resolver isso de forma fácil, rápida e barata? É aí que chegamos ao que vou mostrar neste post.

A tecnologia utilizada

Você já deve ter visto na internet algumas soluções para ampliar as portas analógicas do NodeMCU, uma delas está disponível aqui no blog, inclusive, utilizando o Arduino. Essa abordagem, apesar de muito boa, exige um conhecimento de programação mais avançado e um investimento financeiro maior. Eu vou apresentar para você agora uma opção bem barata e simples de programar, utilizando um pequeno componente eletrônico chamado multiplexador.

De forma resumida, um multiplexador é um elemento responsável por direcionar o sinal que pode entrar por diversas portas diferentes para uma mesma porta de saída. Imagine que você está em um jardim brincando com quatro crianças e que cada um segura dez balões cheios de água. Na frente deles há um balde. Entre eles e o balde está você. Seu papel é garantir que cada criança jogará um balão de cada vez dentro do balde e que nenhuma delas vai arremessar ao mesmo tempo em que a outra, de forma que três sempre estarão esperando enquanto uma estará fazendo seu arremesso. Ao fim de cada arremesso, você coloca aquela criança na espera e dá a vez para a outra, e assim sucessivamente. É mais ou menos desta maneira que as coisas funcionam quando utilizamos um multiplexador, mas em vez de crianças e balões, temos portas de entrada de sinal analógico; no lugar de um balde, temos uma porta de comunicação no NodeMCU; e no seu lugar, temos um multiplexador.

A ideia do projeto, portanto, é conectar os sensores analógicos às portas do multiplexador e a saída deste ao NodeMCU, controlando, através de um chaveamento de bits, de quem é a vez de transmitir os dados.

Materiais necessários

Bom, vamos à lista de materiais que você vai precisar para reproduzir o que vou apresentar aqui, antes de passarmos para a parte técnica da solução e a explicação de como tudo vai se encaixar e funcionar. Os materiais são:

• 1 NodeMCU
• 1 Multiplexador CD74HC4052 (você pode usar o 74HC151N, disponível aqui na MakerHero, ficando atento às modificações necessárias no circuito)
• 1 Sensor de som KY-038
• 1 Sensor de iluminação LDR
• 1 Resistor de 10KΩ
• 1 Protoboard de 400 pontos
• Jumpers macho-macho e macho-fêmea diversos

Existem alguns multiplexadores no mercado e o 74HC151N é um deles, mas eu utilizei o CD74HC4052 pelo simples motivo de que eu já tinha um em casa, ok?

O multiplexador

Vamos analisar o esquema do multiplexador para ver como ele funciona e deve ser conectado ao circuito. Observe a figura abaixo, que representa o CD74HC4052 visto de cima.

Vamos entender o papel de cada um desses conectores.

 

X0..X3	Portas analógicas (entradas) do canal X
X	Saída analógica do sinal do canal X
Y0..Y3	Portas analógicas (entradas) do canal Y
Y	Saída analógica do sinal do canal Y
A, B	Bits de seleção de porta de entrada
VCC	Alimentação (polaridade positiva). Ligado na porta VIN do NodeMCU
GND	GND. Ligado na porta GND do NodeMCU
VEE	Alimentação (polaridade negativa). Ligado no GND do NodeMCU
Enable	Indicador de ativação do multiplexador. Ativa quando estiver com sinal LOW (0)

Resumidamente, o CD74HC4052 funciona com dois canais de saída (X e Y) que possuem quatro portas cada um (X0 a X3 e Y0 a Y3). O que fazemos é conectar os sensores nessas portas e usar os bits A e B para decidir qual delas estará ativa no momento da leitura. As saídas X e Y são conectadas nas portas analógicas do microcontrolador para enviar o sinal selecionado. Como o NodeMCU só tem uma porta analógica, só podemos usar uma das saídas do multiplexador. Como utilizaremos apenas dois sensores, não teremos problemas. Caso você precise de mais do que quatro portas, pode usar o CD74HC4051, por exemplo, que possui oito entradas que saem todas em um único canal.

Os bits de seleção funcionam de forma bem simples:

Entradas de controle			Portas ativadas na saída
Enable	Bit de seleção
	B	A
LOW	LOW	LOW	Y0	X0
LOW	LOW	HIGH	Y1	X1
LOW	HIGH	LOW	Y2	X2
LOW	HIGH	HIGH	Y3	X3
HIGH	—	—	Nenhuma

Como você pode ver, basta enviar combinações de pares de bits 1 e 0 (HIGH e LOW) para as portas A e B do multiplexador e você poderá escolher qual das entradas utilizará para a leitura no NodeMCU.

O circuito

As conexões dos dois sensores com o multiplexador e deste com o NodeMCU é feita da seguinte forma:

Vou dividir o detalhamento do diagrama em duas partes, para facilitar o entendimento, ok? Lembrando que as cores utilizadas no esquema não são obrigatoriamente as mesmas que você deve utilizar, servindo apenas como ilustração. Atente apenas para as cores preto e vermelho para as polaridades negativa e positiva, respectivamente. Esse é um padrão que ajuda muito a leitura de diagramas eletrônicos, portanto tente mantê-lo.

Conexão dos sensores ao multiplexador

Sensor LDR

Você vai achar na internet diversas ligações diferentes para este sensor. Qualquer uma delas serve aqui, mas eu costumo ligá-lo como está apresentado acima. Uma de suas pernas é conectada diretamente no positivo (fio vermelho) e a outra passa pelo resistor de 10KΩ. No mesmo lado em que está a conexão do LDR com o resistor, conecte um jumper até a porta X3 do 74HC4052 (fio verde). A outra extremidade do resistor vai para o GND (negativo, fio preto).

Em uma situação comum, sem uso do multiplexador, o jumper verde iria para a porta A0 do NodeMCU, ok?

Sensor de som KY-038

Este sensor é bem simples de ligar. Ele possui uma os pinos VCC, GND A0 e D0. Sem entrar em maiores detalhes sobre o funcionamento deste componente, pois isto já foi mostrado aqui na MakerHero em outras publicações, vamos utilizar a porta A0. Para conectá-lo ao circuito, plugue o jumper na porta X2 do multiplexador e, como já foi dito, os cabos preto e vermelho seguindo o padrão negativo/positivo, respectivamente.

Com os dois sensores conectados e utilizando duas das quatro portas do canal X do 74HC4052, estamos prontos para ver como ligá-lo ao NodeMCU e obter os dados captados.

Conexão do multiplexador ao NodeMCU

Esta conexão, apesar de aparentar ser complexa, é bem intuitiva e simples, se você conseguir isolar, em seu raciocínio, os diversos elementos do 74HC4052. Se você analisou bem o esquema e nas tabelas que coloquei acima na seção em que explico o funcionamento do multiplexador, percebeu que há dois canais de saída, o X e o Y, cada um contendo quatro portas de entrada analógica (X0 a X3 e Y0 a Y3). Em nosso exemplo, apenas o canal X será utilizado, portanto todas as portas referentes ao canal Y devem ser aterradas, o que nos leva à conectar cada uma delas ao GND do NodeMCU. Fazendo isso, anulamos todo o sinal que poderia passar por ali e “nos livramos” do canal que não será usado.

Os pinos Enable, VEE e GND também devem ser aterrados, pois é assim que cada um deles funciona, também de acordo com as tabelas que apresentei anteriormente. Veja:

• Enable: ativa o multiplexador quando sinal é LOW, portanto deve ser conectado ao GND;
• VEE: entrada do sinal de alimentação de polaridade negativa, isto é, GND;
• GND: bom, este é intuitivo, não é mesmo?

Com as orientações acima, podemos perceber todo o lado inferior do multiplexador sendo enviado para o GND. Perfeito, estamos chegando lá. Agora vamos para o outro lado.

Os pinos A e B controlam quais portas serão abertas e terão seus sinais enviados pelas saídas X e Y. Essa seleção é bem simples e foi demonstrada acima, mas, falando de como isso funciona na prática, basta que enviemos para as portas D1 e D2 do NodeMCU a combinação de bits correta para abrir a porta desejada. Por exemplo, para lermos os valores do sensor LDR (porta X3 do multiplexador), devemos enviar o sinal HIGH para D1 e D2 no NodeMCU. Desta forma, o sinal do sensor capturado nessa porta será direcionado para a saída do canal X, que por sua vez será enviado para a porta A0 do microcontrolador, onde poderemos lê-lo. Da mesma forma, para obtermos o valor do sensor de som, basta que, antes de efetuarmos a leitura, enviemos a combinação de bits corretoa para as portas D1 e D2. Simples assim.

Vejamos o circuito finalizado.

O código-fonte

Agora vamos conhecer o código-fonte, escrito na IDE do Arduino, que faz tudo funcionar. Atente-se para os comentários, pois neles eu explico detalhadamente tudo que está sendo feito em cada etapa.

// Programa: Ampliando as portas analógicas do NodeMCU com multiplexador
// Autor : Leandro Chernicharo (p/ makerhero.com)

/*
 * Constante com o número de pinos (bits) do multiplexador
 * que serão utilizados para controlar a porta selecionada.
 * Caso você use um multiplexador diferente do que eu usei,
 * como o 74HC4051, por exemplo, que usa 3 bits para isso,
 * basta alterar aqui.
*/
#define NUM_PINOS_SELECAO_CANAL 2

/*
 * Pinos dos sensores analógicos. Os números representam as
 * portas dentro do multiplexador. Neste caso aqui, seria
 * o seguinte:
 *  SOM_PIN está na porta 2 de um dos canais (X2 ou Y2)
 *  LDR_PIN está na porta 3 de um dos canais (X3 ou Y3)
 * Estas constantes são utilizadas para controlar a abertura
 * correspondente antes da leitura dos dados do sensor.
 */
#define SOM_PIN 2
#define LDR_PIN 3

/*
 * Vetor com os pinos de seleção de canal no multiplexador.
 * Cada porta no vetor representa o pino ao qual está conectada:
 * D2 -> Pino A
 * D1 -> Pino B
 */
const int pinosSelecaoCanal[] = {D2, D1};

void setup() {
  Serial.begin(9600);
  initPinosSelecaoCanal();
}

void loop() {
  /*
   * Antes da leitura dos dados na porta analógica (A0) do
   * NodeMCU, é preciso definir qual porta do multiplexador
   * será lida. Assim, sempre chamamos a função correspondente
   * para realizar essa tarefa para nós.
   */
  ativarPortaAnalogica(SOM_PIN);
  int som = analogRead(A0);

  /*
   * Observe que a leitura é feita sempre na mesma porta
   * física do NodeMCU. O que vai mudar é a origem do sinal
   * a partir do multiplexador.
   */
  ativarPortaAnalogica(LDR_PIN);
  int luz = analogRead(A0);

  Serial.print("Som: ");
  Serial.print(som);
  Serial.print("\tLuz: ");
  Serial.println(luz);

  delay(5000);
}

/*
 * Esta função abre a porta do multiplexador que desejamos
 * utilizar a partir do número do pino passado para ela. É
 * por isso que definimos as constantes dessas portas no
 * início do programa.
 */
void ativarPortaAnalogica(int porta) {
  /*
   * De acordo com a tabela de portas do 74HC4052,
   * a porta 2 (som) é aberta com o pino A LOW e o pino
   * B HIGH. A porta 3 (luz) é aberta com os A e B HIGH.
   */
  if(porta == SOM_PIN) {
      digitalWrite(pinosSelecaoCanal[0], LOW);
      digitalWrite(pinosSelecaoCanal[1], HIGH);

  } else {
      digitalWrite(pinosSelecaoCanal[0], HIGH);
      digitalWrite(pinosSelecaoCanal[1], HIGH);
  }
}

/*
 * Esta função é muito importante. Ela coloca todas as portas
 * digitais do NodeMCU utilizadas para controlar os pinos
 * (A e B, neste caso) em modo de saída (OUTPUT). Dependendo
 * da porta que você escolher, seu comportamento padrão pode
 * ser o de entrada (INPUT), o que fará com que o programa não
 * funcione corretamente. Assim, para garantir o funcionamento
 * independente da porta, sempre chame esta função no setup.
 */
void initPinosSelecaoCanal() {
  for(int i = 0; i < NUM_PINOS_SELECAO_CANAL; i++) {
    pinMode(pinosSelecaoCanal[i], OUTPUT);
  }
}

Abaixo, você pode ver a saída no monitor serial. Para que haja variações significativas nos valores lidos, é preciso que você altere as condições ambiente. Eu, por exemplo, cobri os sensores, acendi a lanterna do telefone celular, bati palmas, etc. Use sua criatividade!

Conclusão

Neste artigo nós vimos como ampliar o número de portas analógicas do NodeMCU de maneira simples, barata e de fácil programação. Esta foi a abordagem que usei em alguns de meus projetos, sendo que em um deles eu utilizei seis sensores analógicos. Conforme já foi dito antes, você pode experimentar diferentes multiplexadores, analisando qual se adapta melhor a seu caso particular. O mais importante é você entender o funcionamento do mapeamento das portas analógicas para um canal de saída que vai ser passado para o microcontrolador. Com isso dominado, o resto é combinar bits para definir o caminho que você quer usar e então ser feliz. 🙂

Se você ficou com alguma dúvida, possui alguma sugestão ou crítica, por favor, deixe aí embaixo para mim. Se houver algum tema ligado à IoT que você gostaria de ver por aqui, será um prazer poder ajudar.

O código fonte deste projeto você encontra no meu Github e pode baixá-lo para uso e modificações.

Um abraço e até a próxima!