nesse post mostraremos como podermos energiza o Arduino ou outra placa a partir de painéis solares e também como utilizar uma bateria recarregável para manter nossos projetos funcionando mesmo a noite.
O circuito é bem simples, composto pelos seguintes componentes:
Painel solar;
Arduino;
Bateria recarregável e um conector para ela;
Diodo;
Capacitor de 100uF e 16V (não achei o capacitor de 10V do post original);
Fios;
Protoboard;
Microvoltímetro para testar o circuito.
Abaixo temos a imagem com todos os componentes que utilizaremos:
O primeiro passo é remover o plástico do painel solar e soldar fios e seus terminais positivo e negativo que estão na parte de trás dele:
Em seguida solde pinos do tipo macho na outra extremidade dos fios, para podermos utilizálos no protoboard mais facilmente:
Agora, corte os fios do adaptador da bateria removendo o soquete, pois uitlizaremos nesse circuito somente a parte que conecta à bateria. Solde nas extermidades do fios pinos macho, semelhante aos fios conectados ao painel solar:
Agora começaremos a montar o circuito na protoboard: monte o diodo e o capacitor na protoboard como mostrado na imagem abaixo:
Em seguida, coloque o Arduino na protoboard e ligue os pinos Vin na linha positiva (mais próxima da linha vermelha) do protoboard e o pino GND na linha negativa (mais próxima da linha azul):
Por fim, ligue a bateria recaregável no conector e coloque na protoboard, com o fio positivo (geralmente o vermelho) na linha positiva da protoboard e o fio negativo (geralmente o escuro) na linha negativa da protoboard.
Para completar e acionar o circuito, conecte o painel solar na protoboard, onde o fio escuro (ou o fio que etiver soldado no terminal negativo do painel) deve ser ligado à linha negativa da protoboard e o fio vermelho (ou o fio que estiver soldado ao terminal positivo) deve ser conectado ao terminal do diodo.
Veja a imagem abaixo para confirmar suas conexões do circuito:
Teremos nesse ponto o circuito funcionando. Você pode retirar o Arduino para gravar o programa de seu projeto nele e retorná-lo para a protoboard, utilizando a energia solar para alimentar seu projeto.
O primeiro ponto é motarmos os circuitos, tanto da leitura da umidade do solo como o circuito driver para acionar a bomba. Em seguida devemos fincar os pregos na terra onde está a nossa planta e fixar a mangueira na bomba e no vaso ou região de terra que iremos irrigar. No meu projeto eu deixei a bomba submersa na água para evitar usar mais manguiras, mas não há problemas em utilizar a bomba fora da água.
Realizada a montagem fisica do projeto passaremos para o código. O primeiro passo é declarar as seguintes constantes:
pino digital de acionamento da bomba de água;
pino analógico que fará a leitura da umidade do solo;
O tempo que a bomba ficará ligada quando acionada;
Nível mínimo de umidade do solo, onde a bomba será acionada caso o valor fique abaixo desse valor.
As duas primeiras constantes são bem fáceis de serem atribuídas valores. As duas últimas constates são mais difíceis de acharmos os valores, no meu caso identifiquei os valores experimentandos diversos valores.
O passo seguinte é configurarmos na função SETUP o pino digital como OUTPUT e deixá-lo como LOW para manter a bomba desligada. Também é interessante configurarmos a porta serial para realizarmos o debug do código.
Na função LOOP, devemos realizar a leitura do pino analógico e comparar com a constante de nível minímo de umidade. Caso o valor lido do sensor esteja abaixo da constante, devemos acionar a bomba alterando o pino digital para HIGH.
Em seguida devemos aguarda o tempo necessário para molhar as plantas e desligar a bomba, voltando o estado do pino digital para LOW.
Finalmente devemos aguardar algum tempo com a função delay para voltarmos a fazer uma nova medida da umidade do solo. Abaixo temos o código completo de exemplo:
Nesse ponto temos um projeto simples mas funcional para a irrigação de plantas em vaso ou de uma pequena área. Porém esse projeto ainda consume muita energia. Em posts futuros mostraremos como podemos reduzir o consumo de energia desse e de outros projetos que utilizam Arduino, e como podemos alimentá-lo com energia solar.
no post anterior mostramos como podemos realizar a leitura da humidade de solo para construírmos um projeto de automação de irrigação. Nesse post mostratemos como podemos controlar uma bomba de água para enviar água para as plantas quando o sensor acusar que o solo está seco.
Utilizaremos uma bomba de água anfibia, ou seja, uma bomba que pode ser utilizada tanto dentro como fora da água. Essa bomba, do modelo JT-180, possuí três fios, uma para o terra (preto), outro para o positivo (vermelho) e outro que permite a leitura da velocidade da bomba (branco).
Bomba utilizada no projeto
Nesse projeto utilizaremos somente os fios preto e vermelho e calibraremos o volume de água enviado pelo tempo que a bomba ficará acionada.
Como a bomba é um motor DC de 12V, podemos utilizar o circuito do post sobre motores DC. Faremos um novo código para controlar a bomba.
O primeiro passo no código é declarar qual pino do Arduino estará conectado no driver para controla a bomba.
Em seguida faça as seguintes configurações na função setup:
O pino que controlará o motor como OUTPUT com a função pinMode e deixe o pino no estado LOW com o uso da função digitalWrite
Na função setup, escreva o código para executar os seguintes passos:
Aguarde por algum tempo, como 5 segundos com a função delay
Acione a bomba, mudando o estado do pino de LOW para HIGH com a função digitalWrite, e aguarde por agum tempo, como 3 segundos novamente com a função delay
Desligue a bomba, mudado o estado do pino de HIGH para LOW com a função digitalWrite
Código para acionar a bomba
Nesse ponto estaremos ligando e desligando a bomba, mas ainda não direcione a água para as plantas, pois mandaremos muita água que inundará o vaso e oderá mata as plantas.
Porém, é interessante utilizar esse código para calibrar a quantidade de água que será necessária para molhar as plantas. A calibração será pela quantidade de tempo que a bomba ficará ligada.
No próximo post, mostraremos como juntar a leitura do sensor com o acionamento da bomba para concluírmos o noss projeto.
algum tempo atrás montei um projeto de irrigação a partir das instruções que li em um ótimo livre sobre a Intel Galileo. Como o projeto funcionou bem e alguns amigos pediram para publicá-lo, vou colocar as instruções e adaptações em alguns posts.
Nesse post mostrarei como podemos monta o sensor de humidade de solo com materiais simples: pregos, fios e resistores, além de como ler o valor do sensor.
Cada sensor de humidade é composto de dois pregos, um resistor e fios para as ligações. O principio é bem simples: a água conduz eletricidade, portanto quanto mais seca estiver a terra menos corrente circulará entre os pregos, logo teremos menos tensão no pino analógico.
Para montar o sensor utilize os fios para ligar um dos pregos no 5V da sua placa, no meu caso utilizei um Arduino Nano. O outro prego deve ser conectado em um pino analógico da sua placa e em um resistor. O resistor deve ser conectado ao terra da sua placa.
Abaixo temos o diagrama para um sensor, mas você pode ligar mais de um sensor na placa. O limite é a quantidade de pinos analógicos da sua placa.
Com a montagem completa, fixe os dois pregos na terra, com uma distância de aproximadamente 2 cm.
Passaremos agora para o código, que é bem simples:
Declare uma constante do tipo int, que armazenará qual pino analógico o sensor está ligado;
Inicie a porta Serial na função setup;
Na função loop: realize a leitura da porta analógica com a função analogRead e exiba o valor na porta Serial.
Código para leitura do sensor de humidade
Nesse ponto temos o sensor funcionando e o Arduino lendo o valor da humidade do solo. Nos próximos posts mostraremos como controlar uma bomba de água com o Arduino e ligada e desliga-la a partir do valor do sensor.
Nesse post mostraremos a placa WebMos D1, que é uma placa compatível com o padrão Arduino, mas possuí um chip ESP8266 no lugar do Atmel. A placa possuí uma pinagem semelhante à do Arduino Uno, porém apresenta apenas um pino analógico. Em contrapartida a D1 por utilizar o ESP8266 já possuí uma placa de Wifi, dispensando o uso de placa externas ou Shields.
Placa WebMos D1
Para utilizar essa placa no IDE do Arduino devemos antes instalar os arquivos da placa. O primeiro passo é configurarmos o IDE para que ele possa baixar esses arquivos. Para isso vá no menu File, submenu Preferences. Será aberta uma tela de configuração do IDE. No campo Additional Boards Manager URLs informe o endereço em que o IDE pode baixar os arquivos da D1: http://arduino.esp8266.com/stable/package_esp8266com_index.json. Em seguida clique em OK. Para finalizar feche todas as telas do IDE e abra-o novamente.
Configurando o IDE
Para instalar os arquivos da placa, vá no Tools, submenu Board e escolha o item Board Manager. Será aberta uma tela para instalação de arquivos de diversos modelos de placa compatíveis com Arduino. Role a lista até localizar o item esp8266 by ESP8266 Community, selecione esse item e clique no botão Install. Após instalar os arquivos da placa reinicie novamente o IDE.
Instalando os arquivos da placa
Com o IDE configurado, passaremos para o uso. Conecte a placa ao computador utilizando a porta USB e aguarde ele ser reconhecido. Em seguida vá no menu Tools, Board e selecione o item WebMos D1 R2 & mini.
Passaremos agora para o desenvolvimento de um código que utilize uma conexão Wifi, que é o grande diferencial dessa placa. O primeiro passo é incluirmos os arquivos que contém os objetos para controlarmos a D1, esses dois arquivos são ESP8266Wifi.h e ESP8266HTTPClient.h. Em seguida declare dois arrays do tipo char que armazenam o nome da rede Wifi e a senha de acesso à ela:
Adicionando os header
Em seguida crie uma função chamada setup_wifi com o código abaixo. Esse código exibe o nome da rede Wifi e solicita a conexão através do método begin do objeto Wifi. Em seguida é aguardado que a conexão seja estabelecida para em seguida imprimir o endereço IP que foi atribuído à placa, confirmando que a conexão está ok.
Função setup_wifi
Na função setup, configure a porta serial para a velocidade de 9600bps e chame a função setup_wifi:
Função Setup
Passaremos agora para a função loop, que fará uma requisição HTTP. Primeiro confirme que a conexão Wifi continue ative e caso contrário execute novamente a função wifi_setup.
Com a conexão ativa, crie um objeto do tipo HttpClient e configure o endereço da requisição através do método Begin desse objeto. Para executar a requisição e obter o código de retorno utilize o método GET.
Por fim o código verifica o resultado da requisição e escreve na porta serial o conteúdo da resposta da requisição. Caso a requisição tenha falhado o código exibe o erro.
Por fim chame a função end do objeto HttpClient para encerrar essa requisição e utilize a função delay para aguardar algum tempo, no exemplo utilizei 10 segundos.
Função Loop
Por fim compile o programa e transfira para a placa. Note que a compilação para essas placa leva mais tempo que para um Arduino Uno ou Nano. Após transferido o programa abra o monitor serial e verifique a execução do programa.
nesse post mostraremos como podemos utilizar um sensor de infravermelho para identificar objetos que estejam próximos ao sensor para tomar alguma ação. Podemos utilizar o sensor para disparar alarmes ou mesmo para acionar os braques de um veículo controlador por um Arduino, Raspberry PI ou outros microcontroladores/microprocessadores.
Esse sensor é bem simples de utilizar. Ele é composto de um pino alimentação, um pino que deve ser ligado ao terra e um pino digital. Assim que um objeto ou obstáculo esteja a uma distância inferior a distância estabelecida o pino digital é acionado. A distância miníma de acionamento é configurada através de um potêncimetro que está na placa.
Sensor de obstáculo por IR
Primeiro faremos as conexões entre o sensor e o Arduino:
conecte o pino VCC do sensor no pino +5V do Arduino;
conecte o pino GND do sensor em um pino GND do Arduino;
Conecte o pino OUT do sensor em um pino digital do Arduino.
No exemplo conectamos o sensor diretamente com o Arduino utilizando cabos macho-femea, mas também é possível colocar o sensor em uma protobard e conectá-lo ao Arduino com cabos do tipo macho-macho.
Motagem do circuito
Passaremos agora para o desenvolvimento do código: primeiro declare uma variável que indicará em qual pino digital o sensor está conectado.
Em seguida na função setup, inicie a porta serial para verificar o funcionamento do sensor e configure o pino para entrada (INPUT).
Por fim, na funçao loop faça a leitura do pino digital onde o sensor está conectado com a função digitalRead. No exemplo verificamos o valor do pino (HIG/LOW) para exibir uma mensagem na porta serial, mas você poderá dispara outras ações.
Nesse post mostraremos como colocar o Arduino na nossa rede local para acessar servidores nela ou mesmo na internet através do Shield Ethernet. Nesse exemplo acessaremos o Google solicitando sua página inicial.
Note que neste Shield temos também um conector para cartões micro SD, logo podemos utilizá-lo para armazenar ou ler dados desse tipo de cartão de memória.
Shield Ethernet
Para utilizarmos o Shield o primeiro passo é conectá-lo ao Arduino através dos seus pinos inferiores. Para isso encaixe o Shield em cima do Arduino com cuidado para não entortar nenhum pino do Shield.
Shield montado
O próximo passo é determinar um MAC Address, que é um identificador de placas de rede de computadores, e o endereço IP que o Shield terá na rede local. Você pode utilizar um MAC Address qualquer, desde que não esteja em uso por outro equipamento na mesma rede. Para verificar se o MAC Address escolhido não está em uso consulte a tabela de conexões ativas de seu roteador. O MAC Address deve possuir o formato de 6 blocos de números onde cada número é composto de 2 algarismos hexadeciamais. Um exemplo é: 00 AA BB CC DE 02.
Para testar o Shield com o MAC Address escolhido abra o arquivo de exemplo que acompanha o IDE do Arduino chamado DhcpAddressPrinter. Altere o MAC Address que está no início do código e execute o programa. Se tudo estiver correto será impresso o endereço IP que o roteador atribuiu para a placa:
Declaração dos objetosRecuperando IP da placa
Agora passaremos para o código que fará a requisição e mostrará o resultado. Primeiro inclua os arquivos SPI.h e Ethernet.h ao código através da função #include. Em seguida declare o MAC Address e o endereço IP que serão utilizados.
O MAC Address é representado por um array de bytes e o endereço IP é representado por um objeto do tipo IPAddress. Os parâmetros de construção do objeto IPAddress são os octetos do endereço IP separados por virgula.
Declaração dos objetos
Para realizarmos a conexão utilizaremos o objeto EthernetClient. Declare esse objeto no código e também um array de bytes que deverá conter o endereço IP do servidor para o qual faremos a requisição, no nosso caso o Google. Para obter esse endereço abra uma janela do prompt do Windows ou um Terminal Linux e execute o comando ping <endereço>. O Esse comando retornará o endereço IP do servidor.
Declaração dos objetos de conexão
Agora passaremos para o desenvolvimento da função setup. O primeiro passo é configurarmos o Shield através do objeto EthernetClient e a porta serial com o uso do objeto Serial.
Após essas configurações podemos realizar a conexão com o servidor através do método connect do objeto EthernetClient. Esse método recebe o array de bytes com o endereço IP do servidor e a porta que utilizaremos para conectar ao servidor. Com a conexão ativa podemos enviar o corpo da nossa requisição, nesse caso montamos uma requisição HTTP do tipo GET que retorna a página inicial do Google.
Função Setup
Na função loop faremos a leitura da resposta. Utilizamos o método available para verificar se há conteúdo para ser lido e o método read para ler esse conteúdo, semelhante ao objeto que controla a porta serial. Nessa função também verificamos se a conexão ainda está ativa e caso contrário congelamos o programa.
Função loop
Compile o programa e transfira para a placa para iniciar a execução. Abra o terminal serial e acompanhe a execução do programa e veja ocorrer tanto a requisição como a leitura ds resposta.
Nesse post demonstraremos o uso do sensor de chuva/gotajamento que também pode ser utilizado para detectar também o nível de água de um recipiente. Esse sensor é composto de três peças: a placa sensora, um cabo de ligação do tipo femea-femea e o conversor com saída analógica e outra digital.
Partes do sensor
A saída analógica emite sinais na mesma proporção em que a placa sensora é molhada. Já a saída digital é acionada quando uma quantidade de água determinada atinge o sensor. A quantidade de água que dispara a saída digital é ajustada no potenciômetro da placa conversora.
Primeiro vamos montar o circuito: conecte os cabos na placa sensora e em seguida no conversor. Na sequência podemos conectar a placa conversora na protoboard ou diretamente no Arduino com cabos jumper macho-femea, conforme a foto abaixo:
Sensor montado
Passaremos agora para o desenvolvimento do código. Primeiro declare as variáveis que indicarão em quais pinos da placa as saídas do sensor estão conectados. Em seguida inicie o pino digital como INPUT e configure a porta serial.
int digital = 8;
int analogico = A0;
void setup() {
pinMode(digital, INPUT);
Serial.begin(9600);
}
Passaremos agora para a função loop. Primeiro faremos a leitura do pino digital, verificando se o valor limite foi acionado, exibindo o resultado na porta serial. Em seguida faremos a leitura do pino analógico, que indicará o quanto molhado está o sensor.
O valor analógico será alterado tanto quando gotas de água atingem a placa como quando a placa sensora é coloca na parede de um recipiente e o nível de água desse recipiente é alterado. Por isso podemos utilizar esse sensor tanto para identificar chuva ou outros gotejamentos como para medir o nível de líquidos dentro de um recipiente.
Naturalmente em nossos projetos o valor de disparado de alguma ação deverá ser calibrado para identificar o valor ideal, tanto da saída digital como a analógica.
valor = analogRead(analogico);
Serial.println(valor);
delay(1000);
}
Com o circuito montado e o código desenvolvido podemos compilar e rodar o programa. Após a compilação e transferência do programa abra o monitor serial para verificar os estados dos pinos. Atinja a placa com algumas gotas de água e veja os valores alterarem, ou mexa no potenciômetro para ajustar o valor de disparo do pino digital.
nesse post demonstraremos como utilizar o módulo de joystick, que pode ser utilizado tanto para jogos como para controlar outros projetos como veículos, drones e braços de robôs. Esse módulo possui cinco pinos seguindo a seguinte distribuição:
Gnd: que deve ser ligado ao terra da placa;
+5V: que deve ser ligado ao 5V da placa;
VRx: pino onde faremos a leitura do valor do eixo X;
VRy: pino onde faremos a leitura do valor do eixo Y;
SW: pino onde faremos a leitura do estado do botão (pressionado ou não).
O funcionamento desse módulo é bem simples, pois ele é composto de dois potenciômetros, um para cada eixo do joystick e um botão. Portanto ao movimentarmos o joystick em alguma direção movemos os potenciômetros. Portanto a leitura desses potenciômetros deve ser realizada pelos pinos analógicos do Arduino ou outra placa que esteja utilizando.
Devido a simplicidade do módulo faremos nesse post um projeto um pouco mais elaborado: O joystick controlará dois servos, um para o eixo X e outro para o eixo Y e o botão acionará dois leds, um no circuito e outro na placa.
O primeiro passo é montarmos o circuito. Conecte cabos do tipo macho-femea no joystick e em seguida conecte os pinos Gnd e 5V do módulo nas linhas da protoboard. O próximo passo é conectar os cabos dos pinos VRx e VRy aos pinos A0 e A1 do Arduino (ou os pinos equivalentes da sua placa). Em seguida conecte o cabo do pino SW na protoboard.
Agora passaremos para a montagem dos servos: Conecte os cabos de Vcc dos servos na mesma linha de furos da protoboard onde você conectou o pino 5V do joystick. Conexão semelhante deve ser feita com os cabos Gnd dos servos na linha de furos onde foi conectado o pino Gnd do joystick. Finalize essa etapa conectando os cabos de sinais dos servos nos pinos 9 e 10 do Arduino (ou outros pinos que tenham suporte a PWM).
Para finalizar o circuito, conecte o terminal negativo de um led ao cabo que está ligado ao pino SW do módulo e em seguida um resistor ao led e a linha do proboard que possui as conexões de 5V. Ligue finalmente um cabo do pino 5V do Arduino a essa última linha e outro cabo do pino Gnd do Arduino na linha onde foram conectados os Gnds tanto do módulo como dos servos.
Diagrama de montagem do circuitoCircuito montado
Passaremos agora para o desenvolvimento do código. Primeiro declare o uso da biblioteca Servo e em seguida as variáveis para indicar os pinos de leitura do módulo de joystick, escrita dos valores para os servos e escrita do led embutido no Arduino (pino 13). Declare também uma variável que armazenará o valor do eixo X e dois objetos para do tipo Servo.
#include <Servo.h>
int joystickX = A0;
int joystickY = A1;
int botao = 7;
int led = 13;
int eixoX = 9;
int eixoY = 10;
int valorX;
Servo servoX;
Servo servoY;
Passaremos agora para a inicialização do projeto na função setup. Configure o pino do botão do joystick como INPUT e o pino do led da placa como OUTPUT. Em seguida utilize a função attach para indicar ao Arduino em quais pinos estão conectados os cabos de sinal dos servos. Finalize a função setup posicionando os servos em 90 graus e atribua esse valor na variável que armazena o valor do servo X.
void setup() {
pinMode(botao, INPUT);
pinMode(led, OUTPUT);
servoX.attach(eixoX);
servoY.attach(eixoY);
servoX.write(90);
servoY.write(90);
valorX = 90;
}
Passaremos agora para a função loop, que executará a lógica de controle do nosso projeto.
O primeiro trecho fará a leitura do botão e quando acionado ligará o led da placa. Devido a montagem do circuito a leitura está invertida, ou seja, quando o botão é acionado o estado do pino é LOW e quando o botão é solto ele volta para o estado HIGH. Por isso foi colocado o if para a inversão da lógica:
void loop() {
int valor = digitalRead(botao);
if (HIGH == valor)
digitalWrite(led, LOW);
else
digitalWrite(led, HIGH);
}
O próximo passo é o controle do eixo X. O servo desse eixo será movimentado somente quando o valor do joystick ultrapassar um determinado valor para evitar acionamentos indevidos, e continuará movimentando no sentido até que seja atingido o valor máximo ou que a alavanca do módulo volte para a posição inicial. Essa característica foi implementada com os dois conjunto de IFs. O primeiro verifica o valor do potenciômetro que controla o eixo e o segundo garante que o servo não movimentará mais do que o limite que desejamos:
valor = analogRead(joystickX);
if (800 < valor)
valorX += 1;
else if (200 > valor)
valorX -= 1;
if (valorX > 160)
valorX = 160;
else if (valorX < 10)
valorX = 10;
servoX.write(valorX);
Já para o eixo Y teremos outro comportamento: o servo movimentará proporcionalmente ao movimento da alavanca do joystick. Para realizar esse comportamento faremos a leitura do valor do eixo Y e em seguida utilizaremos a função map, que produz o efeito de uma “regra de 3” calculando o valor do grau do servo baseado no valor do eixo Y:
valor = analogRead(joystickY);
int valorY = map(valor, 0, 1023, 10, 160);
servoY.write(valorY);
Para finalizar o código vamos fazer o Arduino aguarda 50 microsegundos, abaixo temos o código completo da função loop:
nesse post demonstraremos como utilizamos sensor de ultrasom HC-SR04 para medir distâncias. Esse sensor calcula o tempo que as ondas de ultrasom que ele mesmo emite demoram para retornar. O retorno dessas ondas é chamado de eco. Como a velocidade da onda de ultrasom é conhecida, o sensor mutiplica o tempo que o eco levou para retornar por essa velocidade para calcular a distância.
O sensor deve ser alimentado com 5V, portanto podemos utilizar o pino de 5V do Arduino. A distância de operação do sensor vai de menos de um 1cm para aproximadamente 4 metros.
Iniciaremos montando o circuito. Primeiro ligue o pino Vcc do sensor no 5V do Arduino ou de outra placa que esteja utilizando. Em seguida conecte o pino Gnd ao terra da placa. Por fim conecte os pinos Echo e Trig a dois pinos digitais do Arduino. A imagem abaixo mostra o circuito montado:
Circuito com o sensro de ultrasom
O próximo passo é escrevermos o código. O primeiro passo é declararmos as variáveis que serão utilizadas no código: uma para o pino do Arduino onde conectamos o pino trig do sensor, outra para o pino da placa onde foi conectado o pino echo do sensor e outras três variáveis para a o tempo do eco, distância em cm e em polegadas:
int trigPin = 11;
int echoPin = 12;
long duration, cm, inches;
O próximo passo é configurarmos os pinos da placa como saída e a porta serial, onde escrevemos a distância medida pelo sensor:
O passo final é utilizarmos o sensor na função loop. O uso do sensor é bem simples: primeiro devemos mandar um pulso alto de 10 microsegundos no pino trig o sensor e em seguida esperar por outros 10 microsegundos. Após essa espera o sensor deve ter calculado a distância, que será medida no pino da placa que está conectada ao pino Echo do sensor. Obtenha esse valor com a função pulseIn.
O passo final é calcular a distância em cm ou polegadas. Para obter a distância em cm divida o valor obtido por 2 e depois por 29.1. Já para obter o valor em polegadas divida o valor original por 2 e depois por 74.
duration = pulseIn(echoPin, HIGH);
cm = (duration/2) / 29.1;
inches = (duration/2) / 74;
Após esse cálculo o valor poderá ser utilizado, no caso desse post apenas enviamos para a porta serial, mas você poderá utilizar esse valor para evitar batidas com outros objetos, acionar ou desligar algum dispositov ou tomar alguma outra decisão decisão.
