LOGO PROJETO BÁSICO

logo do canal do Youtube projeto básico.

https://www.youtube.com/c/projetobasicos

LM25

 Constantemente os meios que nos rodeiam estão sendo monitorados através de sensores, podem ser para tomar atitudes como em algumas automações ou somente para analisar os dados assim como estações metrológicas. Alguns sensores são bem caros, mas usaremos aqui um sensor de custo beneficio bem atrativo.

 O sensor de temperatura lm35 é utilizado em projetos de automação e robótica, sendo simples sua utilização e apresentando uma considerável precisão.

No vídeo abaixo temos um exemplo de utilização do lm35.

O lm35 é um sensor linear que sobe 1ª Celsius a cada 10 miliamperes, ou seja, se estiver circulando 200 miliamperes no lm35, a temperatura vai estar em 20ªC. 

  O código utilizado é pequeno como pode ser observado logo abaixo, o lm35 trabalha na porta analógica do Arduíno, não podendo ter um cabo muito comprido, pois o lm35 sofre com interferências do ambiente. 

int lm35;

float temperatura;

void setup() {

  

Serial.begin(9600);

Serial.println("www.rpsilva100.blogspot.com");

Serial.println("www.youtube.com/c/projetobasicos");

Serial.println("");

temperatura=0;

}

void loop() {

lm35=analogRead(A0);

temperatura=((lm35*0.0048)*100);

Serial.println(temperatura);

delay(1000);

}

Caso tenha alguma dúvida é só postar nos comentários.

Obrigado!

Projeto Básico

www.youtube.com/c/projetobasicos

IRRIGAÇÃO DE GOTEJAMENTO

    Para se obter plantas com qualidade se faz necessário ter um sistema de irrigação com qualidade, trouxemos em outros artigos a montagem de um equipamento de irrigação automatizado com Arduíno, neste post iremos falar sobre a aspersão com mangueira de gotejamento.

Algumas vantagens do gotejamento

    Economia de água esta é uma das melhores vantagens, pois a Irrigação é localizada e não se irriga áreas que não possuem plantas, a perda por deriva é praticamente nula já que a mangueira fica próxima ao solo.

    Economia de herbicida pelo mesmo motivo dá economia dá água, como as partes onde se encontram as ervas daninhas não serão irrigadas, elas terão um baixo desenvolvimento, facilitando seu controle com veneno ou carpa.

    Baixo investimento com motores ou solenoides, o sistema de gotejamento trabalha com  baixa pressão, não necessitando de motores grandes.

    O vídeo abaixo tem mais informações sobre a instalação de sensores para Irrigação nos diferentes tipos de solo.

 

  Mangueira espaguete de irrigação.

Conector para a mangueira de gotejamento.

    Caso queira mais informações sobre sistema de irrigação com Arduíno click neste link. Se surgirem dúvidas postem nos comentários.

    Obrigado.

MÓDULO RELÉ ARDUÍNO

  O Arduíno é uma das plataformas ideais para realização automações em casa (domótica), em hortas ou para uso em rebótica, sendo de fácil utilização pois na internet possui várias informações sobre o mesmo. A princípio o que torna uma dificuldade para a utilização de uma lampada direta nas portas do Arduíno é a baixa corrente e tensão que o Arduíno fornece, sendo facilmente corrigido com a utilização de um relé.

  O relé é um componente eletromecânico utilizado como uma espécie de driver de potencia, ele possui alimentação de 5 até 12 voltes e pode operar cargas de até 10 Amperes por 220 Voltes, o vídeo logo abaixo tem mais detalhes de como fazer a instalação de um relé no Arduíno.    

  O esquema do circuito eletrônico pode ser visualizado na figura abaixo, a alimentação pode ser de até 12 voltes, dependendo somente do relé utilizado, o diodo é de uso comum 1n4147 ou outro substituto, o transistor que irá funcionar como chave para acionar o relé é o bc548 (NPN) e por fim o resistor de corrente de base é de 1K.

  A montagem exige muito simples podendo ser montado facilmente, caso tenha alguma dúvida poste nos comentários.

Obrigado!  

