Monitoramento de energia do painel solar baseado em Iot usando esp32 e thingspeak

Na área de energia renovável, a energia solar está na vanguarda, porque produzir energia usando a força do sol é a forma mais fácil e comercialmente viável de energia renovável. Falando em painéis solares, a potência de saída de uma saída de painel solar precisa ser monitorada para obter a saída de energia ideal dos painéis. É por isso que um sistema de monitoramento em tempo real se torna necessário. Em uma grande usina de energia solar, ele também pode ser usado para monitorar a saída de energia de cada painel, o que ajuda a identificar o acúmulo de poeira. Também evita quaisquer condições de falha durante o tempo de operação. Em alguns de nossos artigos anteriores, construímos alguns projetos relacionados à energia solar, como um carregador de celular movido a energia solar e um circuito inversor solar, etc. Você pode conferir se estiver procurando por mais projetos de energia solar.

Neste projeto, estaremos fazendo um sistema de monitoramento de energia solar baseado em IoT, incorporando a técnica de carregamento de bateria baseada em MPPT (Maximum Power Point Tracker), que ajudará a reduzir o tempo de carregamento e melhorar a eficiência. Além disso, mediremos a temperatura do painel, a tensão de saída e a corrente para melhorar o aspecto de segurança do circuito. Finalmente, para completar, usaremos os serviços em nuvem ThingSpeak para monitorar os dados de saída de qualquer lugar do mundo. Observe que este projeto é uma continuação do projeto MPPT Solar Charge Controller que construímos anteriormente. Aqui, monitoraremos a tensão, a corrente e a potência de saída do painel usando a placa de desenvolvimento ESP32 IoT.

Escolha dos componentes certos para o monitor de energia solar habilitado para IoT

Com um monitor solar, torna-se muito fácil monitorar e detectar falhas em qualquer sistema solar. É por isso que a seleção de componentes se torna uma parte muito importante ao projetar tal sistema. Dada a seguir está a lista de peças que usamos.

Placa de dev ESP32
Circuito MPPT (pode ser qualquer circuito solar)
Um resistor de derivação (por exemplo 1 Ohm 1 watt - adequado para até 1A de corrente)
Uma bateria de lítio (de preferência 7,4 V).
Conexão Wi-Fi ativa
Sensor de temperatura para o painel solar
Circuito divisor de tensão (veja a descrição)

Esp32 Dev Board:

Para um aplicativo habilitado para IoT, é essencial escolher o tipo certo de placa de desenvolvimento que será capaz de processar os dados de seus pinos analógicos e enviar os dados por meio de qualquer tipo de protocolo de conexão, como Wi-Fi ou para a nuvem servidor. Selecionamos especificamente o ESP32 por ser um microcontrolador de baixo custo com muitos recursos. Além disso, possui um rádio Wi-Fi integrado, através do qual podemos nos conectar à internet com muita facilidade.

Circuito Solar:

Um circuito de carga solar é um circuito que obtém uma tensão mais alta do painel solar e a converte em uma tensão de carga para que possa carregar a bateria com eficiência. Para este projeto, usaremos a placa de circuito do controlador de carga MPPT baseada em LT3562 que já fizemos em um de nossos projetos anteriores. Mas se quiser incorporar esse monitoramento de habilitação de IoT, você pode usar qualquer tipo de circuito solar. Escolhemos esta placa porque o circuito está equipado com Rastreamento de Ponto de Potência Máximo (MPPT), o que é benéfico para projetos de painéis solares de baixa energia. É uma maneira eficiente de carregar uma pequena bateria de lítio de um painel solar.

Resistor Shunt:

Qualquer resistor segue a lei do ohm, o que significa que se uma certa quantidade de corrente flui através do resistor, uma certa quantidade de queda de tensão aparecerá. Os resistores de derivação não são uma exceção a isso e são usados especificamente para medir o fluxo de corrente. Porém, dependendo do fluxo de corrente nominal através do painel solar, escolha um resistor shunt que irá produzir uma quantidade adequada de tensão que pode ser medida pela unidade de microcontrolador. Mas, ao mesmo tempo, a potência do resistor também é uma coisa importante. A seleção da potência do resistor shunt também é importante.

A queda de tensão pode ser calculada usando a fórmula fornecida abaixo. Isso é conhecido como lei de Ohm

V = I x R

