Conhecimento

A automatização da aquisição de medidas é uma estratégia fundamental para a pesquisa e desenvolvimento ou para a análise de qualidade industrial, em especial quando as medidas a serem realizadas são repetitivas ou complexas. A programação das medições permitem a obtenção de resultados de forma rápida e eficiente, possibilitando a realização de medidas contínuas, de longa duração ou com diferentes condições, evitando, por vezes, erros decorrentes da ação humana. Com processos de medidas automatizados, é possível coletar dados consistentes e de fácil análise em tempo real. Pensando nisso, escrevemos esse artigo, no qual explicamos como implementar SCPI em  python para que dessa forma, você possa automatizar processos de aquisição de medidas. 

O protocolo SCPI

Antes de realizar a programação efetivamente, é importante conhecermos as ferramentas que usaremos, isto é, o protocolo SCPI (Standard commands for programable instruments). Esse protocolo, como o nome já diz, consiste em comandos de texto padronizados que permitem o controle de dispositivos como fontes, multímetros, osciloscópios, entre outros, usando um computador conectado à mesma rede. Nessa padronização, temos palavras chaves que definem o que será feito pelo instrumento. Essas palavras são organizadas de forma hierárquica, então, os comandos usados dever seguir sempre uma mesma estrutura.

Um exemplo de comando em SCPI seria “MEASure:VOLTage:DC? 10, 1E-3”. Aqui, temos o comando principal “MEASure”, que indica o tipo de comando que queremos executar, que nesse caso é realizar uma medida. Os comandos seguintes são para selecionar dentro das medidas possíveis qual sera realizada, que nesse caso é VOLTage:DC, ou seja, tensão em corrente continua. Em seguida temos um ponto de interrogação (?) que indica que a operação a ser realizada é uma consulta, e portando, o dispositivo enviar o resultado para o computador. Finalmente enviamos os parâmetros “10, 1E-3”, que pré configuram o multímetro para tensões no range de 10V com uma resolução de 1mV.

No comando acima temos parte da palavra em maiúsculo e parte em minúsculo, mas isso é apenas para indicar qual parte do comando é obrigatório para o DM858 compreender, sendo que o comando será entendido se for enviado na sua forma completa, ou omitindo a parte minúscula. Além disso, o protocolo SCPI não é case sensitive, isto é, ele não diferencia letras maiúsculas das minúsculas. Assim, esse mesmo comando pode ser escrito como “meas:volt:dc? 10, 1e-3” ou como “MEAS:VOLT:DC? 10, 1E-3” ou qualquer combinação de maiúsculas e minúsculas, que ele funcionará normalmente. O manual completo de comandos SCPI do DM858 pode ser encontrado aqui.

Configurações inicias

Agora que já estamos familiarizados com o SCPI, podemos fazer umas configurações iniciais para a programação. O que usaremos para a interface de comunicação sera o VISA (Virtual instrument software architecture), que de forma simplificada é um conjunto de ferramentas que facilita a comunicação entre o computador e o instrumento de medição. Ele fornece uma camada de abstração, permitindo que o software controle o instrumento sem precisar lidar diretamente com os detalhes da interface física. O interessante do VISA é que ele não depende do tipo de interface realizada, e portanto pode ser usado quando o instrumento esta ligado por meio de Ethernet, USB, RS232, etc.

Então, para conseguirmos usar o VISA, precisamos instalar a biblioteca pyvisa, que pode ser obtida com o comando “pip install pyvisa-py”. Caso você não possua o pip em sua máquina, você pode encontrar o manual de instalação clicando aqui. Outras bibliotecas que usamos são as bibliotecas matplotlib para a geração de gráficos, que você pode instalar usando “pip install matplotlib”. A biblioteca pandas, para gestão arquivos do tipo .CSV, também foi usada, e você pode obtê-la usando “pip install pandas”.

Com essas instalações feitas, precisamos ainda conectar o multímetro DM858 a rede ethernet, e encontrar o endereço VISA, do multímetro. Isso é simples, para isso, basta realizar a conexão do cabo ethernet na parte de trás do multímetro e no roteador, que a conexão está pronta. Agora, no multímetro, tocamos no “R”, em seguida abrimos o menu “Sistema”, e selecionamos a aba “Rede”, então encontraremos o endereço VISA do seu instrumento. Anotamos esse endereço pois usaremos ele mais adiante.

Programando

Finalmente vamos para o código usado no nosso projeto, que começa importando as bibliotecas que instalamos anteriormente, além da biblioteca “time”, que foi usada para realizar delays e gravar o tempo entre as medidas.

import pyvisa as visa
import pandas as pd
import matplotlib.pyplot as plt
import time

# Define quantidade de medidas e intervalo entre elas
num_medidas = 30
intervalo = 5
# Cria as listas para armazenar as medidas e o intervalo de tempo
momento = [ ]
temperatura = [ ]

Em seguida, definimos o número de medidas e o intervalo entre as medidas, iniciando as variáveis ”momento” e  “temperatura” logo após. Essas variáveis serão usadas para gravar o instante em que a medida foi realizada e a temperatura encontrada respectivamente.

