Seguidor Solar IoT: Gestión Inteligente de Energía con Arduino

Componentes y materiales

Arduino Mega 2560	×	1
Ethernet Shield (Wiznet W5100) para Arduino	×	1
Servomotor SG90	×	2
LDR, 5 Mohm	×	4
Sensor de temperatura y humedad DHT22	×	1
Mini panel solar	×	1
Resistencia 330 Ω	×	4
Resistencia 10 Ω (orificio pasante)	×	2
Resistencia 220 Ω	×	1
LED rojo 5 mm	×	1

Aplicaciones y servicios online

• myDevices Cayenne - Plataforma IoT
• Arduino IDE

Sobre este proyecto

Este proyecto presenta una solución IoT simple y de bajo coste para monitorizar y controlar un sistema de seguimiento solar de doble eje para evaluación de rendimiento.

Descripción del sistema

El sistema propuesto es un seguidor solar de doble eje que puede rotar automáticamente para seguir la posición del sol usando sensores LDR, o manualmente por el usuario a través del panel de control de una aplicación IoT. El sistema detecta la posición del sol (intensidad de luz) mediante sensores LDR y envía los datos al controlador (placa Arduino Mega). Este procesa los datos para comandar los servomotores (SM1 y SM2) que sostienen el panel fotovoltaico para rotar hacia el sol.

Los valores de voltaje y corriente generados por el panel, temperatura y humedad también se envían al Arduino a través de sensores asociados. El Ethernet Shield, montado sobre el Arduino y que permite su conexión a Internet, envía los datos capturados y/o procesados a la nube (servidor web). Finalmente, los datos del seguidor solar (sensores LDR, potencia PV, temperatura y humedad) se muestran en tiempo real en la aplicación de monitorización IoT mediante widgets predefinidos.

La aplicación de monitorización IoT está diseñada usando la plataforma Cayenne myDevices. Una vez que el usuario se conecta a Internet desde su ordenador o smartphone, puede visualizar en el panel de control todos los datos del seguidor solar en sus widgets asociados. Así, el usuario dispone de los datos necesarios vinculados al entorno y rendimiento del panel PV. Además, en modo manual, los servomotores tomarán direcciones angulares desde sus widgets asociados en el panel. Por tanto, el usuario puede controlar su sistema para buscar las mejores condiciones ambientales y extraer la máxima energía del panel PV. La aplicación IoT también está programada para enviar alertas de notificación (SMS o Email) cuando un sensor alcanza un valor umbral predefinido.

Diseño de hardware

Como se muestra en la Fig. 2, el sistema IoT de seguidor solar consiste en un panel PV, dos servomotores, cuatro sensores LDR, un circuito divisor de voltaje, un sensor de temperatura y humedad, un LED y la placa Arduino Mega.

El panel PV usado mide 115 mm x 85 mm con una salida de 1.6 W y puede generar hasta 6 V. Dos servomotores de 180 grados motorizan el seguidor y son controlados por la placa Arduino a través de pines PWM 5 y 6. El servomotor izquierda-derecha (L-R) (MG996R) rota el seguidor en el eje vertical (Este/Oeste), mientras que el servomotor arriba-abajo (U-D) (SG90) lo rota en el eje horizontal (Sur/Norte).

Cuatro LDRs (Cds GL5528) detectan la posición del sol y se fijan en las cuatro esquinas del panel. Los sensores LDR se conectan al Arduino a través de pines analógicos A0 a A3. El LDR es una resistencia cuyo valor disminuye al aumentar la intensidad de luz incidente. El sensor LDR se diseña como un circuito divisor de voltaje. La tensión de salida del divisor es convertida por el microcontrolador del Arduino Mega del valor analógico a digital entre 0 y 1023, ya que el Convertidor Analógico-Digital (ADC) está codificado en 10 bits. El valor de la resistencia en serie en el circuito del sensor LDR es 330 Ω.

La temperatura y humedad se miden mediante el sensor DHT22, que tiene un termistor y un sensor capacitivo de humedad. Su rango de temperatura es de -40 a 80 °C con precisión ±0.5°C, y humedad de 0 a 100% con ±2% (máx ±5%). Usa un hilo de señal para transmitir datos al Arduino (pin digital 2) y dos hilos para alimentación.