V é a tensão que será produzida durante 'I', ou seja, a quantidade de fluxo de corrente através da quantidade de resistor 'R'. Por exemplo, o resistor de 1 ohm produzirá 1 V de queda de tensão quando 1 A de corrente flui por ele.

Para a potência do resistor, a fórmula dada abaixo pode ser usada-

P = I ² R

Onde I é o fluxo máximo de corrente e R é o valor do resistor. Para 1A de corrente com resistor de 1 Ohms, 1 watt é adequado para a dissipação de energia. No entanto, isso é útil para pequenos projetos de painel solar, mas não é adequado para aplicações relacionadas à rede solar. Nesse caso, a técnica de medição de corrente não invasiva é realmente o que precisa ser usado. Nesse caso, o fluxo de corrente pode ser medido com precisão onde uma quantidade muito baixa de corrente, bem como uma quantidade muito alta de corrente, pode ser medida.

Bateria de lítio:

A seleção da bateria de lítio é parte essencial de qualquer projeto que envolva painéis solares. Porque a unidade de microcontrolador que sempre permanece ligada e constantemente verifica e envia os dados requer pelo menos cem miliamperes de corrente para operação estável.

A capacidade da bateria deve ser algo que possa alimentar o microcontrolador por pelo menos 4-5 dias quando o sol não está brilhando por causa da monção. Também é importante que a corrente de carga seja maior do que a corrente de carga da perspectiva da bateria. É bastante incomum se alguém conecta 100mA de carga a uma bateria e fornece uma corrente de carga, que é menor do que isso. Para estar no lado mais seguro, devemos ter pelo menos 5 vezes mais corrente de carga do que a corrente de carga.

Por outro lado, a voltagem da bateria precisa ser maior do que qualquer voltagem de entrada do regulador de voltagem usual que requer para o microcontrolador. Por exemplo, uma bateria de lítio de 7,4 V pode ser conectada ao regulador de voltagem linear de 3,3 V e 5,0 V (já que o regulador linear requer uma queda de tensão mais alta do que o LDO e a comutação.)

Em nosso projeto, usamos uma bateria de 4000mAH com uma classificação de 7,4V. Usamos um regulador de 5,0 V que fornece corrente suficiente e saída de tensão para o ESP32.

Divisor de tensão:

Um divisor de tensão é uma parte essencial da medição de tensão do painel solar. Deve-se escolher um divisor de tensão que irá dividir a tensão de acordo com a entrada de tensão de E / S do microcontrolador.

Escolha os resistores acima de forma que a tensão de saída do divisor de tensão não exceda a tensão máxima de E / S do microcontrolador (3,3 V para ESP32). No entanto, é aconselhável usar um potenciômetro porque ele fornecerá flexibilidade para escolher qualquer painel solar com classificação de tensão mais alta ou mais baixa e pode facilmente definir a tensão usando um multímetro.

No nosso caso, temos um potenciômetro no circuito da placa MPPT que atua como um divisor de tensão. Ajustamos o divisor de tensão com um fator de divisão de 6V. Conectamos dois multímetros, um na entrada e outro na saída do potenciômetro, e configuramos o valor que quando a tensão de entrada for 18V a saída será 3V já que a tensão nominal de saída do painel solar é 18V.

Sensor de temperatura para o painel solar:

A saída de energia do painel solar tem uma conexão direta com a temperatura do painel solar. Por quê? Porque conforme a temperatura de um painel solar começa a aumentar, a corrente de saída do painel solar aumenta exponencialmente, enquanto a saída de tensão começa a reduzir linearmente.

De acordo com a fórmula de potência, a potência é igual a tensão vezes a corrente (W = V x A), diminuindo a tensão de saída também diminui a potência de saída do painel solar mesmo após o aumento do fluxo de corrente. Agora, a próxima pergunta que vem à nossa mente é: como medir a temperatura solar? Bem, é bastante interessante porque os painéis solares são geralmente expostos ao ambiente de calor, pois é exposto à luz solar direta e por razões óbvias. A melhor maneira de medir a temperatura do painel solar é usando um sensor de temperatura de superfície plana. Também é sugerido o uso de um termopar tipo K colocado diretamente no painel solar.

Para nossa aplicação, usamos um módulo sensor de temperatura baseado em termistor, que é mostrado abaixo.

Diagrama de circuito para monitoramento de energia solar baseado em IoT

