Seguidor solar com Arduino: montagem de dois eixos com 4 LDRs e servos

Um seguidor solar com Arduino é um mecanismo automático que mantém um painel solar apontado para o sol o dia todo: sensores medem de onde vem a luz e um motor gira o painel na direção dela. Uma montagem típica com Arduino usa quatro LDRs (resistores dependentes de luz) e dois servo motores. Os LDRs dizem à placa qual lado está mais claro, e os servos giram o painel para esse lado. Um painel fixo vê o sol de lado de manhã e no fim da tarde e perde uma boa parte da energia disponível, enquanto um painel que segue o sol recebe a luz perto do ângulo reto a qualquer hora do dia.

Neste guia você vai aprender passo a passo a diferença entre seguir o sol em um eixo e em dois eixos, como a diferença de luz é calculada com 4 LDRs, a lógica da zona morta (tolerância) que impede o servo de tremer à toa e a estrutura mecânica que sustenta o painel. Além de código pronto para compilar para Arduino Uno, ESP32 e Raspberry Pi Pico, você também encontra um experimento que mede de verdade o ganho de energia comparando o painel que segue o sol com um fixo, uma lista de peças e dicas para apresentar o projeto em uma feira de ciências.

O que é um seguidor solar e por que ele aumenta a produção?

A potência que um painel produz depende do ângulo com que a luz atinge a superfície dele. Quando a luz chega perpendicular à superfície, o painel capta o máximo de luz; conforme a luz chega inclinada, o mesmo feixe se espalha por uma área maior e a intensidade que o painel vê cai segundo o cosseno do ângulo de incidência. Por isso, a luz que chega 60° fora da perpendicular produz só metade da potência da luz que bate de frente no painel. A tabela abaixo mostra essa perda. Olhando com atenção, você também nota que erros pequenos quase não custam nada: um painel que erra o sol por 5° perde só 0,4% da potência. Você vai precisar desse fato mais adiante, ao escolher a zona morta.

A posição do sol no céu é descrita por dois ângulos: o azimute, que diz em que direção ao longo do horizonte ele está, e a elevação (altitude), que diz a que altura ele está acima do horizonte. Como a Terra gira 15° por hora, o sol se move em média cerca de 1° no céu a cada 4 minutos, enquanto a elevação dele muda muito com as estações. A cerca de 39° norte (mais ou menos a latitude de Washington D.C., Lisboa ou do centro da Turquia), os valores ficam assim:

O azimute é medido no sentido horário a partir do norte. Da tabela saem duas conclusões importantes. No verão, o sol nasce no nordeste e se põe no noroeste, então percorre cerca de 240° ao longo do dia; um servo que gira 180° não consegue ficar totalmente de frente para o sol nas primeiras e nas últimas horas de luz, mas a perda é pequena, porque o sol está baixo e fraco nesses horários. No inverno, o sol fica baixo mesmo ao meio-dia, então um painel fixo voltado para o sul precisa de uma inclinação diferente em cada estação. Um seguidor resolve os dois problemas sozinho. (No hemisfério sul, como no Brasil, as estações se invertem e o sol do meio-dia fica ao norte.)

Um eixo ou dois eixos?

Um seguidor de um eixo acompanha só o movimento do sol de leste para oeste; a inclinação dele é fixa e ajustada para um ângulo adequado à estação. Esse eixo dá a maior parte do ganho, porque o maior movimento diário do sol é de leste para oeste. O seguidor de um eixo também é o tipo mais comum nas grandes usinas solares; os sistemas de dois eixos coletam um pouco mais de energia, mas custam mais e exigem mais manutenção. Para um projeto escolar, porém, dois eixos rendem uma demonstração mais impressionante e são um ótimo problema para aprender a controlar dois eixos ao mesmo tempo.

Medindo a diferença de luz: 4 LDRs e uma parede de sombra

Um único LDR só diz o quanto o ambiente está claro; para achar uma direção, você precisa comparar pelo menos dois LDRs. Em um seguidor de dois eixos, os quatro LDRs ficam em um quadrado 2×2, com um divisor opaco em forma de cruz (+) entre eles, a parede de sombra. Quando o sensor aponta direto para o sol, a parede não faz sombra em nenhum LDR e os quatro veem a mesma luz. Quando o sol se move para um lado, a parede sombreia os LDRs do lado oposto e as leituras deles caem. A altura da parede define a sensibilidade: uma parede de 3 cm faz uma sombra de cerca de 2,6 mm de largura com um desvio de 5° (3 cm × tan 5°), o bastante para cobrir metade de um LDR de 5 mm. Uma parede alta dá um sensor mais sensível, mas mais estreito; uma parede baixa, um sensor mais grosseiro, mas mais amplo. Para ver em detalhes como um LDR funciona, leia sensor de luz LDR.