O próximo passo foi criar uma instância para o gerenciamento da comunicação entre o instrumento e o computador, abrindo o “multímetro”, usando o método “open_resource(“Endereço visa”)”. Para este método que enviamos o endereço visa anotado anteriormente. Por fim configuramos a terminação da comunicação, tanto para leitura, quanto para a escrita.

# Configura a comunicacao com o multimetro
rm = visa.ResourceManager()
rm.list_resources()
multimetro = rm.open_resource("TCPIP::192.168.1.93::INSTR")
multimetro.read_termination = '\n'
multimetro.write_termination = '\n'

Na etapa seguinte, realizamos as medidas. Aqui configuramos a unidade de temperatura do multímetro para graus celsius e realizamos as medidas em um loop, que no nosso caso é repetido 20 vezes, com uma vez a cada 5 segundos. Essas quantidades podem ser ajustadas, alterando-se os valores das grandezas “num_medidas” e “intervalo”. Isso ficou como abaixo.

# Realiza as medidas
start_time = time.time()
multimetro.write("UNIT:TEMP C")
for i in range(num_medidas):
    momento.append(time.time() - start_time)
    temperatura.append(float(multimetro.query("MEAS:TEMP? TC, K")))
    time.sleep(intervalo)
rm.close()

Dentro do loop acima, adicionamos o instante e a leitura no final das listas “momento” e “temperatura”,  em seguida, adicionamos uma pausa, antes de realizar a próxima medida. Aqui é importante notar os métodos .write e .query que foram usados. Começando pelo comando .write, temos que ele envia um comando em SCPI para o multímetro, sendo que ele deve ser usado para enviar comandos de configuração. Enquanto isso, o método .query envia comandos e realiza a leitura da resposta do multímetro, por isso usamos ele para enviar o comando “MEAS:TEMP? TC, K”, que realiza a leitura de um termopar tipo k. 

Finalmente vamos para as saídas do nosso programa, que são um arquivo .CSV, resultado do pandas, e um gráfico, advindo da biblioteca matplotlib.

# Salva as medidas em um arquivo CSV
log = pd.DataFrame(data={"momento": momento, "temperatura": temperatura})
log.to_csv("leituras.csv", index=False, sep=",",decimal=",")

# Plota o grafico
fig, ax = plt.subplots(figsize=(10, 5))
ax.set_title("Temperatura x Tempo")
ax.set_xlabel("Tempo")
ax.set_ylabel("Temperatura")
ax.plot(momento, temperatura, color = "red", marker = "o", markerfacecolor = "white", markersize = 5)
ax.xaxis.set_major_locator(plt.MaxNLocator(nbins=7, prune='both'))
plt.tight_layout()
plt.show()

Testando

Agora que já fizemos a nossa programação, podemos ver o nosso código funcionando na prática. Para isso, fizemos uma montagem bastante simples, apenas para ilustrar o funcionamento do código. Essa montagem consiste apenas ao termopar preso junto a ponta de um ferro de solda com o auxilio de uma fita kapton, assim, conseguimos medir a temperatura desse equipamento. Usando essa montagem fizemos o gráfico abaixo.

Nesse gráfico, ligamos o ferro de solda ao mesmo tempo em que executamos o programa escrito. As marcações presentes neste gráfico são as medidas que realmente realizamos, isto é, os valores das variáveis momento, representados na horizontal, e temperatura, na vertical. O formato e a cor desses marcadores, além da cor da linha foram definidos na linha “ax.plot(momento, temperatura, color = “red”, marker = “o”, markerfacecolor = “white”, markersize = 5)”.  Os valores plotados nesse gráfico estão no arquivo .CSV gerados pela biblioteca “pandas”, assim você pode usa-lo em um outro software de sua preferencia. Para acessar o arquivo .CSV, precisamos tomar cuidado com os separadores de casas decimais e de células do arquivo.

Neste artigo discutimos um pouco sobre como usar o protocolo SCPI para controlar instrumentos de bancada, realizando uma pequena automação com o Python. Essa automação é simples, mas ela já serve para demonstrar um caminho para a automação de medidas mais sofisticadas.

Se você esta buscando instrumentos que podem ser usados para as suas medições, a Ryndack Componentes, distribuidora oficial da Rigol, conta com diversos equipamentos como multímetros, osciloscópios e fontes de alimentação.

Conhecimento

Se você gosta de mexer com eletrônica, você já deve ter tido a ideia de fazer uma placa de circuito impresso, afinal, ver as trilhas desenhadas em uma placa é algo fascinante. Além disso, uma placa de circuito impresso permite a construção de projetos compactos e duráveis, já que, a menos que exista problemas na corrosão, a chance de você ter mal contatos é bem menor que no caso dos jumpers de protoboards convencionais.

Pensando nisso, escrevemos este post, no qual ensinamos como você pode construir um placa de circuito impresso de forma bem manual, e econômica. Neste artigo usamos poucos matriais, sendo eles uma placa virgem, um cortador de placas, um perfurador de placas, uma caneta permanente e percloreto de ferro.

Esquemático e Layout

A primeira coisa que precisamos para nossa placa é do seu layout. O layout é uma prévia da placa, isto é, nele temos a posição dos componentes e das trilhas. Como o foco deste artigo é montar a placa, vamos apenas apresentar o layout e o esquemático usados, não nos atendo a criação destes. Começando pelo esquemático que usamos, ele está na imagem abaixo.

