Arquivos Dicas - Blog Ryndack Componentes
Rua Jovelina Claudino Buhrer, 440 - São José dos Pinhais - PR (41) 3383-3034
Dicas

Para quem está acostumado a mexer com eletrônica, é muito comum usar motores DC em aplicações que exigem inverter seu sentido de rotação. Para isso, geralmente usamos módulos com ponte H como o módulo com o L298N. Entretanto, às vezes realizamos aplicações que não requerem muita sofisticação, e comprar esse tipo de módulo acaba sendo uma despesa indesejada. Dessa forma, nesse artigo vamos trazer um projeto de uma ponte H simples e de baixo custo, usando apenas alguns componentes baratos.

Como funcionam as pontes H

Antes de irmos para o nosso projeto de uma ponte H, precisamos entender o funcionamento desse tipo de dispositivo. Para explicar isso, podemos pensar na ponte como um conjunto de quatro chaves dispostas como na imagem abaixo.

Olhando para o esquema entendemos o seu nome “ponte H”, já que as chaves estão ligados formando um H mesmo. Com essa ligação acionamos as chaves sempre duas a duas, conseguindo assim inverter a polaridade da tensão, e da corrente na carga. Para ilustrar isso, pense que as chaves 1 e 4 estão fechadas. Então, a tensão de alimentação será encontrada na carga, além disso, a corrente elétrica pode fluir pelo caminho abaixo.

Ao fluir por esse caminho, a corrente passara pela carga indo da direita para a esquerda (sentido convencional). Entretanto se fecharmos as chaves 2 e 3 abrindo as chaves 1 e 4 abertas, na carga, a corrente passará a ter o sentido oposto como na imagem abaixo.



Assim, conseguimos controlar a direção da corrente elétrica na carga, apenas acionando as chaves duas a duas. Essa é a ideia por trás de uma ponte H.

Agora que sabemos como a ponte H funciona, podemos partir para a construção de uma. Para isso, no lugar das chaves, usaremos transistores, já que assim conseguimos fazer o controle de forma eletrônica, usando um Arduino.

Montando uma ponte H com transistores

Para montarmos a nossa ponte, usaremos 2 BC327 e 2 BC337, que estarão ligados nos lugares das chaves, usando resistores de 1k em suas bases para a polarização, como no esquemático abaixo.


Com os transistores ligados dessa forma já temos nossa ponte, entretanto, podemos fazer algumas melhorias, para que a nossa ponte possa de fato ser usada.

Melhorando nossa ponte H

A primeira melhoria que faremos é adicionar 4 diodos em paralelo com os transistores, e polarizados inversamente. Esses diodos, são chamados de diodos de roda livre, e eles são de grande importância para o funcionamento continuo da ponte. Eles atuam na proteção dos transistores contra tensões reversas, uma vez que as cargas que serão usadas nesse circuito são, na sua grande maioria, de natureza indutiva. No nosso caso, os diodos usados form o 1N4148, já que esses diodos apresentam um tempo de resposta pequeno, e a nossa ponte é pensada para pequenos motores.

Após essa etapa, conectamos as bases dos transistores 1 com o 2  e 3 com o 4. Essa conexão é feita com dois objetivos em mente. Em primeiro lugar buscamos evitar que os pares de transistores 1 e 2 ou 3 e 4 sejam ativados simultaneamente, já que isso seria um curto entre a fonte de tensão e o terra. O segundo objetivo é facilitar o controle, uma vez que nessa nova configuração só é necessário dois sinais lógicos, ao invés de 4, como era o caso. Assim, obtemos o resultado fica como na imagem abaixo.

É importante ressaltar que fazer essa conexão só é possível pois teremos transistores PNP com a base conectada à base de transistores NPN. Isso porque os transistores PNP conduzirão quando a tensão na base for menor que VDC-0,7V, enquanto os transistores NPN conduzirão com uma tensão de base de 0,7V. Dessa forma, ao aplicarmos uma tensão de 0V teremos o transistor PNP em condução e o NPN em bloqueio, enquanto teremos o contrário quando a tensão aplicada for igual a VDC.

Limitações da nossa ponte H

Afim de garantir o funcionamento dessa ponte H, precisamos levar em conta algumas limitações que ela possuí em seu funcionamento. A primeira diz respeito as correntes e tensão máximas, que são de 800mA e 45V respectivamente, uma vez que esses são os maiores valores suportados pelos transistores selecionados.
A segunda e mais problemática limitação diz respeito ao nível de tensão usado para o controle lógico. A tensão da entrada lógica deve ser 0V para o nível baixo e igual a tensão de alimentação da ponte para nível alto. Isso porque se a tensão na entrada lógica entre o intervalo de 0,7V até VDC-0,7V, teremos que os transistores NPN e PNP conduzirão ao mesmo tempo. Então, se quisermos controlar um motor com um Arduino por exemplo, será necessário usar uma fonte de alimentação e um motor de 5V.

Uma segunda topologia

Uma maneira de contornar isso é utilizar apenas transistores NPN, o que foi implementado por nós em uma segunda topologia, que esta representada abaixo.

