Você sabia que é possível ligar dois LEDs independentes em apenas um pino do Arduino? Hoje veremos como fazer isso e otimizar seus circuitos, especialmente quando estão faltando pinos em seus designs.

Em alguns projetos grandes podem ser necessárias técnicas para redução de pinos utilizados, visto que funções importantes ocupam a maioria das portas disponíveis. Algumas vezes podemos resolver isso utilizando microcontroladores maiores, como o Arduino Mega. Outras vezes estes custo se torna proibitivo e temos que “dar nosso jeito” de outra forma.

É aí que entram técnicas como a multiplexação e o charlieplexing, permitindo fazer “mais coisas” com menos portas do nosso Arduino. Porém algumas vezes nem é necessário colocar chips ou circuitos integrados a mais, se temos que ligar (por exemplo) apenas dois LEDs, existe uma forma fácil de resolver esta demanda.

O diagrama esquemático abaixo ilustra nossa solução, onde temos dois LEDs em série com o pino de controle no meio, entre eles. Colocando este pino em nível alto vai ligar o LED de baixo, já colocando-o em nível baixo vai ligar o LED de cima. 

Fonte: o autor

Mas e como desligar os dois LEDs? Para isso basta definir este pino digital como entrada, ele age como se tivesse “alta impedância”, não permitindo a circulação de nenhuma corrente. A explicação para o funcionamento deste circuito é a seguinte: colocando os dois LEDs em série, a tensão necessária para acioná-los é maior do que a tensão que a fonte pode oferecer, então eles não ligam.

Oferecendo-se uma tensão no pino entre eles faz com que um dos dois se energize, dependendo do nível lógico aplicado. No caso do circuito que montei eu utilizei 3,3V, insuficiente para os dois LEDs em série se energizarem.

Na prática este tipo de circuito funciona apenas com LEDs, visto que não é possível garantir um nível lógico consistente da forma que montamos o circuito, com dois LEDs em série. 

O circuito na prática

Montei o circuito em uma protoboard com dois LEDs verdes. Fiz um código para que a cada 500 milissegundos (0,5 segundos) um estado fosse atingido.

Fonte: o autor

Primeiro o LED “de cima”, acionado com nível lógico baixo; depois o LED “de baixo” acionado com nível lógico alto; finalmente nenhum dos dois LEDs, transformando o pino D1 em uma entrada digital.

Fonte: o autor

Primeiro o LED “de cima”, acionado com nível lógico baixo; depois o LED “de baixo” acionado com nível lógico alto; finalmente nenhum dos dois LEDs, transformando o pino D1 em uma entrada digital.

#define LED D1


long oldtime;
int counter= 1;


void setup() {
  // put your setup code here, to run once:
  pinMode(LED, OUTPUT);
 
}


void loop() {
  // put your main code here, to run repeatedly:
  if(millis() - oldtime > 500){
    oldtime= millis();


   
    if(counter == 1){
      pinMode(LED, OUTPUT);
      digitalWrite(LED, LOW);
      counter= counter + 1;
    }else if(counter == 2){
      digitalWrite(LED, HIGH);
      counter= counter + 1;
    }else{
      pinMode(LED, INPUT);
      counter= 1;
    }
   
  }
 
}

https://youtube.com/shorts/JIolENvljAY?feature=share

Aprenderemos como fazer a leitura analógica de um sensor de temperatura NTC utilizando uma entrada analógica do Arduino. O objetivo deste tutorial é ensinar como descobrir a temperatura em seu ambiente através de um sensor barato e fácil de usar, o NTC.