Você talvez reconheça esse projeto, já que ele é muito semelhante ao do nosso artigo no qual montamos um vai e vem de leds, mas caso não conheça, você pode acessa-lo aqui. Usamos este esquemático para montar o layout abaixo.

Com esse layout, podemos começar o processo de corrosão da placa.

Cortando a placa para a corrosão

Como já mencionado, para montarmos nossa placa precisamos de alguns itens. Você pode adquirir eles separadamente, mas se desejar, eles podem ser encontrados no kit disponível aqui.

Para corroer a nossa placa, começamos cortando ela, para isso, usamos o cortador presente no kit. Primeiro posicionamos a placa no meio da régua de alumínio, medindo o tamanho que a placa devera ter, no nosso caso a placa devera medir 52mm x 58mm. Em seguida, usamos o riscador para marcar bem, dos dois lados da placa, o lugar onde ela deverá ser cortada. A placa na verdade será quebrada, então os riscos devem ser bem feitos, sendo que o quanto mais profundo melhor.

Depois de riscar a placa, apoiando ela em uma superfície reta a quebramos, sendo que, caso necessário, as rebarbas podem ser removidas com uma lixa fina. Importante tomar sempre cuidado para não danificar a parte de cobre, já que, apesar de boa parte dele ser corroída, se alguma trilha estiver rompida o circuito não funcionara.

Furando a placa

Com a placa do tamanho certo, prosseguimos furando a placa. Para isto, imprimimos o layout em escala, em seguida, prendemos ele sobre a placa. Importante lembrar que o layout deve ser impresso de forma espelhada, já que as trilhas e os componentes estão em camadas diferentes. Além disso, neste projeto usamos uma placa de face simples, então o layout impresso deve ser fixado sobre a pate cobreada.Para fixarmos o layout usamos fita adesiva, sendo que o resultado ficou como abaixo.

Agora podemos começar a furar a placa com o perfurador. Nesta etapa precisamos tomar o cuidado de perfurar nas posições corretas dos footprints presentes no layout, isto é, furar os lugares corretos para que os componentes possam ser posicionados.

Desenhando a placa para a corrosão

A próxima etapa do nosso processo de corrosão de placa é desenhar as trilhas na placa. Esta etapa é a mais complicada, já que ela exige um pouco de destreza. O que temos que fazer aqui é cobrir as trilhas, para que elas não sejam corroídas com o restante do cobre.

Antes de desenhar as trilhas, começamos limpando bem o cobre, para garantir que o tinta se fixe ao cobre. Para essa limpeza usamos um papel toalha e álcool isopropílico, mas ela pode ser feita com palha de aço, ou outro produto de limpeza que não agrida o cobre.

A seguir, começamos a desenhar a placa. Aqui existem outros métodos, como o da transfusão térmica, mas nós vamos fazer o que provavelmente é o mais simples. O que faremos sera simplesmente desenhar as trilhas da placa com um marcador permanente. Aqui deve ser seguido o desenho espelhado da placa, do mesmo modo que foi feito durante a furação. Além disso, é bom deixar separado álcool isopropílico e um cotonete, para caso o desenho da trilha saia errado.

Aqui vale lembrar que todo o cobre exposto será corroído, assim, se o preenchimento da trilha não for bem feito, teremos que elas podem ser corroídas, rompendo a trilha. Da mesma forma, se duas trilhas se aproximarem de mais a ponto de se tocarem, após a corrosão elas estarão ligadas, por isso devemos cuidar para desenhar as trilhas da forma mais espaçada possível.

Preparo da solução e corrosão da placa.

Agora que já preparamos a placa, vamos par a corrosão dela. Durante esta etapa, temos algumas recomendações. Começando com o uso de luvas, já que o percloreto é uma substância corrosiva, que pode causar danos a pele. Por esse mesmo motivo, a corrosão deve ser feita em lugares arejados, evitando o uso de utensílios de metal, que podem ser corroídos. Além disso, tenha em mente que o percloreto de ferro é uma substância que pode causar manchas permanentes, então seu manuseio deve ser feito com cuidado. Dito isto, podemos começar a preparar a solução para a corrosão.

Para o preparo da solução, seguiremos as instruções do fabricante. No caso do kit que estamos usando, precisamos diluir o conteúdo da embalagem de percloreto (pó preto) em água. Assim, começamos separando 500ml de água em um pote de plastico ou vidro, e em seguida despejamos o conteúdo da embalagem, com cuidado para não derrubar, misturando com uma colher de madeira ou plástico. Feito isto, você vai notar que a solução de percloreto se aquece e sua cor ficará marrom. Quando tivermos o percloreto totalmente diluído, podemos mergulhar a placa para iniciar o processo de corrosão.

A corrosão em si é bem simples, basta mergulhar a placa e deixar o percloreto de ferro agir. Para acelerar o processo, podemos movimentar a placa de tempos em tempos, evitando esfregar a superfície cobreada. Além disso, se você quiser, você pode furar algum lugar que não passe nenhuma trilha e amarrar um fitilho, ou um pedaço de fio esmaltado para facilitar o manuseio. Em pouco tempo você vai notar o cobre sendo consumido, e quando só as trilhas estiverem na placa terminamos com a corrosão.