Nessa nova topologia, contornamos o problema de tensão pois agora nenhum transistor precisa se encontrar em uma tensão próxima a VDC para se encontrar bloqueado. Com essa topologia, teremos como níveis lógicos 0V e qualquer valor maior que 0,7V como nível alto. Para o funcionamento, colocamos dois transistores a mais, que estão conectados às bases dos transistores da parte de cima da ponte. Esses transistores atuam como duas portas inversoras,que fazem com que os transistores da parte superior conduzam e bloqueiem em momentos diferentes dos transistores inferiores.

Entretanto, para essa montagem deve-se tomar alguns cuidados. O primeiro deles é a escolha dos resistores, que deve garantir que para a tensão selecionada o transistor, quando conduzindo, se encontre na região saturada. 

O segundo cuidado é que, diferente da montagem anterior, essa nova montagem não protege a ponte contra curtos caso as duas entradas se encontrem e nível alto, portando, essa combinação deve ser evitada.

Existem outras formas de construir pontes H com transistores, aqui apresentamos dois exemplos simples, que podem ser montados por menos de 5 reais, elas não são sofisticadas como as encontradas em módulos com circuitos integrados como o com o L298, mas já são o suficiente para usar pequenos motores. Você já conhecia essas pontes? Deixe no comentário. Lembrando sempre que todos esses componentes vocês podem encontrar no nosso site.

0

Será que um diodo LED (emissor de luz) pode ser usado como fotodetector (receptor de luz)? A resposta é sim, ele tem toda estrutura interna para transformar fótons em elétrons. Vamos primeiramente conhecer a estrutura interna de um LED, para depois ver como utilizá-lo como receptor. 


Basicamente um diodo LED é composto por uma junção PN e alguma dopagem, podendo ser Arseneto de Gálio ou Fosfato de Gálio (ou outras) responsável pela cor do mesmo. Ao ser percorrido por uma corrente elétrica estes materiais são excitados e então emitem radiação visível. A cor vai depender da sua composição químico-física. 

]

Fonte: https://www.meetoptics.com/academy/light-emitting-diodes

 

De acordo com a imagem acima, a emissão de luz visível ocorre no movimento dos elétrons entre a camada de condução e a de valência. É justamente este efeito, que executado do lado contrário, permite ao diodo LED ser um detector de luz.

 

Mas este efeito é prático e usual, seria possível usar um diodo LED comercialmente para detectar luz? A resposta é quase que certamente não, por alguns detalhes importantes:

  • O encapsulamento do LED (a cor) atrapalha na detecção de cores diferentes daquelas de que o mesmo é feito,
  • A própria química do LED, que define sua cor (em encapsulamentos transparentes) , atrapalha na detecção de comprimentos de onda diferentes.

 

Fora que o conjunto óptico (fisicamente) de um LED é diferente daquele de um fotodiodo, por exemplo. O fotodiodo é fisicamente feito para receber a maior quantidade de luz possível, enquanto o diodo LED é feito para emitir a maior quantidade de luz possível.

 

O experimento

 

Mesmo assim vamos experimentar a utilização de um diodo LED como fototransistor, com um circuito simples de se fazer em casa. Vamos precisar de dois diodos LED (podem ser iguais ou diferentes) e um transistor NPN. No meu caso utilizei um BC547 que tinha disponível, em encapsulamento TO-92.

Fonte: https://www.codrey.com/electronics/the-led-photodiode-trick/

 

A montagem em protoboard ficou conforme abaixo. Estou utilizando como fonte de alimentação os 5V da porta USB, através de uma pequena plaquinha que transforma de USB para pinos 2.54mm.



Fonte: o autor

 

O LED mais abaixo é o detector, enquanto o LED mais acima funciona como indicador de detecção. Percebi que o conjunto não é sensível o suficiente para detectar a lâmpada do meu escritório nem a luz do sol pela janela. O circuito precisou que eu aproximasse a lanterna do celular do LED detector, para poder acionar o LED indicador.

 

Veja o vídeo com o experimento completo: https://youtube.com/shorts/teDNgxlvpOs?feature=share

 

Conforme comentei acima, nem a luz do sol nem do teto do meu escritório foram capazes de acionar o diodo LED indicador. Isto poderia ser minimizado ou até mesmo resolvido utilizando-se um transistor Darlington. Este tipo de transistor apresenta um ganho de corrente bem maior que um transistor comum.

 

Para se ter uma ideia o ganho de corrente de um BC547 é entre 110 e 800 (de acordo com seu datasheet https://www.sparkfun.com/datasheets/Components/BC546.pdf ). Já de um transistor darlington como o  TIP120 pode passar de 2500 (datasheet: https://www.onsemi.com/pdf/datasheet/tip120-d.pdf ) .

 

Pra finalizar

 

Dependendo do projeto, especialmente projetos maker caseiros, utilizar um diodo LED como fotodetector pode ser uma ótima opção. Especialmente quando não se pode ou não se quer gastar muito adquirindo um componente tão específico como um fotodiodo ou fototransistor.

 

O par “LED + transistor darlington” pode vir a “salvar” um projeto com prazo apertado ou até mesmo como desafio para o próprio criador. Agora é sua vez, comente abaixo se alguma vez já usou um diodo LED como fotodetector?

 

0

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;
    }
   
  }
 
}
O vídeo abaixo exemplifica o código acima, aproveite:

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

0

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.

0