Carregador Solar Portátil com Rastreador Solar Arduino e Controle por Servo

Componentes e Materiais

Arduino UNO	×	1
Servos (Tower Pro MG996R)	×	1
Fotorresistor (LDR)	×	2
Resistor 10k ohm	×	2
Conversor Boost 2.5V para 5V - USB Adaptado	×	1
Painel Solar - Tamanho Hobby	×	2

Ferramentas e Máquinas Necessárias

• Ferro de Solda (genérico)

Aplicativos e Serviços Online

• Arduino IDE

Sobre o Projeto

Indo Verde

Tenho trabalhado na indústria de energia renovável na Austrália e mexido com Arduinos há algum tempo, mas foi apenas neste projeto que finalmente decidi combinar os dois e construir meu próprio pequeno dispositivo solar. Uma pequena observação: este projeto obviamente requer 5V para alimentar o Arduino e o servo, que são usados para maximizar a saída de painéis solares que, na melhor das hipóteses, produzem 3.4V. Então não é exatamente auto-sustentável. No entanto, o conceito é escalável. Se, por exemplo, você usasse este conceito em um array de 8 painéis, produzindo 12V, então você poderia alimentar o Arduino e carregar seu telefone sem fonte de energia externa. Planejo fazer isso um dia e adicionarei um link aqui quando acontecer.

Enquanto estou aqui, é melhor dar crédito às minhas fontes...

• The DIY Life - https://www.the-diy-life.com/arduino-solar-tracker/
• Brown Dog Gadgets - https://www.instructables.com/id/Solar-Altoids-USB-Charger/

Ambos são boas fontes de informação sobre o assunto, e de onde tirei o conceito.

COMEÇANDO

Primeiro, você precisa de alguns painéis solares. Usei dois, embora possa usar quantos quiser, apenas pense em quanto um servo de 9g será capaz de levantar/abaixar (não torne muito pesado). Os painéis que encontrei eram classificados em 1.5V, 0.75W de saída, que está na extremidade inferior disponível hoje. Mas eram leves e baratos e, dado que este é um projeto de prova de conceito para mim, a saída não é super importante.

Uni meus dois painéis na borda com epóxi. Para conectar os painéis em série, apenas solde o fio positivo de um painel ao negativo do outro, o que deve deixar você com um fio positivo e um negativo sobrando. Prenda seus dois LDRs em cada lado do painel solar (Leste e Oeste), e solde uma ponta de um jumper em cada um de seus terminais. É mais fácil soldar um jumper se você cortar a ponta de um lado e descascar o terminal cerca de 5mm para expor os fios.

Para o Arduino ler os LDRs, precisamos de um circuito divisor de tensão para cada. Veja aqui para divisores de tensão. Neste circuito, o LDR é R1, e usamos um resistor de 10kohm para R2, e conectamos jumpers ao Arduino onde os dois resistores se encontram. Se estiver montando este projeto em uma protoboard, um terminal do LDR irá para o divisor de tensão, o outro vai para o rail de alimentação positivo. Veja o diagrama Fritzing abaixo.

A Estrutura do Rastreador

A próxima coisa que você precisa construir é uma estrutura de suporte giratória para o painel sentar. Meu design é basicamente um comprimento de aço de mola suportado por dois frames em A. A parte inferior do array de painéis tem pequenas estruturas de madeira, com furos para o aço de mola. Fiz tudo de madeira balsa para manter barato, fácil e leve, mas se fosse para ser um fixo permanente, você iria querer de aço fino ou madeira compensada tratada. Não documentei bem a construção do suporte giratório, mas o vídeo abaixo deve mostrar como é feito, bem como a localização do servo. Construí o meu com o painel em um ângulo para baixo, de forma a poder apontar a base da estrutura para o norte, então seja qual for a direção que o painel balanceie enquanto rastreia o sol, ele sempre estará inclinado um pouco para o norte para maximizar a saída. (Estou no hemisfério sul)