O diagrama de circuito completo para o IoT Enabled Solar Power Monitor é mostrado abaixo. O esquema é simples. O painel vermelho é o painel MPPT que usamos para este projeto.

Configurando o ThingSpeak

Crie uma conta no ThingSpeak e vá até a opção “meu canal”, depois clique em Novo Canal.

Crie um novo canal com os nomes dos campos.

Agora, depois de definir o campo, vá para o campo Chaves de API, onde a Chave de API de gravação está disponível. Essa chave deve ser fornecida no código, bem como no ID do canal.

O endereço do ThingSpeak pode ser encontrado na mesma página.

Com as etapas acima, você pode configurar o ThingSpeak com muita facilidade. Se você quiser saber mais sobre ThingSpeak e seu processo de configuração, você pode verificar nossos artigos anteriores sobre o assunto.

Código Arduino para monitoramento de energia solar usando ESP32

O código completo de monitoramento de energia solar ESP32 pode ser encontrado na parte inferior desta página. O código começa com a definição de seu SSID, senha e alguns outros parâmetros constantes, conforme mostrado abaixo.

// define WiFi SSID e PWD para uplink. #define WLAN_SSID "xxxx" #define WLAN_PASS "xxxxxxxxxx"

// resistência a 25 graus C # define TERMISTORNOMINAL 10000 // temp. para resistência nominal (quase sempre 25 C) # define TEMPERATURENOMINAL 25 // O coeficiente beta do termistor (geralmente 3000-4000) # define BCOEFFICIENT 3950 // o valor do 'outro' resistor # define SERIESRESISTOR 10000

Os ohms nominais do termistor são fornecidos na temperatura nominal. Defina este valor dependendo da folha de dados do termistor. Coloque o coeficiente Beta e o valor do resistor em série do termistor.

// define analógico para corrente e tensão const int curr_an_pin = 35; const int volt_an_pin = 34; const int ntc_temp_an_pin = 33;

Os PINs são definidos aqui.

#define thingSpeakAddress "xxxxxxxxx" #define channelID xxxxx #define writeFeedAPIKey "xxxxxxx" #define readFeedAPIKey "xxxxxxx" #define readFieldAPIKey "xxxxxxxx" #define readStatusAPIKey "xxxxxxx"

Coloque o thingSpeakAddress, channelID, Write Feed API Key. O resto das coisas não são obrigatórias, mas ainda são úteis se os dados precisam ser recebidos da web.

