Solar power is one of the most accessible types of renewable energy and is rapidly increasing in efficiency and affordability. In this project, we will show you how we used our PA-14 Mini Linear Actuator to follow the sun through a single axis of motion. Doing this increases the power yield of the solar panel by up to 25% more than a fixed solar panel.
In this article, we will show you how we put together our very own Portable Single-Axis Solar Tracker! You can also check out an overview of our build process on our YouTube channel!
Control System
The linear actuator is controlled by an Arduino microcontroller using a Wasp motor controller. It takes the reading from photoresistors to determine which side of the panel is receiving more light and adjusts the position of the solar panel until the photoresistor readings are fairly equal. This ensures that the solar panel is pointed directly at the sun and yields maximum power.
Solar Panel Power
There are three simple steps in converting solar energy into electrical energy. Each step is performed by an individual component as listed:- Sungold Solar Panel SGM-90W-18V: absorbs photons from sunlight, and converts it to electricity which is outputted as a varying DC voltage
- Solar Charge Controller Genasun GV-10: regulates the DC voltage from the solar panel to charge the battery
- 12VDC Lithium-Ion Battery: stores the electricity for use immediately or at a later time.
Control System Components
- 1x PA-14 mini-linear actuator – 6 inch – 150 lbs force.
- 1x Sungold SGM-90W-18 90 Watt Solar Panel.
- 1x Genasun GV-10 12VDC Solar Panel Charge Controller.
- 1x Arduino Micro PLC.
- 1x Wasp Motor Controller.
- 2x 10k Ohm Photoresistor and 2x 7k Ohm Resistor.
- 1x 12VDC Lithium Rechargeable Battery.
- 1x Cigarette lighter connector for 12V accessories (optional).
Motor Controller
For the control portion of this solar tracker, we will be using the Arduino Micro and WASP Motor Controller. The Wasp Motor Controller is controlled by the Arduino Micro using Pulse Width Modulation. The Wasp then takes power from the 12V battery to extend and retract the PA-14 mini-linear actuator. We chose the 150 lbs force actuator since it draws less current compared to a 35 lbs force version for the load we have.
Light Sensor
To detect the light intensity from the sun, we used a 10k Ohm photoresistor. A photoresistor behaves like a variable resistor controlled by light. The resistance will decrease as the light intensity increase. We will need two sensors, one on the east side of the panel, and the other on the west to be able to determine the position of the sun.
Connect the one 10k ohm photoresistor and one 7k Ohm resistor in series, and supply a 5V signal from the Arduino Micro. Take the voltage reading across the 7k Ohm resistor using an analog input on the Arduino Micro. Since the circuit behaves exactly like a voltage divider, the analog reading from the 7k Ohm resistor will increase as the light intensity increases.
Please note that the photoresistor is very sensitive and you may need to limit the light received from the sun. For our application, we found that pointing it to the side of the panel and covering it with translucent tape worked best."
Programming
The complete program can be found in the next section under the ‘Source Code’. This section of the article will explain the individual components of the program.
Servo Library
The Servo.h library enables the Arduino Micro to control RC servo motors through single line commands as follows:
myservo.writeMicroseconds (1000); // Actuator full speed backwards (1000)
myservo.writeMicroseconds (1520); // Actuator stop (1520)
myservo.writeMicroseconds (2000); // Actuator full speed forwards (2000)
Pin Assignments
Pin 10 and 11 on the Arduino Micro are set to power and ground to drive the WASP controller. Pin 6 and 8 on the Arduino Micro are assigned to analog 7 & 8, which is set to take readings from the light sensor west & east.
Variable Declaration
In this section, variables are declared and initialized. They will be used in the functions to store readings from the light sensors. The sample time and adjustment interval are also declared here, their value can be changed to set the intervals time between each reading, and the time between each angle adjustment made to the solar panel. The initial value is set to take a reading every 10 seconds and adjust the solar panel position every 10 minutes.
Set Input & Output
Set WASP_Power and WASP_Ground to output in order to drive the WASP controller, sensor_west_pin1 and sensor_east_pin2 to input to take readings from photoresistors light sensors.
Sensor Readings
To determine which direction the solar panel should be facing, we are using two photoresistors as a light sensor to read the light intensity of each side of the solar panel. The program we used will take a sample reading every 10 seconds for 10 samples, and then take the average readings from the two photoresistors to compare.
Solar Panel Movement
With the Arduino Micro, we are using PWM control to drive the actuator. It is a simple and reliable method to control the linear actuator. Depending on the value we set for PWM, we can extend, retract or stop the actuator for any period of time as long as it does not exceed the duty cycle of the actuator.
From our sensor readings, we have two averaged light intensity values from both sensors on the west side and east side. It will then execute the movement command to extend, retract or remain stationary depending on the difference between the two sensors’ reading. This set of commands will run every 10 minutes to ensure the solar panel is always getting the most amount of sunlight.
Overnight Position Reset
One more feature we can implement with the solar tracker is a reset function. Basically, if the solar tracker was left to run over a few days’ periods, we need to ensure that it will reset to its initial position the next morning.
For this, we will use a simple counter function that will reset the position if the solar tracker has not moved for the past 10 hours. That will indicate it is nighttime, and the solar tracker will reset to its initial position and wait for the following day's daylight.
Please see the code we used attached below for this iteration of our solar tracker. The value can always be changed to accommodate different regions and seasons throughout the year.
Source Code
/*
This program will allow the solar panel to track the sun, and drive the actuator using
pwm. Readings from two photoresistors will be taking from each side of the solar panel.
A number of samples will be taken, and a average reading will be calculated in order
to determine which side has a higher sunlight intensity. The linear acutor will then
either extend or retract to angle the solar panel so it is facing the sun.
A reset function is implemented so it will move the solar panel to its defult position.
This allow the solar panel ready to charge in the morning after remain stationary during
night time.
Hardware used:
1 x Arduino Micro
1 x WASP Motor Controller
1 x PA-14-6-150 Linear Actuator
2 x Photoresistors
2 x 7k ohm Resistors
*/
/*
SERVO LIBRARY
Include the Servo library and create the servo object.
*/
#include <Servo.h>
Servo myservo; // Create servo object to control a servo
/*
PIN ASSIGNMENTS
Assign pins from WASP Controller and Arduino Micro to appropriate variable.
*/
const int WASP_Power = 10; // Assign pin 10 to Power for the WASP controller
const int WASP_Ground = 11; // Assign pin 11 to Ground for the WASP controller
const int sensor_west_pin1 = 7; // A7 pin 6 sensor input 1 west
const int sensor_east_pin2 = 8; // A8 pin 8 sensor input 2 east
/*
VARIABLE DECLARATION
Delcare variable that will be used in the functions later and initilize them.
*/
int sensor_west[10]; // 10 sample readings from sensor on the west side
int sensor_east[10]; // 10 sample readings from sensor on the east side
int reset_counter = 0; // Time counter for resetting the solar panel position
const int sample_time_interval = 10000; // Change this value to set the interval between each sample is taken (ms)
const int solar_panel_adjustment_interval = 600000; // Change this value to set the interval between each adjustment from the solar panel (ms)
void setup()
{
/*
SET INPUT & OUTPUT
Set the input and output to the variables and pins.
*/
myservo.attach(9); // Attaches the servo on pin 9 to the servo object
pinMode(WASP_Power, OUTPUT); // Set Power to output
pinMode(WASP_Ground, OUTPUT); // Set Ground to output
digitalWrite(WASP_Power, HIGH); // Set 5V to pin 10
digitalWrite(WASP_Ground, LOW); // Set GND to pin 11
pinMode(sensor_west_pin1, INPUT); // Set sensor west pin to input
pinMode(sensor_east_pin2, INPUT); // Set sensor east pin to input
}
void loop()
{
/*
SENSOR READINGS
Take 10 sample readings from both sensors, and take the average of the inputs.
*/
int solar_input_west = 0; // Sun light intensity readings from sensor west
int solar_input_east = 0; // Sun light intensity readings from sensor east
for( int i=0; i<10; i++)
{
sensor_west[i] = analogRead(sensor_west_pin1); // Taking the analog readings from sensor west
sensor_east[i] = analogRead(sensor_east_pin2); // Taking the analog readings from sensor east
solar_input_west = sensor_west[i] + solar_input_west; // Sum all the inputs from sensor west
solar_input_east = sensor_east[i] + solar_input_east; // Sum all the inputs from sensor east
delay(sample_time_interval);
}
solar_input_west = (solar_input_west) / 10; // The the average of input signals from sensor west
solar_input_east = (solar_input_east) / 10; // The the average of input signals from sensor east
/*
SOLAR PANEL MOVEMENT
The solar panel will tilt toward west if the sunlight intensity detected on the west side of the panel is greater than the
one detected on the east side. The solar panel will tilt toward east if the sunlight intensity detected on the east side
is greater than the one detected on the west side. However, if the readings from both side are similar, the solar panel
will remain stationary.
*/
if( solar_input_west - solar_input_east > 20) // If the sunlight intensity is higher on the west side of the panel
{
myservo.writeMicroseconds(2000); // Full speed forwards (2000) signal pushing the solar panel to the left(west)
delay(500); //0.5 seconds
reset_counter = 0;
}
else if( solar_input_east - solar_input_east > 20) // If the sunlight intensity is higher on the east side of the panel
{
myservo.writeMicroseconds(1000); // Full speed backwards (1000) signal pulling the solar panel to the right(east)
delay(500); //0.5 seconds
reset_counter = 0;
}
else // If ther sunlight intensity is similar from both side of the panel
{
myservo.writeMicroseconds(1520); // Stationary (1520) signal stop the solar panel from moving
reset_counter++;
}
delay(solar_panel_adjustment_interval); // Delay before another adjustment will be made
/*
OVERNIGHT POSITION RESET
If the solar panel will be used overnight, the controller will detect the panel remained stationary for more than 10 hours,
It will then reset the solar panel to its default position facing east.
*/
if( reset_counter > 60) // After the solar panel remained stationary for more than 10 hours, it will move to its default position
{
myservo.writeMicroseconds(1000); // Full speed backwards (1000) signal pulling the solar panel to the right(east)
delay(12000); //12 seconds
myservo.writeMicroseconds(1520); // Stationary (1520) signal stop the solar panel from moving
delay(500); //0.5 seconds
myservo.writeMicroseconds(2000); // Full speed forwards (2000) signal pushing the solar panel to the left(west)
delay(1000); //1 seconds
reset_counter = 0;
}
}
Single-Axis Tracker Hardware
There are countless ways to create a single-axis solar tracker. The easiest method would be to construct the frame using PVC pipes and PVC angled joints. The most important part is the ability to track and this can be done using a simple PA-14 mini-linear actuator and a BRK-14 bracket.
For our build, we chose a tripod frame and used 3D printed parts to create the joints and mounts. This allowed us to create a very portable solar tracker frame with the optimum amount of tilt and tracking ability. For a visual overview of our build process, check out our YouTube channel.
Components
- 3/4" Copper pipe.
- 1x 3/4" Copper pipe end cap.
- 3x 3/4" Gear clamp.
- 3/4" PVC pipe.
- 1x 1 Gear clamp.
- 5x M6 bolt, nut and washer.
- Various 3D printed brackets.
- 2x Actuator mounting pin (can be found in the set BRK-14).
- 1x PA-14 mini-linear actuator.
Optimum Tilt
Aside from adding the ability to track the sun, another way to increase the efficiency of the solar panel is to adjust the fixed-tilt based on your location. The optimum tilt is determined by your location’s latitude. For more information on this, check out this link: Solar Panel Tilt.Here we have a dimensional drawing from the side perspective to show how we calculated our tracker’s tilt. You can calculate Length B using the following equation:
Fabrication and Assembly
For a visual overview of our build process, check out our YouTube video!In this article, we went over the steps we took to build our Portable Single-Axis Tracker.
- Calculate the lengths needed to achieve the optimum tilt.
- Gather all the components needed.
- Attach brackets to the solar panel by drilling holes and fastening with the appropriate bolts.
- Cut the copper and PVC pipes to length.
- Paint and sand the copper and PVC pipes.
- Attach the brackets to the pipes and secure them with gear clamps.
- Mount the PA-14 mini-linear actuator and secure using the BRK-14 actuator mounting pins.
We hope you enjoyed our article and video on creating a portable solar tracker. Subscribe to our channel and follow us on social media so you can be the first to see all of our latest automation videos and articles.
Let us know what kind of project you would like to see next!