Montando o Servo

O Servo fica em uma das vigas de suporte da estrutura em A, e levanta/abaixa um lado do painel. Dobrei algum aço de mola com alicates para obter extremidades ganchadas que você pode passar pela estrutura do painel e braço do servo. Pode ser necessário alargar os furos no braço do servo para encaixar o aço. Usei a menor broca que encontrei. Não cole o aço nem no braço do servo nem na estrutura do painel, pois ele deve ser capaz de girar dentro dos furos para o painel subir suavemente. Uma vez no lugar, retire o painel da estrutura, para que apenas o servo permaneça, para que você possa fazer a calibração.

Calibrando o Servo

Abra um novo sketch e insira o seguinte código.

#include <Servo.h>
Servo myservo1; // Cria objeto servo para controlar o servo
int pos = 10;
void setup() {
  myservo1.attach(9); // anexa o objeto servo ao pino PWM 9
}
void loop() {
  myservo1.write(pos);
}

Faça upload para seu Arduino, e veja para onde o servo move. Continue mudando o valor 'pos' entre 0 e 180 no sketch e reenviando o sketch, até encontrar as posições onde o braço do servo aponta reto para cima e para baixo. Esses são seus valores máximo e mínimo. Para mim, foram 15 e 140. Se o valor de alguma forma sobrepor de 180 de volta a 0, retire o braço do servo e reposicione-o para que possa ser alinhado corretamente.

Juntando Tudo

Vá em frente e conecte tudo, e insira o seguinte sketch.

// Sun Tracker Sketch
// Este sketch é projetado para uso com servo 9g, capaz
// de ser alimentado diretamente do Arduino sem fonte
// de energia externa. Para diagrama Fritzing, veja repositório Github
// https://github.com/nickalanf/Arduino--Projects
// A seção Serial Monitor é para propósitos de debug, ou interesse geral,
// uma vez que o dispositivo está funcionando corretamente, pode ser desabilitada
// Sketch por FIELDING - 8/2/18
#include <Servo.h>
Servo servo; // Cria objeto servo para controlar o servo
int eLDRPin = A0; // Atribui pinos aos LDRs
int wLDRPin = A1;
int eastLDR = 0; // Cria variáveis para armazenar leituras dos LDRs
int westLDR = 0;
int difference = 0; // Cria variável para comparar os dois LDRs
int error = 10; // Variável para diferença perceptível entre os dois LDRs
int servoSet = 130; // Variável para posição do servo - será diferente para cada dispositivo
void setup() {
  servo.attach(9); // anexa objeto servo ao pino PWM 9
  Serial.begin(9600);
}
void loop() {
  eastLDR = analogRead(eLDRPin); // Lê valores dos LDRs
  westLDR = analogRead(wLDRPin);
  if (eastLDR < 400 && westLDR < 400) {
    // Verifica se há pouca luz em ambos os LDRs
    while (servoSet <=140 && servoSet >=15) {
      // se sim, envia painéis de volta para leste para o nascer do sol
      servoSet++;
      servo.write(servoSet);
      delay(100);
    }
  }
  difference = eastLDR - westLDR; // Verifica a diferença
  if (difference > 10) {
    // Envia o painel em direção ao LDR com leitura maior
    if (servoSet <= 140) {
      servoSet++;
      servo.write(servoSet);
    }
  } else if (difference < -10) {
    if (servoSet >= 15) {
      servoSet--;
      servo.write(servoSet);
    }
  }
  Serial.print(eastLDR); // Serial monitor útil para debug/configuração
  Serial.print(" - "); // Use para ver se seus LDRs são notavelmente diferentes quando
  Serial.print(westLDR); // Eles têm luz igual brilhando neles, se sim, corrija com o valor error
  Serial.print(" - ");
  Serial.print(difference);
  Serial.print(" - ");
  Serial.print(servoSet); // Ajuste fino das configurações do servo, para maximizar oscilação disponível
  Serial.print(" - ");
  Serial.println(".");
  delay(100);
}