O termistor NTC é um sensor de temperatura cuja resistência varia conforme o aumento ou diminuição da temperatura, seguindo uma curva e equação conhecidas ( https://pt.wikipedia.org/wiki/Term%C3%ADstor ). NTC significa do Inglês “negative temperature coefficient” ou coeficiente negativo de temperatura. Quer dizer que quando a temperatura aumenta, a resistência dele diminui e vice-versa.

Uma curva característica de NTC é vista na imagem abaixo, para um termistor NTC de aproximadamente 10k Ohm. Sei que é deste valor pois no gráfico abaixo os 25ºC correspondem aproximadamente a 10k Ohm.

Fonte: https://www.researchgate.net/figure/A-typical-NTC-R-T-curve-10k-25C_fig1_310754304

Veja que a resistência cai quase que linearmente (mas não é linear) com o aumento da temperatura. Existe um valor que indica com que “velocidade” esta curva “cai” ou diminui, este valor se chama Beta e é específico para cada termistor. 

O cálculo da temperatura a partir desta resistência é feito utilizando-se uma equação chamada Steinhart-Hart (mais aqui https://www.northstarsensors.com/calculating-temperature-from-resistance ). Esta equação relaciona pontos de “ajuste de curva” com o logaritmo natural “ln” da resistência lida. Para nossa sorte existe um código para Arduino pronto para uso, basta inserirmos alguns valores do nosso sistema/setup.

Hardware necessário

Para experimentar com o termistor NTC, precisaremos de um Arduino qualquer (eu estou utilizando um RA4M1 da SeeedStudio) com entrada analógica, um resistor comum de 10k Ohm e um termistor NTC. Eu adquiri um termistor NTC em formato SMD 0805, modelo B57421V2103J62 com beta 4000 e resistência a 25ºC 10k Ohm.

O diagrama esquemático do teste é visto abaixo. Note que estou utilizando uma placa Arduino que eu mesmo fiz, mas você pode utilizar qualquer outra conectando inclusive no mesmo pino analógico A0.

Fonte: o autor

Fonte: o autor 

Fonte: o autor

As imagens acima trazem o meu Arduino com microcontrolador RA4M1, com destaque para o extremamente pequeno termistor NTC (próximo á inscrição “U3”) ao lado do “grandão” resistor de 10k Ohm.

O código para testes

Implementando as conexões mostradas acima nós podemos então começar a pensar em software para leitura analógica. O primeiro teste que quero fazer é se algum valor está sendo lido na entrada analógica A0, a fim de validar o hardware. Para isso desenvolvi um código inicial para verificar se existe sinal analógico (0-4095 em 12bit).

Se você estiver utilizando os Arduinos “comuns” (UNO, nano, Pro mini, Pro micro) a linha “analogReadResolution(12)” não vai funcionar, visto que a resolução da entrada analógica destes é apenas 10bit fixos. Isto nos traz valores inteiros da entrada analógica entre 0 e 1023 apenas.

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  analogReadResolution(12);
}


void loop() {
  // put your main code here, to run repeatedly:
  Serial.println(analogRead(A0));
  delay(1000);
}

Basicamente eu faço uma leitura analógica em A0 e jogo para o monitor serial do software do Arduino (Arduino IDE) a cada 1000 milissegundos (1 segundo). Podemos então observar (no meu caso) um valor entre 0 e 4095 variando ao se colocar por exemplo um dedo sobre o sensor.

O código completo

Agora já sabemos que o sensor funciona, pois no passo anterior vimos a variação de valores no monitor serial da IDE do Arduino. Vamos então para o código completo final deste artigo, onde obteremos a temperatura em graus Celsius a partir da leitura analógica do termistor.

Observe que temos um pouco mais de complexidade, cálculos com exponencial e logaritmo natural. Porém nada que o Arduino não dê conta de resolver ou calcular, bem tranquilamente.

// Conexão do termistor
const int pinTermistor = A0;
 
// Parâmetros do termistor
const double beta = 4000.0;
const double r0 = 10000.0;
const double t0 = 273.0 + 25.0;
const double rx = r0 * exp(-beta/t0);
 
// Parâmetros do circuito
const double vcc = 3.3;
const double R = 10000.0;
 
// Numero de amostras na leitura
const int nAmostras = 5;
 
// Iniciação
void setup() {
  Serial.begin(9600);
}
 
// Laço perpétuo
void loop() {
  // Le o sensor algumas vezes
  int soma = 0;
  for (int i = 0; i < nAmostras; i++) {
    soma += analogRead(pinTermistor);
    delay (100);
  }
 
  // Determina a resistência do termistor
  double v = (vcc*soma)/(nAmostras*1024.0);
  double rt = (vcc*R)/v - R;
 
  // Calcula a temperatura
  double t = beta / log(rt/rx);
  Serial.println(t-273.0);
 
  // Dá um tempo entre leituras
  delay (1000);
}

O código ainda faz cinco (50 amostras e calcula a média para ter um valor um pouco mais “limpo” de temperatura. Já dentro da impressão na porta serial (Serial.println(t-273.0)) fazemos uma subtração de 273 unidades para transformar de Kelvin para Celsius. Outra consideração importante é o valor de Vcc que você precisa entrar, coloque 5,00V no caso de usar um Arduino UNO, Nano, Pro mini ou Pro micro.

O resultado final é visto abaixo, em um print que tirei do meu monitor serial da IDE do Arduino. O valor de temperatura em graus Celsius é mostrado a cada um (1) segundo, com duas casas decimais. 

Fonte: o autor

Considerações

O formato do termistor NTC pouco importa (SMD, THT pequeno ou grande, etc), o que importa é conhecer sua resistência em 25ºC e seu valor Beta. Assim podemos aplicar exatamente o código presente neste artigo. 

A velocidade de leitura pode ser aumentada, coloquei 1 segundo apenas para ficar fácil de ver no monitor serial. Na prática a grandeza “temperatura” é bem lenta, não adianta muito colocar velocidades de leitura muito grandes.