El voltaje y corriente PV se miden a través de un circuito divisor de voltaje que actúa también como carga, consistente en dos resistencias en serie de 10 Ω. La salida del divisor se conecta al pin analógico A4 del Arduino. Además, un LED conectado al pin digital 3 refleja el modo del seguidor (manual o automático).

El Arduino Mega con microcontrolador ATmega2560 actúa como controlador embebido que interactúa con el Ethernet Shield y la plataforma de monitorización. El Ethernet Shield, montado sobre la placa Arduino, debe conectarse a un router Wi-Fi (o PC) mediante cable RJ45. El Shield se basa en el chip Ethernet Wiznet W5100 que proporciona una pila de red (IP) para protocolos TCP y UDP.

Diseño de software

a. Arduino IDE

Arduino es una plataforma open-source de prototipado electrónico con hardware y software fáciles de usar. Proporciona un entorno de desarrollo integrado (IDE) con soporte para C y C++. La placa Arduino Mega se programa mediante el IDE que sirve como editor de código, desde donde el programa se sube al microcontrolador por USB.

b. myDevices Cayenne

MyDevices ofrece soluciones IoT y una plataforma end-to-end. Nos centramos en Cayenne, que permite a desarrolladores construir prototipos IoT. Cayenne usa el protocolo MQTT (Message Queuing Telemetry Transport) para conectar dispositivos con la nube de Cayenne. Una vez conectado, el usuario puede enviar y recibir datos del dispositivo al panel de Cayenne vía Widgets. MQTT es un protocolo de mensajería publish-subscribe basado en TCP/IP.

Para usar MQTT con Cayenne, se necesitan las librerías Cayenne. Para Arduino, la librería CayenneMQTT se instala desde el Gestor de Librerías del IDE. Para programar nuestra aplicación IoT basada en Cayenne, aprovechamos funciones predefinidas. Por ejemplo, para establecer la conexión entre la nube de Cayenne y Arduino Mega con el módulo Ethernet, se llama a la librería CayenneMQTTEthernet declarando la información de autenticación (usuario, contraseña y Client ID) obtenida del panel de Cayenne. En el setup, se llama a Cayenne.begin() para establecer la conexión. Para cada actuador, se crea una función con parámetro entero 0-31 llamada imperativamente CAYENNE_IN(VIRTUAL_CHANNEL). Para cada sensor, una función CAYENNE_OUT(VIRTUAL_CHANNEL). En el loop, se llama a Cayenne.loop(), que invoca a las funciones CAYENNE_OUT y CAYENNE_IN. El canal virtual permite vincular widgets de visualización o comando con el sensor o actuador correspondiente.

c. Diseño del software embebido

El software embebido se carga en el Arduino Mega para interactuar entre el módulo Ethernet y la nube de Cayenne. Se diseña así:

(i) Modos de funcionamiento: El sistema tiene dos modos: manual y automático. Un botón en el panel de Cayenne cambia entre modos. Cuando está inactivo = manual, activo = automático. Una función en el código Arduino recupera el estado del botón. El LED en el circuito refleja el estado de este interruptor. Para que el controlador sepa el modo, basta probar el estado del pin donde está el LED: si LOW → función modo manual; si HIGH → función modo automático.

(ii) Modo manual: El usuario controla directamente la posición de los servomotores para orientar el panel PV de este a oeste (servo L-R) o de sur a norte (servo U-D) desde los widgets asociados en el panel de la aplicación IoT. El controlador llama a Cayenne.loop() que ejecuta todas las funciones CAYENNE_IN (incluidas las de servomotores) y CAYENNE_OUT (enviando datos de sensores LDR, corriente/voltaje/potencia PV, temperatura y humedad al servidor para visualización).

(iii) Modo automático: Se ejecuta el algoritmo mostrado en Fig. 4. Comienza leyendo valores analógicos de los sensores LDR, procesa los datos para comandar los servomotores que mueven el panel hacia el sol. En el eje vertical, se comparan los promedios de los dos LDRs izquierdos y dos derechos: si los izquierdos reciben más luz, el panel gira en ese sentido (horario) mediante el servo L-R hasta que la diferencia esté entre -10 y 10 (rango para estabilizar y reducir consumo). Si los derechos reciben más luz, gira antihorario hasta que la diferencia esté en [-10, 10]. El mismo enfoque se usa para el eje horizontal comparando promedios de LDRs superiores e inferiores.

