Rastreador Solar de Dois Eixos com Arduino UNO – Alinhamento DIY de Painel Solar

Componentes e Materiais

Componente	Quantidade
Arduino UNO	1
Micro servo motor SG90	2
LDR, 5 Mohm	4
Resistor 330 ohm	4
Potenciômetro rotativo (genérico)	1
Chave pushbutton	2
Mini Painel Solar	1

Ferramentas e Máquinas Necessárias

• Arduino IDE
• Parallax PLX-DAQ

Sobre o Projeto

Este projeto apresenta um banco de teste de hardware/software aberto para rastreador solar. O protótipo proposto baseia-se em um rastreador solar de dois eixos controlado com Arduino Uno, uma plataforma de prototipagem de código aberto baseada em hardware e software fáceis de usar. O rastreador solar pode ser controlado automaticamente com a ajuda de sensores LDR (Resistores Dependentes de Luz) ou manualmente usando um potenciômetro. Além disso, este banco de teste fornece instrumentação virtual baseada em Excel, na qual os dados do rastreador solar podem ser registrados e apresentados. O hardware utilizado foi escolhido para ser barato, compacto e versátil. O banco de teste proposto é projetado para ajudar os alunos a desenvolver sua compreensão da teoria de controle e sua aplicação.

Design Mecânico

O modelo CAD 3D do rastreador solar foi projetado no CATIA. É composto pelo painel PV, servomotores esquerda-direita e cima-baixo, e quatro sensores LDR. Para o eixo horizontal, um rolamento é fixado em paralelo com o servomotor cima-baixo para melhor flexibilidade. O rastreador solar é projetado para ter dois graus de liberdade, de leste a oeste pelo servomotor esquerda-direita e de sul a norte pelo servomotor cima-baixo. Os sensores LDR são colocados nos quatro cantos do painel PV e são colocados em tubos escuros com um pequeno orifício no topo para detectar a iluminação do sol. Esses tubos escuros também são considerados concentradores de radiação e são usados para aumentar a robustez do rastreador solar.

Sistema de Hardware

O circuito eletrônico do banco de teste proposto. Para o modo automático, o microcontrolador converte os valores analógicos dos sensores LDR (pinos A0 a A3) em digitais. Em seguida, controla dois servomotores (cima-baixo e esquerda-direita) usando dois sinais PWM (pinos 5 e 6) para rastrear o sol. Os movimentos de rotação ocorrem em dois eixos, em azimute de leste a oeste de acordo com o caminho diário do sol e em elevação de sul a norte de acordo com o caminho sazonal do sol. Para o modo manual, um potenciômetro (pino A4) é usado para controlar o movimento dos dois servomotores, um pushbutton (pino 11) é usado para conectar o potenciômetro ao servomotor cima-baixo ou esquerda-direita. Além disso, outro pushbutton (pino 12) é usado para alternar entre os dois modos. Ademais, a tensão PV é medida através do pino analógico A5 do Arduino, então a corrente PV é calculada já que o resistor de carga é conhecido. Em seguida, a corrente PV, tensão e potência versus tempo e o modo atual são enviados ao computador para apresentação em tempo real no MS Excel.

O circuito do sensor LDR é projetado como um divisor de tensão. A variação na intensidade da luz é proporcional à variação da tensão de saída do divisor. O topo do divisor de potencial é 5 V, o terra é 0 V, e a saída do divisor de tensão é conectada a uma entrada analógica (A0, por exemplo) do microcontrolador. Subsequentemente, o Conversor Analógico-Digital (ADC) do microcontrolador converte o valor analógico lido por A0 em um valor digital entre 0 e 1023 porque o ADC é codificado em 10 bits, e de acordo com este valor, é possível saber o nível de luz. O valor dos resistores usados nos divisores de tensão é 330 Ω.

Dois servomotores de 180 graus são usados. Um servomotor (MG996R) para controlar o rastreador solar de acordo com o eixo vertical, que é o servomotor esquerda-direita. E um micro servo motor (SG90) para controlar o rastreador solar de acordo com o eixo horizontal, que é o servomotor cima-baixo. A vantagem do servomotor é que podemos controlar sua parada, funcionamento, direção de rotação e velocidade usando um único fio de baixa corrente conectado diretamente a uma saída do microcontrolador sem precisar de drivers. Os servomotores usados são controlados pela placa Arduino UNO via cabo elétrico de 3 fios, dois fios para alimentação e um fio para PWM para controlar suas posições.

