Ter conhecimento sobre a constante evolução da tecnologia pode ser algo útil para a maioria das pessoas, porém ter domínio sobre estas tecnologias é de maior importância ainda. Pensando nisto que a Usinainfo procura sempre auxiliar seus clientes no desenvolvimento dos mais diversificados projetos e hoje vamos trabalhar com o Pluviômetro Arduino.
Pluviômetro Arduino Aplicado em Projeto na Agricultura
Um dos assuntos em alta no momento é a prevenção de acidentes, a procura por respostas para os problemas climáticos e a constante evolução do homem no ambiente ao qual está inserido, pensando nisto desenvolveram-se tecnologias capazes de auxiliar no controle climático e que juntas são chamadas de estações meteorológicas.
Além de proporcionar um controle sobre a quantidade de chuvas, a temperatura e a umidade do ar, a meteorologia utiliza-se de outras variáveis para poder determinar uma linha temporal de acontecimentos e planejamento de estratégias através dos conjuntos de dados que carregam consigo importantes informações.
Chuva
Em poucas palavras, a chuva é um fenômeno meteorológico resultante da precipitação de gotas de água das nuvens até a superfície da terra, sejam gotas líquidas ou sólidas desenvolvidas através da condensação do vapor de água junto às nuvens.
Por mais que seja comumente ignorada, o índice de chuva possui um grande impacto na cultura de um determinado local ou região, principalmente na agricultura, já que todas as plantas precisam de água para sobreviver, por isto que a utilização do Pluviômetro Arduino é tão importante para exercer este controle de nível da chuva.
O que é Pluviômetro?
O Pluviômetro é um instrumento utilizado para medir a quantidade de precipitação de chuva em um determinado local, ao qual estiver instalado, fornecendo em milímetros (mm) a quantia de chuva.
Os pluviômetros simples são baratos e podem ser instalados em diversos locais como jardins e plantações, tanto em ambientes urbanos como rurais, adequados para estações de observação, normalmente são desenvolvidos em acrílico ou outro material de maior dissipação de calor.
Pluviômetro Simples ou Pluviômetro Analógico
A dissipação de calor neste tipo de dispositivo é importante, pois evita a fácil evaporação do líquido, uma vez que não armazena os dados de maneira digital e precisa de observação humana, assim como precisa ser esvaziado a cada precipitação para ter um valor preciso a cada leitura.
Para garantir uma leitura mais precisa e para garantir melhor verificação através de microcontroladores, existem modelos de Pluviômetro Digital que registram dados continuamente através de básculas que possibilitam a contagem do número de vezes que a mesma se movimenta.
Pluviômetro Digital de Báscula
Dentre suas aplicações, o Pluviômetro Digital está normalmente associado a estações meteorológicas e junto de diversos outros equipamentos como anemômetros, barômetros, hidrômetros e termômetros conseguem fazer um excelente trabalho de controle e análise.
Pluviômetro como Funciona?
A unidade de medida utilizada para indicar a precipitação, ou seja, o processo no qual a água se aglutina no interior das nuvens e forma-se a chuva é denominada de pluviosidade e é o resultado da quantidade de chuva acumulado em determinado local dentro de um tempo determinado.
No sistema internacional de medidas, a unidade de medida representativa da pluviosidade é o milímetro (mm), desta maneira, uma pluviosidade de 1 milímetro capturado pelo Pluviômetro equivale a um volume de 1 litro de água da chuva por metro quadrado.
Volume de água por metro quadrado
Realizar a medições e estabelecer um controle dos índices hídricos de uma dada região pode proporcionar a estimativa do potencial de fertilidade da terra, por exemplo, auxiliando na escolha e no controle de locais ideais para plantações que necessitam de chuva para uma safra de qualidade.
Para medir a quantidade de chuva de um determinado local são utilizados instrumentos meteorológicos conhecidos como pluviômetros, instrumentos os quais já tivemos possibilidade de conhecer anteriormente e que variam seu funcionamento de acordo com cada modelo.
Volume de água por milímetro
Saber calcular o volume de chuva é um processo que envolve conceitos de geometria espacial e plana, uma vez que o volume de água em mm é calculado de acordo com o tamanho do recipiente de captação.
Em um local onde choveu 10mm, por exemplo, quer dizer que em uma área de 1m² choveu o equivalente a uma lâmina de água de 10mm de altura e para convertermos este valor em volume de metros cúbicos utilizamos a seguinte fórmula:
Calculo do Volume de água de 1mm em 1m²
Na resolução acima, podemos ver que o valor da altura da lâmina não é de 10, mas sim de 0,01, isto ocorre devido ao fato de que precisamos utilizar a mesma unidade de medida para o nosso cálculo e 10mm convertido em metros é igual a 0,01.
Ao final do cálculo conseguimos verificar que em 1m³, 10mm de chuva correspondem a um volume total de 10 litros, ou seja, se em um quadrado de 1×1 metro despejarmos 10 litros de água, poderemos medir a sua altura e chegarmos aos 10mm.
O pluviômetro analógico segue esta mesma lógica, só que com valores proporcionais, medindo a quantia de água em milímetros de acordo com a quantidade de água acumulada em seu interior.
Sistema de Medida do Pluviômetro Digital
No pluviômetro digital a teoria de cálculo de volume é a mesma, porém ao invés de armazenar todo o líquido em seu interior, o sensor capta o líquido necessário para o envio de pulsos e o despreza o mesmo à medida que não é mais necessário.
O segredo de funcionamento dos Pluviômetro Digitais está nos números de pulsos que os mesmos dão e o quanto representa em milímetros cada um destes pulsos. Para entendermos como funciona este sistema, será utilizado como base, o Pluviômetro Arduino Maker.
O primeiro passo necessário é conhecermos as unidades de medida necessária para o cálculo, como queremos saber a quantia de pulsos por milímetro, a altura da lâmina será de 1mm, enquanto que a área da base será calculada de acordo com as medidas do coletor:
Medidas do Coletor do Pluviômetro Arduino Maker
Tendo as medidas da base do coletor, calculamos a sua área e multiplicamos pela altura da lâmina, porém como já vimos anteriormente, para o cálculo dar certo, ambas as medidas devem ser expressas na mesma unidade, ou seja, ao invés de usarmos 1mm, utilizaremos 0,1cm.
Volume para 1mm do Pluviômetro Arduino Maker
Como cada unidade de centímetro cúbico corresponde a 1ml, para conseguimos a marca de 1mm em nosso Pluviômetro Digital Maker, é necessário que caia sobre sua superfície um total de 6ml.
Com o auxílio de um material de medição podemos realizar o teste de movimentações da báscula e através do mesmo observamos que ao aplicar 6ml de água a mesma movimenta-se por duas vezes, ou seja, cada movimento da mesma representa 0,5mm.
Pluviômetro Arduino Maker
O Pluviômetro Arduino Maker é um produto desenvolvido pela Usinainfo e tem como objetivo a redução dos custos de produção e comercialização, por isto possui um tamanho reduzido e um sistema simplificado de funcionamento.
Pluviômetro Arduino Maker
Um diferencial deste modelo é o seu sistema de verificação de dados, normalmente em equipamentos maiores, com espaço maior de deslocamento das básculas, cada movimento gera um pulso que soma o respectivo valor associado ao total coletado, aqui este sistema é um pouco diferente.
Como a maioria dos sensores de chuva digital, o Pluviômetro Maker possui internamente um sistema de básculas que se assemelham muito a uma gangorra com reservatório para captação de líquidos, como vemos abaixo:
Sistema de Báscula do Pluviômetro Arduino Maker
Diferentes modelos de básculas são utilizadas em sensores como este e cada qual possui seu limite máximo de líquido suportado, no Pluviômetro Arduino Maker, por exemplo, o valor de água para um milímetro é de 6ml e este valor gera duas movimentações da báscula, ou seja, cada lado da mesma suporta 3ml e consequentemente cada movimento representa 0,5mm.
Esta informação será muito importante para nós logo mais quando formos desenvolver o nosso código de funcionamento.
O sistema de detecção de movimento é responsável por detectar quando a báscula muda sua posição e consequentemente avisar o Arduino através do Sensor Magnético. Como já mencionado, este projeto não gera um pulso a cada movimento, então o que devemos observar é o momento em que o sinal muda seu estado de funcionamento (aberto/fechado).
Pluviômetro Arduino de Alumínio
O Pluviômetro Arduino desenvolvido em Alumínio é uma versão mais robusta que a citada anteriormente, seu corpo apresenta maior resistência a instalações externas e também melhores adaptação em ambientes diversos.
Pluviômetro Arduino de Alumínio
Internamente este modelo de Pluviômetro possui um Reed Switch para detectar a movimentação da gangorra, gerando um pulso a cada deslocamento da Báscula, lembrando que um Reed Switch nada mais é que um interruptor de lâmina com duas lâminas flexíveis separadas e hermeticamente seladas dentro de um tubo de vidro com atmosfera interna inerte.
Sistema interno de funcionamento do Pluviômetro em Alumínio
Sempre que um campo magnético exerce algum tipo de influencia próximo ao Reed Switch, a ação do mesmo faz com que as lâminas deste sensor se magnetizem e com isto se unam fechando um contato elétrico e possibilitando a passagem de corrente que gera um pulso para o Arduino e possibilita identificar o movimento.
Ilustração do Sistema de Funcionamento das Básculas
Como podemos observar na imagem acima, o funcionamento do Pluviômetro Arduino é extremamente simples, junto à Báscula é conectado um imã que cada vez que passa pelo reed switch manda um pulso para o Arduino e o mesmo soma 0,25mm à contagem.
Teste Prático Pluviômetro Arduino
A aplicação do Pluviômetro Arduino Digital é bastante comum em instalações de estações meteorológicas, onde a verificação de dados climáticos é de suma importância para o desenvolvimento de plantas, por exemplo.
Através dos projetos que veremos abaixo, entenderemos um pouco mais a principal diferença entre os dois modelos mencionados acima e lembramos que os códigos de funcionamento serão diferentes, porém o esquema de ligação poderá ser o mesmo para ambos os produtos.
Ambos os Pluviômetros contam com apenas dois fios, os quais estão diretamente associados às extremidades de um sensor Reed Switch, facilmente visualizado no Pluviômetro de Alumínio e que se mostra encapsulado no Sensor Magnético do Pluviômetro Maker.
Produtos Utilizados nos Testes
1 Pluviômetro de Báscula Digital Arduino em Alumínio;
1 Pluviômetro Digital de Báscula Arduino em Acrílico;
1 Display LCD 16×2 I2C com Fundo Azul;
1 Válvula Solenoide para Água;
Montagem Física do Projeto Pluviômetro
A montagem física do projeto é extremamente simples já que trabalha com somente dois fios para detecção magnética e um Arduino, o único detalhe que podemos destacar para a instalação é a utilização de um resistor em Pull Down conectado diretamente ao pino D9 do Arduino em conjunto com os demais pinos de alimentação.
Além disto, para melhorar a visualização dos dados, incluímos também ao projeto um Display LCD 16×2 com comunicação I2C, que diminui o número de conexões e facilita a instalação.
Verifique abaixo o esquema de ligação utilizado para conectar o equipamento junto ao Arduino e também o esquema elétrico da ligação utilizada junto aos demais componentes necessários.
Esquema de Ligação do Projeto Pluviômetro Arduino
Vaje abaixo, o esquema elétrico do projeto, lembrando que este modelo de conexão é o mesmo para ambas os pluviômetros já mencionados e como citado anteriormente.
Esquema Elétrico do Projeto Pluviômetro Arduino
LEMBRE-SE: O local de instalação deve ser uma área livre de obstáculos, não é permitido instalar o Pluviômetro em baixo de áreas cobertas e nem mesmo em baixo de árvores ou objetos que possam interferir na captação de líquidos.
Funcionamento do Pluviômetro Arduino Maker
Com um esquema de ligação simplificado e único para ambos os projetos achamos que as semelhanças entre os produtos chega ao fim, porém ao desenvolver o código vemos que esta semelhança mais uma vez pode ser observada.
A base de programação de ambos os produtos acaba sendo a mesma, o que se altera é o valor somado a cada pulso e o fator de que as funções if são duplicadas afim de satisfazer a necessidade de soma tanto para o sensor em HIGH quanto em LOW.
O código de funcionamento do Pluviômetro Arduino Maker trabalha de uma maneira um pouco diferenciada dos demais modelos, uma vez que os dados são somados a cada mudança de estado do sinal e não a cada pulso.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 |
#include "Wire.h"; #include "LiquidCrystal_I2C.h"; // Define o endereço utilizado pelo Adaptador I2C LiquidCrystal_I2C lcd(0x27, 20, 4); // Constantes: const int REED = 6; // Variáveis: int val = 0; int old_val = 0; int REEDCOUNT = 0; void setup() { // Initializa o pino do switch como entrada pinMode (REED, INPUT_PULLUP); //This activates the internal pull up resistor // Initializa a comunicaçao serial: Serial.begin(9600); //Inicializa o LCD e o backlight lcd.init(); lcd.backlight(); lcd.setCursor(0, 0); // Posiciona o cursor lcd.print("Pulsos: "); // Escreve no LCD "Pulsos: " lcd.setCursor(0, 1); // Posiciona o cursor lcd.print("Chuva: "); // Escreve no LCD "Chuva: " } void loop() { val = digitalRead(REED); // Lê o Status do Reed Switch if ((val == LOW) && (old_val == HIGH)) { // Verefica se o Status mudou delay(10); // Atraso colocado para lidar com qualquer "salto" no switch. REEDCOUNT = REEDCOUNT + 1; // Adiciona 1 à cntagem de pulsos old_val = val; //Iguala o valor antigo com o atual // Imprime no Monitor Serial Serial.print("Medida de chuva (contagem): "); Serial.print(REEDCOUNT); Serial.println(" pulso"); Serial.print("Medida de chuva (calculado): "); Serial.print(REEDCOUNT * 0.50); Serial.println(" mm"); // Imprime as informações do Display lcd.setCursor(8, 0); //Posiciona o cursor lcd.print(REEDCOUNT); //Escreve o número de Pulsos lcd.setCursor(8, 1); //Posiciona o cursor lcd.print(REEDCOUNT * 0.50); //Escreve o valor em milímetros lcd.setCursor(14, 1); //Posiciona o cursor lcd.print("mm"); //Escreve no LCD "mm" } if ((val == HIGH) && (old_val == LOW)) { // Verefica se o Status mudou delay(10); // Atraso colocado para lidar com qualquer "salto" no switch. REEDCOUNT = REEDCOUNT + 1; // Adiciona 1 à cntagem de pulsos old_val = val; //Iguala o valor antigo com o atual // Imprime no Monitor Serial Serial.print("Medida de chuva (contagem): "); Serial.print(REEDCOUNT); Serial.println(" pulso"); Serial.print("Medida de chuva (calculado): "); Serial.print(REEDCOUNT * 0.50); Serial.println(" mm"); // Imprime as informações do Display lcd.setCursor(8, 0); //Posiciona o cursor lcd.print(REEDCOUNT); //Escreve o número de Pulsos lcd.setCursor(8, 1); //Posiciona o cursor lcd.print(REEDCOUNT * 0.50); //Escreve o valor em milímetros lcd.setCursor(14, 1); //Posiciona o cursor lcd.print("mm"); //Escreve no LCD "mm" } else { old_val = val; //If the status hasn't changed then do nothing } } |
Por se tratar de um equipamento que possui a capacidade de verificar a quantidade de chuva coletada em sua superfície, o Pluviômetro Arduino necessita de uma visualização de valores, que neste código pode ser realizado tanto através do display quanto através do Monitor Serial.
ATENÇÃO: O Pluviômetro deve ser instalado em local aberto e livre de obstáculos, porém os demais elementos do projeto devem estar devidamente protegidos, impedindo contato com a chuva ou demais elementos externos que possam danificá-lo.
Funcionamento do Pluviômetro Arduino de Alumínio
Este modelo de Pluviômetro normalmente está associado a grandes instalações meteorológicas conciliando seu trabalho com outros dispositivos como anemômetro, indicadores de direção do vento, sensores de temperatura umidade e afins.
De forma direta, o código é simples e de fácil compreensão, possui duas bibliotecas para auxilio no funcionamento do Display I2C e verifica constantemente o número de pulsos para poder atualizar o volume de água captado.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 |
#include "Wire.h"; #include "LiquidCrystal_I2C.h"; // Define o endereço utilizado pelo Adaptador I2C LiquidCrystal_I2C lcd(0x27, 20, 4); // Constantes: const int REED = 6; // Variáveis: int val = 0; int old_val = 0; int REEDCOUNT = 0; void setup() { // Initializa o pino do switch como entrada pinMode (REED, INPUT_PULLUP); //This activates the internal pull up resistor // Initializa a comunicaçao serial: Serial.begin(9600); //Inicializa o LCD e o backlight lcd.init(); lcd.backlight(); . lcd.setCursor(0, 0); // Posiciona o cursor lcd.print("Pulsos: "); // Escreve no LCD "Pulsos: " lcd.setCursor(0, 1); // Posiciona o cursor lcd.print("Chuva: "); // Escreve no LCD "Chuva: " } void loop() { val = digitalRead(REED); // Lê o Status do Reed Switch if ((val == LOW) && (old_val == HIGH)) { // Verefica se o Status mudou delay(10); // Atraso colocado para lidar com qualquer "salto" no switch. REEDCOUNT = REEDCOUNT + 1; // Adiciona 1 à cntagem de pulsos old_val = val; //Iguala o valor antigo com o atual // Imprime no Monitor Serial Serial.print("Medida de chuva (contagem): "); Serial.print(REEDCOUNT); Serial.println(" pulso"); Serial.print("Medida de chuva (calculado): "); Serial.print(REEDCOUNT * 0.25); Serial.println(" mm"); // Imprime as informações do Display lcd.setCursor(8, 0); //Posiciona o cursor lcd.print(REEDCOUNT); //Escreve o número de Pulsos lcd.setCursor(8, 1); //Posiciona o cursor lcd.print(REEDCOUNT * 0.25); //Escreve o valor em milímetros lcd.setCursor(14, 1); //Posiciona o cursor lcd.print("mm"); //Escreve no LCD "mm" } else { old_val = val; //If the status hasn't changed then do nothing } } |
Através da adição de água na superfície de coleta, nosso parceiro do WR Kits simula uma chuva e consequentemente mede a quantia de água em milímetros (mm) que foi captada pelo Pluviômetro de Alumínio, veja no vídeo abaixo:
Por se tratar de um equipamento que possui a capacidade de verificar a quantidade de chuva coletada em sua superfície, o Pluviômetro Arduino necessita de uma visualização de valores, que neste código pode ser realizado tanto através do display quanto através do Monitor Serial.
ATENÇÃO: O Pluviômetro deve ser instalado em local aberto e livre de obstáculos, porém os demais elementos do projeto devem estar devidamente protegidos, impedindo contato com a chuva ou demais elementos externos que possam danificá-lo.
Conclusão
Este é somente um dos equipamentos utilizados em Centrais de Estações Meteorológicas Arduino, com o tempo vamos postando os demais equipamentos que temos disponíveis e você irá perceber que desenvolver a sua própria central é mais fácil do que imagina, basta ter os equipamentos certos e incluí-los todos em um único projeto.
O Projeto Pluviômetro Arduino é somente um exemplo de aplicação realizado para auxiliar hobbistas e projetistas em seus trabalhos, porém você pode fazer outras adaptações que irão enriquecer ainda mais ó seu medidor de velocidade do vento, por exemplo, para se desprender da necessidade de um computador para verificar os valores, pode-se incluir um display LCD e até mesmo um Display de LED.
Anteriormente mencionamos a possibilidade de utilizar um Display LCD através do referente código, porém não demonstramos o esquema de ligação junto ao Arduino, isto pois o código funciona normalmente sem a utilização do mesmo e a inclusão do mesmo fica como tarefa para treinarmos a nossa capacidade, tente aí e não esqueça de comentar aqui em baixo deixando sua opinião e a sua experiência com este incrível sensor para Arduino.
Nunca se esqueça, o limite para os seus projetos e para sua vida é você quem faz, então quebre barreiras, conquiste experiência e evolua cada dia mais!
Conheça toda Linha de Produtos Arduino no Site da UsinaInfo.
E em caso de encher no limite do pluviômetro e continuar caindo água, ele esvazia?
Se sim, como funciona isso? ou se não, teria alguma sugestão de como fazer para esvaziar não sendo manualmente?
Olá João!
O Pluviômetro possui um sistema próprio de vazão que esvazia os líquidos captados para não ficar acumulado em seu interior através de um furo.
Não consigo fazer o pluviômetro funcionar…quais as cores dos fios devo conectar ao Arduíno?
Boa tarde!
O Pluviômetro utilizado para o referente projeto possui apenas fios pretos que trabalham independentemente do terminal ao qual estiverem conectados.
O código possui um erro, não é o pino 9 que está definido no código e sim o pino 6…Basta mudar e colocar 9.
Fiz um código com base neste postado aqui, porem estou tendo problemas pra conciliar o funcionamento do pluviômetro e do anemômetro …quando o código do anemômetro nao esta comentado o pluviômetro não funciona nem com reza ….alguem pode ajudar isso e a base do meu TCC ….
#include
/************* Definições inciais Ipluv **************************/
// Constantes:
const int REED = 6; //The reed switch outputs to digital pin 9
// Variáveis:
int val = 0; //Current value of reed switch
int old_val = 0; //Old value of reed switch
int REEDCOUNT = 0; //This is the variable that hold the count of switching
/**************************** Ipluv ******************************/
/************* Definições inciais Anemometrô **************************/
// Pin definitions
# define Hall sensor 2 // Pino digital 2
// Constants definitions
const float pi = 3.14159265; // Numero pi
int period = 5000; // Tempo de medida(miliseconds)
int delaytime = 2000; // Time between samples (miliseconds)
int radius = 147; // Aqui ajusta o raio do anemometro em milimetros **************
// Variable definitions
unsigned int Sample = 0; // Sample number
unsigned int counter = 0; // magnet counter for sensor
unsigned int RPM = 0; // Revolutions per minute
float speedwind = 0; // Wind speed (m/s)
float windspeed = 0; // Wind speed (km/h)
/******************** FIM Anemometrô ************************************/
// as variaveis a seguir sao do tipo long pois o tempo, medido em milissegundos,
// rapidamente se tornara em um numero grande demais para ser armazenado em uma int.
//My simple Thread
Thread threadIpluv = Thread();
Thread threadVvento = Thread();
void setup() {
Serial.begin(9600);
// Pluviômetro
pinMode (5, OUTPUT); // saida para reset pluviometro *
pinMode (6, INPUT); // entrada pluvio *
digitalWrite(5, HIGH); // ativa pluviom
// Anemômetro
pinMode(2, INPUT); // Entrada anemometro *
digitalWrite(2, HIGH); //internall pull-up active
/*threadIpluv.onRun(niceCallback);
threadIpluv.setInterval(500);
threadVvento.onRun(niceCallback);
threadVvento.setInterval(500);*/
}
void loop() {
float ipluv = getIpluve();
Serial.print(ipluv);
Serial.println(” mm”);
float vvVento = velocidadeVento();
if (vvVento != 0.0) {
Serial.print(vvVento);
Serial.print(” [km/h] “);
Serial.println();
}
delay(1000);
}
float getIpluve() {
// ler o estado do switch pelo pino de entrada:
val = digitalRead(REED); //Read the status of the Reed swtich
float result = 0.0;
if ((val == LOW) && (old_val == HIGH)) { //Check to see if the status has changed
delay(10); // Delay put in to deal with any “bouncing” in the switch.
REEDCOUNT = REEDCOUNT + 1; //Add 1 to the count of bucket tips
old_val = val; //Make the old value equal to the current value
Serial.print(“Medida de chuva (contagem): “);
Serial.print(REEDCOUNT);//*0.2794);
Serial.println(” pulso”);
Serial.print(“Medida de chuva (calculado): “);
result = REEDCOUNT * 0.25;
Serial.print(result);
Serial.println(” mm”);
}
else {
old_val = val; //If the status hasn’t changed then do nothing
}
return result;
}
float velocidadeVento() {
Sample++;
Serial.print(Sample);
Serial.print(“: Start measurement…”);
windvelocity();
Serial.println(” finished.”);
Serial.print(“Counter: “);
Serial.print(counter);
Serial.print(“; RPM: “);
RPMcalc();
Serial.print(RPM);
Serial.print(“; Wind speed: “);
//*****************************************************************
//print m/s
WindSpeed();
Serial.print(windspeed);
Serial.print(” [m/s] “);
//*****************************************************************
//print km/h
SpeedWind();
return speedwind;
}
// Measure wind speed
void windvelocity() {
speedwind = 0;
windspeed = 0;
counter = 0;
attachInterrupt(0, addcount, RISING);
unsigned long millis();
long startTime = millis();
while (millis() < startTime + period) {
}
}
void RPMcalc() {
RPM = ((counter) * 60) / (period / 1000); // Calculate revolutions per minute (RPM)
}
void WindSpeed() {
windspeed = ((4 * pi * radius * RPM) / 60) / 1000; // Calculate wind speed on m/s
}
void SpeedWind() {
speedwind = (((4 * pi * radius * RPM) / 60) / 1000) * 3.6; // Calculate wind speed on km/h
}
void addcount() {
counter++;
}
o código esta contando 0,25mm a cada pulso, mas o valor fica registrado e não sai, somando com outros valores, como faço pra ele zerar e começar uma nova leitura em outra chuva?
Boa Tarde Renan! Ao reiniciar o Arduino, a contagem também reinicia, porém é possível incrementar no projeto um botão para reset ou outro dispositivo mecânico para tal função.
É possível incrementar nesse sistema uma forma de enviar notificações sms? É uma base de registro das leituras?
Boa tarde Higgor, sim, é possível.