Componentes elétricos – Paraíso dos Bits

Usando o Arduino com painel solar

Olá todos,

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.

Esse post é uma tradução do projeto publicado no site Insuctable por p2man (thanks p2man).

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.

Diagrama do circuito

Abaixo temos a imagem com todos os componentes que utilizaremos:

Componentes utilizado

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:

Fios soldados no painel solar

Em seguida solde pinos do tipo macho na outra extremidade dos fios, para podermos utilizálos no protoboard mais facilmente:

Extermidade dos fios soldados ao pino macho

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:

Adaptador de bateria cortado

Agora começaremos a montar o circuito na protoboard: monte o diodo e o capacitor na protoboard como mostrado na imagem abaixo:

Início da montagem do circuito

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):

Colocando o Arduino na protoboard

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:

Circuito montado

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.

Até o próximo post!

Projeto de Irrigação – Parte 3 – Juntando as peças

Olá a todos,

em dois posts anteriores vimos como realizar a leitura da humidade do solo e como controlar uma bomba de água. Nesse post veremos como juntar esses códigos para realizar a leitura da humidade do solo e ligar a bomba para molhar nossas plantas, além dos pontos cruciais desse 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:

Código 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.

Um grande abraço e até o próximo post!

Projeto de irrigação – Parte 2 – Controlando as bombas de água

Olá a todos,

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).

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

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.

Obrigado a todos e até o próximo post!

Onde encontrar:

Projeto de irrigação – Parte 1 – Sensor de humidade do solo

Olá a todos,

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.

Diagrama do sensor de humidade

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.

Obrigado a todos e até o próximo post!

Onde encontrar:

Identificando obstáculos com Infravermelho

Olá a todos,

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.

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.

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.

Obrigado a todos e até o próximo post!

Onde encontrar:

Medindo distâncias com o sensor de ultrasom

Olá a todos,

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:

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:

void setup() {

Serial.begin(9600);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
}

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.

digitalWrite(trigPin, LOW);
delayMicroseconds(5);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);

duration = pulseIn(echoPin, HIGH);

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.

void loop() {

digitalWrite(trigPin, LOW);
delayMicroseconds(5);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);

duration = pulseIn(echoPin, HIGH);

cm = (duration/2) / 29.1;
inches = (duration/2) / 74;

Serial.print(inches);
Serial.println(” in “);
Serial.print(cm);
Serial.println(” cm “);

delay(250);
}

Onde encontrar:

Obrigado a todos e até o próximo post!

Controlando motores DC com o Arduino

Olá a todos,

nesse post aprenderemos como utilizar motores DC em nossos projeto com Arduino. Os motores DC são utilizamos em robôs ou brinquedos de radiocontrole para movimentá-los. Porém esses motores consomem mais potência do que os pinos de controle do Arduino podem fornecer e por esse motivo não podemos conectar os motores diretamente nos pinos digitais do Arduino.

Para contornar esse problema utilizamos drivers de potência que são circuitos que permitem que um sinal de baixa potência controle o fluxo de energia de uma fonte de alta potência. Podemos construir esse tipo de circuito com o uso de transistores, mas existem circuitos integrados (CIs) que já possuem esses circuitos montados.

No nosso circuito utilizaremos um CI chamado L239D que é um circuito driver de potencia chamado de ponte H. Esse tipo de circuito permite controlarmos um motor DC nos dois sentidos (horário e anti-horário). A velocidade do motor poderá ser controlada pelo uso da técnica de PWM onde a velocidade do motor será proporcional a largura do pulso.

O CI L239D possui dois circuitos ponte H que suportam até 36V e 1A, portanto é possível controlarmos dois motores DC com até essa potência com apenas um L239D. Os pinos do L239D devem ser contados como na figura abaixo:

O primeiro passo é conectarmos os terminais 4, 5, 12 e 13 do L293D no terra (GND) do Arduino e em seguida os terminais 1, 8, 9 e 16 também do L293D no pino 5V do Arduino. Agora conecte os terminais 2 e 7 do CI nos pinos do Arduino que controlarão o giro do motor (horário e anti-horário). Para finalizar conecte os pinos do motor nos terminais 3 e 6 do L293D.

Abaixo temos o esquema elétrico e o desenho elaborado no simulador:

Passaremos agora para o código que controlará o motor DC.

O primeiro passo é declarar as constantes que indicarão os pinos do Arduino que controlarão o motor. Na sequência configure esses pinos como saída, com a função pinMode utilizando a constante OUTPUT. Deixe o motor parado deixando os dois pinos em estado LOW. Encerre a inicialização do programa configurando a porta serial:

Passaremos para o desenvolvimento da função loop, que fará a leitura da porta serial e controlará a rotação do motor DC. O primeiro passo é verificar com o método available se há caracteres para serem lidos da porta serial. Caso não exista caracteres na porta serial o programa deve aguardar 300 milissegundos e encerrar essa execução da função loop com o comando return.