IRRIGAÇÃO ARDUÍNO (ELETRÓLISE)

 Caso você não tenha acessado o material anterior, ele pode ser visualizado por este link.

 Dando sequência ao assunto sobre irrigação iremos falar sobre hidrólise, este fenômeno ocorre toda vez em que se alimenta o sensor quando ele está  em contato com o solo úmido, ocasionando em corrosão do mesmo. Uma forma para reduzir esta corrosão do sensor é liga-lo somente em horários pré definidos para a leitura de dados, usando para isso um relógio de tempo real (RTC), este componente funciona como o relógio do computador, mesmo que a alimentação do Arduíno seja desligada o horário permanece gravado. O Arduíno ira verificar se a hora atual é a mesma da programação, caso seja irá realizar a irrigação das plantas.

 Será necessário colocar um horário para ligar o sensor e um horário para desligar o sensor, caso a umidade esteja abaixo da necessária a válvula solenoide irá ser acionada e efetuará a irrigação, caso a umidade esteja acima, a válvula continuará desligada mesmo com o sensor ligado.    



Funcionamento



O Arduíno irá verificar a hora, caso seja a hora pré programada a porta 7 irá ser acionada, ligando o sensor.
 O sensor sendo ligado ele verificará se à umidade é maior que 700 através da porta analógica A0, caso seja o solenoide que está ligado ao pino 13 continuará desligado, no entanto se a umidade for menor que 700 o pino 13 irá acionar a solenoide e as plantas serão irrigadas.
 O vídeo abaixo tem mais informações sobre a montagem.

 Uma das formas de ligação do RTC é vista no desenho abaixo, o Arduíno utilizado tem duas portas especificas para os pinos SCL e SDA.

Fonte: http://blog.filipeflop.com/wp-content/uploads/2014/06/Circuito_DS1307_Serial_Monitor1-630x287.png

 Para se utilizar o RTC é necessário a utilização de uma biblioteca que pode ser baixada neste link.


 O código fonte está disponibilizado logo abaixo, recomendamos acompanhar à matéria anterior neste link.


#include <Wire.h>
#include "RTClib.h"
int umidade;
RTC_DS1307 rtc;

void setup () {
pinMode(13,OUTPUT);
pinMode(7,OUTPUT);

digitalWrite(13,LOW);// Desliga o solenóide
   digitalWrite(7,LOW); // Desliga o sensor

 
    Serial.begin(9600);
 
   #ifdef AVR
      Wire.begin();
      #else
      Wire1.begin();
      #endif

  rtc.begin();


  if (! rtc.isrunning()) {
     Serial.println("RTC is NOT running!");
     rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
 
   ///Serial.print("inicializaçao");
        }
  }

void loop () {

 umidade = analogRead(A0);
 
   DateTime now = rtc.now();
 
    Serial.print(now.hour()); // Mostra a hora
    Serial.print(":");        // mostra separação da hora
    Serial.println(now.minute(),DEC);//mostra os minutos
  //Serial.println(now.year(), DEC); // Mostra anos

 Serial.println(umidade); //Mostra o valor da umidade

    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////  
       
          //Verifica se está no horário do acionamento

if (( now.hour()==(23)and ( now.minute()==(28)))){


  Serial.println("Ligado");


    digitalWrite(7,HIGH); // Liga pino 7 para acionar o sensor

     if (umidade > 700){  //Se a umidade for maior que 700 desliga o solenoide
   
      digitalWrite(13,LOW);// Desliga o pino 13 do solenoide
   
      }

  else{
    digitalWrite(13,HIGH);  //Caso o valor esteja abaixo de 700 liga o pino 13 do solenoide
 
  }}

              //Desliga a acionamento na parte da manha

if (( now.hour()==(23)and ( now.minute()>=(29)))){

  Serial.println("Desligado");
    digitalWrite(7,LOW);  //Desliga o pino 7
    digitalWrite(13,LOW); //Desliga pino 13
 
}


   
   delay(1000);


   }

Abaixo podemos ver o esquema de ligação completo, a alimentação da válvula solenoide esta separada do Arduíno, nota, a foi utilizado uma bateria nesse esquema, mas a válvula pode funcionar na rede elétrica ( 127V) também.

Caso tenha dificuldades em fazer o modulo relé você pode encontrar mais informações nesse vídeo.

A figura abaixo mostra o esquema de ligação utilizando um módulo relé comercial encontrado a venda na internet, um detalhe ao utilizar estes tipos de módulos é a inversão nas linhas onde aciona o relé, onde for LOW deve se utilizar HIGH e vise versa.

    digitalWrite(13,HIGH);   Passa a ser digitalWrite(13,LOW);
    digitalWrite(13,LOW);    Passa a ser digitalWrite(13,HIGH);