• Média de cima: (cima à esquerda + cima à direita) / 2
• Média de baixo: (baixo à esquerda + baixo à direita) / 2
• Média da esquerda: (cima à esquerda + baixo à esquerda) / 2
• Média da direita: (cima à direita + baixo à direita) / 2
• Diferença vertical (dV): cima − baixo. Se for positiva, o painel deve inclinar para cima; se for negativa, para baixo.
• Diferença horizontal (dH): esquerda − direita. Se for positiva, o painel deve girar para a esquerda; se for negativa, para a direita.

Seguir o sol com sensores ou com relógio?

Seguir com LDRs não é o único método. Como a posição do sol pode ser calculada antecipadamente a partir da data, da hora e do local, alguns sistemas não usam sensor de luz nenhum. Vamos comparar as três abordagens:

Neste guia montamos a versão por sensores, porque ela não precisa de dados de local nem de hora, é fácil de configurar e corrige sozinha os erros mecânicos. Se quiser levar o projeto adiante, acrescentar depois o seguimento por relógio com um módulo RTC e comparar os dois métodos vira um experimento extra muito forte diante dos avaliadores.

Lista de peças

Ligação: Arduino Uno, ESP32 e Pico

Uma perna de cada LDR vai na alimentação (5V no Uno, 3V3 no ESP32 e no Pico) e a outra perna em um pino analógico; um resistor fixo vai do mesmo pino analógico até o GND. Assim, a leitura sobe conforme a luz aumenta. No lado dos painéis, um resistor de carga (33 Ω) é ligado entre os dois terminais de cada painel. A tensão do painel é dividida por 3,2 com um divisor de 22 kΩ e 10 kΩ antes de chegar ao pino analógico: 22 kΩ do terminal positivo do painel até o pino analógico, 10 kΩ do pino analógico até o GND. O terminal negativo do painel também precisa ir ao GND da placa; sem GND comum, a medição não tem sentido.

Mecânica: suporte pan-tilt e equilíbrio do painel

A solução mecânica mais fácil é um suporte pan-tilt pronto que empilha dois servos SG90: o servo de baixo gira o painel na horizontal (leste–oeste), o servo de cima o inclina na vertical. Monte o bloco de sensores na borda do painel de modo que a face dele fique exatamente paralela à superfície do painel. Se o sensor apontar para uma direção diferente da do painel, o sistema vai seguir o sol perfeitamente enquanto o painel fica sempre alguns graus fora. Um minipainel de 6 V 1 W de 110×60 mm pesa cerca de 22 g; a 3 cm do eixo, isso dá mais ou menos 0,07 kg·cm de torque, bem abaixo dos 1,8 kg·cm do SG90. A carga de verdade é o vento: se for testar ao ar livre, centralize o painel no eixo do servo, use o MG90S de engrenagens metálicas e, para painéis maiores, passe para um servo forte como o MG996R. Deixe uma folga nos cabos para a rotação; um cabo esticado força o servo e solta as ligações. Para o básico de servos, leia O que é um servo motor?.

Montagem passo a passo

1. Solde os quatro LDRs em um pedaço de placa perfurada formando um quadrado 2×2 e cole entre eles um divisor em cruz de papelão ou impresso em 3D, com 2–3 cm de altura; pinte-o de preto fosco ou cubra-o com fita preta.
2. Monte o divisor de cada LDR: LDR da alimentação até o pino analógico, resistor fixo do pino analógico até o GND.
3. Encaixe os servos no suporte pan-tilt, coloque os dois em 90° e parafuse os braços na posição do meio.
4. Fixe o painel e o bloco de sensores no suporte de cima, com as faces paralelas.
5. Monte o circuito de medição do painel: resistor de carga entre os terminais do painel, divisor entre o terminal positivo do painel e o GND, ponto central no A4.
6. Alimente os servos com a fonte externa de 5 V, una todos os GNDs e ligue o capacitor de 470 µF em paralelo com a alimentação dos servos.
7. Carregue primeiro o código de calibração, depois o código de seguimento, e teste o sistema com uma lanterna.

Passo 1: teste e calibre os LDRs

Mesmo LDRs do mesmo saquinho dão leituras bem diferentes sob a mesma luz; o datasheet do GL5528 especifica uma faixa tão larga quanto 10–20 kΩ a 10 lux. Um sensor não calibrado acha que um lado está mais claro mesmo apontando direto para o sol e gira o painel alguns graus para o lado errado. Carregue o código abaixo, abra o Plotter Serial pelo menu Ferramentas e ilumine o bloco de sensores por igual; por exemplo, uma folha de papel branco esticada na frente de uma luminária difunde e uniformiza a luz.