Limpeza e reparo

Com a corrosão da placa pronta, podemos transferir o percloreto para um pote ou garrafa com tampa, e guarda-lo em um lugar seguro, para posterior reutilização. Enquanto a placa precisa ser lavada. Aqui podemos usar água mesmo, mas é importante remover qualquer resto de percloreto de ferro que tenha ficado na placa. Se essa limpeza não for feita o cobre continuará sendo corroído, e como consequência podemos ter rompimento de trilhas. Após a lavagem, removemos a tinta do marcador permanente, esfregando um papel toalha com álcool isopropílico. Nesse momento podemos ver como as trilhas ficaram.

Com as trilhas expostas, podemos testar e corrigir problemas gerados na etapa de corrosão. Uma forma de testar as trilhas consiste em realizar testes de continuidade entre elas, assim, conseguimos não apenas verificar se uma trilha foi rompida, como também encontrar trilhas distintas que estejam se tocando.

Durante estes testes, é normal encontramos algumas trilhas defeituosas, mas isso não significa que o processo deu errado. No caso em que existem trilhas com defeitos, podemos conserta-las manualmente. Começando pelos trechos que não foram corroídos, podemos raspa-los usando o riscador de placas. Por outro lado, as trilhas que foram rompidas podem ser reparadas durante a soldagem dos componentes, apenas completando os pontos rompidos com estanho.

Finalizando

O ultimo passo é montar a placa, isto é, soldar os componentes nela. Aqui também aproveitamos para reparar as trilhas que estão rompidas. Além disso, indicamos o uso de um estanho e de uma ponta de ferro de solda finos, para garantir maior precisão na soldagem.

Nessa parte também precisamos tomar cuidado para não danificar as trilhas do circuito, em especial em torno da parte cobreada.

Com isso terminamos nossa placa de circuito impresso. O resultado ficou como no vídeo abaixo.

Esse post foi para ensinar um método bem simples de se fazer a corrosão de placas de circuito impresso. Ele usou poucos materiais, e foi um método bastante manual. Vale lembrar que o kit de fabricação caseira de placas pode ser encontrado no site da Ryndack Componentes, clicando aqui. Além disso, caso você tenha apenas se interessado pelo projeto executado, você pode compra-lo aqui.

Conhecimento

O que é um sensor indutivo?

Como funciona um sensor indutivo?

• O sensor indutivo utiliza um oscilador em conjunto com uma bobina localizada na extremidade do dispositivo para gerar um campo eletromagnético variável.
• Quando um material metálico entra nesse campo, ocorre uma dispersão na energia do campo, o que reduz a amplitude do sinal proveniente do oscilador.
• O circuito de disparo do sensor detecta essa redução no sinal e fornece uma tensão de saída (resposta lógica) quando o sinal atinge um nível muito baixo, indicando a presença do objeto metálico.

Características elétricas

Tensão de operação:

• DC (Corrente Contínua): Operam com tensões que variam de 5V a 30V.

Lógica de chaveamento:

• Normalmente Aberto (NA): O circuito permanece aberto (sem condução) até que um objeto metálico seja detectado.
• Normalmente Fechado (NF): O circuito permanece fechado (conduzindo) até que um objeto metálico seja detectado, interrompendo o circuito.

Configuração de saída:

• PNP: Quando o sensor detecta um objeto metálico, ele conecta a saída à tensão positiva.
• NPN: Quando o sensor detecta um objeto metálico, ele conecta a saída ao terra (GND).

Implementação do Sensor Indutivo na Categoria Trekking

Aspectos de funcionamento

• Tipo de Saída: NPN (normalmente aberto).
• Alcance de Detecção: 8 mm.
• Tensão de Operação: 5-36V DC.
• Corrente de Saída: Até 300 mA.
• Frequência de Chaveamento: 100 Hz.

Conexão do Sensor ao Circuito

O sensor LJ18A3-8-Z/CX possui três fios:

• Marrom (V+): Conecte à tensão positiva da fonte de alimentação (6-36V DC).
• Azul (GND): Conecte ao terra da fonte de alimentação.
• Preto (Saída): Conecte à entrada do microcontrolador ou ao circuito de controle.

Conexão com Arduino

• V+ (Marrom): Conecte ao pino 5V ou Vin do Arduino (dependendo da tensão de operação).
• GND (Azul): Conecte ao GND do Arduino.
• Saída (Preto): Conecte a um pino digital do Arduino (por exemplo, D2).

const int sensorPin = 2; // Pino onde o sensor está conectado

void setup() {
  pinMode(sensorPin, INPUT); // Configura o pino como entrada
  Serial.begin(9600); // Inicia a comunicação serial
}

void loop() {
  int sensorState = digitalRead(sensorPin); // Lê o estado do sensor
  if (sensorState == LOW) { // Se o sensor detectar um objeto metálico
    Serial.println("Objeto metálico detectado!");
    // Acione um mecanismo de resgate ou pare o robô
  } else {
    Serial.println("Nenhum objeto detectado.");
  }
  delay(100); // Pequeno atraso para evitar leituras repetidas
}

Conhecimento