Obrigado.

IRRIGAÇÃO SIMPLES ARDUÍNO

Ôhmimetro Arduíno com lm35

Coleta de dados de  NTC com ôhmimetro Arduíno e sensor de temperatura lm35

O presente protótipo tem a finalidade de obter dados de um NTC (Negative Temperature Coeficient), a partir da temperatura ambiente que tende ir aumentando em intervalos de 2 em 2 graus por intermédio de uma lâmpada incandescente controlada por um dimmer de chuveiro, podendo ouvir um sinal sonoro toda vez que o dado é coletado assim que a temperatura soma dois graus, o monitoramento da temperatura se deve ao sensor lm35, para o ôhmimetro um divisor de tensão com resistor e o NTC ao qual se quer averiguar a resistência.

Todos os dados coletados mais os cálculos foram processados pelo Arduíno Mega, sendo possível verificar os resultados via display de cristal liquido 16X2 e porta serial aparecendo na tela do notebook, a placa controladora foi acomodada dentro de uma caixa plástica de “luz”, com uma tampa cega devidamente perfurada para á fixação do display, as demais ligações ocorreram na proto-board, a caixa que continha o Arduíno foi fixada na proto-board com o auxilio de elásticos de amarrar dinheiro.

Cálculos

O ohmímetro consiste em um divisor de tensão, onde temos R1 ligado ao positivo (5 volts), estando em série com R2 que está ligado no GND, a tensão de saída (vs) é obtida na ligação entre os resistores R1 e R2.

No circuito apresentado deve-se substituir R1 pelo NTC ou resistor que se queira saber a resistência, o cálculo do divisor de tensão pode ser efetuado pela seguinte expressão:

Como se deseja saber o valor de R1, este deve ser isolado na formula.

Onde:

vs= valor lido na porta analógica

R1=?

R2= valor de resistor conhecido (ex 470Ω)

V= tensão total, no caso 5 volts

Como a porta analógica do  Arduíno lê valores de 0 á 1023 bits, e necessita-se valores de 0 á 5, se faz necessário uma regra de 3 para obter esse valor, onde:

5= Tensão máxima

1023= é o máximo de dados lidos pela porta analógica

vs= é o valor convertido para aplicar na formula do divisor de tensão.

Dessa forma temos que 5 é igual a 1023, e VS é igual á porta analógica

5-------1023

vs-----porta analógica

multiplicando cruzado temos a seguinte expressão:

 vídeo abaixo mostra o cálculo passo a passo.

O sensor de temperatura lm35 vem calibrado de fábrica para sua utilização, precisando apenas multiplicar  o valor lido pela porta analógica por 0.00488 e multiplicar por 100, para se ter o valor em graus Celsius.

temperatura = (valorLido * 0.00488*100);

Disposição dos sensores

Os sensores mantiveram contato direto com a lâmpada, sendo preso por um elástico de prender dinheiro, a utilização da lâmpada neste circuito é mais simples, uma vez que dispensa o isolamento dos sensores com esmalte, técnica usada quando se mergulha os sensores em líquidos quente, caso não se tenha o dimmer para controlar a lâmpada, á possibilidade de utilizar uma lâmpada de consumo 220V  em uma rede com 110V, o resultaria em um brilho e aquecimento menor.

Arduíno IDE

Todo o código do programa foi escrito no software do Arduíno IDE (Integrated Development Environment), que utiliza uma linguagem de programação C. A plataforma Arduíno permite a utilização de cálculos nas montagens de equipamentos, por ser dinâmico auxilia em algumas rotinas necessárias para corrigir erros de sensores, como no caso da variação do Lm35, que necessitou á soma de 200 dados do lm35 seguindo da divisão por 200, o que garante um valor estável.

Os dados foram visualizados via display LCD 16X2 e monitor serial, da própria interface IDE, os números separados por virgulas facilitam a exportação  para  planilhas eletrônicas.


O vídeo abaixo mostra o  funcionando.

Figura 1. Display com a temperatura real (38º), o valor da próxima leitura e abaixo o valor da resistência.

Fonte. Próprio autor.

Figura 2. Dados coletados no serial monitor da IDE.

Fonte. Próprio autor.

Figura 3. Lâmpada com sensores instalados, á direita Lm35, a esquerda NTC 50D-9.

Fonte. Próprio autor.