Existindo caracteres para serem lidos, deveremos utilizar o método read para obtê-los. Caso tenha sido enviado o caractere A, deixaremos um dos pinos em estado LOW, e no outro pino utilizaremos o PWM com valor 128 para o motor girar em um sentido. Quando for enviado o caractere L faremos ação contrária e o motor girará no outro sentido. Ao enviarmos o caractere de espaço em branco deixaremos os dois pinos com valor LOW para parar o motor.

Compile o código, transfira o programa e acesse o monitor serial. Envie um caractere A ou L para fazer o motor girar em um sentido. Envie o caractere espaço para fazer o motor parar. Se desejar altere o valor do PWM de 128 para outro valor para alterar a velocidade do motor.

Onde encontrar alguns dos componentes:

Obrigado pela atenção e até o próximo post!

Controlando servo motores com o Arduino

Olá a todos,

neste post aprenderemos utilizar servos motores em nossos projetos. Servos motores são dispositivos que permitem controlarmos com precisão a posição do seu eixo. A posição do eixo de um servo é controlada com o uso do PWM, onde a largura do pulso HIGH informa a posição do servo. Existem servos que permitem a rotação de 90°, 180°e até 360°de seu eixo. Servos são muito utilizados em robôs e brinquedos de radio controle, como carrinhos e drones.

Controlaremos a posição do servo enviando comandos pela porta serial, assim quando enviarmos o caractere A o servido deslocará o eixo um grau no sentido anti-horário e ao enviarmos o caractere S o servo deslocará o eixo um grau no sentido horário.

Ao contrário dos post apresentados até o momento não será necessário a montagem de um circuito na protoboard, pois o servo utilizado nesse exemplo possui um conector que se encaixa no cabo macho-macho. Simplesmente conecte o fio do terra do servo em um pino terra (GND) do Arduino, o fio do VCC do servo no pino 5V do Arduino e o fio que sobrará em um pino digital do Arduino que suporte o uso de PMW.

Abaixo temos o esquema elétrico e o desenho elaborado no simulador:

Diagrama da montagem do Servo no Arduino

Passaremos agora para o desenvolvimento do programa que controlará o servo. O primeiro passo é utilizarmos o comando #include para incluirmos a biblioteca Servo.h que possui o objeto e métodos para trabalharmos com servo motores. Essa biblioteca disponibiliza métodos mais simples para trabalhar com os servos, como o método write que recebe o grau que queremos o eixo do servo seja movido ao invés do comprimento do pulso.

Em seguida declare um objeto do tipo Servo para controlarmos o servo e uma variável do tipo inteiro para armazenar o ângulo que o eixo estará. Em seguida escreva na função setup a inicialização do objeto Servo com o método attach. Esse método recebe o pino que o servo está conectado. Os valores de comprimento mínimo e máximo do pulso devem ser obtidos na documentação do servo. Inicie também na função setup a porta serial.

Na função loop verifique se há caracteres para serem lidos na porta serial. Caso não exista caracteres para serem lidos o programa aguardará 300 milissegundos e terminará esse execução da função loop com o comando return.

Existindo caracteres na porta serial, estes deverão ser lidos. Quando o caractere enviado for A a variável com os graus da posição do eixo será incrementada em uma unidade e quando for enviado o caractere S essa variável será decrementada em uma unidade. Após o cálculo da nova posição ela será enviada e o eixo do servo será movimentado. Por fim a função aguarda 300 milissegundos para verificar novamente a porta serial.

Onde encontrar alguns dos componentes:

Obrigado pela atenção e até o próximo post!

Utilizando display de LCD com o Arduino

Olá a todos,

Até o momento utilizamos a porta serial do Arduino em conjunto com o monitor serial do IDE para recebermos mensagens dos nossos programas como a temperatura ou a intensidade de luz do ambiente. Nesse post aprenderemos como utilizar um display de cristal liquido para dispensar o uso do cabo USB e do computador.

Nesse exemplo utilizaremos um display LCD de 2 linhas e 16 posições por linhas, mas existem outros modelos disponíveis no mercado. Para esses outros modelos é importante você consultar o datasheet, que normalmente está disponível na internet, para verificar as conexões necessárias.

Para montarmos o circuito coloque o display na protoboard e também um potenciômetro. O potenciômetro será utilizado para controlarmos o brilho do LCD. Em seguida ligue o terminal da esquerda do potenciômetro no terra (GND) do Arduino e no terminal 1 do display (o terminal mais próximo da borda do LCD). Conecte também no terra os terminais 5 e 16 do LCD.

Agora conecte o pino de 5V do Arduino no terminal da direita do potenciômetro e também nos pinos 2, 11 e 15 do LCD. Conecte o terminal 3 do LCD no terminal central do potenciômetro.

O próximo passo é conectar o terminal 4 do LCD no pino 12 do Arduino e o terminal 6 do LCD no pino 11 do Arduino. Conecte também os terminais 11, 12, 13 e 14 do LCD nos pinos 5, 4, 3 e 2 do Arduino respectivamente. Revise todas as conexões utilizando a imagem e os diagramas do circuito que estão abaixo:

Abaixo temos o esquema elétrico e o desenho elaborado no simulador:

Passaremos agora para o desenvolvimento do programa que receberá textos pela porta serial e exibirá esses textos no LCD.

O primeiro passo é incluir no nosso programa o arquivo com as funcionalidades do LCD através do comando #include < LiquidCrystal.h >. Esse comando importa todas as funcionalidades existentes do arquivo informado para o nosso programa.

Importado o arquivo o próximo passo será a declaração de um objeto do tipo LiquidCrystal para operarmos o LCD e de uma variável inteira para controlar em qual linha do LCD escreveremos a mensagem. Note que no construtor do objeto do tipo LiquidCrystal devem ser informados os pinos do Arduino que estão conectados ao LCD.

O objeto do tipo LiquidCrystal possui métodos que facilitam o uso do LCD dispensando a necessidade de controlar diretamente os pinos do Arduino.

Em seguida escreva na função setup a configuração do LCD com uso do método begin. Nesse método devem ser informadas a quantidade de colunas e quantidade linhas do display. Escreva também na função setup a configuração da porta serial.

Passaremos para o desenvolvimento da função loop. O primeiro passo é verificarmos a quantidade de caracteres disponíveis na porta serial com o método available. Note que no programa foi limitada a quantidade de caracteres em 16 para evitar estouros na linha do LCD.

Em seguida declare uma variável do tipo String. Esse tipo de variável representa uma cadeia de caracteres, ou seja, um texto. O próximo passo é ler os caracteres disponíveis na porta serial com o método read e adicionarmos esses caracteres na variável String. Como o método read do objeto Serial lê apenas um caractere por vez colocamos esse trecho de código em uma laço do tipo FOR para lermos todos os caracteres.

Com o texto na memória do programa vamos primeiro escrever no LCD uma linha em branco para limpar a mensagem anterior para em seguida escrever a nossa mensagem. Ambas as instruções são executadas com o método print. Note que sempre na sequência da chamada do método print utilizamos o método setCursor para ajustarmos o cursos na posição no início da linha.

O método setCursor recebe dois parâmetros: o primeiro é o índice da coluna onde desejamos escrever o próximo caractere e o segundo parâmetro é o índice da linha do display onde o texto será escrito.

O último passo é alterarmos a variável que controla linha do display para na próxima execução da função loop o programa escrever na outra linha. Caso deseje limpar a próxima linha basta pressionar o botão Send do monitor serial para enviar um texto em branco.

Compile e transfira o programa para o Arduino. Após o programa iniciado acesse o monitor serial, digite algum texto e pressione o botão Send. O texto deverá aparecer no LCD, mas caso nada apareça mexa na haste do potenciômetro para alterar o brilho do texto.

Onde encontrar alguns dos componentes:

Obrigado pela atenção e até o próximo post!

Medindo a temperatura com o Arduino

Olá a todos,

nesse post veremos como podemos usar sensores de temperatura para medir a temperatura do ambiente ou do local ou objeto que o sensor esteja. Utilizaremos o sensor de temperatura LM35 que é um termistor, ou seja, um resistor que possuí resistência variável com a temperatura. Um ponto interessante desse componente é que a sua resistência varia de modo linear com a variação da temperatura em graus Celsius (°C).

Passaremos para a montagem do circuito: Coloque o LM35 na protoboard e em seguida conecte seu terminal da esquerda (deixe a parte plana para frente) ao pino 5V e o terminal da direita ao pino terra do Arduino. Para encerrar a montagem do circuito conecte o pino central do LM35 a um pino analógico.

Abaixo temos o esquema elétrico e o desenho elaborado no simulador:

Com o circuito montado desenvolveremos o programa. Primeiro precisamos declarar uma constante que indicará em qual pino analógico do Arduino o LM35 está conectado. Em seguida faremos a configuração da porta serial na função setup e utilizaremos a função analogReference para alterar o valor de referencia dos pinos analógicos de 5V para 1,1V. Essa alteração do valor de referência permite maior sensibilidade na porta analógica de modo que poderemos medir temperatura de 0°C à 110°C. Porém poderemos danificar o Arduino se tivemos níveis de tensão superiores a 1,1V em algum dos pinos analógicos quando utilizamos essa função.

O próximo passo é escrevermos a função loop para ler o valor do LM35 e escrever esse valor na portal serial. Primeiro faça a leitura da porta analógica onde está conectado o LM35. Esse valor deverá ser convertido para graus Celsius pela constante 0,1075268817204301. Em seguida envie o valor convertido pela porta serial com o método println e faça o Arduino aguardar 500 milisegundos com a função delay.

Compile o código e transfira o programa para o Arduino. Acesse o monitor serial e veja a temperatura ser enviada para o computador. Faça variar a temperatura do LM35, como colocando seus dedos nele, para ver a temperatura variar.

Onde encontrar alguns dos componentes:

Obrigado pela atenção e até o próximo post!