Medir a intensidade de campo magnético de objetos pode ser um maneira bastante eficiente de extrair informações uteis dele. Afinal, avaliando o campo magnético podemos definir grandezas como posição, velocidade, correntes, entre outras. Por isso, saber como fazer isso é muito importante para quem gosta de eletrônica. Pensando nisso, trazemos este artigo apresentando para vocês o SS49E, um sensor baseado no efeito Hall, que é barato, mas extremamente versátil e capaz de realizar ótimas medidas de campo magnético.

Conhecendo o sensor de efeito Hall

Como já mencionado, esse sensor tem como base o efeito Hall, um fenômeno curioso do electromagnetismo. De maneira simplificada, esse fenômeno se trata do surgimento de uma tensão elétrica, quando uma corrente passa por uma região de campo magnético presente. A figura abaixo ilustra isso.

Nessa imagem, temos o campo magnético e a corrente elétrica passando por uma região com um campo magnético, e perpendicular a ambos temos a tensão Hall, representada por . É importante ressaltar que a tensão Hall sempre é perpendicular ao campo magnético e a corrente simultaneamente, isso é, ele é perpendicular ao plano que os contém.

Outra característica da tensão Hall é que ela é proporcional a densidade do fluxo magnético e a corrente elétrica. Então, se desejamos medir o campo magnético devemos manter a corrente constante e medir a tensão Hall gerada no material condutor.
Agora que já apresentamos um pouco sobre o efeito Hall, podemos ir para o seu uso na prática.

Montando o circuito

O SS49E, sensor usado nesse artigo possui aplicação bem simples, se tratando de um sensor com apenas três terminais, sendo dois deles usados para a alimentação e o terceiro para saída. Assim, montamos um pequeno circuito usando um Arduíno UNO. Além disso usamos alguns jumpers e o protoboard para a conexão, o esquema abaixo mostra como ele foi montado.

Nessa montagem, usamos os pinos de 5V e GND do Arduino para alimentar o sensor, ligando-os aos pinos 1 e 2 respectivamente. Já o terceiro pino do sensor foi ligado diretamente à entrada analógica A0 do Arduino. Aqui é importante usar uma entrada analógica, pois a saída do sensor varia continuamente de 0V à 5V, dependendo da intensidade do campo externo. A relação entre a tensão de saída e o campo magnético é explicado um pouco mais adiante.

Programando

Com o circuito montado, podemos escrever o código que será executado no Arduino. Como esse código serve apenas para ilustrar o uso do SS49E mantivemos ele simples. Com ele fazemos a leitura da entrada analógica, convertemos o valor lido a um valor de campo e finalmente exibimos os valores envolvidos no monitor serial. Esse código está abaixo, mas como todos os códigos de nossos projetos, você pode encontra-lo em nosso github.

// Pino do sensor como o A0
const int pinoSensor = A0;

// Valor recebido pelo conversor A/D
int Valor_medido = 0;
// Valor_medido convertido para tensao
float Tensao_lida = 0;
// Valor de campo calculado
float Campo_calculado = 0;

void setup() {
  //inicia comunicação serial
  Serial.begin(9600);
}

void loop() {
  // Leitura do valor de 0 a 1023 do conversor A/D:
  Valor_medido = analogRead(pinoSensor);

  // Conversão do valor lido para a tensao de saida do sensor:
  Tensao_lida = 5.0*Valor_medido/1023;

  // Calculo do valor de tensão do campo 
  Campo_calculado = (Tensao_lida-2.5)/0.019;

  // Envia os resultados para a porta serial:
  Serial.print("Valor Medido = ");
  Serial.print(Valor_medido);
  Serial.print("\t Tensão_sensor = ");
  Serial.print(Tensao_lida);
  Serial.print("V");
  Serial.print("\t Campo = ");
  Serial.print(Campo_calculado);
  Serial.print("mT");
  Serial.print("\n");
  delay(500);
}

Começamos o código definindo a entrada analógica como sendo a A0 e declarando as 3 variáveis principais. A primeira é a “Valor_medido”, onde armazenamos o valor lido pelo conversor analógico digital do Arduino. Nessa variável constará sempre um valor de 0 até 1023, uma vez que o conversor A/D do Arduino possui 10 bits.

A segunda variável é a “Tensao_medida”, onde convertemos o valor obtido pelo conversor A/D em um valor de tensão. Para isso, multiplicamos o valor medido pela tensão mais alta que pode ser lida pelo Arduino (5V) e dividimos pelo nível mais alto do conversor (1023), ou seja, fazemos.

(1)  

Finalmente, usamos a variável  “Campo_calculado” para armazenar o valor do campo magnético. Para isso, usamos os dados do datasheet do SS49E para determinar a equação da reta . Nele observa-se que a sensibilidade do sensor é de aproximadamente 1,9mV/Gs, que convertendo equivale a 0,019V/mT. Além disso, temos que para um campo de 0mT, a tensão sera de 2,5V, assim, montamos a equação:

O que o loop em execução faz então é realizar a leitura do conversor A/D, determinar a tensão do sensor, calcular o valor do campo e finalmente enviar todos os dados coletados para o monitor serial.

Testando o circuito

O vídeo abaixo mostra o circuito funcionando.
https://youtube.com/shorts/t-J75gkJPYY?feature=share