En modo automático, el controlador también llama a Cayenne.loop() para enviar datos a la aplicación IoT.

d. Desarrollo de la aplicación de monitorización IoT

(i) Interfaz de hardware con plataforma Cayenne IoT

Para interfazar hardware (sensores y actuadores) con la plataforma IoT:

1. Iniciar sesión en Cayenne myDevice tras crear cuenta.
2. Clic en "Bring Your Own Things" desde Cayenne API.
3. Copiar credenciales MQTT (usuario, contraseña, client ID) desde "Create App" y pegarlas en el código Arduino. Tras compilar y subir el código, abrir Monitor Serie en Arduino IDE para ver logs de Cayenne. Cuando el dispositivo se conecta, la página se actualiza automáticamente mostrando el dispositivo online.
4. Para interfazar sensores y actuadores (crear widgets): clic en "Add new…", seleccionar "Device/Widget" y "Custom Widgets". Seleccionar widget, completar ajustes (el número de canal debe coincidir con el código), clic en "Add Widget". Se usó widget "value" para sensores, "Button" para cambio de modo y "Slider" para servomotores.

La Fig. 10 ilustra la aplicación IoT diseñada. Una vez establecida la conexión, los datos de sensores se visualizan en sus widgets, el modo de seguimiento (automático/manual) se selecciona desde el botón, y se controlan ángulos de servomotores. Los datos también pueden verse en forma gráfica modificando el tipo de representación o clicando el icono de gráfico sobre el widget.

(ii) Creación de alertas

Un criterio importante en sistemas de monitorización es la capacidad de enviar alertas cuando ocurre un evento. Aprovechamos una función de Cayenne para añadir alertas: se puede preprogramar el envío de notificación (SMS, Email, o ambas) o realizar una acción específica. Por ejemplo, una alerta de temperatura envía email cuando se alcanza un valor umbral. Para crear una alerta: clic en "Add new...", seleccionar "Trigger", configurar evento y acción, clic en "save".

Prototipo

La Fig. 12 muestra el prototipo del seguidor solar en estado desmontado y ensamblado. Consiste en el panel PV, servomotores L-R y U-D y sensores LDR. El panel se une al servo U-D por un lado y con un rodamiento por el otro para mayor flexibilidad al rotar en el eje horizontal. El conjunto se une al servo L-R. Los sensores LDR se fijan en las cuatro esquinas del panel dentro de cilindros huecos. Si el panel no es perpendicular al sol, al menos un LDR quedará cubierto por la sombra del cilindro circundante, creando diferencia de intensidad lumínica. La mejor orientación es cuando las intensidades son iguales en todos los LDRs. La Fig. 13 muestra el prototipo completo del sistema IoT, donde todos los componentes reportados en hardware han sido usados.

Para más detalles sobre resultados, consultar el artículo: https://link.springer.com/chapter/10.1007%2F978-3-030-64565-6_4

Código

Código embebido del sistema de seguidor solar IoT (Arduino)

/***************************************************************
 * PROJECT: IoT based solar tracker system / the embedded software
 * Aboubakr El Hammoumi / aboubakr.elhammoumi@usmba.ac.ma
 ***************************************************************/
#define CAYENNE_PRINT Serial
#include  //CayenneMQTT library
#include  //Servo motor library
#include  //DHT library
#define DHTTYPE DHT22
#define DHTPIN 2
DHT dht(DHTPIN,DHTTYPE);

//MQTT credentials
char username[]="498d2d00-afe2-11ea-883c-638d8ce4c23d";
char password[]="ab4a8f92d94033c01f6e18ce1d8a84d8c304c9c4";
char clientID[]="17798a40-b968-11ea-93bf-d33a96695544";

Servo servo_x; //up-down servomotor
int servoh = 0;
int servohLimitHigh = 170;
int servohLimitLow = 10;
Servo servo_z; //left-right servomotor
int servov = 0;
int servovLimitHigh = 170;
int servovLimitLow = 10;
int topl,topr,botl,botr;
int threshold_value=10;
float Vout;