Design de Software Embarcado

O software embarcado é a peça que será incorporada no hardware (Arduino Uno) para controlar e monitorar o banco de teste do rastreador solar. O software embarcado é projetado para cobrir os seguintes requisitos:

1. O banco de teste tem dois modos: manual e automático. Um pushbutton conectado ao pino 12 alterna entre os dois modos.
2. Se o modo manual estiver ativo, o potenciômetro pode controlar servomotores tanto de leste a oeste para o motor esquerda-direita quanto de sul a norte para o motor cima-baixo. Um pushbutton conectado ao pino 11 alterna o potenciômetro entre os dois motores.
3. Se o modo automático estiver ativo, o algoritmo apresentado será executado. Este usa os valores analógicos retornados pelos sensores LDR. Por exemplo, considerando o azimute ou eixo vertical, os valores médios de dois LDRs direitos e dois LDRs esquerdos são comparados e se o conjunto esquerdo de LDRs recebe mais luz, o rastreador solar mover-se-á nessa direção através do servomotor esquerda-direita. Este continuará a girar até que a diferença esteja no intervalo [−10, 10]. Este intervalo é usado para estabilizar o controlador e uma vez que o rastreador solar está perpendicular ao sol, nenhum controle adicional é feito. Por outro lado, se o conjunto direito de LDRs receber mais luz, o rastreador solar move-se nessa direção através do servomotor esquerda-direita e continuará a girar até que a diferença esteja no intervalo [−10, 10]. A mesma forma é usada para o eixo de elevação. Além disso, também determinamos a radiação média entre os quatro sensores LDR e se este valor for menor que um pequeno valor (8: um valor ajustado e testado na prática e retornado quando a irradiação é nula). Ou seja, a noite chegou. Neste caso, o rastreador solar deve retornar à posição do nascer do sol. Por exemplo, se a posição do nascer do sol pode ser alcançada definindo 0 graus no servomotor esquerda-direita e 30 graus no servomotor cima-baixo. Isso pode ser feito facilmente através da função C “servox.write(ângulo)” fornecida pela Arduino IDE.
4. A tensão PV adquirida através do pino analógico A5 deve ser tratada e usada para calcular a corrente e potência PV. Então todos esses dados e o modo atual devem ser enviados através de um cabo USB ao computador e apresentados no MS Excel.

PLX-DAQ

A macro PLX-DAQ Excel é usada para aquisição de dados do microcontrolador Arduino para uma planilha Excel. Basta baixá-la. Após a instalação, uma pasta chamada "PLX-DAQ" será criada automaticamente no PC, contendo um atalho chamado "PLX-DAQ Spreadsheet". Então, para estabelecer a comunicação entre a placa e o Excel, basta abrir a Planilha e definir as configurações de conexão (Baud rate e porta) na janela PLX-DAQ. Após clicar em "connect", os dados de saída serão coletados e exibidos em tempo real na Planilha Excel.

O Protótipo

O rastreador solar em estados desmontado e montado. Toda a estrutura foi fabricada usando placas de madeira, e todos os componentes mencionados foram usados para construir o rastreador solar com modos manual e automático (sensores LDR, Arduino Uno, servomotores, potenciômetro, pushbuttons e o pequeno painel PV).

O banco de teste completo: rastreador solar com instrumentação virtual e uma lâmpada artificial que pode expor luz para testar o rastreador solar. O rastreador solar e o computador são conectados através de um cabo USB. Uma vez que a tensão PV é adquirida, o controlador trata essa informação e a usa para calcular a corrente e potência PV. Então, todos esses dados são enviados ao computador para apresentação no MS Excel. O banco de teste proposto é pequeno, flexível e fácil de usar. Pode permitir que alunos, pesquisadores e engenheiros apliquem seus algoritmos de forma fácil antes de prosseguir com a implementação de um grande dispositivo de rastreamento solar.