Nele vemos que na ausência de um campo magnético a leitura tida é de aproximadamente 2,5V. Sendo que esse valor aumenta quando aproximamos um dos pólos do ímã. Ao aproximar o outro polo,  a tensão de saída do sensor reduzirá, permitindo assim realizar a distinção entre o pólo norte e sul do ímã.

Outro ponto importante de notarmos é que os valores de leitura estão sempre entre -100mT a 100mT, ou de 0,86V a 4,21V. Isso acontece porque valores de campo maiores que estes saturam o sensor, não podendo ser lidos adequadamente. Além disso, você pode aumentar a precisão do sensor obtendo a sensibilidade experimentalmente, medindo a tensão de saída para diferentes campos conhecidos.

Lendo o sensor com o DM858

Finalmente, usamos o multímetro digital DM858 da Rigol para realizar essas medidas, já que esse multímetro consegue realizar a leitura de diversos tipos de sensores de maneira prática e rápida, apenas inserindo um conjunto de valores conhecidos.

Afim disso, mantemos a alimentação do sensor com o Arduino, e conectamos o GND e a saída ao pinos do multímetro, em seguida, na tela tocamos no ícone da função atual e selecionamos “sensor”, então vamos para a aba “measure” e selecionamos “customize sensor”. Após isso tocamos em “+” e inserimos os dados conhecidos. Aqui colocamos os pares “2,5V e 0mT” e “5V e 131,579mT”, que satisfazem a equação 2, apesar do segundo ponto não ser possível, já que o sensor se encontraria saturado. Por fim em “sensor unit” escolhemos “customize” e digitamos “mT” no campo ao lado.

Com o multímetro configurado, a tela encontrada sera como abaixo:

Após realizarmos algumas medidas com o multímetro, vemos que os valores se aproximam bastante dos medidos com o Arduino, o que nos leva a acreditar que o código que fizemos está funcionando adequadamente.

Aplicações do sensor Hall

Agora que sabemos que o sensor está funcionando, usamos ele para traçar o gráfico do campo magnético x distância. Para isso, deixamos o sensor parado, e com o auxílio de uma régua, aproximamos um imã à ele em passos de 1 centímetro, obtendo como resultado o gráfico abaixo.

Esse interessante gráfico mostra como o campo magnético decai a medida em que a distância aumenta, além disso, ele mostra que esse tipo de sensor pode ser usado para se medir pequenas distâncias, apesar da baixa linearidade. 

Outra aplicação na qual esse tipo de sensor é aplicada é na medição de velocidade angular em motores. Para isso, basta ter um pequeno imã no eixo do motor, que sempre que ele passa pelo sensor um pulso de tensão será emitido, assim, a velocidade pode ser obtida contando esses pulso.

Já conhecia o sensor SS49E? Conte para gente nos comentários o que você achou deste post. Lembrando que esse sensor e muitos outros você pode encontrar na Ryndack Componentes clicando aqui.

Conhecimento

Os LEDs são um dos componentes mais utilizados na eletrônica, estando presentes em quase todos os equipamentos eletrônicos que usamos no dia a dia. Por serem bonitos, baratos e de fácil uso, é difícil encontrar eletrônicos que não possuam pelo menos um LED em sua montagem. Porém, apesar de serem bastante versáteis, pouca gente sabe como eles funcionam. E é por isso que trazemos esse artigo, explicando detalhadamente o funcionamento dos LEDs.

O LED como um diodo

Antes de mais nada, é preciso entender que os LEDs são diodos emissores de luz, ou seja, seu funcionamento é o mesmo que um diodo comum. Tanto os LEDs quanto os diodos comuns são junções P-N, e podem conduzir ou bloquear a corrente elétrica, dependendo da sua polarização. 

Entretanto, existem algumas diferenças entre a operação dos LEDs e dos diodos comuns. Começando pela polarização inversa, quando ambos bloqueiam corrente. A tensão máxima que os LEDs suportam costuma ser muito baixa, não excedendo 5V, na maioria das vezes. Por outro lado, em diodos comuns é normal esse valor chegar ou até exceder 1000V. A outra diferença está na tensão necessária para condução, quando o diodo está diretamente polarizado. Em diodos comuns, essa tensão costuma girar em torno de 0,7V, entretanto para os LEDs, esse valor geralmente esta entre 2V a 3,5V, dependendo da cor.

Essas diferenças aparecem pois os diodos comuns foram construídos com propósitos diferentes. Já que enquanto os diodos foram feitos para explorar a capacidade de condução e bloqueio, nos LEDs a propriedade de interesse é a eletroluminescência. Apesar dessas diferenças, é importante entender que o led continua sendo um diodo, e por isso, discutiremos um pouco sobre os diodos a seguir.

Como os diodos são construídos

Para entender bem o diodo, é preciso entender sua construção. Eles são formados por um material semicondutor puro conhecido como intrínseco, que recebe impurezas selecionadas. Essas impurezas tem o propósito de garantir ao semicondutor as propriedades físicas desejadas. A essas impurezas chamamos de material dopante, e ao semicondutor após a dopagem de extrínseco. Os semicondutores extrínsecos podem ser de dois tipos:

O primeiro tipo é formado quando o material dopante possui um elétron a mais que o semicondutor na sua camada de valência, assim quando o dopante e o semicondutor são ligados, um elétron fica disponível como elétron livre, servindo como um portador de carga. Esse tipo de semicondutor extrínseco é chamado de tipo N. 
 
O segundo tipo é o P, e ele se forma quando o material dopante apresenta um elétron de valência a menos que o semicondutor intrínseco. Nessa situação, na ligação entre o dopante e o semicondutor falta um elétron, assim surge uma lacuna (ou buraco, do inglês hole) como portador de carga.

Um diodo é a junção de um semicondutor P com um semicondutor N, e ele é formado quando se deposita dopantes do tipo N sobre um semicondutor extrínseco do tipo P (ou vice e versa), o que gera uma região com dopagem N e uma região com dopagem P juntas em um mesmo cristal semicondutor. Abaixo temos uma representação de uma junção P-N, nela temos lacunas no semicondutor P e elétrons livres no semicondutor N.

Como funciona a junção P-N

Quando a junção P-N é formada, temos na região da junção o deslocamento de elétrons do lado N para o lado P. Esse deslocamento deixa as proximidades da junção no lado P com carga negativa. Após esse deslocamento de elétrons, lado N da junção fica com carga positiva, como mostra a figura abaixo.

Dessa forma,  na região próxima da junção surge um campo elétrico que aponta de N para P, que constitui uma barreira de potencial elétrico. Essa região recebe o nome de região de depleção, e é essa região responsável tanto pelo bloqueio na polarização inversa, quanto pela tensão de polarização direta.

Quando submetemos ao diodo a uma tensão elétrica temos duas situações:
A primeira é quando temos o polo positivo da fonte ligada a região N e o negativo a região P. Nesse caso temos um campo externo de mesma direção ao campo da região de depleção. Nessa configuração, os portadores de carga do semicondutor são atraídos em direção a fonte e, consequentemente, a região de depleção aumenta, não permitindo que a corrente da fonte flua. Nesse caso, dizemos que o diodo esta inversamente polarizado.

A outra situação é quando o polo negativo esta ligado ao semicondutor N e o positivo ao semicondutor P. Assim os campos externo e da região de depleção estão em sentidos opostos, e se o campo elétrico é o suficientemente grande, portadores de carga conseguem vencer a barreira de potencial da camada de depleção. Quando isso ocorre, elétrons e lacunas se recombinam, o que por sua vez libera espaço para que a corrente elétrica da fonte flua livremente.

Como os LEDs emitem luz

Enquanto o diodo está em condução, os elétrons e as lacunas estarão se recombinando, entretanto, para que isso ocorra é necessário que os elétrons saltem da camada de condução para a banda de valência. Para realizar este salto os elétrons precisam perder parte de sua energia. É nesse momento que um LED se diferencia de um diodo convencional. Em um diodo comum a energia é liberada para o cristalino do semicondutor, na forma de calor, ou seja, sem emitir radiação eletromagnética. Porém, em um LED essa energia é liberada na forma de um fóton que é radiado para o ambiente.

A cor da luz emitida pelo LED depende da distância energética entre as bandas de condução e valência do material, isto é, depende da energia perdida pelo elétron. Essa distância varia de acordo com o material ao qual o semicondutor é formado. Alguns exemplos de materiais usados na fabricação de LEDs são o arseneto de gálio, que produzem LEDs infravermelhos e fosfeto de gálio, para LEDs vermelhos, amarelos e verdes.

Tipos de Leds

Atualmente existem diversos tipos de LEDs como os SMD’s, amplamente utilizados em placas de circuito impresso devido ao seu tamanho compacto. Eles podem ser de diversas cores, sendo um modelo bastante comum os RGB endereçáveis, com eles é possível formar uma diversa gama de cores com facilidade e rapidez.

Outro LED comumente encontrado é o infravermelho, usado na maior parte de controles remotos, além de sensores reflexivos como o TCRT5000. Esses LEDs não emitem luz na faixa visível, mas sim na faixa infravermelha, sendo assim usado para a transmissão de sinais em curtas distâncias e de forma direcionada.

A Ryndack Componentes possui uma grande variedade de LEDs em seu catálogo. Por la você também consegue encontrar diversos outros itens para te ajudar em seus projetos. Tá afim de conhecer nossos produtos, então de uma olhadinha no nosso site.

Conhecimento

Conexão elétrica/diagrama esquemático

O código

O resultado

Resultados e discussões

Conhecimento

No artigo de hoje, usaremos um sensor de nível de luz LDR. LDR significa “light dependent resistor”, que é exatamente o que esse sensor faz. É um resistor cuja resistência (entre dois terminais) depende da quantidade de luz que ele recebe.

Segundo essa fonte, sua resistência aumenta com menos luz e diminui com mais luz. A resposta espectral na imagem abaixo mostra que ele é mais sensível à luz verde do que qualquer outra cor. Isso se deve à sua constituição, feita de CdS (Sulfeto de Cádmio).


LDRs são considerados dispositivos lentos, com respostas levando entre 2ms e 50ms. É muito
mais lento do que um fotodiodo ou fototransistor, por exemplo. É por isso que você o vê sendo
aplicado principalmente à detecção crepuscular em iluminação pública.
Você poderia, é claro, aplicá-lo para robótica caseira/hobby, como em construções com
Arduíno

