Seguidor solar con Arduino: dos ejes con 4 LDR, servos y código

Un seguidor solar con Arduino es un mecanismo automático que mantiene una placa solar orientada hacia el sol durante todo el día: unos sensores miden de dónde viene la luz y un motor gira el panel hacia ella. Un montaje típico con Arduino usa cuatro LDR (resistencias dependientes de la luz) y dos servomotores. Las LDR le dicen a la placa qué lado está más iluminado y los servos giran el panel hacia ese lado. Un panel fijo ve el sol de lado por la mañana y por la tarde y desperdicia buena parte de la energía, mientras que un panel con seguimiento recibe la luz casi en ángulo recto a cualquier hora del día.

En esta guía aprenderás paso a paso la diferencia entre el seguimiento de un eje y de dos ejes, cómo se calcula la diferencia de luz con 4 LDR, la lógica de la zona muerta (tolerancia) que evita que el servo vibre sin motivo y la estructura mecánica que sostiene el panel. Además de código listo para compilar en Arduino Uno, ESP32 y Raspberry Pi Pico, encontrarás un experimento que mide de verdad la ganancia de energía comparando el panel con seguimiento con uno fijo, la lista de materiales y consejos para presentar el proyecto en una feria de ciencias.

¿Qué es un seguidor solar y por qué aumenta la producción?

La potencia que produce un panel depende del ángulo con el que la luz llega a su superficie. Cuando la luz incide perpendicularmente, el panel capta la mayor cantidad; cuanto más inclinada llega, más se reparte el mismo haz sobre una superficie mayor y la irradiancia que recibe el panel disminuye según el coseno del ángulo de incidencia. Por eso la luz que llega desviada 60° de la perpendicular produce solo la mitad de potencia que la luz que incide de frente. La tabla siguiente muestra esta pérdida. Si la miras con atención verás también que los errores pequeños casi no cuestan nada: un panel que se desvía 5° del sol pierde solo el 0,4 % de su potencia. Te servirá más adelante para elegir la zona muerta.

La posición del sol en el cielo se describe con dos ángulos: el azimut, que indica en qué dirección del horizonte está, y la altura (elevación), que indica cuánto se eleva sobre el horizonte. Como la Tierra gira 15° por hora, el sol se desplaza de media alrededor de 1° cada 4 minutos, mientras que su altura cambia mucho con las estaciones. A unos 39° de latitud norte (la latitud de Valencia y, casi, de Madrid) los valores son estos:

El azimut se mide desde el norte en el sentido de las agujas del reloj. De la tabla salen dos conclusiones importantes. En verano el sol sale por el noreste y se pone por el noroeste, así que recorre unos 240° a lo largo del día; un servo que gira 180° no llega a orientarse del todo hacia el sol en las primeras y últimas horas, pero la pérdida es pequeña porque a esas horas el sol está bajo y es débil. En invierno el sol se queda bajo incluso a mediodía, por lo que un panel fijo orientado al sur necesitaría una inclinación distinta en cada estación. Un seguidor resuelve ambos problemas por sí solo.

¿Un eje o dos ejes?

Un seguidor de un eje solo sigue el movimiento del sol de este a oeste; su inclinación es fija y se ajusta a la estación. Este eje aporta la mayor parte de la ganancia, porque el mayor desplazamiento diario del sol es de este a oeste. En las grandes plantas solares también es el tipo más habitual; los sistemas de dos ejes captan algo más de energía, pero son más caros y necesitan más mantenimiento. Para un proyecto escolar, en cambio, los dos ejes ofrecen una demostración más llamativa y un buen problema para aprender a controlar dos ejes a la vez.

Medir la diferencia de luz: 4 LDR y una pared de sombra

Una sola LDR solo te dice cuánta luz hay; para encontrar una dirección tienes que comparar al menos dos. En un seguidor de dos ejes, las cuatro LDR se colocan formando un cuadrado de 2×2 con un separador opaco en forma de cruz (+) entre ellas: la pared de sombra. Cuando el sensor apunta directamente al sol, la pared no proyecta sombra sobre ninguna LDR y las cuatro ven la misma luz. Cuando el sol se desplaza hacia un lado, la pared sombrea las LDR del lado contrario y sus lecturas bajan. La altura de la pared fija la sensibilidad: una pared de 3 cm proyecta con 5° de desvío una sombra de unos 2,6 mm de ancho (3 cm × tan 5°), suficiente para tapar la mitad de una LDR de 5 mm. Una pared alta da un sensor más sensible pero de ángulo más estrecho; una baja, uno más tosco pero de ángulo más amplio. Para ver en detalle cómo funciona una LDR, consulta sensor de luz LDR.