void setup () { // coloque seu código de configuração aqui, para ser executado uma vez: // defina a porta serial em 115200 Serial.begin (115200); // Inicializar atraso serial (1000); WiFi.mode (WIFI_STA); ThingSpeak.begin (cliente); // Inicialize ThingSpeak // todo: crie uma tarefa para ler um pino para obter corrente e tensão e calcular watt e temperatura do painel solar xTaskCreate ( wifi_task, / * Função de tarefa. * / "Wifi_task", / * String com o nome de tarefa. * / 1024 * 2, / * Tamanho da pilha em bytes. * / NULL, / * Parâmetro passado como entrada da tarefa * / 5, / * Prioridade da tarefa. * / NULL); / * Identificador de tarefa. * / Serial.print ("Leitura de dados."); }

No código acima, o servidor ThingSpeak é inicializado e uma tarefa é criada que irá obter os dados relacionados ao painel solar.

No loop principal, a corrente solar e a tensão são detectadas por meio de um pino analógico e a média é feita.

float solar_curr_adc_val = 0; float solar_volt_adc_val = 0; para (i = 0; i <NUMSAMPLES; i ++) { curr_samples = analogRead (curr_an_pin); volt_samples = analogRead (volt_an_pin); temp_samples = analogRead (ntc_temp_an_pin); atraso (10); } // tirar a média de todas as amostras float curr_avg = 0; float volt_avg = 0; float temp_avg = 0; para (i = 0; i <NUMSAMPLES; i ++) { curr_avg + = curr_samples; volt_avg + = volt_samples; temp_avg + = temp_samples; } curr_avg / = NUMSAMPLES; volt_avg / = NUMSAMPLES; temp_avg / = NUMSAMPLES; //Serial.print("ADC VALUE = "); //Serial.println(ADC_VALUE); // converte o valor adc em voltagens para obter a corrente e a voltagem reais. float solar_curr = (curr_avg * 3.3) / (4095); float solar_volt = (volt_avg * 3.3) / (4095); // usando um divisor de tensão, reduzimos a tensão real. // por esse motivo, multiplicamos 6 pela tensão média para obter a tensão real do painel solar. solar_volt * = 6;

A tensão solar é submetida multiplicando-se por 6, pois criamos o divisor de tensão que dividirá a tensão de entrada por 6 vezes.

A temperatura é gerada a partir do termistor usando uma formação logarítmica.

// converta o valor para resistência temp_avg = 4095 / temp_avg - 1; temp_avg = SERIESRESISTOR / temp_avg; //Serial.print("Thermistor resistência "); //Serial.println(temp_avg); float steinhart; steinhart = temp_avg / THERMISTORNOMINAL; // (R / Ro) steinhart = log (steinhart); // ln (R / Ro) steinhart / = BCOEFFICIENT; // 1 / B * ln (R / Ro) steinhart + = 1.0 / (TEMPERATURENOMINAL + 273,15); // + (1 / To) steinhart = 1.0 / steinhart; // Inverter steinhart - = 273.15; // converter a temperatura absoluta em C

Os dados são lidos a cada 15 segundos.

atraso (1000); contagem ++; Serial.print ("."); if (contagem> = 15) { contagem = 0; Serial.println ("=================================================== ============================== "); Serial.print ("Solar Voltage ="); Serial.println (solar_volt); Serial.print ("Corrente Solar ="); Serial.println (solar_curr); float solar_watt = solar_volt * solar_curr; Serial.print ("Solar Watt ="); Serial.println (solar_watt); Serial.print ("Temperatura Solar ="); Serial.println (steinhart); Serial.println ("=================================================== ============================== ");

Os dados para os respectivos campos são transmitidos usando a função Thing.Speak.setField (); quando o WiFi está conectado.

if (WiFi.status () == WL_CONNECTED) { ThingSpeak.setField (1, solar_volt); ThingSpeak.setField (2, solar_curr); ThingSpeak.setField (3, solar_watt); ThingSpeak.setField (4, steinhart); // escreve no canal ThingSpeak int x = ThingSpeak.writeFields (channelID, writeFeedAPIKey); if (x == 200) { Serial.println ("Atualização dos canais com sucesso."); } else { Serial.println ("Problema ao atualizar o canal. Código de erro HTTP" + String (x)); } } else { Serial.println ("\ r \ n ############################################# ############################## "); Serial.println ("Falha ao atualizar dados para o servidor thingSpeak."); Serial.println ("WiFi não conectado…"); Serial.println ("################################################################################################## ################### \ r \ n "); } Serial.print ("Leitura de dados."); } }

A tarefa Wi-Fi criada no trecho de código abaixo-

void wifi_task (void * parâmetro) { while (1) { if (WiFi.status ()! = WL_CONNECTED) { Serial.print ("Tentando conectar ao SSID:"); Serial.println (WLAN_SSID); enquanto (WiFi.status ()! = WL_CONNECTED) { WiFi.begin (WLAN_SSID, WLAN_PASS); // Conecte-se à rede WPA / WPA2. Altere esta linha se estiver usando a rede aberta ou WEP Serial.print ("."); atraso (5000); } Serial.println ("\ nConnected."); Serial.println (); Serial.println ("WiFi conectado"); Serial.println ("endereço IP:"); Serial.println (WiFi.localIP ()); } vTaskDelay (1000 / portTICK_PERIOD_MS); } vTaskDelete (NULL); }

Dados de teste e monitoramento

O painel solar é conectado ao circuito e colocado à luz do sol para teste, conforme mostrado abaixo.

O funcionamento completo é demonstrado no vídeo abaixo. Nosso circuito foi capaz de ler a tensão de saída, corrente e potência do painel e atualizá-lo ao vivo no canal Thingspeak, conforme mostrado abaixo.

Como podemos ver, os dados de 15 minutos são mostrados no gráfico acima. Como este é um projeto de operação ao ar livre, deve-se usar uma PCB adequada junto com uma caixa fechada. O invólucro deve ser feito de forma que o circuito permaneça à prova d'água na chuva. Para modificar este circuito ou para discutir outros aspectos deste projeto, use o fórum ativo do Circuit Digest. Espero que você tenha gostado do tutorial e aprendido algo útil.