O circuito para testes

Implementamos um circuito de teste simples, com o LDR em série com um resistor de 10k
Ohm. Ele é lido pelo Raspberry Pi Pico 2 por meio de uma entrada analógica, A0. Poderia ser
qualquer outra placa com uma entrada analógica, como o Arduino UNO, ESP32, STM32,
família PIC etc.
Ele é fornecido pelos 3,3 V do próprio Pi Pico 2, já que ele consome apenas alguns
miliamperes. Se você fosse usar um Arduino UNO, poderia fornecer ao sensor 5 V sem
problemas. Em sistemas de 3,3 V como o ESP32, é melhor usar 3,3 V.

Código para Arduíno

Como dito antes, a interface de um LDR com um microcontrolador é tão fácil quanto ler uma
entrada analógica. É basicamente o que eu faço no código abaixo, a cada 500 ms (meio
segundo) eu leio a entrada analógica com analogRead(A0).
Então eu imprimo a variável “ldrvalue” no console serial no software Arduino IDE.


Um recurso importante a ser lembrado sobre o Raspberry Pi Pico 2 é a capacidade de alterar a
resolução da entrada analógica. Esta é a razão pela qual eu uso analogReadResolution(12),
para definir a resolução para o máximo (12 bits).
Isso significa que podemos ler valores entre 0 e 3,3 V que serão convertidos em inteiros entre 0
e 4095, no monitor serial. Depois de copiar e colar o código acima no seu software Arduino
IDE, conecte seu microcontrolador ao computador via cabo USB.
Em seguida, clique no botão de upload e aguarde um pouco. Você pode então abrir o monitor
serial do IDE, indo em “Ferramentas > Monitor serial” ou Ctrl + Shift + M.

Testando o circuito

Ao abrir o monitor serial ele começará a receber valores, assim como na imagem abaixo.
Cobrindo a face do LDR ou oferecendo mais luz, você pode ver o valor inteiro mudando.


Fiz um vídeo completo sobre o circuito, o código e os testes.
Vídeo sobre o teste: https://www.youtube.com/watch?v=sWoHgWNHI4E

Considerações finais sobre o LDR

O LDR é um sensor super simples e muito útil, capaz de traduzir nível de luz em nível de
resistência elétrica. Apesar de ser “lento” para sistemas mais críticos, ele serve muito bem para
detecção crepuscular (dia/noite) e de nível de luz em aplicações simples.
É também um sensor barato e muito consolidado, fácil de interfacear e ler. O fato de sua
resposta espectral ser diferente para cada cor também o torna interessante, possibilitando uma
aplicação de detecção de cores bem simples.

Clique e confira em nosso site alguns dos sensores LDR disponíveis: https://www.ryndackcomponentes.com.br/catalogsearch/result/?q=ldr

Conhecimento

O que são resistores de Pull-Up e Pull-Down?

Na eletrônica, sempre queremos que os sinais digitais sejam bem definidos, os resistores de Pull-Up e Pull-Down são usados para garantir isso!

Por exemplo, ao ligar um botão em um microcontrolador da seguinte maneira:

Dessa forma, ao pressionar o botão, será enviado 5V ao microcontrolador, o que corresponde ao sinal lógico 1. Mas e quando o botão não está pressionado ou durante o pequeno período onde ele está sendo solto? Nesse caso, não há um sinal bem definido sendo enviado ao microcontrolador, fazendo com que ele possa oscilar entre 0V e 5V, ou entre 0 e 1.

Ou seja, Pull-Up e Pull-Down são técnicas usadas em circuitos eletrônicos para definir o estado padrão de um pino quando não há sinal ativo!

Qual a Diferença entre Pull-Up e Pull-Down?

• – Pull-Up: Imagine que você está “puxando” o pino para a posição mais alta. Isso significa que, na ausência de um sinal, o pino estará em um estado lógico alto (1), que pode ser 5V ou 3,3V, dependendo do circuito. Então, o Pull-Up é usado para garantir que o pino esteja no nível alto quando não está sendo ativamente dirigido por outro componente.

• – Pull-Down: Aqui, você está “puxando” o pino para a posição mais baixa. Assim, quando não há sinal ativo, o pino estará em um estado lógico baixo (0), que geralmente é 0V ou GND. O Pull-Down é utilizado para assegurar que o pino esteja no nível baixo quando não está sendo controlado por outro dispositivo.
• 
• Caminho da Corrente com o Botão Solto, Enviando GND ao Pino

Em resumo, o Pull-Up mantém o pino em um estado alto por padrão, enquanto o Pull-Down o mantém em um estado baixo por padrão.

Qual Devo Usar, Pull-Up ou Pull-Down?

A resposta depende de o que o seu circuito se propõe a fazer. Mas há algumas recomendações. Por exemplo, ao usar um botão conectado a um microcontrolador, faz sentido usar um resistor de Pull-Down, visto que quando o botão não estiver sendo pressionado, a leitura será 0, e quando for pressionado, irá para 1.

Já, por exemplo, se estiver utilizando o protocolo I2C em seu circuito, é necessário utilizar resistores de Pull-Up nos pinos de clock e data, visto que é um requisito do protocolo de comunicação.