void setup() {
  Serial.begin(9600);
  Cayenne.begin(username, password, clientID);
  servo_x.attach(5);
  servo_z.attach(6);
  dht.begin();
  pinMode(3,OUTPUT);
  digitalWrite(3,LOW);
}

void loop() {
  topr= analogRead(A2);
  topl= analogRead(A3);
  botl= analogRead(A4);
  botr= analogRead(A5);
  Vout=(analogRead(A1) * 5.0) / 1023;
  Serial.println(" Manual-mode");
  Cayenne.loop();
  
  if (digitalRead(3)==HIGH){
    Serial.println(" Automatic-mode");
    servoh = servo_x.read();
    servov = servo_z.read();
    int avgtop = (topr + topl) / 2;
    int avgbot = (botr + botl) / 2;
    int avgright = (topr + botr) / 2;
    int avgleft = (topl + botl) / 2;
    int diffhori= avgtop - avgbot;
    int diffverti= avgleft - avgright;
    
    /*tracking according to horizontal axis*/
    if (abs(diffhori) <= threshold_value) {
      servo_x.write(servoh); //stop the servo up-down
    }else {
      if (diffhori > threshold_value) {
        Serial.println(" x - 2 ");
        servo_x.write(servoh -2); //Clockwise rotation CW
        if (servoh > servohLimitHigh) {
          servoh = servohLimitHigh;
        }
        delay(10);
      }else {
        servo_x.write(servoh +2); //CCW
        if (servoh < servohLimitLow) {
          servoh = servohLimitLow;
        }
        delay(10);
      }
    }
    
    /*tracking according to vertical axis*/
    if (abs(diffverti) <= threshold_value) {
      servo_z.write(servov); //stop the servo left-right
    }else{
      if (diffverti > threshold_value) {
        servo_z.write(servov -2); //CW
        if (servov > servovLimitHigh) {
          servov = servovLimitHigh;
        }
        delay(10);
      }else{
        servo_z.write(servov +2); //CCW
        if (servov < servovLimitLow) {
          servov = servovLimitLow;
        }
        delay(10);
      }
    }
  }
}

// Cayenne Functions
CAYENNE_IN(8){
  int value = getValue.asInt();
  CAYENNE_LOG("Channel %d, pin %d, value %d", 8, 3, value);
  digitalWrite(3,value);
}

CAYENNE_IN(7){
  //up-down servo motor
  if (digitalRead(3)==HIGH){
    //Automatic_mode
  } else{
    //Manual_mode
    servo_x.write(getValue.asDouble() * 180);
  }
}

CAYENNE_IN(6){
  //left-right servo motor
  if (digitalRead(3)==HIGH){
  } else{
    servo_z.write(getValue.asDouble() * 180);
  }
}

CAYENNE_OUT(0) {
  //Current
  float current = Vout/10;
  Cayenne.virtualWrite(0, current);
  Serial.print("Current: ");
  Serial.println(current);
}

CAYENNE_OUT(1) {
  //Voltage
  float voltage = Vout * 2;
  Cayenne.virtualWrite(1, voltage);
  Serial.print("Voltage: ");
  Serial.println(voltage);
}

CAYENNE_OUT(2){
  //LDR Top-right
  Cayenne.virtualWrite(2, topr);
}

CAYENNE_OUT(3){
  //LDR Top-left
  Cayenne.virtualWrite(3,topl);
}

CAYENNE_OUT(4){
  //LDR Bot-left
  Cayenne.virtualWrite(4,botl);
}

CAYENNE_OUT(5){
  //LDR Bot-right
  Cayenne.virtualWrite(5,botr);
}

CAYENNE_OUT(10) {
  //Power
  float power = (Vout * 2 * Vout)/10 ;
  Cayenne.virtualWrite(10, power);
  Serial.print("Power: ");
  Serial.println(power);
}

CAYENNE_OUT(11){
  //Temperature
  float t = dht.readTemperature();
  Cayenne.virtualWrite(11, t, TYPE_TEMPERATURE, UNIT_CELSIUS);
  Serial.print("temperature: ");
  Serial.println(t);
}

CAYENNE_OUT(12){
  //Humidity
  float h = dht.readHumidity();
  Cayenne.virtualWrite(12, h);
  Serial.print(" humidity: ");
  Serial.println(h);
}

Esquemáticos