1// 4 LDR'yi okuyup Seri Çizici'ye yazar / reads 4 LDRs for the Serial Plotter
2const int LDR[4] = {A0, A1, A2, A3};   // sol üst, sağ üst, sol alt, sağ alt / TL, TR, BL, BR
3
4void setup() {
5  Serial.begin(9600);
6}
7
8void loop() {
9  for (int i = 0; i < 4; i++) {
10    Serial.print(analogRead(LDR[i]));
11    Serial.print(i < 3 ? '\t' : '\n');  // sekmeyle ayır / separate with tabs
12  }
13  delay(100);
14}

As quatro linhas devem ficar no mesmo nível sob a mesma luz. Digamos que as leituras sejam 612, 640, 598 e 625; a média é 619. A correção de cada LDR é a média menos o próprio valor: +7, −21, +21 e −6. Você coloca esses números no array OFFSET do código do passo 3. Como a resistência de um LDR não muda de forma linear com a luz, calibrar com um nível de luz próximo daquele em que o sistema vai trabalhar de fato dá o resultado mais preciso. O Plotter Serial também mostra o ruído: anote quantas contagens as leituras variam enquanto você não toca em nada, porque vai precisar desse número ao escolher a zona morta.

Passo 2: código do seguidor solar de um eixo

Vamos ver primeiro a lógica em um único eixo. Dois LDRs, separados por uma parede de sombra vertical, ficam voltados para os lados leste e oeste: A0 é o LDR leste e A1 o LDR oeste. O código subtrai uma leitura da outra; se a diferença for maior que a zona morta, o servo gira 1° para o lado mais claro; caso contrário, fica parado. Este sketch curto é um sistema completo de um eixo. Se o painel fugir da luz, troque o angle++ e o angle-- nas duas condições.

1#include <Servo.h>
2
3Servo servo;
4const int LDR_EAST = A0;   // doğu tarafındaki LDR / east-side LDR
5const int LDR_WEST = A1;   // batı tarafındaki LDR / west-side LDR
6const int TOL = 30;        // ölü bölge (ADC birimi) / dead band (ADC counts)
7int angle = 90;            // başlangıç: tam güney / start: due south
8
9void setup() {
10  servo.attach(9);
11  servo.write(angle);
12}
13
14void loop() {
15  int diff = analogRead(LDR_EAST) - analogRead(LDR_WEST);
16  if (diff > TOL && angle < 180) angle++;   // doğu daha aydınlık / east is brighter
17  if (diff < -TOL && angle > 0) angle--;    // batı daha aydınlık / west is brighter
18  servo.write(angle);
19  delay(30);                                // servo yetişsin / let the servo settle
20}

Com delay(30), o servo gira no máximo 1° a cada 30 ms, o que dá cerca de 33° por segundo, então o painel segue fácil uma lanterna durante uma demonstração. O sol se move muito mais devagar, então, no uso real, uma correção a cada poucos segundos basta.

Passo 3: código de dois eixos, zona morta e registro de dados

A versão completa calcula duas diferenças a partir dos quatro LDRs, corrige cada eixo separadamente, estaciona o painel pronto para a manhã quando a noite chega e, uma vez por minuto, escreve no Monitor Serial, em CSV, a tensão, a potência e a energia coletada dos dois painéis. O código usa millis() em vez de delay(), então o seguimento e o registro rodam sem esperar um pelo outro. Os detalhes dessa técnica estão em millis e delay.