• Media superior: (arriba izquierda + arriba derecha) / 2
• Media inferior: (abajo izquierda + abajo derecha) / 2
• Media izquierda: (arriba izquierda + abajo izquierda) / 2
• Media derecha: (arriba derecha + abajo derecha) / 2
• Diferencia vertical (dV): arriba − abajo. Si es positiva, el panel debe inclinarse hacia arriba; si es negativa, hacia abajo.
• Diferencia horizontal (dH): izquierda − derecha. Si es positiva, el panel debe girar a la izquierda; si es negativa, a la derecha.

¿Seguimiento con sensores o con reloj?

El seguimiento con LDR no es el único método. Como la posición del sol puede calcularse de antemano a partir de la fecha, la hora y el lugar, algunos sistemas no usan ningún sensor de luz. Comparemos los tres enfoques:

En esta guía montamos la versión con sensores, porque no necesita ubicación ni hora, es fácil de poner en marcha y corrige sola los errores mecánicos. Si quieres ampliar el proyecto, añadir más adelante el seguimiento por reloj con un módulo RTC y comparar ambos métodos es un experimento adicional muy potente ante el jurado.

Lista de materiales

Conexiones: Arduino Uno, ESP32 y Pico

Una pata de cada LDR va a la alimentación (5V en el Uno, 3V3 en el ESP32 y la Pico) y la otra a un pin analógico; del mismo pin analógico sale una resistencia fija a GND. Así la lectura sube cuando aumenta la luz. En el lado de los paneles, entre los dos terminales de cada panel se conecta una resistencia de carga (33 Ω). La tensión del panel se divide entre 3,2 con un divisor de 22 kΩ y 10 kΩ antes de llegar al pin analógico: 22 kΩ del positivo del panel al pin analógico y 10 kΩ del pin analógico a GND. El negativo del panel también debe ir al GND de la placa; sin masa común la medida no tiene sentido.

Mecánica: soporte pan-tilt y equilibrio del panel

La solución mecánica más sencilla es un soporte pan-tilt que apila dos servos SG90: el servo inferior gira el panel en horizontal (este–oeste) y el superior lo inclina en vertical. Pega el bloque de sensores en el borde del panel de forma que su superficie quede exactamente paralela a la del panel. Si el sensor mira en otra dirección que el panel, el sistema seguirá al sol a la perfección, pero el panel apuntará siempre unos grados de lado. Una mini placa de 6 V y 1 W de 110×60 mm pesa unos 22 g; a 3 cm del eje eso supone unos 0,07 kg·cm de par, muy por debajo de los 1,8 kg·cm del SG90. La carga real es el viento: si pruebas al aire libre, centra el panel sobre el eje del servo, usa el MG90S de engranajes metálicos y, con paneles más grandes, pasa a un servo potente como el MG996R. Deja a los cables un bucle holgado para el giro; un cable tenso fuerza el servo y arranca las conexiones. Para lo básico sobre servos, lee qué es un servomotor.

Montaje paso a paso

1. Suelda las cuatro LDR en un trozo de placa perforada formando un cuadrado de 2×2 y pega entre ellas un separador en cruz de cartón o impreso en 3D de 2–3 cm de alto; píntalo de negro mate o cúbrelo con cinta negra.
2. Monta el divisor de cada LDR: la LDR de la alimentación al pin analógico y la resistencia fija del pin analógico a GND.
3. Coloca los servos en el soporte pan-tilt, llévalos ambos a 90° y atornilla los brazos en posición central.
4. Fija el panel y el bloque de sensores sobre el soporte superior con las superficies paralelas.
5. Monta el circuito de medida del panel: la resistencia de carga entre los terminales del panel, el divisor entre el positivo del panel y GND, y el punto medio a A4.
6. Alimenta los servos con la fuente externa de 5 V, une todos los GND y conecta el condensador de 470 µF en paralelo con la alimentación de los servos.
7. Sube primero el código de calibración, después el de seguimiento, y prueba el sistema con una linterna.

Paso 1: prueba y calibra las LDR

Incluso las LDR de la misma bolsa dan lecturas claramente distintas con la misma luz; la hoja de datos de la GL5528 indica un rango tan amplio como 10–20 kΩ a 10 lux. Un sensor sin calibrar cree que un lado está más iluminado aunque apunte directamente al sol, y gira el panel unos grados en la dirección equivocada. Sube el código siguiente, abre el Serial Plotter desde el menú Herramientas e ilumina el bloque de sensores de manera uniforme; por ejemplo, una hoja de papel blanco delante de una lámpara difunde y reparte bien la 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}