Gráfico 1. Curva gerada com dados obtidos pelo aparelho.

Fonte. Próprio autor.

Conclusão

O presente equipamento permitiu a coleta e visualização de dados obtidos dos sensores Lm35 e NTC, conflitando esses dados foi possível traçar um gráfico para analisar se o NTC possui resistência ôhmica. A eletrônica empregada no equipamento foi bem simples como visto no texto, exigindo um pouco mais de pesquisa e testes para o código empregado.

Deixem um comentário sobre o artigo, caso necessitem de alguma correção me avisem, obrigado!




Referencia

http://www.if.ufrgs.br/mpef/mef004/20061/Cesar/SENSORES-Termistor.html

http://www.marcelomaciel.com/2013/03/sensor-ntc-no-pic.html

http://mecatronizando.blogspot.com.br/2014/12/tutorial-como-fazer-um-ohmimetro-com.html

Anexo

Lista de materiais

01 Arduíno 

01 NTC 50D-9

01 Resistor 470Ω

01 Buzzer

01 Display de cristal liquido 16x2

01 Proto-board 

Fios para ligação

Garra de jácaré

Código

/*Referencia blog Mecatronizando Ideias

Programa Ohmimetro Basico com Arduino

Blog Mecatronizando Ideias

Qualquer copia do codigo deve ser feita com devida atribuicao de autoria do mesmo

05/12/2014*/

#include <LiquidCrystal.h>

float Vr;

int lm35 = 0;

int valorLido;

int temperaturamais2 = 0;

float temperatura = 0;

int tempz=0;

char pino_leitura = 1;                                   // Pino para a leitura dos valores da tensão Vx  \\ Pode ser suprimida essa linha sem problemas

float leitura = 0;                                         // Variavel para armazenar o valor lido pela entrada analógica (valor entre 0 e 1023)

float Vs = 0.0;                                          // Variavel para calcular o valor lido pela entrada analóica em volts (entre 0 e 5 volts)

float R = 0.0;                                           // Variavel para receber o valor do resistor de referencia a ser dado pelo usuario via serial monitor

float resultado = 0;                                   // Variavel para calcular o valor do resistor utilizando a formula (3) do embasamento teorico

int tem=0;

int i;

const int buzzer = 12; //Buzzer

LiquidCrystal lcd(8, 9, 5, 7, 3, 2); // Cria um objeto lcd e atribui os pinos

void setup() {

pinMode(buzzer,OUTPUT);

Serial.begin(9600);                                    // Configuraçao do serial monitor

lcd.begin(16, 2);

Serial.println("Temperatura,Resistencia");

pinMode(pino_leitura, INPUT);                          // Configuraçao do pino de leitura como entrada de dados \\ também pode ser suprimida essa linha

}

void loop() {

delay(1000);

while(i < 200){

valorLido = analogRead(lm35);

temperatura = (valorLido * 0.00488);

temperatura = (temperatura *100);

tem=tem+temperatura;

i++;

}

while(i >=200) {

tem=tem/200;

temperatura=tem;

i=0;

}

tempz=temperatura;

lcd.setCursor(0, 0);

lcd.print("Temper");

lcd.setCursor(7, 0);

lcd.print(tempz);

lcd.print ((char) 223);

lcd.setCursor(0,1);

lcd.print("Resist ");

lcd.setCursor(7,1);

lcd.print(Vr);

lcd.print ((char) 244);

float Vs;// 470 é o valor do resistor R1

Vs = (5.0*analogRead(A1))/1023.0;

Vr=(5*470/Vs);

Vr=(Vr-470);

if (temperatura >= temperaturamais2) {

lcd.setCursor(0, 0);

lcd.print("Temper");

temperaturamais2 = tempz + 2;

lcd.setCursor(12,0);

lcd.print(temperaturamais2);

//Ligando o buzzer com uma frequencia de 1500 hz.

tone(buzzer,1500);

delay(300);

//Desligando o buzzer.

noTone(buzzer);

float Vs;

Vs = (5.0*analogRead(A1))/1023.0;

Vr=(5*470/Vs);

Vr=(Vr-470);

Serial.print(tempz); // Imprime no serial monitor o resultado calculado

Serial.print(",");

Serial.println(Vr); // Imprime no serial monitor o resultado calculado

lcd.setCursor(0,1);

lcd.print("Resist ");

lcd.setCursor(7,1);

lcd.print(Vr);

lcd.print ((char) 244);

}

}