ESTAÇÃO METEOROLÓGICA COM ARDUINO

Autor: William Tadeu da Conceição

1. OBJETIVO
O objetivo deste trabalho é construir uma estação meteorológica com a plataforma de
prototipagem eletrônica "arduino", coletando dados atmosféricos como: temperatura,
umidade, pressão, velocidade do vento, direção do vento, rajada de vento, radiação solar
e pluviosidade. indicando os dados coletados em um display, salvando os dados em um
cartão de memória e enviando os dados para um site especializado em hospedar dados
chamado ThingSpeak.

2. FUNCIONAMENTO
O funcionamento da estação se divide em cinco fases:
I - Coleta de dados - coleta os dados dos sensores e módulos agregados ao arduino;
II - Cálculos - calcula média do vento, radiação solar acumulada, converte dados e
unidades de medidas;
III - Exibição de dados no display - exibe dados instantâneos no display;
IV - Envio de dados para a internet - envia dados instantâneos a cada 15 minutos
para o site para o site ThingSpeak, para facilitar a leitura e compreensão de usuários
comuns a velocidade do vento é exibida em (Km/h), a radiação solar em (W/m²) e a
pluviosidade acumulada no dia sendo zerada às 00:00hs.
V - Gravação de dados no cartão de memória - os dados são gravados a cada hora
no cartão de memória no mesmo formato utilizado pelo INMET(Instituto Nacional
de Meteorologia) , sendo os dados tratados da seguinte forma:
- Temperatura, umidade, pressão e direção do vento instantâneas;
- Velocidade média do vento em (m/s), obtida através de 60 medições, uma a cada
minuto;
- Rajada de vento, obtido através da maior velocidade registrada na hora;
- Radiação solar acumulada, radiação medida a cada minuto e somada, resultado
em (Kj/m²) acumulada em uma hora.
- Pluviosidade acumulada em uma hora em (mm).
 FUNCIONAMENTO DO PROGRAMA

FASE TAREFA QUANDO DURAÇÃO AÇÃO

Acessa o relógio e atualiza a
Hora A cada loop 1 segundo hora.
Acessa o sensor dht22 e
Temperatura e
A cada loop 1 segundo atualiza a temperatura e
umidade
umidade.
Acessa o sensor BMP 180 e
Pressão A cada loop 1 segundo atualiza pressão.
Conta os pulsos vindos do
Velocidade de
A cada loop 5 segundos anemômetro e calcula a
vento
I velocidade
Verifica direção do vento
Direção do vento A cada loop 0 segundos através da biruta.
Verifica se o vento coletado
Rajada de vento A cada loop 0 segundos é maior que o anterior
Soma cada pulso vindo do
Pluviosidade A cada loop 0 segundos pluviômetro.
Verifica a radiação solar
Radiação solar A cada loop 0 segundos através da tensão vinda da
célula solar “Piranômetro”
Imprime dados instantâneos
II Imprime no LCD A cada loop 0 segundos no LCD

Soma a radiação A cada Soma a radiação solar até

0 segundos fechar a hora
solar minuto
Conta quantos dados foram
Conta dados para A cada
0 segundos coletados para fechar a
média minuto
média
Calcula média do Soma do vento / quantidade
III vento
A cada hora 0 segundos de dados
Zera a média de vento,
rajada de vento,
pluviosidade e radiação
Zera os dados A cada hora 0 segundos
solar
Zera pluviosidade da
internet às 00:00hs
FASE DESCRIÇÃO QUANDO DURAÇÃO AÇÃO
Envia dados para o site
ThingSpeak, serão enviados
dados instantâneos:
- Temperatura (°C)
- Umidade (%)
- Pressão (hPa)
- Vento (Km/h)
Envia dados para A cada 15
IV internet minutos
5 segundos - Direção do vento (em
graus)
- Rajada de Vento (maior
velocidade da hora)
- Radiação solar
instantânea (W/m²)
- Pluviosidade (acumulado
do dia)
Serão gravados os seguintes
dados
- dia e hora
- Temperatura (°C)
- Umidade (%)
- Pressão (hPa)
- Média de Vento (m/s)
Grava dados no
V cartão
A cada hora 5 segundos - Direção do vento (em
graus)
- Rajada de Vento ( maior
velocidade da hora)
- Radiação solar (Kj/m²)
(acumulado da hora)
- Pluviosidade (acumulado
da hora)
3. O PROJETO
Dada a complexidade do projeto, ele será abordado em módulos (Figura 1), os quais
serão integrados no final, culminando na estação meteorológica, os módulos consistem
em:
- RELOGIO (módulo DS1307);
- TEMPERATURA e UMIDADE (sensor DHT22);
- BARÔMETRO (módulo BMP180);
- ANEMOMETRO;
- BIRUTA;
- PLUVIÔMETRO;
- PIRANÔMETRO “ Medidor de radiação solar”;
- INTERNET e CARTÃO DE MEMORIA (Ethernet Shield W5100);
- DISPLAY LCD; e
- FONTE.
 Figura 1: Diagrama em bloco da estação meteorológica