Con la misma luz, las cuatro líneas deberían quedar al mismo nivel. Supongamos que las lecturas son 612, 640, 598 y 625; la media es 619. La corrección de cada LDR es la media menos su propio valor: +7, −21, +21 y −6. Escribes estos números en el array OFFSET del código del paso 3. Como la resistencia de una LDR no cambia de forma lineal con la luz, calibrar con un nivel de luz parecido al de uso real da el resultado más preciso. En el Serial Plotter también verás el ruido: apunta cuántas unidades oscilan las lecturas sin que toques nada, porque necesitarás ese número al elegir la zona muerta.

Paso 2: código del seguidor solar de un eje

Veamos primero la lógica en un solo eje. Dos LDR, separadas por una pared de sombra vertical, miran hacia el este y el oeste: A0 es la LDR este y A1 la LDR oeste. El código resta una lectura de la otra; si la diferencia supera la zona muerta, el servo gira 1° hacia el lado más iluminado y, si no, se queda quieto. Este breve sketch ya es un seguidor de un eje completo. Si el panel huye de la luz, intercambia angle++ y angle-- en las dos condiciones.

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}

Con delay(30) el servo gira como mucho 1° cada 30 ms, unos 33° por segundo, así que en una demostración el panel sigue sin problema a una linterna. El sol se mueve mucho más despacio, de modo que en uso real basta con corregir cada pocos segundos.

Paso 3: código de dos ejes, zona muerta y registro de datos

La versión completa calcula dos diferencias a partir de las cuatro LDR, corrige cada eje por separado, deja el panel aparcado para la mañana cuando se hace de noche y, una vez por minuto, escribe en el Monitor serie la tensión, la potencia y la energía acumulada de ambos paneles en formato CSV. El código usa millis() en lugar de delay(), para que el seguimiento y el registro funcionen sin esperarse. Tienes los detalles en millis en lugar de 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}

Evitar la vibración con una zona muerta (tolerancia)

Sin zona muerta el sistema nunca se para. Incluso apuntando directamente al sol, las lecturas de las LDR oscilan unas cuantas unidades por el ruido, la diferencia pasa de positiva a negativa y el servo va sin parar 1° a la derecha, 1° a la izquierda. Esa vibración desgasta los engranajes y malgasta energía. La solución es ignorar las diferencias pequeñas: si la diferencia está por debajo de cierto límite, no se hace nada. Usa el ruido que viste al calibrar para elegir el límite y haz la zona muerta al menos 3–4 veces mayor que el ruido. En el Uno, si el ruido ronda ±5 unidades, 20–40 es un buen punto de partida.

El método del código va un paso más allá: la histéresis. El servo empieza a moverse cuando la diferencia supera 40, pero no se detiene hasta que baja de 15. Con una zona muerta de un solo límite, el panel se para justo en el borde y una pequeña nube o una ráfaga lo vuelven a poner en marcha; el sistema de dos límites lleva cada vez el panel bien hacia el sol y luego se calma. El efecto de la zona muerta en la energía es despreciable: como mostró la tabla del coseno, unos grados de desvío suponen menos del 1 % de pérdida. Para más técnicas de filtrado, consulta filtrar datos de sensores.

Experimento de rendimiento: panel con seguimiento frente a panel fijo

La única forma de demostrar que el seguidor funciona es medirlo. El error habitual es medir solo la tensión en circuito abierto del panel. La tensión sin carga apenas cambia con la luz: cuando la luz se reduce a la mitad, la corriente también baja más o menos a la mitad, pero la tensión en circuito abierto solo cae un 3–5 %. Así, los dos paneles marcan unos 7 V y la diferencia desaparece. Lo correcto es conectar la misma resistencia de carga a cada panel y medir la tensión en ella. La potencia se obtiene con P = V² / R y la energía sumando la potencia a lo largo del tiempo. Elige la resistencia de carga según el punto de máxima potencia del panel: un panel de 6 V y 1 W da unos 1 / 6 = 0,17 A, así que la resistencia adecuada es 6 / 0,17 ≈ 36 Ω; un valor estándar de 33 Ω es buena elección. Como la resistencia disipa casi 1 W en calor, usa una de al menos 2 W, mejor una cerámica de 5 W. Puedes comprobar las cuentas con la calculadora de la ley de Ohm.

