Cómo hacer un seguidor solar casero con Arduino

Seguramente habrás escuchado hablar mucho de la energía solar en los últimos años. Cuando hablamos de energía solar, el primer componente que se nos viene a la cabeza son las placas solares. Vamos a construir un seguidor solar casero para maximizar su rendimiento y obtener la mayor cantidad de energía solar posible.

Resumen del proyecto seguidor solar casero

Las placas solares convierten la energía solar en energía eléctrica. Esta transformación de energía es posible gracias a materiales, como por ejemplo el silicio, que tienen la propiedad de generar corriente eléctrica cuando están sometidos a la radiación solar.

Cuanto más apunte el sol a la placa solar, más radiación solar le llegará, y por lo tanto más corriente eléctrica generará. El problema es que muchas veces las placas solares tienen una posición estática, es decir, que no varía. Sin embargo, la posición del sol si cambia a lo largo del día.

Para conseguir que el sol siempre apunte a la placa solar y obtener la máxima corriente posible podemos construir un seguidor solar. Un seguidor solar es una estructura que tiene incorporada una o varias placas solares y las va moviendo para que siempre apunten al sol. De esta forma conseguimos mejorar el rendimiento de las células fotovoltaicas.

Lista de materiales del seguidor solar casero

Nosotros hemos utilizado PLA para imprimir la estructura del seguidor solar casero. Hemos puesto ABS en la lista de materiales porque algunos compañeros nos han comentado que hubiera sido mejor utilizar este material, ya que tiene mejor resistencia al sol y no se deteriora. Por ello os recomendamos utilizar ABS.

Esquemas eléctricos

Conexión de las placas solares entre sí

Nosotros hemos utilizado dos placas solares para hacer el seguidor solar casero. Cada una es de 5 Voltios y proporciona una corriente máxima de 0.5 Amperios. Puedes conectarlas en serie y así obtener 10 Voltios y 0,5 Amperios o conectarlas en paralelo y obtener 5 Voltios y 1 Amperio.

Cómo los componentes electrónicos del seguidor solar funcionan con 5 Voltios y lo vamos a utilizar para cargar dispositivos que funcionen con este voltaje, como por ejemplo los móviles, nosotros hemos conectado las placas solares en paralelo. Te dejamos también el esquema de conexión en serie por si acaso necesitas obtener más voltaje y no te importa tanto la corriente.

¿Para qué sirve obtener más corriente? Si en vez de 0.5 amperios, las placas proporcionan 1 amperio, las baterías se cargarán el doble de rápido. Sin embargo esto tiene un límite, ya que si utilizas una corriente muy alta para cargar las baterías las dañarás. Aun así, 1 amperio está muy lejos de dicho límite.

Circuito completo

Una vez tienes conectadas las placas solares entre sí, tienes que conectar el resto de componentes electrónicos. Por un lado conectamos las células fotovoltaicas al módulo cargador TP4056 y a las baterías de litio. De esta forma podemos almacenar la energía obtenida.

Con estas baterías alimentaremos el resto de componentes. Para poder hacerlo hay que transformar su voltaje, que es de 3.7 Voltios, a 5 Voltios. El «cerebro» del proyecto es un Arduino Nano. Se encarga de ejecutar el código que le subamos y por lo tanto de controlarlo todo. Le hemos añadido una placa de extensión para que sea más fácil realizar las conexiones y no haga falta soldar.

A esta placa de extensión hemos conectado los dos servomotores MG996R, para que el solar tracker se pueda mover, los sensores de luz (LDR), el sensor de corriente y una pantalla LCD para mostrar la corriente medida.

Código del seguidor solar casero

Aquí te dejamos el código que hemos utilizado en el seguidor solar casero. Si has seguido el esquema eléctrico y lo has montado todo exactamente igual que nosotros, simplemente tendrás que subirlo y ya tendrás tu solar tracker funcionando.

En cambio, si has hecho alguna modificación es posible que tengas que cambiar alguna parte del código. Si no sabes hacer esto, y te gustaría aprender para poder modificar códigos o escribir los tuyos desde cero, puedes entrar a nuestro curso de programación y electrónica con Arduino desde 0.

Curso de Arduino desde Cero

Aprende programación y electrónica de forma rápida y sencilla con Arduino para que puedas montar tus proyectos tecnológicos lo antes posible.

				
					#include <LiquidCrystal_I2C.h>