1#include <Servo.h>
2
3// Pinler / Pins
4const int LDR[4] = {A0, A1, A2, A3};   // sol üst, sağ üst, sol alt, sağ alt / TL, TR, BL, BR
5const int PANEL_TRACK = A4;            // takip eden panelin bölücüsü / tracking panel divider
6const int PANEL_FIXED = A5;            // sabit panelin bölücüsü / fixed panel divider
7
8// Ayarlar / Settings
9const int OFFSET[4] = {0, 0, 0, 0};    // Adım 1'deki düzeltmeler / corrections from step 1
10const int TOL_START = 40;              // fark bunu aşınca dön / start turning above this
11const int TOL_STOP = 15;               // fark bunun altına inince dur / stop below this
12const int DIR_H = 1, DIR_V = 1;        // ters dönüyorsa -1 yap / set to -1 if it turns away
13const int H_MIN = 0, H_MAX = 180;      // yatay sınırlar / horizontal limits
14const int V_MIN = 10, V_MAX = 90;      // dikey sınırlar / vertical limits
15const int H_PARK = 180, V_PARK = 45;   // gece konumu: doğu (batıda bekliyorsa H_PARK = 0) / night position: east (0 if it waits facing west)
16const int NIGHT = 60;                  // ortalama bunun altındaysa gece / below this average = night
17const float DIVIDER = 3.2;             // (22k + 10k) / 10k
18const float LOAD_OHM = 33.0;           // yük direnci / load resistor
19const unsigned long LOG_MS = 60000;    // kayıt aralığı: 1 dk / log interval: 1 min
20
21Servo servoH, servoV;                  // yatay ve dikey eksen / horizontal and vertical axis
22int angleH = 90, angleV = 45;
23bool movingH = false, movingV = false;
24unsigned long lastStep = 0, lastLog = 0, darkSince = 0;
25float mWhTrack = 0, mWhFixed = 0;      // toplanan enerji / collected energy
26
27int readAvg(int pin) {                 // 8 okumanın ortalaması / average of 8 readings
28  long sum = 0;
29  for (int i = 0; i < 8; i++) sum += analogRead(pin);
30  return sum / 8;
31}
32
33// Ölü bölge + histerezis / dead band + hysteresis
34int correct(int diff, bool &moving, int angle, int dir, int lo, int hi) {
35  if (abs(diff) > TOL_START) moving = true;
36  if (abs(diff) < TOL_STOP) moving = false;
37  if (moving) angle += (diff > 0 ? 1 : -1) * dir;
38  return constrain(angle, lo, hi);
39}
40
41float panelVolts(int pin) {            // bölücüden panel gerilimi / panel voltage from divider
42  return readAvg(pin) * 5.0 / 1023.0 * DIVIDER;
43}
44
45void setup() {
46  Serial.begin(9600);
47  servoH.attach(9);
48  servoV.attach(10);
49  servoH.write(angleH);
50  servoV.write(angleV);
51  Serial.println("dk,V_takip,V_sabit,mW_takip,mW_sabit,mWh_takip,mWh_sabit");
52}
53
54void loop() {
55  unsigned long now = millis();
56
57  if (now - lastStep >= 40) {          // saniyede 25 düzeltme / 25 corrections per second
58    lastStep = now;
59    int v[4];
60    for (int i = 0; i < 4; i++) v[i] = readAvg(LDR[i]) + OFFSET[i];
61    int avg = (v[0] + v[1] + v[2] + v[3]) / 4;
62    int dV = (v[0] + v[1]) / 2 - (v[2] + v[3]) / 2;   // üst - alt / top - bottom
63    int dH = (v[0] + v[2]) / 2 - (v[1] + v[3]) / 2;   // sol - sağ / left - right
64
65    if (avg > NIGHT) {
66      darkSince = now;
67      angleV = correct(dV, movingV, angleV, DIR_V, V_MIN, V_MAX);
68      angleH = correct(dH, movingH, angleH, DIR_H, H_MIN, H_MAX);
69    } else if (now - darkSince > 600000UL) {           // 10 dk karanlık / 10 min of darkness
70      angleH = H_PARK;
71      angleV = V_PARK;
72    }
73    servoH.write(angleH);
74    servoV.write(angleV);
75  }
76
77  if (now - lastLog >= LOG_MS) {       // dakikada bir CSV satırı / one CSV line per minute
78    lastLog = now;
79    float vt = panelVolts(PANEL_TRACK), vf = panelVolts(PANEL_FIXED);
80    float pt = vt * vt / LOAD_OHM * 1000.0;    // P = V² / R (mW)
81    float pf = vf * vf / LOAD_OHM * 1000.0;
82    mWhTrack += pt * LOG_MS / 3600000.0;       // enerji = güç × süre / energy = power × time
83    mWhFixed += pf * LOG_MS / 3600000.0;
84    Serial.print(now / 60000); Serial.print(',');
85    Serial.print(vt, 2); Serial.print(',');
86    Serial.print(vf, 2); Serial.print(',');
87    Serial.print(pt, 1); Serial.print(',');
88    Serial.print(pf, 1); Serial.print(',');
89    Serial.print(mWhTrack, 1); Serial.print(',');
90    Serial.println(mWhFixed, 1);
91  }
92}

Evitando a tremedeira com uma zona morta (tolerância)

Sem zona morta, o sistema nunca descansa. Mesmo apontando direto para o sol, as leituras dos LDRs variam algumas contagens por causa do ruído, a diferença alterna entre mais e menos e o servo fica dando passos de 1° para a direita e 1° para a esquerda. Essa tremedeira desgasta as engrenagens do servo e desperdiça energia. A solução é ignorar as diferenças pequenas: se a diferença estiver abaixo de um certo limite, nada acontece. Use o ruído que você viu na calibração para escolher o limite e faça a zona morta ter pelo menos 3–4 vezes o ruído. No Uno, se o ruído estiver em torno de ±5 contagens, 20–40 é um bom ponto de partida.

