A necessidade de utilizarmos fontes alternativas e renováveis de energia elétrica é cada vez maior, seja para gerar energia elétrica de forma mais sustentável ou para complementar a malha energética atual. Dentre as opções de fontes renováveis de energia, a energia solar é uma das mais relevantes pois, fraco ou forte, praticamente todos os dias há luz solar aproveitável.
Sendo assim, aproveitar essa enorme (e grátis) oferta de energia limpa pode ser fundamental para alimentar e recarregar as baterias de alguns projetos situados em locais remotos e sem acesso à rede elétrica, por exemplo. Porém, como saber, na prática, exatamente o quanto se pode gerar de energia elétrica limpa a partir da luz solar? É justamente isso que o projeto deste artigo irá mostrar: como monitorar a energia elétrica limpa possível de se gerar em um determinado local utilizando como conectividade o SigFox e como carga uma bateria do tipo Li-Ion (1 célula).
Kit RedFox
Este projeto faz uso do kit de desenvolvimento RedFox, de autoria de Luiz Henrique Corrêa Bernardes. O kit de desenvolvimento, vendido junto com o livro “IoT SigFox com Edukit Redfox” (escrito pelo mesmo autor do kit), permite o uso da rede IoT SigFox a partir de um Arduino Nano para programação e como “modem” SigFox um microcontrolador HT32SX, do fabricante nacional HT Micron. Dessa forma, este é um dos poucos kits de desenvolvimento de excelência feitos em grande parte com material nacional. Ainda, o kit conta com 1 ano de conectividade SigFox de forma gratuita, permitindo que você avalie o uso de SigFox.
O kit exige o uso de um Arduino Nano para que o usuário faça a programação do projeto / solução. Isso torna o uso do kit muito simples, pois é possível programá-lo de forma idêntica a um Arduino comum.
O kit e o livro podem ser adquiridos na loja virtual Curto-Circuito, no seguinte endereço: https://www.curtocircuito.com.br/kit-iot-sigfox-com-edukit-redfox.html
Material necessário
Para fazer este projeto, você precisará dos seguintes materiais:
Um kit de desenvolvimento RedFox
Um Arduino Nano V3
Dois ou mais mini-painéis solares de 12V (com quaisquer potências)
Dois ou mais diodos Schottky 1N5819 (um para cada mini-painel solar)
Uma fonte externa confiável de 12V
Um módulo regulador de tensão Step-Down LM2596
Um módulo carregador de baterias TP4056
Uma bateria Li-Ion (1 célula), de qualquer valor de carga (mAh)
Um suporte para bateria Li-Ion (1 célula)
Um sensor de corrente e tensão DC INA219
Uma barra de pinos fêmea 1x40
Jumpers macho-macho e macho-fêmea
Material para solda (ferro de solda, estanho, etc.)
Visão geral - projeto
O projeto consiste em:
Medir, a cada segundo, a tensão e corrente geradas pelos painéis solares.
Com os resultados das medições, calcular a energia elétrica gerada e acumular esse valor ao longo do tempo.
A cada 30 minutos, enviar a energia elétrica total contabilizada (kWh), tensão instantânea (V) e corrente instantânea (mA) geradas com SigFox.
Estas informações, quando recebidas no backend SigFox, serão automaticamente encaminhadas por e-mail.
Circuito esquemático
O circuito esquemático da solução pode ser visto na figura 2. Note que o número de mini-painéis solares fica a sua escolha, lembrando que quanto mais mini-painéis solares utilizar, mais corrente útil para a carga da bateria (e, logo, mais energia elétrica) você terá.
É preciso soldar a barra de pinos fêmea 1x40 na placa RedFox (nos terminais espelhados do Arduino Nano).
Ajuste do módulo regulador step-down LM2596
O módulo regulador step-down LM2596 é capaz de reduzir a tensão de entrada (nível máximo: 40V) para um nível ajustado, fazendo isso com alta eficiência (muito superior que a de um regulador linear como o popular 7805, por exemplo). Dessa forma, perde-se o menos possível de energia gerada, algo essencial em se tratando de energia solar, onde a eficiência dos painéis solares, por natureza, já não é muito alta.
No projeto, este módulo tem como função reduzir a tensão de entrada fornecida pelos painéis (12V, no máximo) para 5V, tensão adequada para o módulo carregador de baterias TP4056 operar. Para que o módulo regulador step-down LM2596 faça seu trabalho, é preciso ajustá-lo através do trimpot em destaque na figura 3.
Este ajuste é feito conforme o seguinte procedimento:
1. Com o auxílio de uma fonte externa confiável de 12V, aplique 12V na entrada (IN+ e IN-) do módulo regulador step-down LM2596.
Importante: aplicar o positivo em IN+ e a referência / negativo / terra / GND / comum em IN-
2. Coloque um multímetro na saída do módulo regulador step-down LM2596.
Importante: colocar a ponteira de referência / negativo / terra / GND / comum em OUT- e a outra ponteira em OUT+
3. Vá girando / ajustando o trimpot até que a tensão de saída medida no multímetro seja igual a 5V.
Medição de tensão e corrente geradas com sensor de corrente e tensão DC INA219
A medição de tensão e corrente úteis geradas pelos mini-painéis solares é feito pelo sensor de corrente e tensão DC INA219. Este sensor é capaz de medir tensões DC (de 0V até 26V) e correntes DC (±3.2A com resolução de 0.8mA), disponibilizando tais medições via interface I²C, interface suportada pela grande maioria dos microcontroladores do mercado atualmente.
Este módulo contém, além do próprio circuito integrado INA219, um resistor shunt de 0,1? e conector KRE para ligação à carga. A ligação (em série) com a carga é feita a partir de Vin+ e Vin-.
Nesse projeto, é lida diretamente a tensão e corrente de saída do módulo step-down LM2596, de forma a ser possível medir e calcular a energia elétrica útil usada para a carga da bateria Li-Ion.
Código-fonte do projeto
O código-fonte do projeto pode ser visto abaixo:
/* Programa: monitoramento de geração de enrgia elétrica
* com painéis solares via SigFox
* Autor: Pedro Bertoleti
*/
#include
#include
/* Definições gerais */
#define BOTAO_PRESSIONADO 0x01
#define BOTAO_SOLTO 0x00
/* Definições - breathing light */
#define TEMPO_BREATHING_LIGHT 500 //ms
/* Definiççao - habilita debug do INA219 */
#define ESCREVE_DEBUG_DO_INA219
/* Definições - comandos AT para o HT32SX */
#define CMD_AT_HT32SX_RESET "AT+RESET;"
#define CMD_AT_HT32SX_RCZ2 "AT+CFGRCZ=2;"
#define CMD_AT_HT32SX_MANDA_BYTES "AT+SEND=0:" //sem downlink
/* Definições - tempo entre envios SigFox */
#define TEMPO_ENTRE_ENVIOS_SIGFOX 1800000 /* 1800000ms = 30 minutos */
/* Definições - GPIOs usados na comunicação com HT32SX*/
#define RESET 4 /* Reset no HT32SX */
#define TX 2 /* Serial TX (Nano -> HT32SX */
#define RX 3 /* Serial RX (Nano
/* Definições - GPIO do LED e do botão */
#define LED 13
#define SW1 5
/* Definições - tempo para debouncing do botão */
#define TEMPO_DEBOUNCING_BOTAO 250 //ms
/* Definições - baudrates das comunicações seriais */
#define BAUDRATE_SERIAL_DEBUG 115200
#define BAUDRATE_SERIAL_HT32SX 9600
/* Definições - INA219 e contabilização de energia */
#define INA219_I2C_ADDR 0x40
/* Objeto para controle da software serial
(para comunicação Nano HT32SX */
SoftwareSerial serial_HT32SX(RX, TX);
/* Objeto para controle do INA219 */
Adafruit_INA219 ina219(INA219_I2C_ADDR);
/* Variáveis globais */
unsigned long timestamp_medicao_energia;
unsigned long timestamp_envio_sigfox;
unsigned long timestamp_breathing_light;
float energia_total_gerada_kwh = 0.0;
float tensao_gerada_V = 0.0;
float corrente_gerada_mA = 0.0;
bool led_aceso = false;
unsigned long contador = 0;
char comando_at_envio_sigfox[50] = {0};
/* Protótipos */
void hardware_reset_HT32SX(void);
void envia_comando_AT_HT32SX(char * pt_comando);
unsigned long diferenca_tempo(unsigned long tref);
char verifica_botao_pressionado(int gpio_botao);
/* Função: reseta (via hardware) o HT32SX
* Parâmetros: nenhum
* Retorno: nenhum
*/
void hardware_reset_HT32SX(void)
{
digitalWrite(RESET, HIGH);
delay(1000);
digitalWrite(RESET, LOW);
delay(100);
}
/* Função: envia comando AT para o HT32SX
* Parâmetros: ponteiro para string de comando
* Retorno: nenhum
*/
void envia_comando_AT_HT32SX(char * pt_comando)
{
char cmd_buffer[50] = {0};
memcpy(cmd_buffer, pt_comando, strlen(pt_comando));
serial_HT32SX.write(cmd_buffer, strlen(cmd_buffer));
serial_HT32SX.flush();
}
/* Função: calcula a diferença entre instante atual e
* uma referência de tempo
* Parâmetros: referência de tempo
* Retorno: diferença de tempo calculada
*/
unsigned long diferenca_tempo(unsigned long tref)
{
return (millis() - tref);
}
/* Função: verifica se o botao foi pressionado
* Parâmetros: GPIO do botão
* Retorno: BOTAO_PRESSIONADO: botão foi pressionado
* BOTAO_SOLTO: botão está solto
*/
char verifica_botao_pressionado(int gpio_botao)
{
char status_botao = BOTAO_SOLTO;
if (digitalRead(gpio_botao) == LOW)
{
/* Confirma se botão foi pressionado */
delay(TEMPO_DEBOUNCING_BOTAO);
if (digitalRead(gpio_botao) == LOW)
{
/* Botão foi realmente pressionado */
status_botao = BOTAO_PRESSIONADO;
}
}
return status_botao;
}
void setup()
{
/* Inicializa as comunicações seriais */
Serial.begin(BAUDRATE_SERIAL_DEBUG);
serial_HT32SX.begin(BAUDRATE_SERIAL_HT32SX);
Serial.println("SigFox - monitor de energia solar");
/* Inicializa GPIOs */
pinMode(RESET, OUTPUT);
digitalWrite(RESET, HIGH);
pinMode(LED, OUTPUT);
digitalWrite(LED, LOW);
pinMode(SW1, INPUT_PULLUP);
/* Inicializa INA219 */
ina219.begin();
/* Reseta HT32SX via hardware, via software e configura zona para RCZ2*/
hardware_reset_HT32SX();
delay(8000);
envia_comando_AT_HT32SX(CMD_AT_HT32SX_RCZ2);
/* Inicializa temporização da medição de energia e
temporização de envio SigFox */
timestamp_medicao_energia = millis();
timestamp_envio_sigfox = millis();
timestamp_breathing_light = millis();
}
void loop()
{
char c;
unsigned char tensao_byte;
short corrente_bytes;
float potencia_kw;
float tensao_shunt;
/* Escreve mensagens recebidas da UART com o HT32SX */
if (serial_HT32SX.available())
{
c = serial_HT32SX.read();
Serial.print(c);
}
/* Pisca breathing light */
if (diferenca_tempo(timestamp_breathing_light) >= TEMPO_BREATHING_LIGHT)
{
if (led_aceso == false)
{
digitalWrite(LED, HIGH);
led_aceso = true;
}
else
{
digitalWrite(LED, LOW);
led_aceso = false;
}
timestamp_breathing_light = millis();
}
/* Verifica se o botão da placa foi pressionado.
Se sim, zera energia gerada acumulada. */
if (verifica_botao_pressionado(SW1) == BOTAO_PRESSIONADO)
{
energia_total_gerada_kwh = 0.0;
Serial.println("[ALERTA] Energia gerada acumulada foi zerada.");
}
/* Contabiliza a energia gerada a cada segundo */
if (diferenca_tempo(timestamp_medicao_energia) >= 1000)
{
tensao_shunt = ina219.getShuntVoltage_mV()/1000.0;
tensao_gerada_V = ina219.getBusVoltage_V() + tensao_shunt;
corrente_gerada_mA = ina219.getCurrent_mA();
potencia_kw = (tensao_gerada_V*corrente_gerada_mA*0.001)*0.001;
energia_total_gerada_kwh = energia_total_gerada_kwh +
potencia_kw/3600.0;
ifdef ESCREVE_DEBUG_DO_INA219
Serial.print("Tensao do resistor shunt: ");
Serial.println(tensao_shunt);
Serial.print("Tensao na carga: ");
Serial.print(tensao_gerada_V);
Serial.println("V");
Serial.print("Corrente: ");
Serial.print(corrente_gerada_mA);
Serial.println("mA");
Serial.print("Potencia instantanea: ");
Serial.print(potencia_kw);
Serial.println("kW");
Serial.print("Energia acumulada: ");
Serial.print(energia_total_gerada_kwh);
Serial.println("kWh");
endif
contador++;
timestamp_medicao_energia = millis();
}
/* Verifica se é o momento de enviar energia gerada acumulada via SigFox */
if (diferenca_tempo(timestamp_envio_sigfox) >= TEMPO_ENTRE_ENVIOS_SIGFOX)
{
Serial.print("Energia gerada acumulada: ");
Serial.print(energia_total_gerada_kwh);
Serial.println("kWh");
/* Reduz a tensao e corrente para 1 byte */
tensao_byte = (unsigned char)(tensao_gerada_V*10.0);
corrente_bytes = (short)(corrente_gerada_mA*10.0);
/* Formata e envia comando AT */
sprintf(comando_at_envio_sigfox, "%s%08lx%02x%04x;", CMD_AT_HT32SX_MANDA_BYTES,
energia_total_gerada_kwh,
tensao_byte,
corrente_bytes);
Serial.print("Comando AT: ");
Serial.println(comando_at_envio_sigfox);
/* Faz envio */
envia_comando_AT_HT32SX(comando_at_envio_sigfox);
timestamp_envio_sigfox = millis();
}
}
Ativação do seu kit na rede SigFox
Para ativar seu kit na rede SigFox, siga as instruções fornecidas no documento do link https://www.newtoncbraga.com.br/arquivos/edukit_redfox_ativacao.pdf . Uma vez ativado o kit na rede SigFox, você irá dispor de uma conta para acesso ao Backend SigFox, onde poderá acompanhar seu dispositivo SigFox (obter as mensagens enviadas, qualidade de transmissão, etc.), gerenciar seus dispositivos SigFox e, ainda, configurar redirecionamento automático dos dados recebidos via callbacks.
Configuração de um callback de e-mail
Um callback serve para repassar / encaminhar automaticamente os dados recebidos de seu dispositivo SigFox para algum e-mail, aplicação ou serviço on-line. O callback é programado pelo usuário, e é executado pela nuvem SigFox assim que um pacote de dados for recebido de seu dispositivo SigFox. Dessa forma, os dados recebidos podem ser direcionados para onde o usuário desejar.
Neste artigo, será utilizado o callback de e-mail, de forma a permitir o acompanhamento dos dados recebidos através de mensagens de e-mail, enviadas diretamente e automaticamente pela nuvem SigFox. Para criar este callback, siga o procedimento abaixo:
1. No Backend SigFox, vá até a aba Device Type e clique sobre o nome de seu dispositivo.
2. Clique em Callbacks, à esquerda, conforme ilustra a figura 4.
3. Clique em New para criar um novo Callback, conforme mostra a figura 5.
4. Uma tela com várias opções de callbacks vai surgir. Escolha a opção Custom Callbacks conforme ilustra a Figura 6.
5. Irá surgir a tela solicitando dados para o callback de e-mail. Preencha conforme mostra a figura 7. Não se esqueça de colocar seu e-mail no lugar de
O custom payload deve ser:
Energia:0:float:32 Tensao:4:uint:8 Corrente:5:uint:16
O corpo da mensagem deve ser:
Energia: {customData#Contador} kWh
Tensão: {customData#Tensao} V
Corrente: {customData#Corrente} mA
Informações do dispositivo e transmissão:
Device ID: {device}
Horário: {time}
SNR: {snr}
Estação Base: {station}
RSSI:{rssi}
N. Sequencial: {seqNumber}
Após o preenchimento, clique em Ok para criar o callback.
6. Agora, todos os dados recebidos pelo dispositivo gerarão uma mensagem para o e-mail configurado, como mostra a figura 8
Conclusão
Neste artigo, você aprendeu a utilizar o kit RedFox, juntamente com circuitaria adicional, para monitorar a energia elétrica (em kWh) gerada por mini-painéis solares, energia essa utilizada para a carga de uma bateria Li-Ion 18650. Isso permite que seja mapeado, com precisão, quanta energia limpa é possível gerar em um local, sendo muito útil para determinar com exatidão a autonomia de um sistema embarcado com bateria e mini-painéis solares naquela área.
Este projeto pode ser modificado e expandido para outros tipos de monitoramento, sendo, portanto, muito útil para monitorar equipamentos e experimentos à distância sem conectividade direta à internet e gastando pouca energia elétrica para isso.
Deseja aprimorar ainda mais esse projeto? Que tal utilizar a plataforma IoT TagoIO para visualizar e processar os dados gerados pelo dispositivo? Veja como fazer isso aqui [COLOCAR LINK PARA ARTIGO COM PROCEDIMENTO DA TAGOIO] IoT SigFox com Edukit Redfox.
