Rastreador Solar IoT: Gestão Inteligente de Energia com Arduino

Componentes e Materiais

• 1x Arduino Mega 2560
• 1x Ethernet Shield (Wiznet W5100) para Arduino
• 2x Servomotores SG90 (micro-servo)
• 4x LDR (Fotorresistor) 5 MΩ
• 1x Sensor de Temperatura e Umidade DHT22
• 1x Mini Painel Solar (115×85 mm, 1.6W, até 6V)
• 4x Resistores 330Ω (para divisores de tensão dos LDRs)
• 2x Resistores 10Ω (para medição de tensão/corrente do painel)
• 1x Resistor 220Ω
• 1x LED Vermelho 5mm (indica modo automático/manual)
• Fios jumper, protoboard, cabos de conexão

Software e Serviços Online

• Arduino IDE
• Plataforma myDevices Cayenne (MQTT)

Sobre o Projeto

Este projeto apresenta uma solução IoT de baixo custo para monitorar e controlar um sistema de rastreamento solar de duplo eixo para avaliação de desempenho. O sistema alterna entre modo automático (rastreamento solar via LDRs) e manual (controle remoto via dashboard), enviando dados em tempo real para a nuvem.

Arquitetura do Sistema

O rastreador solar IoT é composto por:

• Sensores de posição solar: 4 LDRs nos cantos do painel detectam a intensidade da luz. A diferença entre os valores médios dos pares (esquerda/direita, topo/base) determina o movimento dos servomotores.
• Atuação: Dois servomotores de 180° — um para eixo horizontal (Leste/Oeste) e outro para eixo vertical (Sul/Norte).
• Monitoramento ambiental: Sensor DHT22 mede temperatura (-40 a 80°C, ±0.5°C) e umidade (0-100%, ±2%).
• Medição elétrica: Circuito divisor de tensão com resistores de 10Ω mede tensão e corrente do painel, calculando a potência.
• Conectividade: Ethernet Shield (W5100) conecta o Arduino à internet via cabo RJ45 para comunicação MQTT com a plataforma Cayenne.
• Indicação local: LED no pino 3 mostra o modo ativo (aceso = automático, apagado = manual).

Design de Hardware

Painel Solar e Servomotores

Painel de 115×85 mm, 1.6W, até 6V. Dois servos: MG996R (eixo vertical, Leste/Oeste) no pino PWM 5 e SG90 (eixo horizontal, Sul/Norte) no pino PWM 6.

Sensores LDR

Quatro LDRs GL5528 nos cantos do painel, conectados aos pinos analógicos A0–A3. Cada LDR forma um divisor de tensão com resistor de 330Ω. O ADC de 10 bits do Arduino converte a tensão em valores 0–1023.

Sensor DHT22

Conectado ao pino digital 2. Usa um fio de sinal e dois de alimentação.

Medição de Tensão/Corrente do Painel

Divisor de tensão com dois resistores de 10Ω em série atua também como carga. Saída no pino analógico A4.

Ethernet Shield e Conectividade

Shield W5100 montado sobre o Arduino Mega, conectado a roteador Wi-Fi via cabo RJ45. Suporta TCP/UDP via stack IP do chip Wiznet.

Design de Software

a. Arduino IDE

Ambiente de desenvolvimento open-source para C/C++. Usado para compilar e fazer upload do firmware para o Arduino Mega via USB.

b. Plataforma myDevices Cayenne

Plataforma IoT baseada no protocolo MQTT (Message Queuing Telemetry Transport). Permite criar dashboards com widgets para visualização de sensores e controle de atuadores. A biblioteca CayenneMQTTEthernet gerencia a conexão.

Fluxo principal:

1. Obter credenciais MQTT (username, password, client ID) no dashboard Cayenne.
2. No setup(), chamar Cayenne.begin() com as credenciais.
3. Para cada atuador: criar função CAYENNE_IN(VIRTUAL_CHANNEL).
4. Para cada sensor: criar função CAYENNE_OUT(VIRTUAL_CHANNEL).
5. No loop(), chamar Cayenne.loop() que invoca automaticamente as funções IN/OUT.

Canais virtuais (0–31) ligam widgets do dashboard a sensores/atuadores físicos.

c. Firmware Embarcado

O firmware implementa dois modos de operação:

Modo Manual

Usuário controla ângulos dos servos via sliders no dashboard Cayenne. O Cayenne.loop() processa comandos de entrada (CAYENNE_IN dos servos) e envia dados dos sensores (CAYENNE_OUT).

Modo Automático

Algoritmo de rastreamento solar (Fig. 4):

1. Ler valores analógicos dos 4 LDRs (topo-esquerda, topo-direita, base-esquerda, base-direita).
2. Calcular médias: topo = (TL+TR)/2, base = (BL+BR)/2, esquerda = (TL+BL)/2, direita = (TR+BR)/2.
3. Eixo horizontal (servo UD): comparar média topo vs base. Diferença > threshold (10) → mover servo. Parar quando diferença ∈ [-10, 10].
4. Eixo vertical (servo LR): comparar média esquerda vs direita. Mesma lógica.
5. Chamar Cayenne.loop() para enviar telemetria.

