- Elección de los componentes adecuados para el monitor de energía solar habilitado para IoT
- Diagrama de circuito para el monitoreo de energía solar basado en IoT
- Configuración de ThingSpeak
- Código Arduino para monitoreo de energía solar usando ESP32
- Prueba y monitoreo de datos
En el área de las energías renovables, la energía solar está a la vanguardia, porque producir energía utilizando la energía del sol es la forma más fácil y comercialmente viable de energía renovable. Hablando de paneles solares, la potencia de salida de un panel solar debe ser monitoreada para obtener una potencia óptima de los paneles. Es por eso que se hace necesario un sistema de monitoreo en tiempo real. En una gran planta de energía solar, también se puede usar para monitorear la salida de energía de cada panel, lo que ayuda a identificar la acumulación de polvo. También previene cualquier condición de falla durante el tiempo de operación. En algunos de nuestros artículos anteriores, hemos construido algunos proyectos relacionados con la energía solar, como un cargador de teléfono celular con energía solar y un circuito de inversor solar, etc. Puede consultarlos si está buscando más proyectos sobre energía solar.
En este proyecto, crearemos un sistema de monitoreo de energía solar basado en IoT incorporando la técnica de carga de batería basada en MPPT (Maximum Power Point Tracker), que ayudará a reducir el tiempo de carga y mejorar la eficiencia. Además, mediremos la temperatura del panel, el voltaje de salida y la corriente para mejorar el aspecto de seguridad del circuito. Finalmente, para colmo, usaremos los servicios en la nube ThingSpeak para monitorear los datos de salida desde cualquier lugar del mundo. Tenga en cuenta que este proyecto es una continuación del Proyecto de controlador de carga solar MPPT que construimos anteriormente. Aquí, estaremos monitoreando el voltaje de salida, la corriente y la potencia del panel usando la placa de desarrollo ESP32 IoT.
Elección de los componentes adecuados para el monitor de energía solar habilitado para IoT
Con un monitor solar, es muy fácil monitorear y detectar fallas en cualquier sistema solar. Es por eso que la selección de componentes se convierte en una parte muy importante al diseñar un sistema de este tipo. A continuación se muestra la lista de piezas que utilizamos.
- Placa de desarrollo ESP32
- Circuito MPPT (puede ser cualquier circuito solar)
- Una resistencia de derivación (por ejemplo, 1 ohmio 1 vatio, adecuada para hasta 1 A de corriente)
- Una batería de litio (se prefiere de 7,4 v).
- Conexión Wi-Fi activa
- Sensor de temperatura para el panel solar
- Circuito divisor de voltaje (ver descripción)
Tablero de desarrollo de Esp32:
Para una aplicación habilitada para IoT, es esencial elegir el tipo correcto de placa de desarrollo que podrá procesar los datos de sus pines analógicos y enviar los datos a través de cualquier tipo de protocolo de conexión, como Wi-Fi o la nube. servidor. Seleccionamos específicamente ESP32 ya que es un microcontrolador de bajo costo con toneladas de características. Además, cuenta con radio wifi incorporada a través de la cual podemos conectarnos a internet de forma muy sencilla.
Circuito solar:
Un circuito de carga solar es un circuito que obtiene un voltaje más alto del panel solar y lo convierte en un voltaje de carga para que pueda cargar la batería de manera eficiente. Para este proyecto, utilizaremos la placa de circuito del controlador de carga MPPT basada en LT3562 que ya hemos fabricado en uno de nuestros proyectos anteriores. Pero si desea integrar este monitoreo de habilitación de IoT, puede usar cualquier tipo de circuito solar. Hemos elegido esta placa porque el circuito está equipado con seguimiento del punto de máxima potencia (MPPT) que es beneficioso para proyectos de paneles solares de baja potencia. Es una forma eficiente de cargar una pequeña batería de litio desde un panel solar.
Resistencia de derivación:
Cualquier resistencia sigue la ley de ohmios, lo que significa que si una cierta cantidad de corriente fluye a través de la resistencia, aparecerá una cierta cantidad de caída de voltaje. Las resistencias de derivación no son una excepción a esto y se utilizan específicamente para medir el flujo de corriente. Sin embargo, dependiendo del flujo de corriente nominal a través del panel solar, elija una resistencia de derivación que produzca una cantidad adecuada de voltaje que pueda ser medido por la unidad del microcontrolador. Pero, al mismo tiempo, la potencia de la resistencia también es importante. La selección de la potencia de la resistencia de derivación también es importante.
La caída de voltaje se puede calcular utilizando la fórmula que se proporciona a continuación. Esto se conoce como ley de Ohm.
V = yo x R
V es el voltaje que se producirá durante 'I', es decir, la cantidad de flujo de corriente a través de la cantidad de resistencia 'R'. Por ejemplo, una resistencia de 1 ohmio producirá 1 V de caída de voltaje cuando 1 A de corriente fluya a través de ella.
Para el vataje de la resistencia, se puede usar la fórmula que se proporciona a continuación:
P = I 2 R
Donde I es el flujo de corriente máximo y R es el valor de la resistencia. Para 1 A de corriente con una resistencia de 1 ohmio, 1 vatio es suficiente para la disipación de potencia. Sin embargo, esto es útil para proyectos pequeños de paneles solares, pero no es adecuado para aplicaciones relacionadas con la red solar. En tal caso, la técnica de medición de corriente no invasiva es en realidad lo que debe utilizarse. En tal caso, el flujo de corriente se puede medir con precisión donde se puede medir una cantidad muy baja de corriente, así como una cantidad muy alta de corriente.
Batería de Litio:
La selección de la batería de litio es una parte esencial de cualquier proyecto que involucre paneles solares. Porque la unidad del microcontrolador que siempre permanece encendida y verifica y envía los datos constantemente requiere al menos cien miliamperios de corriente para un funcionamiento estable.
La capacidad de la batería debe ser algo que pueda alimentar el microcontrolador durante al menos 4-5 días cuando el sol no brilla debido al monzón. También es importante que la corriente de carga debe ser mayor que la corriente de carga desde la perspectiva de la batería. Es bastante inusual si alguien conecta 100 mA de carga con una batería y proporciona una corriente de carga, que es menor que eso. Para estar más seguros, deberíamos tener al menos 5 veces más corriente de carga que la corriente de carga.
Por otro lado, el voltaje de la batería debe ser más alto que cualquier voltaje de entrada del regulador de voltaje habitual que requiere el microcontrolador. Por ejemplo, una batería de litio de 7,4 V se puede conectar a un regulador de voltaje lineal de 3,3 V y 5,0 V (ya que el regulador lineal requiere un voltaje de caída más alto que el LDO y la conmutación).
En nuestro proyecto, utilizamos una batería de 4000 mAH con una clasificación de 7,4 V. Usamos un regulador de 5.0V que proporciona suficiente corriente y voltaje de salida para el ESP32.
Divisor de voltaje:
Un divisor de voltaje es una parte esencial de la medición de voltaje del panel solar. Uno debe elegir un divisor de voltaje que dividirá el voltaje según la entrada de voltaje de E / S del microcontrolador.
Elija las resistencias anteriores de tal manera que el voltaje de salida del divisor de voltaje no exceda el voltaje máximo de E / S del microcontrolador (3.3V para ESP32). Sin embargo, se recomienda usar un potenciómetro porque proporcionará flexibilidad para elegir cualquier panel solar con una clasificación de voltaje más alta o más baja y puede configurar fácilmente el voltaje con un multímetro.
En nuestro caso, tenemos un potenciómetro en el circuito de la placa MPPT que actúa como divisor de voltaje. Configuramos el divisor de voltaje con un factor de división de 6V. Conectamos dos multímetros, uno en la entrada y otro en la salida de la olla, y establecemos el valor que cuando el voltaje de entrada sea de 18V la salida será de 3V ya que el voltaje de salida nominal del panel solar es de 18V.
Sensor de temperatura para el panel solar:
La salida de energía del panel solar tiene una conexión directa con la temperatura del panel solar. ¿Por qué? Porque a medida que la temperatura de un panel solar comienza a aumentar, la corriente de salida del panel solar aumenta exponencialmente mientras que la salida de voltaje comienza a reducirse linealmente.
Según la fórmula de potencia, el vataje es igual al voltaje multiplicado por la corriente (W = V x A), la disminución del voltaje de salida también disminuye la potencia de salida del panel solar incluso después del aumento del flujo de corriente. Ahora, la siguiente pregunta que nos viene a la mente es, ¿cómo medir la temperatura solar? Bueno, es bastante interesante ya que los paneles solares generalmente están expuestos al calor del ambiente, ya que están expuestos a la luz solar directa y por razones obvias. La mejor manera de medir la temperatura del panel solar es utilizando un sensor de temperatura de superficie plana. También se sugiere utilizar un termopar tipo K colocado directamente en el panel solar.
Para nuestra aplicación, hemos utilizado un módulo sensor de temperatura basado en termistor, que se muestra a continuación.
Diagrama de circuito para el monitoreo de energía solar basado en IoT
A continuación, se muestra el diagrama de circuito completo para el monitor de energía solar habilitado para IoT. El esquema es simple. El tablero de puntos rojos es el tablero MPPT que usamos para este proyecto.
Configuración de ThingSpeak
Cree una cuenta con ThingSpeak y vaya a la opción "mi canal", luego haga clic en el nuevo canal.
Crea un nuevo canal con los nombres de los campos.
Ahora, después de configurar el campo, vaya al campo Claves de API donde la clave de API de escritura está disponible. Esta clave debe proporcionarse en el código, así como en el ID del canal.
La dirección de ThingSpeak se puede encontrar en la misma página.
Con los pasos anteriores, puede configurar ThingSpeak muy fácilmente. Si desea obtener más información sobre ThingSpeak y su proceso de configuración, puede consultar nuestros artículos anteriores sobre el tema.
Código Arduino para monitoreo de energía solar usando ESP32
El código completo de monitoreo de energía solar ESP32 se puede encontrar en la parte inferior de esta página. El código comienza con la definición de su SSID, contraseña y algunos otros parámetros constantes como se muestra a continuación.
// define WiFi SSID y PWD para enlace ascendente. #define WLAN_SSID "xxxx" #define WLAN_PASS "xxxxxxxxxx"
// resistencia a 25 grados C #define THERMISTORNOMINAL 10000 // temp. para resistencia nominal (casi siempre 25 C) #define TEMPERATURENOMINAL 25 // El coeficiente beta del termistor (generalmente 3000-4000) #define BCOEFFICIENT 3950 // el valor de la 'otra' resistencia #define SERIESRESISTOR 10000
Los ohmios nominales del termistor se proporcionan a la temperatura nominal. Establezca este valor según la hoja de datos del termistor. Ponga el coeficiente Beta y el valor de la resistencia en serie del termistor.
// define Analógico para Corriente y Voltaje const int curr_an_pin = 35; const int volt_an_pin = 34; const int ntc_temp_an_pin = 33;
Los PIN se definen aquí.
#define thingSpeakAddress "xxxxxxxxx" #define channelID xxxxx #define writeFeedAPIKey "xxxxxxx" #define readFeedAPIKey "xxxxxxx" #define readFieldAPIKey "xxxxxxxx" #define readStatusAPIKey "xxxxxxx"
Ponga thingSpeakAddress, channelID, Write Feed API Key. El resto de las cosas no son necesarias, pero siguen siendo útiles si es necesario recibir datos de la web.
void setup () { // ponga su código de configuración aquí, para que se ejecute una vez: // establezca el puerto serie en 115200 Serial.begin (115200); // Inicializar el retardo en serie (1000); Modo WiFi (WIFI_STA); ThingSpeak.begin (cliente); // Inicializar ThingSpeak // todo: crear una tarea para leer un pin para obtener la corriente y el voltaje y calcular los vatios y la temperatura del panel solar xTaskCreate ( wifi_task, / * Función de tarea. * / "Wifi_task", / * Cadena con el nombre de tarea. * / 1024 * 2, / * Tamaño de pila en bytes. * / NULL, / * Parámetro pasado como entrada de la tarea * / 5, / * Prioridad de la tarea. * / NULL); / * Identificador de tareas. * / Serial.print ("Lectura de datos"); }
En el código anterior, el servidor ThingSpeak se inicializa y se crea una tarea que obtendrá los datos relacionados con el panel solar.
En el bucle principal, la corriente solar y el voltaje se detectan a través de un pin analógico y se realiza el promedio.
flotar solar_curr_adc_val = 0; flotar 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); retraso (10); } // promediar todas las muestras de float curr_avg = 0; flotador 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); // convierte el valor de adc en voltajes para obtener la corriente y el voltaje reales. flotar solar_curr = (curr_avg * 3.3) / (4095); flotador solar_volt = (volt_avg * 3.3) / (4095); // Al usar un divisor de voltaje, reducimos el voltaje real. // por esa razón multiplicamos el 6 por el voltaje promedio para obtener el voltaje real del panel solar. solar_volt * = 6;
El voltaje solar se envía multiplicando por 6, ya que creamos el divisor de voltaje que dividirá el voltaje de entrada por 6 veces.
La temperatura se genera a partir del termistor utilizando una formación logarítmica.
// convierte el valor en resistencia temp_avg = 4095 / temp_avg - 1; temp_avg = SERIESRESISTOR / temp_avg; //Serial.print("Resistencia de termistor "); //Serial.println(temp_avg); flotador 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 / Para) steinhart = 1.0 / steinhart; // Invertir steinhart - = 273.15; // convierte la temperatura absoluta a C
Los datos se leen cada 15 segundos.
retraso (1000); contar ++; Serial.print ("."); si (cuenta> = 15) { cuenta = 0; Serial.println ("============================================= ============================ "); Serial.print ("Voltaje solar ="); Serial.println (solar_volt); Serial.print ("Corriente solar ="); Serial.println (solar_curr); flotador solar_watt = solar_volt * solar_curr; Serial.print ("Solar Watt ="); Serial.println (solar_watt); Serial.print ("Temperatura solar ="); Serial.println (steinhart); Serial.println ("=========================================== ============================ ");
Los datos de los campos respectivos se transmiten mediante la función Thing.Speak.setField (); cuando el 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); // escribe en el canal ThingSpeak int x = ThingSpeak.writeFields (channelID, writeFeedAPIKey); if (x == 200) { Serial.println ("Los canales se actualizan correctamente"); } else { Serial.println ("Problema al actualizar el canal. Código de error HTTP" + String (x)); } } más { Serial.println ("\ r \ n ################################### ####################### "); Serial.println ("No se pudieron actualizar los datos a thingSpeak Server."); Serial.println ("WiFi no conectado…"); Serial.println ("########################################## ############### \ r \ n "); } Serial.print ("Lectura de datos"); } }
La tarea de Wi-Fi creada en el siguiente fragmento de código:
void wifi_task (void * parámetro) { while (1) { if (WiFi.status ()! = WL_CONNECTED) { Serial.print ("Intentando conectarse a SSID:"); Serial.println (WLAN_SSID); while (WiFi.status ()! = WL_CONNECTED) { WiFi.begin (WLAN_SSID, WLAN_PASS); // Conéctese a la red WPA / WPA2. Cambie esta línea si utiliza una red abierta o WEP Serial.print ("."); retraso (5000); } Serial.println ("\ nConectado."); Serial.println (); Serial.println ("WiFi conectado"); Serial.println ("dirección IP:"); Serial.println (WiFi.localIP ()); } vTaskDelay (1000 / portTICK_PERIOD_MS); } vTaskDelete (NULL); }
Prueba y monitoreo de datos
El panel solar se conecta con el circuito y se coloca a la luz del sol para realizar pruebas como se muestra a continuación.
El trabajo completo se demuestra en el video a continuación. Nuestro circuito pudo leer el voltaje de salida, la corriente y la potencia del panel y actualizarlo en vivo en el canal de voz como se muestra a continuación.
Como podemos ver, los datos de 15 minutos se muestran en el gráfico anterior. Como se trata de un proyecto de operación al aire libre, es necesario utilizar una placa de circuito impreso adecuada junto con una caja cerrada. El cerramiento debe realizarse de tal manera que el circuito permanezca impermeable bajo la lluvia. Para modificar este circuito o discutir otros aspectos de este proyecto, por favor utilice el foro activo de Circuit Digest. Espero que hayas disfrutado del tutorial y hayas aprendido algo útil.