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

}

}

LDR

O componente LDR varia sua resistência de acordo com a luminosidade, para poder verificar essa alteração foi utilizado um LED de alto brilho e um resistor para limitar a corrente de energia que alimenta o LED, evitando danos ao mesmo.

Para evitar a interferência da iluminação ambiente foi necessário a confecção de um cone de papel, onde o LED estava em uma extremidade oposta ao LDR, o LED foi alimentado de 2 em 2 até o limite de 20 Volts, sendo coletada o valor da resistência do LDR com um multímetro na escala de ohmímetro.

Volts	Resistência em KΩ
2	30
4	11
6	6
8	4,4
10	3,6
12	3
14	2,7
16	2,4
18	2,2
20	2,1

Como se pode observar no gráfico, o LDR é um componente não linear, tendo uma curva mais acentuada entre 6 e 30 kΩ. Dessa forma dependendo do tipo de aplicação é mais aconselhável trabalhar com o LDR na faixa entre 2 e 4,4 KΩ. Esse esquema pode ser usado como fotoacoplador servindo de proteção ao Arduíno, as pontas do LDR devem ser ligadas as portas analógicas do Arduíno.

Arduino + Autocomplete

Quem já trabalhou com Delphi, possivelmente deve se lembrar do comando Ctrl + espaço, utilizado para listar os possíveis códigos da sequencia, o que acelerava o rendimento das escritas e diminuía os erros da digitação, uma vez que os comandos são em inglês. 

Para quem acha útil essa ferramenta, uma boa noticia! 

Foi desenvolvida uma nova versão modificada Open Source para a plataforma Arduíno, como vantagens temos o suporte autocomplete, erros de sintaxe em tempo real. Alguns relatam que a versão modificada da IDE vem com um novo editor mais robusto e poderoso (cheio de atalhos). 

É possível fazer o downloads pelo neste link com outras versões, ou pelos links abaixo.

Windows ZIP file for non admin install

Mac OS X for Java 6 (recommended)

Mac OS X for Java 7+ | Troubleshooting

Linux 32 bits

Assista o vídeo abaixo para maiores informações.

https://www.youtube.com/watch?v=jSRuVy_fcVM 

Obrigado! 

BIBLIOTECAS ARDUINO

   O Arduíno é uma ferramenta responsável pela criação de vários projetos que estimulam o desenvolvimento de tecnologias, algumas ligadas a automação residencial, outras em robóticas para enterimento e ainda para auxiliar pessoas com necessidades especiais, como o Tacit, para deficientes visuais. A grande variedade de sensores e atuadores é o que torna possível a realização de tantos projetos

     Existe sensores de utilização bem simples que utilizam pouco recurso físicos ou de memórias do Arduíno, para aqueles que exigem bastante recurso, foi desenvolvido bibliotecas que facilitam bastante, reduzindo até a quantidade de portas usadas pelo Arduíno. Neste link possui algumas bibliotecas, para usa-las, basta copiar a pasta da biblioteca escolhida e colar dentro da pasta libraries que fica junto do Arduíno.
   
    

Projeto Tacit : Dando Sonar aos cegos

   O uso do Arduíno vem crescendo em várias áreas, não se limitando na robótica ou domótica, seu uso também pode proporcionar conforto a deficientes, como os visuais. O projeto Tacit, trás uma inovação com o Arduíno, sensores ultrassônicos e servos é possível uma pessoa com visão reduzida caminhar sem colidir com obstáculos, como pode ser visto no vídeo abaixo. Com aproximadamente R$100,00 é possível construir um protótipo desses, os detalhes para montagem juntamente com o código fonte mais os gabaritos são encontrados neste link.