#include <Servo.h>


//LDRs
const int LDR_TOP_LEFT = A0;
const int LDR_TOP_RIGHT = A1;
const int LDR_BOTTOM_LEFT = A2;
const int LDR_BOTTOM_RIGHT = A3;
const int LIGHT_THRESHOLD = 10;

//Servos
Servo servo_horizontal;
Servo servo_vertical;
int pos_sh = 90;
int pos_sv = 90;
const int UPPER_LIMIT_POS = 160;  //Límite superior de los servos
const int LOWER_LIMIT_POS = 20;   //Límite inferior de los servos

//Sensor de corriente ACS712 5A
const int CURRENT_SENSOR = A6;
const float SENSIBILITY = 0.185;
const int CURRENT_SAMPLES = 10;

unsigned long lastTime = 0;
unsigned long threshold = 2000;

//Pantalla LCD con I2C
LiquidCrystal_I2C lcd(0x27, 16, 2);  //LCD de 16 columnas y 2 filas


void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  delay(500);
  lcd.init();
  delay(2000);
  lcd.backlight();
  servo_vertical.attach(5);
  servo_horizontal.attach(6);
  servo_vertical.write(90);
  servo_horizontal.write(90);
  pos_sv = servo_vertical.read();
  pos_sh = servo_horizontal.read();
}

void loop() {
  //Leemos los 4 LDRs
  int ldr_tl_value = analogRead(LDR_TOP_LEFT);
  int ldr_tr_value = analogRead(LDR_TOP_RIGHT);
  int ldr_bl_value = analogRead(LDR_BOTTOM_LEFT);
  int ldr_br_value = analogRead(LDR_BOTTOM_RIGHT);

  int average_top = (ldr_tl_value + ldr_tr_value) / 2; //Media de los 2 LDR de arriba
  int average_bottom = (ldr_bl_value + ldr_br_value) / 2; //Media de los 2 LDR de abajo
  int average_left = (ldr_tl_value + ldr_bl_value) / 2; //Media de los 2 LDR de la izquierda
  int average_right = (ldr_tr_value + ldr_br_value) / 2; //Media de los 2 LDR de la derecha

  //Movemos el solar tracker
  moveSolarTracker(average_top, average_bottom, average_left, average_right);

 
  if ((millis() - lastTime) > threshold) {
    lastTime = millis();
    
    //Medimos la corriente
    float current_measured = medirCorriente(CURRENT_SENSOR, SENSIBILITY, CURRENT_SAMPLES);
   
    //Mostramos la corriente en el LCD
    lcd.clear();
    lcd.setCursor(2, 0);
    lcd.print("Corriente:");
    lcd.setCursor(2, 1);
    Serial.print(current_measured);
    lcd.print(String(current_measured));
    lcd.print("A");
  }


  //Delay de 30 ms para que los servos no se muevan demasiado rápido
  delay(30);
}

void moveSolarTracker(int average_top, int average_bottom, int average_left, int average_right) {
  //Movemos el solar tracker hacia arriba o hacia abajo
  if ((average_top - average_bottom) > LIGHT_THRESHOLD && pos_sv < UPPER_LIMIT_POS) {
    pos_sv++;
    servo_vertical.write(pos_sv);
  }
  else if ((average_bottom - average_top) > LIGHT_THRESHOLD && pos_sv > LOWER_LIMIT_POS) {
    pos_sv--;
    servo_vertical.write(pos_sv);
  }

  //Movemos el solar tracker hacia la derecha o hacia la izquierda
  if ((average_left - average_right) > LIGHT_THRESHOLD && pos_sh < UPPER_LIMIT_POS) {
    pos_sh++;
    servo_horizontal.write(pos_sh);
  }
  else if ((average_right - average_left) > LIGHT_THRESHOLD && pos_sh > LOWER_LIMIT_POS) {
    pos_sh--;
    servo_horizontal.write(pos_sh);
  }
}

float medirCorriente(int current_sensor, float sensibility, int samples) {
  float sensor_read = 0;
  float current_measured = 0;
  for (int i = 0; i < samples; i++) {
    sensor_read += analogRead(CURRENT_SENSOR);
  }

  sensor_read = sensor_read / samples;
  sensor_read = sensor_read * (5.0 / 1023.0);
  current_measured = (sensor_read - 2.5) / sensibility;
  Serial.println(sensor_read);

  return current_measured;
}