1. Usa dos paneles idénticos: el mismo modelo y, si puede ser, del mismo lote. Conecta a ambos una resistencia de carga de 33 Ω y un divisor de 22 kΩ / 10 kΩ; el panel con seguimiento va a A4 y el fijo a A5.
2. Haz una prueba previa: coloca los dos paneles uno junto al otro con la misma orientación e inclinación y mide durante 30–60 minutos. Anota la diferencia (por ejemplo un 2 %) y corrige tus resultados con ella. Mejor aún, intercambia los paneles el segundo día.
3. Orienta el panel fijo exactamente al sur y ajusta su inclinación al sol del mediodía de ese día (mira el aviso de abajo).
4. Separa los paneles lo suficiente para que ninguno haga sombra al otro ni al sensor, en un lugar sin sombras de árboles o paredes.
5. Mide una vez la tensión del panel con un multímetro y compárala con la lectura del Arduino; si no coinciden, corrige el valor DIVIDER (cómo usar un multímetro).
6. Registra una vez por minuto desde la salida hasta la puesta del sol y anota el tiempo (despejado, parcialmente nublado, cubierto).
7. Repite el experimento al menos tres días despejados, registra aparte un día cubierto y compara la energía media diaria.

Puedes copiar los datos del Monitor serie y guardarlos como archivo CSV o enviarlos directamente a Excel (pasar datos de Arduino a Excel); si no quieres quedarte junto al ordenador, añade un módulo de tarjeta SD. En la gráfica de un día despejado, la línea del panel con seguimiento queda claramente por encima por la mañana y por la tarde, mientras que hacia el mediodía las dos líneas casi se superponen. Para sistemas grandes se citan ganancias de energía de alrededor del 15–35 % con un eje y del 30–45 % con dos ejes; en un montaje pequeño el resultado depende mucho del tiempo, la estación y lo bien orientado que esté el panel fijo. Deja claro en tu informe que lo que has medido no es la eficiencia del panel, sino el aumento de energía que capta el mismo panel. Añade también una limitación: con una resistencia de carga fija, la potencia cambia con el cuadrado de la corriente, así que cuando la luz se debilita la potencia del panel cae más rápido que la luz; por eso la ganancia porcentual que mides puede salir mayor que en un sistema real con regulador de carga. Si además sumas y comparas las corrientes de los dos paneles (V / R), verás también cuánta diferencia de luz reciben realmente.

Balance energético: ¿puede el sistema alimentarse solo?

Es la pregunta favorita del jurado. Un seguidor gana energía, pero también la consume. Para una maqueta pequeña, las cuentas aproximadas son estas:

La tabla lo deja claro: una maqueta pequeña no produce suficiente energía para su propia electrónica. Los 1–1,5 Wh extra que aporta el seguimiento son poco al lado de los unos 6 Wh que gasta el Uno al día. No es un fracaso, sino un resultado honesto y valioso. Al crecer la escala, la situación se invierte: el consumo del motor y del controlador que mueven paneles de kilovatios pasa a ser una pequeña fracción de la producción. Para reducir el consumo en un sistema pequeño, corrige una vez por minuto, libera los servos con detach() cuando no se mueven y elige un Pro Mini que entre en reposo o un ESP32 con deep sleep en lugar del Uno. Para estimar la autonomía con batería, usa la calculadora de duración de batería y la guía de mAh y Wh.

Seguidor solar con ESP32 y control desde el móvil

El ESP32 ejecuta la misma lógica con un ADC más fino y Wi-Fi. Hay algunas diferencias a tener en cuenta. Las lecturas analógicas van de 0 a 4095, así que la zona muerta es unas 4 veces la del Uno. Con el Wi-Fi activo solo funcionan de forma fiable los pines ADC1 (GPIO 32–39), porque los pines ADC2 los usa el Wi-Fi. Para los servos, instala la librería ESP32Servo desde el Gestor de bibliotecas. La función analogReadMilliVolts(), con la que se mide la tensión del panel, corrige el comportamiento no lineal del ADC del ESP32 con la calibración de fábrica. Alimenta siempre los divisores de las LDR desde 3V3. Tras subir el código, abre en un móvil conectado a la misma red la dirección IP que aparece en el Monitor serie y verás la tensión en tiempo real de ambos paneles, la energía acumulada y la ganancia. Si empiezas con el ESP32, lee primero qué es el 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}

Si quieres guardar las medidas durante días, puedes enviar los mismos valores a una hoja de cálculo en línea; consulta guardar datos del ESP32 en Google Sheets. Encontrarás más sobre la resolución del ADC y la tensión de referencia en ADC y conversión analógico-digital.

Seguimiento de un eje con Raspberry Pi Pico y MicroPython