Código

Software Embarcado do Banco de Teste do Rastreador Solar

//Biblioteca de motor servo
#include 
//Inicializa variáveis
int mode = 0;
int axe = 0;
int buttonState1 = 0;
int buttonState2 = 0;
int prevButtonState1 = 0;
int prevButtonState2 = 0;
int ldrtopr= 0; // LDR superior direito
int ldrtopl = 1; // LDR superior esquerdo
int ldrbotr = 2; // LDR inferior direito
int ldrbotl = 3; // LDR inferior esquerdo
int topl = 0;
int topr = 0;
int botl = 0;
int botr = 0;
//Declara dois servos
Servo servo_updown;
Servo servo_rightleft;
int threshold_value=10; // sensibilidade de medição
void setup() {
  Serial.begin(9600);
  Serial.println("CLEARDATA");
  Serial.println("LABEL,t,voltage,current,power,Mode");
  pinMode(12, INPUT); // Botão de modo
  pinMode(11, INPUT); // Botão de eixo
  pinMode(A4, INPUT); // Potenciômetro para movimento direita-esquerda e cima-baixo
  servo_updown.attach(5); // Servo motor movimento cima-baixo
  servo_rightleft.attach(6); // Servo motor movimento direita-esquerda
}
void loop() {
  char Mode;
  float volt = analogRead(A5)*5.0/1023;
  float voltage = 2*volt; // Volt=(R1/R1+R2)*Voltage / R1=R2=10Ohms => voltage=2*volt
  float current = voltage/20; // I=voltage/(R1+R2)
  float power = voltage*current;
  Serial.print("DATA,TIME,");
  Serial.print(voltage);
  Serial.print(",");
  Serial.print(current);
  Serial.print(",");
  Serial.print(power);
  Serial.print(",");
  buttonState1 = digitalRead(12);
  if (buttonState1 != prevButtonState1) {
    if (buttonState1 == HIGH) {
      if (mode == 1) { mode = 0; }
      else { mode = 1; }
    }
  }
  prevButtonState1 = buttonState1;
  delay(50);
  if (mode == 0) {
    Mode='M';
    Serial.println(Mode);
    manualsolartracker();
  } else {
    Mode = 'A';
    Serial.println(Mode);
    automaticsolartracker();
  }
}
void automaticsolartracker(){
  topr= analogRead(ldrtopr);
  topl= analogRead(ldrtopl);
  botr= analogRead(ldrbotr);
  botl= analogRead(ldrbotl);
  int avgtop = (topr + topl) / 2;
  int avgbot = (botr + botl) / 2;
  int avgleft = (topl + botl) / 2;
  int avgright = (topr + botr) / 2;
  int diffelev = avgtop - avgbot;
  int diffazi = avgright - avgleft;
  if (abs(diffazi) >= threshold_value){
    if (diffazi > 0) {
      if (servo_rightleft.read() < 180) {
        servo_rightleft.write((servo_updown.read() + 2));
      }
    }
    if (diffazi < 0) {
      if (servo_rightleft.read() > 0) {
        servo_rightleft.write((servo_updown.read() - 2));
      }
    }
  }
  if (abs(diffelev) >= threshold_value){
    if (diffelev > 0) {
      if (servo_updown.read() < 180) {
        servo_updown.write((servo_rightleft.read() - 2));
      }
    }
    if (diffelev < 0) {
      if (servo_updown.read() > 0) {
        servo_updown.write((servo_rightleft.read() + 2));
      }
    }
  }
}
void manualsolartracker(){
  buttonState2 = digitalRead(13);
  if (buttonState2 != prevButtonState2) {
    if (buttonState2 == HIGH) {
      if (axe == 1) { axe = 0; }
      else { axe = 1; }
    }
  }
  prevButtonState2 = buttonState2;
  delay(50);
  if (axe == 0) {
    servo_rightleft.write(map(analogRead(A4), 0, 1023, 0, 180));
  } else {
    servo_updown.write(map(analogRead(A4), 0, 1023, 0, 180));
  }
}

Esquemáticos

Diagrama de conexões do rastreador solar de dois eixos.