O método do código vai um passo além: a histerese. O servo começa a se mover quando a diferença passa de 40, mas só para quando ela cai abaixo de 15. Com uma zona morta de um único limite, o painel para bem na borda do limite e uma nuvem pequena ou uma rajada de vento o põe em movimento de novo; o sistema de dois limites leva o painel bem para cima do sol a cada vez e depois se acalma. O efeito da zona morta na energia também é desprezível: como mostrou a tabela de cossenos, um erro de alguns graus significa uma perda abaixo de 1%. Para mais técnicas de filtragem, veja filtragem de dados de sensores.

Experimento de eficiência: painel que segue o sol vs painel fixo

O único jeito de provar que o seguidor funciona é medir. O erro comum aqui é medir só a tensão de circuito aberto do painel. A tensão sem carga de um painel quase não muda com a luz: quando a luz cai pela metade, a corrente também cai mais ou menos pela metade, mas a tensão de circuito aberto cai só 3–5%. Então os dois painéis mostram cerca de 7 V e a diferença some. O método certo é ligar o mesmo resistor de carga em cada painel e medir a tensão sobre ele. A potência sai de P = V² / R, e a energia, somando a potência ao longo do tempo. Escolha o resistor de carga para o ponto de máxima potência do painel: um painel de 6 V 1 W fornece cerca de 1 / 6 = 0,17 A, então o resistor que combina é 6 / 0,17 ≈ 36 Ω; um de 33 Ω padrão é uma boa escolha. Como o resistor dissipa perto de 1 W em calor, use um resistor cerâmico de pelo menos 2 W, de preferência 5 W. Você pode conferir os números com a calculadora da lei de Ohm.

1. Use dois painéis idênticos: o mesmo modelo, de preferência do mesmo lote. Ligue um resistor de carga de 33 Ω e um divisor de 22 kΩ / 10 kΩ nos dois; o painel que segue o sol vai no A4, o fixo no A5.
2. Faça um pré-teste: monte os dois painéis lado a lado, com a mesma direção e inclinação, e meça por 30–60 minutos. Anote a diferença (por exemplo, 2%) e corrija seus resultados com ela. Melhor ainda: troque os painéis de lugar no segundo dia.
3. Aponte o painel fixo para o sul exato (no hemisfério sul, como no Brasil, para o norte exato) e ajuste a inclinação para o sol do meio-dia daquele dia (veja o aviso abaixo).
4. Coloque os dois painéis afastados o bastante para que nenhum faça sombra no outro nem no sensor, em um lugar sem sombra de árvores ou paredes.
5. Meça uma vez a tensão do painel com um multímetro e compare com a leitura do Arduino; se forem diferentes, corrija o valor de DIVIDER (como usar um multímetro).
6. Registre uma vez por minuto do nascer ao pôr do sol e anote o tempo (céu limpo, parcialmente nublado, nublado).
7. Repita o experimento em pelo menos três dias de céu limpo, registre à parte um dia nublado e compare a energia média diária.

Você pode copiar os dados do Monitor Serial e salvá-los como arquivo CSV ou mandá-los direto para o Excel (enviando dados do Arduino para o Excel); se não quiser ficar ao lado de um computador, acrescente um módulo de cartão SD. No gráfico de um dia de céu limpo, a linha do painel que segue o sol fica claramente acima de manhã e no fim da tarde, enquanto, perto do meio-dia, as duas linhas quase se sobrepõem. Para sistemas grandes, relatam-se ganhos de energia de cerca de 15–35% com um eixo e 30–45% com dois eixos; com uma montagem mini, o resultado depende muito do tempo, da estação e de quão bem o painel fixo está orientado. Deixe claro no relatório que o que você mediu não é a eficiência do painel em si, mas o aumento da energia coletada pelo mesmo painel. Acrescente também uma limitação: com um resistor de carga fixo, a potência muda com o quadrado da corrente, então, conforme a luz enfraquece, a potência do painel cai mais rápido que a luz; por isso, o ganho percentual que você mede pode sair maior que em um sistema real com controlador de carga. Se você também somar e comparar as correntes dos dois painéis (V / R), vai ver de verdade o tamanho da diferença na luz que chega a eles.

Balanço de energia: o sistema consegue se alimentar sozinho?

Esta é a pergunta favorita dos avaliadores. Um seguidor ganha energia, mas também gasta um pouco. Para uma maquete mini, os números aproximados ficam assim:

A tabela deixa claro: uma maquete mini não consegue produzir energia suficiente para alimentar a própria eletrônica. O extra de mais ou menos 1–1,5 Wh ganho com o seguimento é pequeno perto dos cerca de 6 Wh que o Uno gasta por dia. Isso não é um fracasso; é um resultado honesto e valioso. Conforme a escala cresce, o quadro se inverte: o consumo do motor e do controlador que giram painéis de quilowatts vira uma pequena fração da produção. Para cortar o consumo em um sistema mini, corrija uma vez por minuto, solte os servos com detach() quando não estiverem se movendo e escolha, no lugar do Uno, um Pro Mini que entra em sleep ou um ESP32 usando deep sleep. Para estimar a autonomia da bateria, use a calculadora de autonomia da bateria e o guia mAh e Wh.

Seguidor solar com ESP32 e acompanhamento pelo celular

O ESP32 roda a mesma lógica com um ADC mais fino e Wi-Fi. Há algumas diferenças a observar. As leituras analógicas vão de 0 a 4095, então a zona morta fica cerca de 4 vezes a do Uno. Com o Wi-Fi ligado, só os pinos ADC1 (GPIO 32–39) funcionam de forma confiável, porque os pinos ADC2 são usados pelo driver do Wi-Fi. Para os servos, instale a biblioteca ESP32Servo pelo Gerenciador de Bibliotecas. A função analogReadMilliVolts(), usada para medir a tensão do painel, corrige o comportamento não linear do ADC do ESP32 com a calibração de fábrica. Alimente sempre os divisores dos LDRs pelo 3V3. Depois de carregar, abra o endereço IP mostrado no Monitor Serial em um celular conectado à mesma rede e você verá a tensão ao vivo dos dois painéis, a energia coletada e o ganho. Se você está começando com o ESP32, comece por O que é o ESP32?.

1#include <WiFi.h>
2#include <WebServer.h>
3#include <ESP32Servo.h>
4
5const char* ssid = "AgAdi";            // Wi-Fi adın / your Wi-Fi name
6const char* password = "Sifre123";     // Wi-Fi şifren / your Wi-Fi password
7
8const int LDR[4] = {32, 33, 34, 35};   // sol üst, sağ üst, sol alt, sağ alt (ADC1) / TL, TR, BL, BR (ADC1)
9const int PANEL_TRACK = 36;            // VP: takip eden panel / tracking panel
10const int PANEL_FIXED = 39;            // VN: sabit panel / fixed panel
11const int TOL_START = 160, TOL_STOP = 60;  // 12 bit ölçek: Uno'nun 4 katı / 12-bit scale: 4x the Uno
12const int DIR_H = 1, DIR_V = 1;        // ters dönüyorsa -1 yap / set to -1 if it turns away
13const int NIGHT = 240;                 // gece eşiği / night threshold
14const float DIVIDER = 3.2, LOAD_OHM = 33.0;
15
16Servo servoH, servoV;
17WebServer server(80);
18int angleH = 90, angleV = 45;
19bool movingH = false, movingV = false;
20unsigned long lastStep = 0, lastLog = 0;
21float vt = 0, vf = 0, mWhTrack = 0, mWhFixed = 0;
22
23int readAvg(int pin) {
24  long sum = 0;
25  for (int i = 0; i < 8; i++) sum += analogRead(pin);
26  return sum / 8;
27}
28
29float panelVolts(int pin) {            // kalibre edilmiş mV okuması / calibrated mV reading
30  long mv = 0;
31  for (int i = 0; i < 8; i++) mv += analogReadMilliVolts(pin);
32  return mv / 8 / 1000.0 * DIVIDER;
33}
34
35int correct(int diff, bool &moving, int angle, int dir, int lo, int hi) {
36  if (abs(diff) > TOL_START) moving = true;
37  if (abs(diff) < TOL_STOP) moving = false;
38  if (moving) angle += (diff > 0 ? 1 : -1) * dir;
39  return constrain(angle, lo, hi);
40}
41
42void handleRoot() {                    // telefondan izleme sayfası / page for your phone
43  float gain = mWhFixed > 0 ? (mWhTrack - mWhFixed) / mWhFixed * 100.0 : 0;
44  String s = "Takip / tracking: " + String(vt, 2) + " V, " + String(mWhTrack, 1) + " mWh\n";
45  s += "Sabit / fixed: " + String(vf, 2) + " V, " + String(mWhFixed, 1) + " mWh\n";
46  s += "Kazanc / gain: %" + String(gain, 1) + "\n";
47  s += "Aci / angle: H " + String(angleH) + ", V " + String(angleV) + "\n";
48  server.send(200, "text/plain", s);
49}
50
51void setup() {
52  Serial.begin(115200);
53  servoH.setPeriodHertz(50);           // standart servo: 50 Hz / standard servo: 50 Hz
54  servoV.setPeriodHertz(50);
55  servoH.attach(18, 500, 2400);        // 500–2400 µs darbe / pulse
56  servoV.attach(19, 500, 2400);
57  servoH.write(angleH);
58  servoV.write(angleV);
59  WiFi.begin(ssid, password);
60  for (int i = 0; i < 40 && WiFi.status() != WL_CONNECTED; i++) delay(500);  // en fazla 20 s bekle; Wi-Fi yoksa da takip eder / wait up to 20 s; tracks even without Wi-Fi
61  Serial.println(WiFi.localIP());      // bu adresi telefonda aç / open this address on your phone
62  server.on("/", handleRoot);
63  server.begin();
64}
65
66void loop() {
67  server.handleClient();
68  unsigned long now = millis();
69
70  if (now - lastStep >= 40) {
71    lastStep = now;
72    int v[4];
73    for (int i = 0; i < 4; i++) v[i] = readAvg(LDR[i]);
74    int avg = (v[0] + v[1] + v[2] + v[3]) / 4;
75    int dV = (v[0] + v[1]) / 2 - (v[2] + v[3]) / 2;   // üst - alt / top - bottom
76    int dH = (v[0] + v[2]) / 2 - (v[1] + v[3]) / 2;   // sol - sağ / left - right
77    if (avg > NIGHT) {                 // gece hareket etme / do not move at night
78      angleV = correct(dV, movingV, angleV, DIR_V, 10, 90);
79      angleH = correct(dH, movingH, angleH, DIR_H, 0, 180);
80      servoV.write(angleV);
81      servoH.write(angleH);
82    }
83  }
84
85  if (now - lastLog >= 60000) {        // dakikada bir ölç / measure once a minute
86    lastLog = now;
87    vt = panelVolts(PANEL_TRACK);
88    vf = panelVolts(PANEL_FIXED);
89    mWhTrack += vt * vt / LOAD_OHM * 1000.0 / 60.0;   // 1 dakikalık enerji (mWh) / energy of one minute
90    mWhFixed += vf * vf / LOAD_OHM * 1000.0 / 60.0;
91    Serial.printf("%.2f,%.2f,%.1f,%.1f\n", vt, vf, mWhTrack, mWhFixed);
92  }
93}

