Medindo a radiação solar com Arduino
Componentes e suprimentos
 |
| × | 1 | |||
 |
| × | 1 | |||
| × | 1 | ||||
 |
| × | 1 |
Ferramentas e máquinas necessárias
|
Sobre este projeto
Sobre
Existem muitos sensores disponíveis para medir todos os tipos de condições climáticas, como temperatura, umidade, intensidade da luz, etc., mas não existem sensores facilmente disponíveis para medir quantidades de radiação solar. Isso ocorre porque a radiação solar pode ser difícil de medir, embora a sintamos todos os dias em nossa pele.
A irradiância solar é a potência por unidade de área recebida do Sol na forma de radiação eletromagnética na faixa de comprimento de onda do instrumento de medição. A ampla faixa de comprimento de onda do Sol é outro fator que torna difícil a medição.
O instrumento para medir a radiação solar é chamado de Piranômetro. Os piranômetros podem custar de US $ 200 a US $ 800, até mesmo de fornecedores chineses, tornando-os inacessíveis para o amador comum. Você pode ler mais sobre eles aqui:https://en.wikipedia.org/wiki/Pyranometer
Recentemente, estava pensando em comprar um painel solar para minha casa e queria saber se valeria a pena e, por isso, queria estimar a quantidade de energia solar disponível onde moro.
Eu não estava interessado em comprar um piranômetro, então pensei que poderia economizar algum dinheiro e me divertir um pouco ao mesmo tempo, fazendo o meu próprio.
Foi assim que fiz meu próprio gadget bacana, muito mais barato e que pode ajudar a estimar a quantidade de radiação solar. Ele usa alguns componentes facilmente acessíveis e o Arduino para os cálculos. Eu obtive a maior parte dos meus componentes da Chinavasion, mas existem muitos outros lugares onde você pode obter as ferramentas e equipamentos, já que todos estão comumente disponíveis.
Configuração
1. Sua célula solar deve ter 2 fios, um aterrado (preto) e o outro ativo (vermelho). Se você tiver códigos de cores diferentes ou não puder diferenciá-los, verifique com seu multímetro. Conecte as pontas de prova do seu multímetro a ambos os fios, se a tensão exibida for positiva, então o fio ao qual sua ponta de prova do multímetro preta está conectada é o terra, enquanto a vermelha está ligada, se a voltagem for negativa, é o contrário por aí.
2. Conecte o fio terra de sua célula solar ao aterramento do Arduino e o fio VCC a qualquer pino analógico através do resistor que escolhemos. Para este projeto, usaremos o pino analógico A0. O resistor é muito importante para nossos cálculos, pois esperamos que seja muitas vezes maior do que a resistência interna da célula.
Isso é tudo de que precisamos por agora. Passando para a parte de codificação. As células solares geram energia convertendo a energia solar do Sol em energia elétrica, quanto maior a energia (radiação e luz) do sol. Quanto maior será a tensão produzida. Usaremos essa relação diretamente proporcional para estimar a radiação solar.
Os seguintes parâmetros serão necessários:
- Tensão de referência analógica do Arduino =5V (talvez diferente na sua placa)
- Tensão máxima de saída de sua célula solar (isso vai variar dependendo do painel solar que você está usando, você deve verificar para confirmar isso, pois é muito essencial para o nosso cálculo, para a célula solar média da calculadora é em torno de 5V) .
- Dimensão da célula solar. Você pode medir isso usando uma régua (comprimento e com ou quaisquer parâmetros necessários para encontrar a área).
Portanto, estimaremos nossa radiação solar calculando a potência da célula solar e dividindo por sua área.
- Potência =pow (analogRead (A0), 2) / Resistência
- Área =comprimento * largura (assumindo que temos um retângulo)
- radiação solar =potência / área
Aqui está o código de exemplo abaixo:
/ * ------------------------------------------ -------------------------------------------------- ---------------------------- * / # define ANALOG_PIN A0 // Pino analógico # define RESISTÊNCIA 10 // Resistência em milhares de ohms # define PANEL_LENGTH 60 // Comprimento da célula solar em mm # define PANEL_WIDTH 20 // Largura da célula solar em mmvolatile float Area; volatile float Power; volatile float Radiation; / ** Função de configuração principal * / void setup () {// Begin serial communicationSerial.begin (9600); while (! Serial); delay (100);} / ** Função de configuração principal * / void loop () {Area =PANEL_LENGTH * PANEL_WIDTH / (100 * 100); // estamos dividindo por 10000 obtemos a área em metros quadradosPower =pow (analogRead (ANALOG_PIN), 2) / RESISTANCE; // Calculando powerRadiation =Power / Area; char * msg; sprintf (msg, "A radiação solar é% f W / M2", radiação); // Gerando mensagem a ser impressa Serial.println (msg); delay (1000);} / * ---------------------------- -------------------------------------------------- ---------------------------------------------- * / Os valores médios de irradiância para um dia normal podem variar de 150 a 300 W / M2. Mas isso vai variar muito dependendo da sua localização. Pode chegar a 900 em um dia ensolarado ou em áreas ao redor do equador.
Para adicionar funcionalidade de internet, podemos usar o escudo Ethernet. Não precisamos fazer nenhuma outra conexão, apenas montar a blindagem no Arduino e colocar os pinos em suas posições correspondentes na blindagem (ou seja, o pino 1 no Arduino permanece o pino 1 na blindagem)
Código
- amostra de código para piranômetro
- código de função Ethernet
amostra de código para piranômetro Arduino
# define ANALOG_PIN A0 // Pino analógico# define RESISTÊNCIA 10 // Resistência em milhares de ohms
#define PANEL_LENGTH 60 // Comprimento da célula solar em mm
#define PANEL_WIDTH 20 // Largura da célula solar em mm
Área de flutuação volátil;
poder de flutuação volátil;
Radiação flutuante volátil;
/ *
* Função de configuração principal
* /
void setup () {
// Comece a comunicação serial
Serial.begin (9600);
while (! Serial);
atraso (100);
}
/ *
* Função de configuração principal
* /
void loop () {
Área =PANEL_LENGTH * PANEL_WIDTH / (100 * 100); // estamos dividindo por 10.000 obtém a área em metros quadrados
Potência =pow (analogRead (ANALOG_PIN), 2) / RESISTÊNCIA; // Calculando o poder
Radiação =Potência / Área;
char * msg;
sprintf (msg, "A radiação solar é% f W / M2", radiação); // Gerando mensagem a ser impressa
Serial.println (msg);
atraso (1000);
}
Sem visualização (somente download).
Código de função Ethernet Arduino
#include#include
# define ANALOG_PIN A0 // Pino analógico
# define RESISTÊNCIA 10 // Resistência em milhares de ohms
#define PANEL_LENGTH 60 // Comprimento da célula solar em mm
#define PANEL_WIDTH 20 // Largura da célula solar em mm
Área de flutuação volátil;
poder de flutuação volátil;
Radiação flutuante volátil;
// Insira um endereço MAC e um endereço IP para o seu controlador abaixo.
// O endereço IP dependerá da sua rede local:
byte mac [] ={
0xDE, 0x0D, 0x8E, 0xEF, 0xFE, 0xED
};
Endereço IP ip (192, 168, 1, 177);
// Inicialize a biblioteca do servidor Ethernet
// com o endereço IP e a porta que você deseja usar
// (a porta 80 é padrão para HTTP):
Servidor EthernetServer (80);
void setup () {
// Abra as comunicações seriais e espere a porta abrir:
Serial.begin (9600);
while (! Serial) {
; // aguarde a conexão da porta serial. Necessário apenas para porta USB nativa
}
// inicie a conexão Ethernet e o servidor:
Ethernet.begin (mac, ip);
server.begin ();
Serial.print ("o servidor está em");
Serial.println (Ethernet.localIP ());
}
void loop () {
Área =PANEL_LENGTH * PANEL_WIDTH / (100 * 100); // estamos dividindo por 10.000 obtém a área em metros quadrados
Potência =pow (analogRead (ANALOG_PIN), 2) / RESISTÊNCIA; // Calculando o poder
Radiação =Potência / Área;
char * msg;
sprintf (msg, "A radiação solar é% f W / M2", radiação); // Gerando mensagem a ser impressa
// escuta os clientes que chegam
Cliente EthernetClient =server.available ();
if (cliente) {
Serial.println ("novo cliente");
// uma solicitação http termina com uma linha em branco
boolean currentLineIsBlank =true;
while (client.connected ()) {
if (client.available ()) {
char c =client.read ();
Serial.write (c);
// se você chegou ao fim da linha (recebeu uma nova linha
// caractere) e a linha está em branco, a solicitação http terminou,
// então você pode enviar uma resposta
if (c =='\ n' &¤tLineIsBlank) {
// envia um cabeçalho de resposta http padrão
client.println ("HTTP / 1.1 200 OK");
client.println ("Content-Type:text / html");
client.println ("Conexão:fechar"); // a conexão será fechada após a conclusão da resposta
client.println ("Atualizar:5"); // atualiza a página automaticamente a cada 5 segundos
client.println ();
client.println ("");
client.println ("");
/ *
* Enviar mensagem ao cliente
* /
client.print (msg);
client.println ("
");
client.println ("");
pausa;
}
if (c =='\ n') {
// você está começando uma nova linha
currentLineIsBlank =true;
} else if (c! ='\ r') {
// você obteve um personagem na linha atual
currentLineIsBlank =false;
}
}
}
// dê ao navegador da web tempo para receber os dados
atraso (1);
// feche a conexão:
client.stop ();
Serial.println ("cliente desconectado");
}
}
Sem visualização (somente download).
Esquemas
Esquema do painel solar, resistor e conexões
Processo de manufatura
- Medindo a temperatura com RASPBERRY PI
- Monitoramento de CO2 com Sensor K30
- Comunicação para surdos-cegos com 1Sheeld / Arduino
- Aceitar moeda de controle com Arduino
- Arduino com Bluetooth para controlar um LED!
- Sensor capacitivo de impressão digital com um Arduino ou ESP8266
- Brincando com Nextion Display
- Braço robótico controlado por Nunchuk (com Arduino)
- Solar Tracker V2.0
- Roda de medição simples DIY com codificador rotativo