3.1 RELÓGIO
O relógio tem a função de marcar o tempo que ocorre cada função e fornecer a
data e hora para registro de dados no cartão de memória, ele se comunica com o arduino
através do protocolo I2C.
Ele é formado pelo módulo DS1307 que funciona diretamente ligado ao arduino
conforme diagrama da Figura 2.

Figura 2: Esquema de ligação do módulo relógio

Segue abaixo o programa utilizado para testar o relógio, a biblioteca RTClib.h para
utilização do programa segue em anexo.
A função de ajuste hora "rtc.adjust" deverá ser retirada após o ajuste do dia e hora.

#include <RTClib.h> // bibioteca relogio

#include <Wire.h> // biblioteca comunicação I2C

RTC_DS1307 rtc;

void setup() {

rtc.begin(); // inicializa comunicação com relógio

Serial.begin(9600); // inicializa a comunicação serial
delay(5000);

// Função ajuste dia e hora, exemplo 8/11/2016 23:59:0

rtc.adjust(DateTime(2016, 11, 8, 23, 59, 0));

void loop()
{
DateTime now = rtc.now(); // atualiza hora no programa

Serial.print(now.day(), DEC); // imprime o dia

Serial.print('/');
Serial.print(now.month(), DEC); // imprime o mês
Serial.print('/');
Serial.println(now.year(), DEC); // imprime o ano

if (now.hour() < 10) Serial.print("0"); // adiciona zero a hora menor que 10

Serial.print(now.hour(), DEC); // imprime hora
Serial.print(":");
if (now.minute() < 10) Serial.print("0"); // adiciona zero a minuto menor que 10
Serial.print(now.minute(), DEC); // imprime minuto
Serial.print(":");
Serial.println(now.second(), DEC); // imprime segundo
Serial.println(); // pula linha
delay(3000);
}
3.2 TEMPERATURA e UMIDADE
A medição de temperatura e umidade é feita pelo sensor DHT22, que atualiza o
programa com os dados de temperatura e umidade a cada loop. Na Figura 3 podemos
identificar o esquema de ligação.

Figura 3: Esquema de ligação do sensor DHT 22

Segue abaixo o programa utilizado para testar o sensor DHT22, a biblioteca "DHT.h"
para utilização do programa segue em anexo.

#include "DHT.h" // Biblioteca do sensor

DHT dht(2, DHT22); // Configura pino 2 arduino entrada para dados, e modelo de sensor
void setup() {
Serial.begin(9600);
dht.begin(); // Inicia sensor
}
void loop() {
delay(2000);
float h = dht.readHumidity(); // atualiza umidade
float t = dht.readTemperature(); // atualiza temperatura
Serial.print("Umidade: ");
Serial.print(h);
Serial.print(" %\t"); // Caractere % e espaçamento
Serial.print("Temperatura: ");
Serial.print(t);
Serial.println();
3.3 BARÔMETRO
A medição de pressão atmosférica é feita pelo sensor BMP180 que atualiza o
programa com a pressão atmosférica a cada loop, ele se comunica com o arduino
através do protocolo I2C. Na Figura 4 podemos identificar o esquema de ligação.
Obs: O sensor é alimentado por 3,3Volts.

Figura 4: Esquema de ligação do sensor BMP180

Segue abaixo o programa utilizado para testar o sensor BMP180, a biblioteca "
Adafruit_BMP085.h " para utilização do programa segue em anexo.

#include <Wire.h> // Biblioteca protocolo I2C

#include <Adafruit_BMP085.h> // Biblioteca barômetro

float pressao;
float pressaohpa;
Adafruit_BMP085 bmp;

void setup() {
Serial.begin(9600);
bmp.begin(); // inicia barômetro
}
void loop() {
pressao = bmp.readPressure(); // atualiza pressão em Pa
pressaohpa = pressao / 100; // transforma pressão Pa para hPa
Serial.print("Pressao = ");
Serial.print(pressao, 1); // imprime pressão em Pa com uma casa decimal
Serial.println(" Pa");
Serial.print("Pressao = ");
Serial.print(pressaohpa, 1); // imprimi pressão em hPa, com uma casa decimal
Serial.println(" hPa");
Serial.println();
delay(3000);
}
3.4 ANEMÔMETRO
3.4.1 CIRCUITO
O circuito do anemômetro é formado por um anemômetro de Robinson que possui
um uma chave magnética chamada “reed-switche” responsável por enviar um
pulso a cada volta do anemômetro, que serão contadas pelo arduino no intervalo
de 5 segundos, a fim de obter a velocidade do vento.
O sensor reed-switche é um interruptor de lâminas magnético, e como todo
interruptor mecânico sofre o efeito conhecido como Efeito Bounce (Figura 5), que
nada mais é que o aparecimento de diversos pulsos no momento do fechamento e
abertura da chave, levando a erro leitura no anemômetro.

Figura 5: Efeito Bounce

Para eliminar este efeito é montado um circuito chamado “Debounce” (Figura 6), que
tem a finalidade de filtrar estes pulsos deixando passar somente o pulso do fechamento
e abertura da chave.

Figura 6: Circuito debounce

O circuito completo do anemômetro é composto pelo: anemômetro, circuito debounce
e arduino (Figura 7).

Figura 7: Esquema de ligação do anemômetro

3.4.2 ANEMOMETRO
O anemômetro utilizado pela estação meteorológica é fabricado pela
WRFCOMERCIAL (Figuras 8 e 9) e foi adquirido pelo site do mercado livre,
sofreu aferições dinâmicas e estáticas para fornecer dados para o algoritmo que
transformará os pulsos do anemômetro em velocidade do vento em m/s e Km/h.

7,5 cm

11,5 cm

Figura 8: Dimensões do anemômetro

 Figura 9: Anemômetro WRFCOMERCIAL

3.4.3 AFERIÇÃO DINÂMICA

Pode ser feita através de um túnel de vento, comparação com outro anemômetro
aferido ou utilizando um veiculo em movimento em um dia sem vento e mantendo o
anemômetro afastado pelo menos 1,5 metros do veiculo (Tabela 1).

Tabela 1: Aferição dinâmica do anemômetro

VELOCIDADE PULSOS VELOCIDADE
REAL (km/h) cada 5 segundos MEDIDA (Km/h)
10 4 9,8
20 10 20,1
30 16 30,4
40 22 40,7
50 27 49,3
60 33 59,6
70 38 68,1
80 45 80,2

Fórmula final (aproximada)

P=PULSOS
Velocidade (m/s) = 0,4765*P + 0,833
Velocidade (Km/k) = 1,7154*P + 3
3.4.5 AFERIÇÃO ESTÁTICA

Fórmula para aferição estática:

1+ α 
V =  * W * Rc
1−α 

Cd 1 1,40
α= = = 1,870
Cd 2 0,40

V = velocidade do vento em m/s

W = velocidade angular = 2*π*F
Rc = Raio até o meio da concha = 11,5 cm = 0,115 metros
F = frequência = Pulsos / 5 segundos = P/5
Cd1 = 1,40 coeficiente de arrasto na parte frontal da concha
Cd2 = 0,40 coeficiente de arrasto na parte trazeira da concha

1 + 1,870 P
V= * W * Rc => 3,298 * 2 * π * * 0,115
1 − 1,870 5

Formula teórica final

V(m/s) = 0,4766 * P

V(Km/h) = 1,7154 * P

Obs: m/s * 3,6 = Km/h

3.4.6 PROGRAMA

volatile unsigned long contvento; // Variavel contagem de pulsos

float vento; // variável velocidade vento em Km/h
float ventoms; // variável velocidade do vento em m/s

void setup() {

pinMode(3, INPUT); // configura o pino para entrada de pulsos

Serial.begin(9600);

void loop() {

attachInterrupt(1, addvento, RISING); // Liga o contador

contvento = 0;
delay(5000); // Tempo de contagem dos pulsos

vento = contvento * 1.7174; // calcula velocida do vento em Km/h

ventoms = vento / 3.6; // transforma vento km/h para m/s

detachInterrupt(1); // Desliga o contador

Serial.print("velocidade do vento: ");

Serial.print(vento); // imprime vento em Km/h
Serial.println("Km/h");
Serial.print("velocidade do vento: ");
Serial.print(ventoms); // imprime vento em m/s
Serial.println("m/s");
Serial.println();
delay(2000);
}

void addvento(){ // função para contagem de pulsos

contvento++;
}

3.5 BIRUTA
A direção do vento é adquirida através de uma biruta fabricada pela
WRFCOMERCIAL (Figura 10) a biruta transforma a direção de vento em um sinal
elétrico, onde cada direção do vento representa uma tensão que será identificada
pelo programa do arduino indicando a direção do vento.
 Figura 10: Biruta da WRFCOMERCIAL
3.5.1 ESQUEMA DE LIGAÇÃO
A biruta tem ligação simples, bastando adicionar uma resistência e um capacitor ao
circuito, conforme Figura 11:

Figura 11: Circuito da biruta

Tabela 2: Aferição da biruta

AFERIÇÃO
DIREÇÃO TENSÃO VALOR
N 2,49 511
NE 1,66 340
E 1,24 255
SE 0,99 203
S 0,82 169
SW 0,70 145
W 0,61 126
NW 0,54 112

Obs: no arduino a tensão de 5 volts é equivalente ao numero 1023.

3.5.2 PROGRAMA
O valor obtido na tabela 2 será utilizado para atribuir a direção do vento no
programa.

String direcao; // Variavel texto

int valor = 0; // Variavel tensão na entrada

void setup() {
Serial.begin(9600);
}

void loop() {
valor = analogRead(A0); // Variável valor = entrada analógica (0)
if (valor <= 119) {
direcao = "NW";
}
else if (valor <= 135) {
direcao = "W";
}
else if (valor <= 157) {
direcao = "SW";
}
else if (valor <= 186) {
direcao = "S";
}
else if (valor <= 229) {
direcao = "SE";
}
else if (valor <= 297) {
direcao = "E";
}
else if (valor <= 425) {
direcao = "NE";
}
else {
direcao = "N";
}

Serial.print("direção do vento: ");

Serial.println(direcao); // imprime direção do vento
delay(1000);
}
3.6 PLUVIÔMETRO
A medida da pluviosidade é feita por um pluviômetro de báscula que possui uma
gangorra que alterna de posição a cada 0,25mm de chuva, e aciona uma chave
magnética “reed-switche” responsável por enviar um pulso a cada variação da
gangorra (Figuras 12 e 13).

Figura 12: Principio de Funcionamento Figura 13: Pluviômetro de báscula

3.6.1 CIRCUITO
Por utilizar um sensor reed-switche é necessário a utilização do circuito
“debounce”, que tem a finalidade de filtrar estes pulsos deixando passar somente
o pulso do fechamento e abertura da chave (Figura14).

Figura 14: Circuito debounce

O circuito completo do pluviômetro é composto pelo: pluviômetro, circuito debounce
e arduino conforme Figura 15.

Figura 15: Esquema de ligação do pluviômetro

3.6.2 PLUVIOMETRO
O pluviômetro utilizado na estação meteorológica é fabricado pela
WRFCOMERCIAL (Figura 16) e mede a pluviosidade a cada 0,25mm.

Figura 16: Pluviômetro da WRFCOMERCIAL

3.6.3 AFERIÇÃO
A boca do funil do pluviômetro tem um diâmetro de 14,5cm o que equivale a
uma área 0,01651m² .
Na aferição foi adicionado 250ml (0,00025m³) de água no pluviômetro e
detectou-se 57 pulsos.
Dividindo-se o volume total de água (0,00025 m³) por 57 pulsos temos
0,000004385m³ de água por pulso, sendo assim dividindo-se o volume por pulso
(0,000004385m³) pela área (0,01651m²) temos 0,000265 metros de chuva por
pulso ou 0,26mm.

3.6.4 PROGRAMA

volatile unsigned long contchuva; // Variavel contagem de pulsos

float chuva = 0 // variável chuva em mm

void setup() {

pinMode(2, INPUT); // configura o pino para entrada de pulsos

attachInterrupt(0, addchuva, RISING); // liga o contador
Serial.begin(9600);

void loop() {

chuva = contchuva * 0.25;

Serial.print("chuva: ");
Serial.print(chuva); // imprime quantidade de chuva
Serial.println("mm");
delay(2000);
}

void addchuva(){
contchuva++;
}

3.7 PIRANÔMETRO
A função do piranômetro é medir a radiação solar, o piranômetro instalado na
estação utiliza uma célula fotovoltaica que converte a radiação solar em uma
tensão que será convertida pelo circuito em radiação solar em (W/m²) e em
(KJ/m².h)
3.7.1 CIRCUITO
O circuito consiste em uma célula solar de 5v e 0,2W de potência que é ligada em
paralelo com um resistor de 89 ohm e um capacitor de 4,7uF (Figura 17).
O objetivo do resistor é fornecer uma carga a célula solar com o objetivo de
ocorrer um variação de tensão de acordo com a intensidade de radiação solar.
Caso o circuito fique aberto a célula solar em questão indicará 5 volts com uma
quantidade mínima de radiação.
Obs: como não há no mercado resistores de 89 ohm, foi utilizado um resistor de
150ohm em paralelo com um de 220 ohm

Figura 17: Circuito do Piranômetro

3.7.1 AFERIÇÃO
Para aferição do piranômetro por ser utilizado um outro piranômetro aferido,
dados de uma estação meteorológica localizada em um local próximo, ou o Atlas
Solarimétrico do Brasil, utilizando dados previsíveis para o local e data onde
será aferido o piranômetro, deve ser feito em um dia sem nuvens (Tabela 3).

Tabela 3: Aferição do piranômetro

Dia 07/11/2016 (HORÁRIO DE VERÃO)

8:00 9:00 10:00 11:00 12:00 13:00 14:00 15:00 16:00 17:00 18:00
Tensão na
1,58 1,87 2,86 3,12 3,40 3,40 3,00 2,80 1,40 1,00 0,28
célula solar
Radiação
solar 502 594 909 992 1081 1081 954 890 445 318 89
(W/m²)

Fórmula final

Radiação solar(Wm²) = Tensão * 318

 3.7.1 PROGRAMA

float tensao = 0; // Variável tensão célula solar

float radiacao = 0; // Variável radiação solar

void setup() {

Serial.begin(9600);

void loop() {
tensao = analogRead(A0) * (5.0 / 1023.0); // Lê a entrada e converte para o valor da tensão
radiacao = tensao * 318; // Transforma a tensão em Radiação solar

Serial.print("Radiação solar: ");

Serial.print(radiacao); // imprime radiação solar
Serial.println(" W/m²");
delay(2000);
}

3.8 INTERNET e CARTÃO DE MEMORIA (Ethernet Shield W5100)

O envio de dados pela internet e armazenamento no cartão de memória é feito pelo
módulo Ethernet Shield W5100 que se encaixa perfeitamente sobre o arduino uno
ou mega como nas Figuras 18 e 19.

Figura 18: Encaixe sobre o arduino uno Figura 19: Encaixe sobre o arduino mega
3.8.1 INTERNET
Para configurar o programa para envio de dados para o site https://thingspeak.com é
necessário cadastrar uma conta e criar um canal no site do thingspeak, após criada a
conta você vai na aba chave e copiar a API Key “ chave de escrita”, que é o código
utilizado pelo programa para enviar os dados para o site.
O canal possui 8 campos, onde é possível enviar dados de 8 tipos de medições.
A estação envia os dados instantâneos a cada 15 minutos.

3.8.2 CARTÃO DE MEMORIA

O dados também são gravados em formato .txt em um cartão de memória um vez a
cada hora, nos mesmos padrões utilizados em estações meteorológicas do INMET
“Instituto Nacional de Meteorologia”.
Para a gravação dos dados basta inserir um cartão de memória micro devidamente
formatado

3.8.3 PROGRAMA
Segue abaixo o programa utilizado para testar o módulo, as bibliotecas utilizadas
seguem em anexo.

#include <SPI.h> // Biblioteca comunicação protolo SPI

#include <Ethernet.h> // Biblioteca Internet
#include <SD.h> // Biblioteca cartão SD

char thingSpeakAddress[] = "api.thingspeak.com"; // endereço site thingspeak

String writeAPIKey = "7DFDJ8F7E93"; //<-- SUBSTITUIR SEU "API Key"
int cont = 0; // Cria uma variável chamada cont para TESTE

byte mac[] = { 0xD4, 0x28, 0xB2, 0xFF, 0xA0, 0xA1 }; // Configuração internet
EthernetClient client; // Inicializa internet
File myFile; // cartão SD

void setup() {
Serial.begin(9600);
SD.begin(4); // Pino conectado ao CS do modulo
}
void loop() {

// CARTÃO DE MEMÓRIA
myFile = SD.open("data.txt", FILE_WRITE); // Abre ou cria arquivo data.txt
if (myFile) { // Verifica se arquivo foi aberto e inicializa gravação
Serial.print("Gravando dados ");
myFile.print(“Teste: ”); // Grava a palavra “Teste”
myFile.print(cont); // Grava a variavel cont
myFile.close(); // Fecha arquivo
} else {
Serial.print("Erro na gravação de dados ");
}
// INTERNET

client.stop();
Serial.println("Conectando arduino");
delay(1000);

if (Ethernet.begin(mac) == 0) { // conectando arduino

Serial.println("Conexao falhou");
}
else
{
Serial.println("Arduino concectado");
}

delay(1000);

if(!client.connected()) { // envio de dados

updateThingSpeak("field1="+String(cont)+"&field2="+String(cont)+"&field3="+String(cont)
+"&field4="+String(cont)+"&field5="+String(cont)+"&field6="+String(cont)+"&field7="+Stri
ng(cont)+"&field8="+String(cont)); // Enviando a variavel cont para os 8 campos
}
}
void updateThingSpeak(String tsData) { // FUNÇÃO ENVIO DE DADOS
if (client.connect(thingSpeakAddress, 80)) {
client.print("POST /update HTTP/1.1\n");
client.print("Host: api.thingspeak.com\n");
client.print("Connection: close\n");
client.print("X-THINGSPEAKAPIKEY: "+writeAPIKey+"\n");
client.print("Content-Type: application/x-www-form-urlencoded\n");
client.print("Content-Length: ");
client.print(tsData.length());
client.print("\n\n");
client.print(tsData);
if (client.connected()) {
Serial.println ("Conectando ThingSpek");
} else {
Serial.println ("Falha ThingSpeak");
}
} else {
Serial.println ("Falha ThingSpeak");
}
}
3.9 DISPLAY LCD
A estação utiliza um Display LCD 20x4 com a finalidade de verificar as condições
de tempo no momento e também verificar o funcionamento da estação, o display
LCD se comunica com o arduino através do protocolo I2C (Figura 20).

Figura 20: Esquema de ligação do LCD

Segue abaixo o programa utilizado para testar o sensor Display LCD, a biblioteca
"LiquidCrystal_I2C.h" para utilização do programa segue em anexo.

#include <Wire.h> // Biblioteca protocolo I2C

#include <LiquidCrystal_I2C.h> // Biblioteca LCD com I2C

LiquidCrystal_I2C lcd(0x3F,2,1,0,4,5,6,7,3, POSITIVE); // Configuração LCD

void setup()
{
lcd.begin (20,4); // Inicio LCD
}

void loop()
{
lcd.setBacklight(HIGH); // Acende luz do LCD
lcd.setCursor(0,0); // Posiciona curso do LCD (nenhum espaço e linha 0)
lcd.print("Arduino e Cia !!"); // Escreve no LCD
lcd.setCursor(0,1); // Posiciona curso do LCD (nenhum espaço e linha 1)
lcd.print("LCD e modulo I2C");
delay(1000);
lcd.setBacklight(LOW); // Desliga LCD
delay(1000);

Obs: a) Regular o potenciômetro atrás do LCD para regular o contraste.

b) O módulo I2C possui um jump para desligar a luz do LCD, podendo ser
ligado a uma chave.
3.10 FONTE
O arduino possui um regulador interno, que reduz a tensão para 5 volts que é a
tensão de funcionamento do arduino, este regulador pode trabalhar com tensões na
entrada em torno de 7 a 12 volts, porém a tensão padrão de entrada é 9 volts.
Para evitar que o circuito sofra desligamentos ou oscilações da rede a estação
possui um circuito eletrônico responsável por estabilizar a tensão, e carregar uma
bateria que tem a função de nobreak (Figura 21).
O circuito eletronico é alimentado por uma fonte de 15V 1A (Figura 22) e uma
bateria de 12V e 7Ah (Figura 23), sendo protegido contra sobrecargas e curto-
circuito na bateria, possui também uma chave que controla a carga na bateria,
flutuação (12,4V) ou carga normal (13,8V).
Utiliza-se carga normal por 24horas quando a bateria precisou ser utilizada em
caso de falta de energia na rede e utiliza-se flutuação quando a bateria está
carregada e se quer manter a carga garantindo grande durabilidade a bateria.
Obs: O transistor 2SD401 e o regulador 7809 devem ser montados em um
radiados de calor.

Figura 21:Circuito eletrônico da fonte

 Figura 22: Fonte 15V 1A Figura 23: Bateria 12V 7Ah

4 ESTAÇÃO METEOROLÓGICA
Devido a complexidade da estação meteorológica o projeto utiliza o arduino modelo
mega que possui uma quantidade maior de memória para suportar o algoritmo da
estação.

4.1 LIGAÇÃO
Os módulos da estação são ligados da seguinte forma:
a) Alimentação 5 volts fornecidos pelo arduino:
- DS1307;
- DHT22;
- ANEMÔMETRO;
- BIRUTA;
- PLUVIÔMETRO; e
- LCD
b) Alimetação 3,3 volts fornecidos pelo arduino:
- BMP180.
c) Pino 5, dados DHT22.
d) Pino 3, dados anemômetro.
e) Pino 2, dados pluviômetro.
f) Comuicação I2C, pino 20 (SDA) e pino 21 (SCL):
- LCD;
- BMP180; e
- DS1307.
g) Pino A2, dados biruta.
h) Pino A3, dados piranômetro.
i) Fonte 9V, pino Vin.
 j) O módulo W5100 é encaixado sobre o arduino conforme Figura 19.

Nas figuras 24 e 25 podemos identificar as ligações entre os módulos e o arduino

mega, cabe ressaltar que o modelo BMP180 funciona com 3,3 volts.

Figua 24: Esquema de ligação dos módulos ao arduino mega.

Figura 25: Estação completa

4.2 PROGRAMA FINAL
Depois de montada e feita todas as ligações entre os módulos e o arduino mega,
basta carregar o programa final junto com as bibliotecas no arduino e iniciar o
funcionamento.
Obs: O programa final e as bibliotecas encontran-se em anexo.

5.0 CONCLUSÃO
A estação funcionou perfeitamente conforme o esperado, manteve seu
funcionamento mesmo com cortes no fornecimento de energia da concessionária,
indicou os dados na tela, gravou os dados no cartão e enviou os dados para
internet sem problemas (Figuras 26, 27 e 28).

Figura 26: Dados gravados no cartão de memória

Figura 27: Tela LCD da estação com a luz acesa.

Figura 28: Canal da estação no site ThingSpeak