Se quiser guardar as medições por dias, você pode enviar os mesmos valores para uma planilha on-line; veja registrando dados do ESP32 no Google Sheets. Mais sobre resolução do ADC e tensão de referência está em ADC e conversão analógico-digital.

Seguidor de um eixo com Raspberry Pi Pico e MicroPython

O Pico expõe só três entradas analógicas (GP26, GP27, GP28), o que não basta para quatro LDRs e dois painéis. Por isso, a solução mais limpa com o Pico é um seguidor de um eixo: dois LDRs acham a direção e a terceira entrada analógica mede a tensão do painel. Para dois eixos, você pode acrescentar um ADC I2C externo, como o ADS1115 de 4 canais. O servo é acionado diretamente com PWM de 50 Hz: um pulso de 500 µs significa 0° e um de 2400 µs, 180°. Como o read_u16() retorna valores em uma escala de 0–65535, a zona morta é um número grande, como 2000. Você encontra como instalar o MicroPython no Pico em O que é o Raspberry Pi Pico?.

1from machine import Pin, PWM, ADC
2import time
3
4east = ADC(26)                 # GP26: doğu LDR'si / east LDR
5west = ADC(27)                 # GP27: batı LDR'si / west LDR
6panel = ADC(28)                # GP28: panel bölücüsü / panel divider
7
8servo = PWM(Pin(15))           # GP15: servo sinyali / servo signal
9servo.freq(50)                 # 50 Hz = 20 ms periyot / period
10
11TOL = 2000                     # ölü bölge (0–65535 ölçeği) / dead band (0–65535 scale)
12DIVIDER = 3.2                  # (22k + 10k) / 10k
13LOAD = 33.0                    # yük direnci (ohm) / load resistor (ohm)
14
15def set_angle(a):
16    # 0° = 500 µs, 180° = 2400 µs darbe / pulse
17    servo.duty_ns(int((500 + a * 1900 / 180) * 1000))
18
19def read(adc, n=8):
20    return sum(adc.read_u16() for _ in range(n)) // n
21
22angle = 90
23set_angle(angle)
24energy = 0.0                   # mWh
25last_log = time.ticks_ms()
26
27while True:
28    diff = read(east) - read(west)
29    if diff > TOL and angle < 180:
30        angle += 1             # doğuya dön / turn east
31    elif diff < -TOL and angle > 0:
32        angle -= 1             # batıya dön / turn west
33    set_angle(angle)
34
35    if time.ticks_diff(time.ticks_ms(), last_log) >= 60000:
36        last_log = time.ticks_ms()
37        v = read(panel) * 3.3 / 65535 * DIVIDER
38        p = v * v / LOAD * 1000            # mW
39        energy += p / 60                   # 1 dakikalık enerji / energy of one minute
40        with open("log.csv", "a") as f:    # Pico'nun kendi belleğine yaz / write to Pico's flash
41            f.write("{},{:.2f},{:.1f},{:.1f}\n".format(angle, v, p, energy))
42    time.sleep_ms(30)