Abra o Monitor Serial e ilumine os LDRs. Tente iluminar uniformemente ambos, e verifique qual o valor da diferença sendo impresso no monitor serial. Se for maior que cerca de 25, ou menor que -25, você precisa adicionar uma calibração de erro. Adicione o valor de erro relevante no código, e então adicione ou subtraia esse valor do LDR relevante. Se os valores de diferença estiverem próximos, deve ficar bem como está.

Você está pronto para testar! O mais fácil é entrar em um quarto escuro e com uma lanterna/lâmpada. Balançe a luz de um LDR lentamente para o outro e observe o painel mover. Você também pode cobrir um LDR e o painel deve balançar para longe daquele.

BÔNUS - CARREGADOR DE TELEFONE

Se você quiser realmente fazer uso da saída dos painéis, pode ligar um conversor boost DC-DC 2.5V-5V diretamente nos fios saindo dos painéis. É um circuito totalmente separado do Arduino/protoboard. Note que um telefone padrão carrega a 5V, e seus painéis podem estar produzindo 5V mas com corrente baixa, então se sua bateria estiver cheia ou a luz solar baixa, você não terá saída suficiente para carregar. A maneira mais fácil de contornar isso é simplesmente adicionar mais painéis!

Código

Sun Tracker Processing

// Sun Tracker Sketch
// Este sketch é projetado para uso com servo 9g, capaz
// de ser alimentado diretamente do Arduino sem fonte
// de energia externa. Para diagrama Fritzing, veja repositório Github
// https://github.com/nickalanf/Arduino--Projects
// A seção Serial Monitor é para propósitos de debug, ou interesse geral,
// uma vez que o dispositivo está funcionando corretamente, pode ser desabilitada
// Sketch por FIELDING - 8/2/18
#include <Servo.h>
Servo servo; // Cria objeto servo para controlar o servo
int eLDRPin = A0; // Atribui pinos aos LDRs
int wLDRPin = A1;
int eastLDR = 0; // Cria variáveis para armazenar leituras dos LDRs
int westLDR = 0;
int difference = 0; // Cria variável para comparar os dois LDRs
int error = 10; // Variável para diferença perceptível entre os dois LDRs
int servoSet = 130; // Variável para posição do servo - será diferente para cada dispositivo
void setup() {
  servo.attach(9); // anexa objeto servo ao pino PWM 9
  Serial.begin(9600);
}
void loop() {
  eastLDR = analogRead(eLDRPin); // Lê valores dos LDRs
  westLDR = analogRead(wLDRPin);
  if (eastLDR < 400 && westLDR < 400) {
    // Verifica se há pouca luz em ambos os LDRs
    while (servoSet <=140 && servoSet >=15) {
      // se sim, envia painéis de volta para leste para o nascer do sol
      servoSet++;
      servo.write(servoSet);
      delay(100);
    }
  }
  difference = eastLDR - westLDR; // Verifica a diferença
  if (difference > 10) {
    // Envia o painel em direção ao LDR com leitura maior
    if (servoSet <= 140) {
      servoSet++;
      servo.write(servoSet);
    }
  } else if (difference < -10) {
    if (servoSet >= 15) {
      servoSet--;
      servo.write(servoSet);
    }
  }
  Serial.print(eastLDR); // Serial monitor útil para debug/configuração
  Serial.print(" - "); // Use para ver se seus LDRs são notavelmente diferentes quando
  Serial.print(westLDR); // Eles têm luz igual brilhando neles, se sim, corrija com o valor error
  Serial.print(" - ");
  Serial.print(difference);
  Serial.print(" - ");
  Serial.print(servoSet); // Ajuste fino das configurações do servo, para maximizar oscilação disponível
  Serial.print(" - ");
  Serial.println(".");
  delay(100);
}

Esquemáticos