d. Desenvolvimento da Aplicação de Monitoramento IoT

Interfaceamento Hardware-Cayenne

1. Criar conta no Cayenne myDevices.
2. Selecionar "Bring Your Own Things" na API.
3. Copiar credenciais MQTT e colar no código Arduino.
4. Compilar e fazer upload. Monitorar Serial Monitor para logs de conexão.
5. No dashboard, "Add new → Device/Widget → Custom Widgets":

• Widgets "Value" para sensores (LDRs, tensão, corrente, potência, temperatura, umidade).
• Widget "Button" para chave automático/manual (canal 8).
• Widgets "Slider" para servos UD (canal 7) e LR (canal 6).

Criação de Alertas

O Cayenne permite configurar triggers (gatilhos) para notificações SMS/Email quando sensores ultrapassam limites. Exemplo: alerta de temperatura alta.

1. "Add new..." → "Trigger".
2. Definir evento (ex: temperatura > 40°C) e ação (enviar email).
3. Salvar.

Protótipo

O protótipo inclui painel solar, dois servomotores (L-R e U-D) e LDRs fixados nos cantos dentro de cilindros ocos que criam sombra quando o painel não está perpendicular ao sol. A melhor orientação iguala a intensidade em todos os LDRs.

Para resultados detalhados, consulte o artigo científico: Springer Link

Código Completo

/***************************************************************
 * PROJECT: IoT based solar tracker system / embedded software
 * Aboubakr El Hammoumi / aboubakr.elhammoumi@usmba.ac.ma
 ***************************************************************/
#define CAYENNE_PRINT Serial
#include 
#include 
#include 

#define DHTTYPE DHT22
#define DHTPIN 2
DHT dht(DHTPIN, DHTTYPE);

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

Servo servo_x; // up-down (pino 5)
int servoh = 0;
int servohLimitHigh = 170;
int servohLimitLow = 10;

Servo servo_z; // left-right (pino 6)
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); // LED modo: LOW = manual
}

void loop() {
  // Leitura dos LDRs (A2-A5 no código original, ajustar conforme wiring)
  topr = analogRead(A2);
  topl = analogRead(A3);
  botl = analogRead(A4);
  botr = analogRead(A5);

  // Leitura tensão painel (A1)
  Vout = (analogRead(A1) * 5.0) / 1023;

  Serial.println("Manual-mode");
  Cayenne.loop();

  // Verifica modo via LED no pino 3
  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;    // eixo horizontal (UD)
    int diffverti = avgleft - avgright; // eixo vertical (LR)

    // --- Rastreamento eixo horizontal (servo_x) ---
    if (abs(diffhori) <= threshold_value) {
      servo_x.write(servoh); // para
    } else {
      if (diffhori > threshold_value) {
        // Topo mais iluminado → mover CW
        servo_x.write(servoh - 2);
        if (servoh > servohLimitHigh) servoh = servohLimitHigh;
        delay(10);
      } else {
        // Base mais iluminada → mover CCW
        servo_x.write(servoh + 2);
        if (servoh < servohLimitLow) servoh = servohLimitLow;
        delay(10);
      }
    }

    // --- Rastreamento eixo vertical (servo_z) ---
    if (abs(diffverti) <= threshold_value) {
      servo_z.write(servov); // para
    } else {
      if (diffverti > threshold_value) {
        // Esquerda mais iluminada → CW
        servo_z.write(servov - 2);
        if (servov > servovLimitHigh) servov = servovLimitHigh;
        delay(10);
      } else {
        // Direita mais iluminada → CCW
        servo_z.write(servov + 2);
        if (servov < servovLimitLow) servov = servovLimitLow;
        delay(10);
      }
    }
  }
}

// ===== Funções Cayenne =====

// Canal 8: Botão modo (controla LED pino 3)
CAYENNE_IN(8) {
  int value = getValue.asInt();
  CAYENNE_LOG("Channel %d, pin %d, value %d", 8, 3, value);
  digitalWrite(3, value);
}

// Canal 7: Servo UD (manual)
CAYENNE_IN(7) {
  if (digitalRead(3) == HIGH) {
    // Modo automático: ignora comando manual
  } else {
    servo_x.write(getValue.asDouble() * 180);
  }
}

// Canal 6: Servo LR (manual)
CAYENNE_IN(6) {
  if (digitalRead(3) == HIGH) {
    // Modo automático: ignora
  } else {
    servo_z.write(getValue.asDouble() * 180);
  }
}

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

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

// Canais 2-5: LDRs
CAYENNE_OUT(2) { Cayenne.virtualWrite(2, topr); }  // Top-right
CAYENNE_OUT(3) { Cayenne.virtualWrite(3, topl); }  // Top-left
CAYENNE_OUT(4) { Cayenne.virtualWrite(4, botl); }  // Bot-left
CAYENNE_OUT(5) { Cayenne.virtualWrite(5, botr); }  // Bot-right

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

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

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

Esquemático