O código acrescenta as medições a um arquivo log.csv na própria memória flash do Pico. Uma linha por minuto soma 30–40 KB por dia, então o sistema de arquivos de cerca de 1,4 MB do Pico dura semanas. Se você salvar o arquivo como main.py, o Pico inicia o programa sozinho assim que é alimentado por bateria ou por um adaptador USB, sem computador ligado. No fim do dia, você pode baixar o log.csv para o computador com o Thonny e abri-lo no Excel.

Dicas para apresentar em uma feira de ciências

O seguidor solar é um projeto comum em feiras de ciências e competições escolares; o que faz o seu se destacar não é a maquete em si, mas os seus dados medidos e como você os interpreta. Para ideias de projetos e a estrutura do relatório, veja também ideias de projetos Arduino para feira de ciências.

• Faça uma pergunta mensurável: quanto mais energia, em porcentagem, o seguimento em dois eixos coleta em um dia limpo de outono do que um painel idêntico fixo no melhor ângulo voltado para o sol do meio-dia?
• Escreva a hipótese antes: por exemplo, preveja que o ganho vai se concentrar de manhã e no fim da tarde; mesmo que o resultado não a confirme, discutir o porquê rende pontos.
• Separe as variáveis: a variável independente é o método de seguimento (nenhum, um eixo, dois eixos), a variável dependente é a energia diária (Wh) e as variáveis controladas são o modelo do painel, o resistor de carga, o local e a data.
• Conte com gráficos: um gráfico de linha tempo–potência mostra os dois painéis sobrepostos; compare a energia diária com um gráfico de barras e mostre a variação de um dia para o outro como a sua margem de erro.
• Discuta a energia líquida: meça o consumo do próprio sistema e coloque a tabela do balanço de energia no pôster; isso mostra que o projeto é honesto e científico.
• Não tem sol no salão da feira: faça a demonstração ao vivo com uma lanterna ou um refletor e leve um vídeo em time-lapse do experimento ao ar livre e o arquivo CSV bruto.
• Estruture o pôster: problema, método, esquema do circuito, fluxograma do código, resultados, limitações e sugestões; frases curtas e gráficos grandes em todas as seções.
• Aponte você mesmo as limitações: mencionar limites como o painel pequeno, poucos dias de dados, o vento e as diferenças entre os LDRs antes que os avaliadores perguntem gera confiança.

Erros comuns e soluções

Ideias para levar o projeto adiante

• Estação de carga solar: ligue o painel que segue o sol a um módulo carregador TP4056 e a uma célula 18650 e compare o tempo de carga com o do painel fixo.
• Seguimento híbrido: calcule a posição do sol com um módulo de relógio RTC e use os LDRs só para o ajuste fino; o painel aponta certo mesmo em dias nublados.
• Registro de dados por Wi-Fi: envie as medições do ESP32 para o Google Sheets e acompanhe o gráfico ao vivo no celular.
• Estufa movida a energia solar: use o painel que segue o sol para alimentar a ventoinha e a irrigação de uma maquete de estufa inteligente.
• Rastreador de luz: monte uma versão que varre um único LDR de 0 a 180° com um servo e encontra a direção mais clara; a lógica é muito parecida com a do projeto de radar com Arduino.
• Medição de potência mais precisa: ao lado do resistor de carga, use um sensor de potência I2C como o INA219, que mede corrente e tensão juntas, e trace a curva de potência do painel.

Um seguidor solar reúne em um só projeto leitura de sensores, tomada de decisões, controle de motores e medição científica, o que faz dele uma ótima escolha tanto para aprender quanto para mostrar em uma competição. Comece com um eixo, ajuste a zona morta e depois acrescente o segundo eixo e o experimento com o painel fixo. No app BlueGrays você encontra projetos que permitem testar cada parte desse sistema separadamente, como medição de luz com LDR, luz noturna, controle de ângulo de servo e voltímetro digital, cada um com esquemas do circuito e código.