La Pico solo tiene tres entradas analógicas accesibles (GP26, GP27, GP28), que no alcanzan para cuatro LDR y dos paneles. Por eso la solución más limpia con la Pico es un seguidor de un eje: dos LDR encuentran la dirección y la tercera entrada analógica mide la tensión del panel. Si quieres dos ejes, puedes añadir un ADC externo I2C como el ADS1115 de 4 canales. El servo se controla directamente con PWM a 50 Hz: un pulso de 500 µs equivale a 0° y uno de 2400 µs a 180°. Como read_u16() devuelve valores en una escala de 0 a 65535, la zona muerta es un número grande como 2000. Cómo instalar MicroPython en la Pico lo tienes en qué es la 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)

El código añade las medidas al archivo log.csv en la memoria flash de la propia Pico. Una línea por minuto suma 30–40 KB al día, así que el sistema de archivos de unos 1,4 MB de la Pico da para semanas. Si guardas el archivo como main.py, la Pico arranca el programa sola en cuanto recibe alimentación de una batería o un cargador USB, sin ordenador. Al final del día puedes descargar log.csv al ordenador con Thonny y abrirlo en Excel.

Consejos para presentarlo en una feria de ciencias

El seguidor solar es un proyecto habitual en ferias de ciencias y concursos escolares; lo que hará destacar el tuyo no es la maqueta, sino tus datos medidos y cómo los interpretas. Para ideas de proyectos y la estructura del informe, mira también proyectos Arduino para feria de ciencias.

• Plantea una pregunta medible: ¿Qué porcentaje más de energía capta un seguimiento de dos ejes en un día despejado de otoño que un panel idéntico fijado al sur con el mejor ángulo?
• Escribe antes tu hipótesis: Por ejemplo, predice que la ganancia se concentrará por la mañana y por la tarde; aunque el resultado no la confirme, discutirlo suma puntos.
• Separa las variables: La variable independiente es el método de seguimiento (ninguno, un eje, dos ejes), la dependiente la energía diaria (Wh) y las controladas el modelo de panel, la resistencia de carga, el lugar y la fecha.
• Cuéntalo con gráficas: Una gráfica de líneas hora–potencia muestra los dos paneles superpuestos; compara la energía diaria con un gráfico de barras e indica la diferencia entre días como margen de error.
• Habla de la energía neta: Mide el consumo propio del sistema y pon la tabla del balance energético en el póster; demuestra que el proyecto es honesto y científico.
• En la sala de la feria no hay sol: Haz la demostración en directo con una linterna o un foco y lleva un vídeo a cámara rápida del experimento exterior y el archivo CSV original.
• Organiza el póster: Problema, método, esquema del circuito, diagrama de flujo del código, resultados, limitaciones y propuestas; frases cortas y gráficas grandes en cada apartado.
• Cuenta tú las limitaciones: Mencionar límites como el panel pequeño, pocos días de datos, el viento y las diferencias entre LDR antes de que pregunte el jurado da confianza.

Errores frecuentes y soluciones

Ideas para ampliar el proyecto

• Estación de carga solar: Conecta el panel con seguimiento a un módulo de carga TP4056 y una celda 18650 y compara el tiempo de carga con el del panel fijo.
• Seguimiento híbrido: Calcula la posición del sol con un módulo de reloj RTC y usa las LDR solo para afinar; el panel apuntará bien incluso en días nublados.
• Registro por Wi-Fi: Envía las medidas del ESP32 a Google Sheets y sigue la gráfica en directo desde el móvil.
• Invernadero solar: Usa el panel con seguimiento para alimentar el ventilador y el riego de una maqueta de invernadero inteligente.
• Escáner de luz: Haz una versión que barra una sola LDR de 0 a 180° con un servo y busque la dirección más luminosa; la lógica se parece mucho al proyecto de radar con Arduino.
• Medida de potencia más precisa: Junto a la resistencia de carga, usa un sensor de potencia I2C como el INA219, que mide corriente y tensión a la vez, y dibuja la curva de potencia del panel.

Un seguidor solar reúne en un solo proyecto la lectura de sensores, la toma de decisiones, el control de motores y la medida científica, por lo que es una opción estupenda tanto para aprender como para presentar en un concurso. Empieza con un eje, ajusta la zona muerta y luego añade el segundo eje y el experimento con el panel fijo. En la app BlueGrays encontrarás proyectos para probar por separado cada parte de este sistema, como medir la luz con una LDR, una lámpara nocturna, el control del ángulo de un servo y un voltímetro digital, con esquemas y código.