Introduction

This tutorial will demonstrate how to make a simple direct drive solar chimes sculpture with a Voltaic mini solar panel. The solar chimes concept is based on an early solar power sound installation, from 1977, by the sound artist Joe Jones.

Solar chimes sculpture installed on wall.

This circuit is about as simple of a solar circuit as possible. The PV cell is wired directly to the motor, without any additional components. The use of a geared motor allows us to avoid using more complex motor driver circuitry while still producing a nice slow movement.

The structure is made from two sheets of balsa wood that form a T turned 90 degrees. A couple additional small pieces are used as supports.

In this example, I’m using 5.9”x3.9”x0.08” sheets of balsa wood for the structure. Many other materials will work just as well, from upcycled cardboard to higher quality materials. Similarly, you don’t necessarily need actual chimes like I’m using here. Experiment with different materials to get different types of sounds from your sculpture.

This project is intended to be mounted on an indoor wall. Mount the sculpture in a location that gets hit with sunlight in the afternoon and it will be a good reminder to get off the computer and go for a walk.

Parts List for Solar Chimes

• 0.6 Watt 6 Volt Mini Solar Panel (P123)
• Balsa wood
• String
• 12 gauge steel wire (You can substitute wire from a metal coat hanger or any other type of sturdy wire that can be bent as needed)
• Chimes
• Geared 6V DC Motor
• Screw or hook
• 22 gauge electrical wire

Recommended Tools:

• Soldering iron and solder
• Hot glue gun and hot glue
• Drill
• 1/2” Drill bit
• 1/16” – 3/32” Drill bit (size depends on the string thickness)
• Pliers
• Scissors
• Pencil
• Wire strippers
• Wire cutter
• Exacto knife
• Ruler

Build Instructions

1. Prepare the horizontal piece that the motor will be attached to.
   • Mark the motor shaft hole. The hole should be located at least ¼” off center on the long edge. By offsetting the motor, it is easier to keep the motor arm from hitting the wall when it is installed.
   • Mark pairs of holes in a semi circle around the motor to hang the chimes from.
     

     Step 1

   • Drill the hole for the motor shaft with a ½” drill bit. Use a small drill bit for the chime strings. The exact size of these holes may depend on the thickness of string you are using. (I used a 1/16” bit.)
   • Lightly sand the holes. (optional)
2. Cut the support pieces
   • Cut a thin strip of wood about 3.7”x1/4”.
   • Cut 2 small 90 degree triangles (roughly ¼” and 1” sides)
     

     Step 2

3. Assemble wooden structure
   • Draw a line across the center of the board
   • Glue the thin strip of wood from step 2A centered underneath the line
   • Glue the long edge of the triangular pieces to the edges of the board
   • Glue the horizontal piece that the motor will be mounted on to the support pieces.
     

     Step 3

4. Attach the arm to the motor shaft
   • Cut an 8″ to 12” piece of 12 gauge wire.
   • Stick the wire through the hole on the motor shaft so that roughly 3/4” is sticking out.
   • Using a pair of pliers, crimp the wire to the shaft so that it cannot move.
     

     Step 4

5. Cut a piece of string roughly 16” long and tie each end to the flanges on either side of the motor (note that the length of the string will need to change if the back of your structure is larger than this example).
6.  Stick the arm and motor shaft through the hold on the horizontal board. Glue the edges of the motor into place. Avoid gluing the flanges where the string is tied in case you need to adjust the length of the string.
   

   Step 6 (Left: top view, Right: bottom view)

7. Prepare the solar panel
   • Hold the solar panel in place and measure out the length of your wires. (You may want to leave them a little long and cut them down as needed, because it will be difficult to attach new wires to the panel once it is glued in place.)
   • Solder one wire to the positive terminal of the panel and the other wire to the negative terminal of the panel.
   • Glue the panel to the top of the backboard with the wires sticking out the bottom.
     

     Step 7

8. Connect the positive wire from the solar panel to the positive (red) terminal on the motor. Connect the negative wire from the solar panel to the other terminal on the motor.
   

   Step 8

9. Attach chimes with length of string about 8″ – 10” long.
10. Bend the 12 gauge wire slightly so that it catches the chimes as it turns. Shorten the chime strings and 12 gauge wire as needed.
11. Hang the sculpture on a screw or hook on a wall that gets sun at some point during the day.
    

    Solar chimes sculpture installed on wall.

Introduction
Parts List and Arduino Wiring
Arduino Code and Battery Charge Tests
Python Code and Datalogging Battery Voltage Output
Conclusion and Continuation

Introduction

Parts List and Arduino Wiring

An Arduino Uno board is used as the main datalogger for the tutorial, which will allow for real-time measurement of voltages and currents as a function of time. The 10-bit ADC of the Arduino is used to measure the voltage outputted by the V25 battery’s USB-C D+ pin, while the INA219 reads the input voltage and current of the power supply. The INA219 is a good choice due to its low quiescent current during power down (~6μA) and minimal consumption during reading (~1mA).

V25 USB Battery Pack

The principal components required to follow along with the experiment are:

• V25 USB Battery Pack – $35 [Buy from Voltaic]
• Arduino Uno Board – $13.00 [Buy from Maker Portal]
• INA219 Current/Voltage Sensor – $7.89 [Buy from Amazon]
• USB-C Terminal Breakout – $8.99 [Buy from Amazon]
• 0V-30V, 5A Variable Power Supply – $69.97 [Buy from Amazon]
• 18 AWG Solid Core Wire – $14.49 [Buy from Amazon]
• Mini Breadboard – $3.00 [Buy from Maker Portal]

The 18 AWG wire is a particularly important requirement for the power supply and load circuit, as many of the standard jumper wires included with Arduino kits are incapable of handling the 2A supply currents requested by the V25 battery pack. Another important caveat of the 18 AWG is that the diameter is too thick for Arduino input pins, so be sure to use 22 AWG for the Arduino components and 18 AWG for the power circuit. Any power supply should work for this particular application, under the assumption that it can supply the 5V/2A specification of the USB-C port of the battery. Keep in mind – if a lower capacity charger is used, longer charge times will result. It is also important to use the terminal portion of the INA219 voltage/current sensor, instead of the inline pins. This will again circumvent any amperage limitations on the traces of the breadboard used to wire the INA219 (if at all).

The wiring diagram is given below that links all components used in the tutorial:

Figure 1: Wiring diagram between Arduino board, V25 battery, INA219 voltage/current sensor, and external power supply

The relationship between a USB-C plug and the USB-C terminal can be seen in the figure below:

Figure 2: USB-C plug in relation to USB-C terminal pin inputs.

Since the INA219 is a high-side current sensor, we see its function at the beginning of the circuit taking the input directly from the power supply. Then, the V25 battery follows next in the circuit, ultimately leading back to the power supply’s ground. Additionally, the D+ is broken out from the USB-C terminal to go directly to the Arduino board’s A0 analog pin, which is where we will measure the V25 cell voltage. We also need the Arduino to share a ground with the power supply, which is also what’s done in Figure 1. Lastly, the INA219 is wired to the Arduino Uno via the Inter-Integrated Circuit (I²C) protocol. Another important point to note is the use of the 3.3V analog reference. As stated at the introduction, the V25 battery has a scaled voltage of roughly 1/2, which means that we will see a maximum cell voltage around 4.2 – which scales by half to 2.1. Thus, we don’t need the entire 5V analog range of the Arduino, which is why we have chosen 3.3V as the reference. This will give us higher resolution on the 10-bit reading, which consequently is from 0V-3.3V. In the next section, the Arduino code used to measure voltage and current in real-time is introduced and explained.

Arduino Code and Battery Charge Tests

The Arduino code given below measures voltage from the input power supply and load current from the V25 battery, while also reading the USB-C D+ voltage output on pin A0 of the Arduino board. The code was developed using the Arduino IDE version 1.8.13. 

/*
 * Reading Voltages and Current with Arduino ADC + INA219
 * -------------------------------------------------------
 *
 * Maker Portal LLC Copyright 2020
 * Written by: Joshua Hrisko
 *
 */
#include <Wire.h>
#include <Adafruit_INA219.h>

Adafruit_INA219 ina219_A(0x40); // start INA219 current/voltage sensor

void setup(void)
{
  analogReference(EXTERNAL); // set analog reference to 3.3V
  Serial.begin(115200); // open serial port at 115200 bps
  Serial.println("Acquisition Start"); // start word for Python code

  // check to make sure INA219 is being read
  if (! ina219_A.begin()) {
    Serial.println("Failed to find First INA219 chip (0x40)");
    while (1) { delay(10); }
  }
  // print header for logging data:
  Serial.println("Time[s],InputVoltage[V],InputCurrent[mA],D+[V]");
}

void loop(void)
{
  // preallocate variables
  float shuntvoltage = 0.0; float busvoltage = 0.0;
  float current_mA = 0.0; float loadvoltage = 0.0;
  float d_plus = 0.0;

  // read variables from INA219 (voltages/current)
  shuntvoltage = ina219_A.getShuntVoltage_mV();
  busvoltage = ina219_A.getBusVoltage_V();
  current_mA = ina219_A.getCurrent_mA(); // load current
  loadvoltage = busvoltage + (shuntvoltage / 1000); // load voltage
  d_plus = 3.3*analogRead(A0)/1023.0; // reading D+ from USB-C on Arduino pin A0
 
  Serial.print(millis()/1000.0); // print milliseconds since code start
  Serial.print(","); // comma-separation
  Serial.print(loadvoltage); // load voltage
  Serial.print(",");
  Serial.print(current_mA); // load current
  Serial.print(",");
  Serial.println(d_plus); // D+ scaled cell voltage
  delay(1000); // wait 1 second between readings
}

The code outputs four variables: seconds since the start of the Arduino program, voltage passing through the load, current passing through the load, and scaled voltage outputted by the USB-C D+ pin. These four variables will help us determine what is happening with the system over time during charging. Below is an example output from the Arduino’s serial port upon correct wiring according to Figure 1 and uploading of the code above:

Figure 3: Arduino INA219 serial output example showing the time, load voltage, load current, and USB-C scaled voltage output.

Investigation of Figure 3 tells us that we have an input voltage of roughly 5V (~5.3V in my case), a load amperage of 2A, and a scaled voltage of 2.01V. Similar values should give confidence that the user has wired the components correctly, uploaded the code properly, and is following along closely with the expectations of the experiment. In the next section, a Python code will be presented that reads the serial outputs shown above and plots them in real time. Later in the code, the outputs will be saved for analysis and post processing.

Python Code and Datalogging Battery Voltage Output

At this stage in the experiment, the user should have a constant stream of voltage and current values being outputted by the Arduino board. In this section, a Python script will be used to read the Arduino serial data and plot the values in real time. Python 3.7 is used, in conjunction with a series of libraries and protocols for reading from the Arduino serial port. The Python code for reading and plotting in real time is given below:

##################################################
# ---- Python Serial Port Datalogger
# 
# ---- Maker Portal LLC Copyright 2020
# ---- Written by: Joshua Hrisko
#
##################################################
#
# This code reads from the serial port and saves
# the data until the user presses
# CTRL+C, wherein the acquisition ceases
#
##################################################
#
import numpy as np
import matplotlib.pyplot as plt
import serial,datetime,csv,os
import serial.tools.list_ports as COMs
#
#
############################################
# Real-time plotter functions
############################################
#
def plotter_start(x_lims=[0.0,1.0],new_plot=1):
    if new_plot:
        plt.style.use('ggplot')
        fig = plt.figure(figsize=(12,9))
        ax = fig.add_subplot(111)
        ax2 = ax.twinx()
        ax.set_xlim(x_lims)
        ax.set_ylim([0.0,6.0])
        ax2.set_ylim([0.0,2200.0])
        ax.set_ylabel('Voltage [V]')
        ax2.set_ylabel('Current [mA]')
        ax.set_xlabel('Time [s]')
        lines = []
        for ii,header_ii in enumerate(header[1:]):
            if ii==1:
                line_ii, = ax2.plot([],color=plt.cm.Set1(ii),linewidth=3.0,
                         label=header_ii)
            else:
                line_ii, = ax.plot([],color=plt.cm.Set1(ii),linewidth=3.0,
                         label=header_ii)
            lines.append(line_ii)
        ax.legend(loc='upper left')
        ax2.legend(loc='upper right')
        fig.canvas.draw()
        ax_background = fig.canvas.copy_from_bbox(ax.bbox)
        plt.show(block=False)
    else:
        fig = plt.gcf()
        for ii in fig.get_axes():
            ii.cla()
        fig.clf()
        ax = fig.add_subplot(111)
        ax2 = ax.twinx()
        ax.set_xlim(x_lims)
        ax.set_ylim([0.0,6.0])
        ax2.set_ylim([0.0,2200.0])
        ax.set_ylabel('Voltage [V]')
        ax2.set_ylabel('Current [mA]')
        ax.set_xlabel('Time [s]')
        lines = []
        for ii,header_ii in enumerate(header[1:]):
            if ii==1:
                line_ii, = ax2.plot([],color=plt.cm.Set1(ii),linewidth=3.0,
                         label=header_ii)
            else:
                line_ii, = ax.plot([],color=plt.cm.Set1(ii),linewidth=3.0,
                         label=header_ii)
            lines.append(line_ii)
        ax.legend(loc='upper left')
        ax2.legend(loc='upper right')
        fig.canvas.draw()
        ax_background = fig.canvas.copy_from_bbox(ax.bbox)
        
    return fig,ax,ax2,lines,ax_background

def plotter_update(xs,y_vec):
    y_vec = np.transpose(y_vec)
    for iter_ii in range(0,len(lines)):
        if iter_ii==1:
            lines[iter_ii].set_data(xs,y_vec[iter_ii])
            ax2.draw_artist(lines[iter_ii])
        else:
            lines[iter_ii].set_data(xs,y_vec[iter_ii])
            ax.draw_artist(lines[iter_ii])
    fig.canvas.restore_region(ax_background)
    fig.canvas.blit(ax.bbox)
    fig.canvas.draw()
    return
#
############################################
# Find Arudino ports, select one,
# start communication with it
############################################
#
arduino_ports = [ii.device for ii in COMs.comports() if\
                 len((ii.device).split('ttyACM'))>1 or\
                 len((ii.device.split('ttyUSB')))>1]
ser = serial.Serial(arduino_ports[0],baudrate=115200) # match baud on Arduino
ser.flush() # clear the port
#
############################################
# Grabbing real-time data from Arduino
############################################
#
t_now = datetime.datetime.strftime(datetime.datetime.now(),
                                   '%Y_%m_%d_%H_%M_%S')
datafile = 'arduino_data_'+'{0}'.format(t_now)+'.csv' # date 
t_vec = [] # allocate time vector
data_array,data_plot = [],[] # for saving all values
start_bool = False
plot_refresh_dt = 60 # every # of seconds between axes limit updates
plot_update_pts = 10 # number of pts to read before plotting
#
while True:
    try:
        ser_bytes = ser.readline() # read Arduino serial data
        decoded_bytes = ser_bytes.decode('utf-8') # decode data to utf-8
        data = (decoded_bytes.replace('\r','')).replace('\n','')
        if start_bool==False and data=='Acquisition Start':
            # read the first line after acquisition start as header
            header = (((ser.readline()).decode('utf-8').replace('\r','')).\
                     replace('\n','')).split(',')
            # create csv file for saving the data each loop
            with open(datafile,'w') as csvfile:
                csv_writer = csv.writer(csvfile,delimiter=',')
                csv_writer.writerow([header])
            fig,ax,ax2,lines,ax_background = plotter_start(x_lims=[0.0,
                                plot_refresh_dt],new_plot=1) # start plot
            start_bool = True
            print('Data Acquisition Starting...')
            ser.flush()
            continue
        if start_bool:
            try:
                if len([float(ii) for ii in data.split(',')[1:]])!=3:
                    continue
                t_vec.append(float(data.split(',')[0]))
                data_plot.append([float(ii) for ii in data.split(',')[1:]])
                data_array.append([float(ii) for ii in data.split(',')])
            except:
                continue # if data format issue - skip
            if len(t_vec)%plot_update_pts==0:
                plotter_update(t_vec,data_plot) # update data on plot

            # set new limits on plot to create scrolling effect
            if ax.get_xlim()[1]<t_vec[-1]:
                new_xlims = [0.0,plot_refresh_dt+t_vec[-1]]
                fig,ax,ax2,lines,ax_background = plotter_start(new_xlims,0)
                plotter_update(t_vec,data_plot) # update data on plot
            # save data to the existing csv file
            with open(datafile,'a',newline='',encoding='utf-8') as csvfile:
                csv_writer = csv.writer(csvfile,delimiter=',')
                csv_writer.writerow(data_array[-1])
    except KeyboardInterrupt:
        ser.close() # close the serial port 
        print('Exiting Loop')
        break # finally, exit loop after save

If we first ensure that the battery is fully discharged (this can be done rapidly by using a high current-draw source), we can observe the battery’s behavior as it goes from fully discharged to fully charged. We expect to see several stages of the charge curve: a startup stage involving a rapid change in cell voltage, a constant current stage where the current is steady and the cell voltage is slowly changing, and finally a constant voltage stage where the cell voltage reaches an asymptote and the current decreases [read more about charge curves here]. Typically, the maximum cell voltage is set to 4.2V, which is what we use as the predictor for the maximum voltage in the case of the V25 battery. 

The experimental procedure for logging battery voltage is quite simple:

1. Ensure the Arduino, INA219, and V25 Battery Pack are wired correctly
2. Start the Python data acquisition script
3. Set the input voltage to 5V (±5% for DC wall plug supplies)
4. Set the input current to 2A (or ensure the wall plug can maintain this)
5. Wait for the current to reach approximately 0mA on the Python plot
6. Look for the file stored locally with the voltage/current experiment data

Another Python script is included below for data analysis and visualization purposes:

##################################################
# ---- Python Data Plotter (for: Arduino+INA219)
# 
# ---- Maker Portal LLC Copyright 2020
# ---- Written by: Joshua Hrisko
#
##################################################
#
# This code reads from locally saved .csv files
# that have Arduino + INA219 values saved by
# the Python script: INA219_pylogger.py
#
##################################################
#
import numpy as np
import matplotlib.pyplot as plt
import csv,datetime
#
################################################
# Data File Reader
################################################
#
#
csv_filename ='./arduino_data_2020_10_31_13_52_15.csv'
data = [] # data vector for storing values
with open(csv_filename,'r') as csvfile:
    reader = csv.reader(csvfile,delimiter=',')
    header = next(reader)[0].split(',') # header info
    for row in reader:
        data.append([float(ii) for ii in row]) # append data into array

data = np.array(data) # put into numpy array
# scale voltage based on 4.2V peak:
data[:,3] = (4.2/np.nanmax(data[:,3]))*data[:,3] 

start_indx = 0 # start index
end_hour = 6 # hour when charging stops
end_indx = int(end_hour*(3600.0)) # end index 
data = data[start_indx:end_indx,:] # clip data
#
################################################
# Plot Routine 
################################################
#
plt.style.use('ggplot') # visual formatting
fig = plt.figure(figsize=(14,9)) # open figure
ax = fig.add_subplot(111) # add subplot

t_vec = data[:,0] # time vector 
t_diffs = np.append(0.0,np.diff(t_vec)) # finding spikes
t_vec/=(3600.0)
lines,lines_leg = [],[]
for ii in range(1,np.shape(data)[1]):
    plot_data = data[:,ii] # variable (currrent, voltage, etc.)
    y_diffs = np.abs(np.append(0.0,np.diff(plot_data))) # de-spike
    if ii==2: # place current to other side of x-axis
        current_label_color = plt.cm.Set1(0)
        ax2 = ax.twinx() # move current to other side of axis
        ax2.plot(t_vec,plot_data,label=header[ii],
                 color=current_label_color,linewidth=3.5) # current plot
        ax2.set_ylabel('Current [mA]',fontsize=16,color=current_label_color)
        ax2.tick_params(axis='y',colors=current_label_color)
        ax2.spines['right'].set_color(current_label_color)
        ax2.grid(False)
    else:
        current_label_color=plt.cm.Set1(ii)
        ax.plot(t_vec,plot_data,label=header[ii],
                color=current_label_color,linewidth=3.5) # voltages
    lines.append(plt.Line2D([0],[0],color=current_label_color,
                                                label=header[ii]))
ax.legend(handles=lines,bbox_to_anchor=(0.7,0.5,0.25,0.25),
          fontsize=14) # plot legends 
ax.set_ylim([2.5,6.0]) # set voltage axis bounds
ax2.set_ylim([0.0,2200.0]) # set current axis bounds
ax.set_xlabel('Time [hours]',fontsize=16)
ax.set_ylabel('Voltage [V]',fontsize=16)
fig.savefig('V25_charge_cycle_readouts.png',dpi=300,bbox_inches='tight')
plt.show()

The script above will create a visualization of the charge curve for the V25 battery. We should see several of the stages expected: startup, constant-current (CC), constant-voltage (CV). If these are not visible on your curve after several hours – there is likely either a wiring issue, Arduino code issue, or Python code issue. Look for errors in wiring if the current are very low or voltages are very low. It is also possible that the charger being used is insufficient. It is best to use a supply to get accurate and steady input. 

Figure 4: V25 charge cycle results showing the different stages of charge. The cell voltage (purple) has been approximated using a scale factor of 1.84.

The results from our charging experiment are shown above in Figure 4 , where we see five stages of charging. We see the startup stage where the D+ voltage output ramps up, then we see stage two with the long constant-current (CC) spanning just over one hour; finally, we see a crossover stage where the current begins dropping off. The LEDs on the V25 battery stop blinking somewhere in the middle of the third stage, as expected. Then, we see a sharper current dropoff decreasing further, while the voltage starts to decrease as well. Finally, a switched-off stage appears where the current is approximately 0mA and we see steady cell and input voltages. This process takes roughly 3.3 hours, whereas, the technical time to a state-of-charge (SoC) of 100% takes approximately 2.5 hours.

Conclusion and Continuation

In this tutorial, we showed how to read the voltage of the cells in a V25 USB Battery Pack with an Arduino board. The Arduino was wired to the V25 battery, an external power supply, and an INA219 current/voltage sensor. An Arduino code was then introduced as a way of monitoring the input voltage, load current, and cell voltage. A datalogging routine in Python acquired data from the Arduino board that represented each input and plotted the results in real time.

In the next post, we will show you how to use the cell voltage to monitor charge level and change behavior of your application. For example, when the battery starts to become low, you can put your device into a sleep mode or transmit data less frequently.

Bug Labs has ended their free plans of freeboard so we are no longer reporting data for this tracker as of April, 2018. You can use the same code and update to other IoT dashboards.

Since this system is intended to operate remotely, we focused on reducing power consumption so that the tracker can run from a small solar panel and battery pack.

Getting Started:

The tracking device will locate itself with the GPS/GSM signal and upload the location to the server using the GSM signal. We acquire and transmit the GPS/GSM location every 30 minutes and then put the device in deep sleep mode.

We are powering the device with a 1200 mAh, 3.7V LiPo battery recommended by Adafruit and we keep that charged using Voltaic V15 “Always On” battery pack and a 3.5W solar panel.

Parts List

Required:

1. Adafruit FONA 808 Shield (https://www.adafruit.com/product/2636) and accessories: SIM Card (https://www.adafruit.com/product/2505), Lipoly Battery (https://www.adafruit.com/product/258), External GSM Antenna (https://www.adafruit.com/product/1991), and External Passive GPS Antenna(https://www.adafruit.com/product/2461).
2. Arduino Pro Mini 5V (https://www.adafruit.com/product/2378) and accessory: USB to TTL cable(http://a.co/i8mCIDd).
3. Adafruit Micro Lipo Charger(https://www.adafruit.com/product/1904)

Optional:

1. XActo knife (http://a.co/ezihBvr).
2. Arduino Uno (https://www.adafruit.com/product/50).
3. Jumper Wires(https://www.adafruit.com/product/758)
4. Voltaic V15
5. Voltaic 3.5 Watt, 6 Volt Solar Panel
6. F3511-MicroUSB Connector
7. PG 13.5 Waterproof Gland

Enclosure & CAD Model:

To make sure all the components were secure, we customized and 3D printed this case.

You can access the design on the Sketchfab link at https://skfb.ly/6qSZq or Github and download the STL files. By zooming in the case, you can visualize the Voltaic V15 battery pack on the top and the Arduino, GPS/GSM board, charger, and LiPo battery on the lower half.

Here is detail of the posts in the case designed to hold each component including the battery.

A hole in the case accomodates a PG13.5 gland. This allows us to make a waterproof connection from the solar panel to the Voltaic battery inside the case.

Hardware:

Start by cutting the thin metal trace between the two larger pads of the GND pin on the FONA board. Make sure to scrape it away using an XActo knife or any other sharp metal tool. By doing this, you will be able to wake/sleep the FONA board.

Next, refer to the Fritzing diagram below and make the proper electronic connections.

This is what the components will look like inside the case.

The completed case with components looks like this.

Notice that the LiPo battery is the primary power source for the FONA and Arduino board. The V15 battery keeps that topped up. Also, make sure to manually switch the button on the FONA board from charge to power mode. Lastly, properly install the SIM card (we used Ting from the Adafruit site) as well as both the GSM and GPS antennas.

Software:

For the coding part, we should acquire a location every 30 minutes (timeout 1minute), upload the data to the server, and put Arduino in deep sleep between transmission. Failure might occur while acquiring or uploading a location to the server thus we should always monitor the process by providing an override software reset in every step of the code. Preventing a failure using the out of the shelf Arduino Pro Mini is not possible therefore we need to bootload the Arduino with a different software “Optiboot”. Follow the first 4 steps to flash Optiboot and then Upload the Code to your Arduino.

Step 1: Upload the ArduinoISP code located under Examples to the Arduino Uno.

Step 2: Install Optiboot by following the instructions at this GitHub Link: https://github.com/Optiboot/optiboot under “To install the Arduino software”.

Step 3: Connect your Arduino Pro Mini to an Arduino Uno acting as an ISP programmer by referring to the Fritzing diagram below.

Step 4: Under tools select “Optiboot on 32-pin cpus”, “ATmega328”, “16MHz”, “Arduino as ISP” and flash the bootloader by selecting “Burn Bootloader”.

Step 5: Disconnect the Arduino Pro Mini from the Arduino Pro Uno.

Step 6: Connect your Arduino Pro Mini to the PC via the USB to TTL Cable.

Step 7: Access the Arduino code from GitHub at https://github.com/VoltaicEngineering/Solar-Bicycle-Tracker and modify the code by customizing “yourthing” variable.

Step 8: Upload the modified code to your Arduino Pro Mini.

System Power Consumption:

The Arduino Pro Mini is consuming only 23 μA while in sleep mode and a maximum of 20mA with peaks of 2A while acquiring a location. We believe that the system can run for at least a week without any solar charge.

Data Presentation/Server Side:

We are uploading the location to a Dweet server and we would like to graphically display it on the Freeboard website. Access Freeboard.io, create an account and follow the instructions to customize your dashboard.

Step 1: Create a new panel and give it a name (example: Solar Bicycle Track).

Step 2: Access the newly created panel and select “ADD” under Datasources.

Step 3: Select the Dweet.io as a type of Datasource and enter the modified “yourthing” from the Arduino code in the THING NAME.

Step 4: Select “Add Pane” and start customizing your dashboard. Select different type of widgets and replace the [“gsmlatitude”] to any of these (“gsmlongitude”,” ti” referring to time,” da” referring to date,” gpslatitude”,” gpslongitude”, “batt” referring to battery % level) streamed by Arduino.

On the Bicycle

The Xtracycle has lots of nice mounting points for everything. On a traditional bike, we could see this going under a bike rack. Here, we use the hooptie to mount the panel and the cargo rack to hold the case.

Tracking the Bicycle

Read more information on Voltaic Systems work powering remote IoT products.

About the Author: Karim Chamaa is a Mechatronics and Robotics Engineer. His portfolio can be found here.

A solar charger is a portable power system made up of a solar panel and an external battery pack. For Voltaic Systems, we pair one of our high performance, monocrystalline solar panels with a solar optimized lithium ion battery pack. When paired together these systems use solar energy to charge your electronics anywhere you need power. So how do these systems work?

How do Solar Charger Work? The Short Answer…

When sunlight hits solar panels, the solar cells generate electricity. This electricity flows into a lithium ion battery pack with stores and regulates power to your devices when plugged in.

Shop Solar Chargers

How do Solar Chargers Work? The Long Answer…

We’ve created a four part tutorial to take you through every stage of the process. Solar is obviously much less predictable than plugging into the grid so we’ll be focusing both on specifications and what to expect in the real world. Bring along a multimeter and some parts from Amazon and you can get a pretty good idea of how exactly how solar charger work.

• Tutorial 1: How do I measure Open Circuit Voltage and Short Circuit Current? (below)
• Tutorial 2: How do I measure total power output?
• Tutorial 3: How (and why) do I store power?
• Tutorial 4: How do charge circuits protect the battery?

Tutorial 1:

How do I measure Open Circuit Voltage and Short Circuit Current?

There are lots of great resources on how solar panels generate electricity including Wikipedia so we’re going to focus here on measuring the Open Circuit Voltage and Short Circuit Current of a solar panel in “perfect” and less than perfect conditions.

Every solar panel has a rated output that includes its Open Circuit Voltage (Voc), Peak Voltage (Vmp), Short Circuit Current (Isc), Peak Current (Imp). The Peak Voltage and Short Circuit Current tell you the Voltage and Current of the panel before you connect it to anything, e.g. there is no load attached to the panel.

As a reminder, Voltage is represented by the symbol V for Volts and is a measure of the difference in electric potential energy between two points. Like air pressure, it flows from high to low. Current is a measure of the flow of charge through an area over time. We use the symbol I to stand for current and measure it in Amps, or simply A for short.

Let’s measure the output of a solar panel. You’ll need:

• Multimeter
• Solar Panel – we use our 2 Watt 6 Volt solar panel that uses Monocrystalline cells, but you can use any panel you have lying around with any type of cells
• Sunlight – alternatively, you could use a couple high-powered incandescent bulbs but then you don’t get to spend the afternoon outside

1. Measure Open Circuit Voltage – The black lead should be connected to COM and the red lead should be connected to V or VDC. Set the dial to 20 which means the Multimeter can measure up to 20 Volts.

Touch and hold the black lead to the “sleeve” of the solar panel connector or the black wire. Now touch and hold the red lead to the red wire or insert it into the “tip” of the solar panel connector.

You’ll notice that the Voltage moves around, but with the panel pointed at the sun, we saw between 6.89 and 6.98 Volts for Open Circuit Voltage. This is close to our specification of 7.0V Open Circuit Voltage on the 2 Watt panel.

2. Measure Short Circuit Current – The black lead should be connected to COM and the red lead should be connected to the mA. Set the dial to an amount greater than what you expect the current to be. In our case, we set it to 10.

We measured got 0.33 Amps or 330 mAmps which is close to our specification of 333mA.

3. Assess the impact of real-world conditions.
In the real world, it is not sunny all the time and our panels are not always pointed directly at the sun. So what happens when we move away from perfection?

Angle the panel so that it is facing the sun and record the voltage. Try slowly angling the panel away from the sun and note the changes in Voltage and current. Try shading parts of the panel and then the whole panel and note the changes in Voltage and current.

Here is what we recorded:

Thumb covering half a cell

Thumb covering whole cell

Solar panel with heavy shade

As you can see, minor changes in angle don’t have a very significant impact on Voltage or current. However, once you get to about 45 degrees away from the sun, current starts to drop very sharply, meaning total power will also drop.

Similarly, light shadows on the panels decrease current by about 25%, but a heavy shadow over all or part of the panel drop panel output by 90%.

Move on to Part 2 of our Tutorial – How do I measure total output? In this tutorial we start connecting solar panels to loads and measuring how much power it is capable of generating.

Skip ahead to Part 3 of our Tutorial – How (and why) do I store power? In this tutorial we explain how to store solar energy in batteries for use when there is no sunlight available.

Skip ahead to Part 4 of our Tutorial – How do charge circuits protect batteries? In this tutorial we explain how built-in circuits protect both our batteries and your devices.

This post has been updated from our original post in September 2011.

In this guide we look at the options you have when deciding on solar panels for small motors starting with how to begin select the right panel for your motor. In general, we found to get the best performance to cost/size ratio when the voltage of the panel slightly exceeded the voltage rating of the motor and a peak current 25-50% higher than the max current of the motor.

Please repeat the tests for your projects and let us know what you find.

We experimented with four simple motors:

• DC Toy Hobby Motor (4.5 – 9V, 0.25A)
• HSD-8025 Brushless DC Cooling Fan (12V/ 0.12A)
• DAGU robot DG01D Mini DC Gear Box (4.5V, .25A)
• Liquid Pump – 350GPH (12V, 1.5A)

And we used a suite of panels for testing including: 2 Watt, 6 Volt / 3.5 Watt, 6 Volt x 2 (paired in series to get 12V) / 6 Watt, 6 Volt / 9 Watt, 6 Volt / 9 Watt, 18 Volt / 17 Watt, 18 Volt panel.

Shop Solar Panels

Making the Connection

You can simply twist the positive and negative leads from the solar panel to the motor. We recommend using our 1 Foot Extension so you don’t have to hack our cable.

To make things easier to swap panels and take measurements, we wired each of the small motors and our extension cable with exposed leads to jumper wires.

This DAGU Motor already had jumper wires.

Basic Behavior

When a panel isn’t connected to anything, it has a relatively high voltage and zero current. Our 2 Watt, 6 Volt panel has an open circuit voltage a bit over 7V. As soon as you connect to the motor the voltage drops and, if you meet the minimum threshold of the motor, current flows and the motor spins.

In this video, you will see motor speed up when pointed directly at the sun and slow down when panel is angled away from the sun or shaded.

2 Watt, 6 Volt Panel Results

With a 2 Watt, 6 Volt panel and less than ideal conditions, the motor spins, but the motor draws less voltage and current than its’ specification. In good conditions, the voltage and current climb slightly above the spec of 0.25A and the total power through the motor is about 3/4 of the rated specification of the panel. When we connect to a larger 6 Watt panel, the motor reaches a maximum current of 0.43 Amps, well above the spec of the motor and less than half the rated output of the 6 Watt Panel. Our 2 Watt or 3.5 Watt panel seems like the best fit if you are expecting reasonably good conditions.

DAGU DG01D Results

We see similar behavior with the DAGU DG01D, but it has more resistance than the toy motor and needs more power to reach its max. A 2 Watt panel can get it turning, but it is too small to get much speed going and we’re only able to get about 30% rated power from the panel. In this case, we’re exceeding the rated current with a 6 Watt panel in perfect conditions, but in imperfect conditions, we are able to make the motor move consistently. We’re also getting 75% of the rated power into the motor. Bumping up to 9 Watts, it is easy to exceed the max current specification of the motor in a range of conditions.

Low Voltage Kills Power

We tested also tested a 12V motor, 0.1A motor with 2 x 6V panels in series and parallel (6V and 12V). With the lower voltage setup, the voltage, current and total power output were less than with the panels in series, the power output increased by about 4X. The lesson is that if the panel is well below the rated spec of the motor, it may spin, but you will be wasting a lot of power.

Real Work – Doubling Power on a Pump

If you are below the rating of a motor or pump, increasing the amount of solar power, will increase the power through the motor. As a quick example, we connected a single 17 Watt panel up to a water pump and it moved water pretty quickly out of the bucket through a 3/4 “ hose. However, that panel outputs 1A max, below the maximum rating of the pump. Adding a second panel increases the current and voltage and increases the through put of the motor.

Parts List
– 12volt 20amp hour deep-cycle battery (available at Lowe’s or your local marine store)
– Velleman SOL4UXN2 solar DC charge controller 5A max input. Switched 12/6/3 volt output. Input for two panels.
– Blue Sea Systems Dual USB Charger Socket (x2)
– Bicycle headset spacers 32mm, metal as standoffs and heat sinks for USB chargers
– Voltaic 16.8 watt 18 volt panel
– 24 year old Plano tackle box (check eBay!)
– Various odds and ends from the parts box

According to our Ben, “the lead acid battery just fit in the tool box with two strips of aluminum angle riveted to the bottom to keep the battery centered. The charge controller, V39 battery/V11/V15, adaptors and USB chargers fit in to cutouts in the upper tray partitions with the battery and charger cables exiting the bottom of the tray.

The Velleman SOL4UNX2 has switched 12/6/3 volt power outlets using 1/4″ and two 1/8″ audio jacks. The plan is to connect the Fuse 10W to the second input to increase the incoming current.

Designed for damp environments, the two Blue Sea Systems USB chargers will charge one device at 2.1 amps or two devices each at 1 amp. A green LED confirms power at the chargers with a 15mA parasitic current.

iPads, iPhones, any USB device can be charged from this set up as long as the total current draw is kept at or below 4A.

The weight, not including solar panel is 17.4 lbs. Not exactly bike portable, but good for car camping.”

Thanks to Ben for sharing the project.

Here’s a guide to building a USB powered LED lamp compatible with Voltaic Systems products. This is a quick and easy way to convert the solar energy we’ve stored in our Voltaic Systems batteries into light. We’ve used ours when building some cables in low light conditions, but it could also be useful on a camping trip.

Note: As with all our DIY projects, try this project at your own risk. Voltaic Systems makes no guarantees against damage to the Voltaic battery or your LEDs. Use caution in your wiring.

Instructions: Solar Lamp

Parts List:
• 3x White LEDs
• 3x 8 ohm resistors **
• Electrical Wire ( we recommend 22AWG stranded)
• Craft Wire (we recommend 18 AWG)
• Shrink Tube
• USB male plug
• USB Battery Pack

Tools:
• Soldering Iron
• Pliers
• Wire Cutters
• Wire Stripper
• Heat Gun

There are two pins on each LED, one is the positive (+) pin or anode, and the other is the negative (-) pin or cathode.

Attach the resistors to the anode pins of the LEDs. Then cover the resistors and LED pins in shrink tube to prevent short circuits in the future.

Twist together and solder the resistor pins so that the common connection is in the middle of the three LEDs. Trim back excess pin material.

Solder a red wire (for positive connection) to the bundle of resistor pins and cover this connection with shrink tube.

Solder wires to the cathode pins of the LEDs. Then twist and solder the other end of these wires together. Solder a white wire (for a negative connection) to the bundle of LED cathode wires. Cover this joint with shrink tube as well.

Cut a length of craft wire.

Wrap one end of the craft wire around the LED assembly. Use shrink tube to keep the electrical wires fixed to the craft wire. Wrap the electrical wire around the craft wire.

We used a USB connector from one of our output wires. The red wire is connected to pin #1 of the USB plug, and the white wire is connected to pin #4. Connect the wires from the LEDs to the wires on the USB plug. Cover the connection in shrink tube. Wrap the craft wire around the USB plug and twist to lock into place. You may consider using an epoxy or other adhesive to make this connection if wrapping and twisting isn’t enough.

Finally, turn on the battery and connect the light!

Performance
For a small 3-LED lamp, it outputs quite a bit of light. The quality leaves a little to be desired (it is a very cool 7500K) and the output is too focused to be a general use lamp. It works really as a reading light and as a focused work light for detail work. The LED Lamp is designed to use 500mA at 5V or 2.5W. The V11 capacity is 11Wh, so you can expect this LED Lamp to run for about 3.5 hours before the V11 needs to be recharged.

** Calculating the Resistor Size
To calculate the resistor size we determined that we wanted to draw no more than 500mA from the V11. Because the LEDs are wired in parallel the total share of 500mA for each is about 167mA (500mA / 3). For our lamp design, each LED is its own circuit consisting of a 5V power supply, an LED and a resistor. Our power supply is limited to 5V and the LEDs require 3.7V to begin conducting fully, which leaves a 1.3V drop across the resistor (according to Kirchoff’s Voltage Law). Because the resistor is the element which limits the current flow in the system, we must calculate its minimum size given the voltage drop across it and the current restriction we set above. Using Ohm’s Law (V=IR), we can solve for Resistance (R) using Voltage (V) =1.3V and Current (I) =.167A. We get about 7.8 ohms (R=1.3V/.167A). The closest standard resistor value we had in our lab was 8 ohms, which is what we recommend for your project.

Increasing the resistance will make your lamp less bright. It is not recommended to reduce the resistance below 8 ohms. This may cause damage to the LEDs or any USB supply you connect your lamp to.

Once you have assembled the LED lamp cluster, try inserting different resistor values between the USB connector and the red wire leading to the LEDs. Using a switch, it is possible to choose between full brightness and a dimmer output.

Voltaic Systems employee, Phillip Stearns will be teaching a 2-day class in DIY Renewable Electricity at 3rd Ward in Brooklyn, NY.  Students will learn how to charge AA batteries using our 2-Watt solar panels, as well as from bike driven dynamos. Sign up now and reserve your seat. If this class session fills up, there will be more classes scheduled for February and March 2012.

1. Replace the stock batteries with higher capacity batteries
2. Modify the battery compartment to accept Voltaic Systems small solar panels
3. Re-wire the lamp to accommodate Adafruit’s MintyBoost module

Disclaimer: We here at Voltaic Systems are trained professionals and have taken precautions to ensure that this modification is fully functional; however, we cannot guarantee that it complies with any safety standards or regulations and is not responsible for any damage that might occur to the lamp, batteries, or any other device connected to the modified circuits. Batteries can overheat and catch fire if overcharged or short circuited. Attempt this modification at your own risk!

Things you’ll need:
• Sunnan IKEA Lamp (available here)
• soldering iron, solder, solder wick/pump
• pliers, wire cutters, wire strippers, utility knife
• phillips head screwdrivers (medium and small)
• rotary tool (dremel, etc.), cutting wheel, routing bit
• epoxy putty (quick setting is the best, we use JB Weld)
• power drill, 5/16” bit
• MintyBoost v3 by Adafruit (available here)
• 2x Schottky Barrier Diodes (1N5817)
• 1x 39K Ohm resistor
• Small piece of circuit prototyping or perf-board
• USB output wire from Voltaic Systems
• 2 Watt solar panel from Voltaic Systems

UPGRADE THE BATTERIES

Remove the Battery Pack from the lamp base and remove the four screws from the corners.

Remove stock IKEA AA NiMH batteries. Replace with higher capacity cells. We used Tenergy 2700mAh cells. Energizer, Duracell, and other provide comparable high-capacity cells. This boosts capacity of the battery pack from about 4.3Wh (1.2V * 1.2Ah * 3 cells) to about 9.7Wh (1.2V * 2.7Ah * 3 cells).

INSTALL INPUT FOR MORE SOLAR PANELS

Remove the screws holding the circuit board inside the battery pack in place. This board contains a fuse, blocking diode between the solar panels and the batteries, and a current regulator to limit the amount of current flowing from the batteries into the light. De-solder the wires connected to the circuit board. Set this board aside, as we will be re-installing it in the lamp base a bit later.

Our External Solar input will be made from the Voltaic Systems USB output wire (available at the bottom of this page). Cut the 3.5×1.1mm female end of the USB output wire from Voltaic Systems about an inch into the curly wire. Strip back the jacket to gain access to the two wires. Strip and tin the tips of each of the wires.

Drill a 5/16” hole in the side of the battery case to permit access the 3.5×1.1mm External Solar socket

Insert the 3.5×1.1mm External Solar socket into the battery case and epoxy it into position.

While the epoxy is setting, create a diode junction using the two 1N5817. Connect the cathodes together and leave the anodes open for connections from the solar panel and the external solar input. This allows energy to flow from both the supplied Sunnan Solar Panel and the External Solar input into the batteries without them interfering with one another, and prevents the batteries from discharging into either panel.

Solder the solar panel + and the external solar + wires, one to each of the Anodes on the diode board. Solder the battery + and the connector + wires to the Cathodes on the diode board.

Join all of the negative wires in the battery pack and solder them together (battery -, solar panel -, and external solar -. Then solder them to the negative tab on the battery pack connector socket.

Check your wiring and make sure that there is a positive voltage (around 4V if batteries are fully charged) between the connectors for the battery pack socket. Then close the battery case.

MINTYBOOST!

Assemble your Adafruit MintyBoost v3. The only change you need to make is to replace resistor R4 with a 39k ohm resistor. Instead of connecting to the battery pack provided with your Minty Boost kit, attach about 6 inches of 24 AWG stranded wire to the + and – points on the PCB.

The replacement of R4 with the 39K ohm resistor reconfigures the MintyBoost USB pin voltages to measure as below:

• Pin1 = 5V
• Pin2 = 2.75V
• Pin3= 2V
• Pin4 = 0V (ground)

This tells Apple devices, such as the iPad2, that is can draw up to 1A from the supply. If you wish to limit the current to 500mA, use the resistors supplied with the kit as directed. Please note that the iPad2 requires the 1A configuration to charge and that by reverting to 500mA, the iPad2 will not support charging.

REWIRING THE LAMP

Turn the lamp base over and remove the 4 screws.

Remove one of the cast-iron weights in the base of the lamp.

Using a routing or grinding bit, remove the screw-post to create a space for the MintyBoost.

Mark and route a hole for the USB port of the MintyBoost.

Peel off one side of the small adhesive pad included in your MintyBoost kit and place the pad in the lamp base.

Remove peel off the other side of the adhesive pad and insert the MintyBoost.

Remove the two screws holding the cover for the two-prong connection to the battery pack in place.

Mark the prongs indicating which wire was soldered to them (black is negative and white is positive). Remove the wires from the solder pads.

Solder the black wire going to the LED to the “L-” pad on the Sunnan circuit board, and the white wire running to the lamp switch to the “L+” pad on the Sunnan circuit board.

Solder a wire from the negative prong to the “BT-” pad on the Sunnan circuit board, and solder a wire from the positive prong to the “BT+” pad on the Sunnan circuit board.

Use a cutting wheel or routing bit to remove enough plastic to stow the Sunnan circuit board at the base of the goose neck connection.

Remove the fuse on the Sunnan circuit board and replace with a piece of jumper wire.

Solder the negative power wire for the MintyBoost to the “Sun -” pad on the Sunnan circuit board. Solder the positive wire for the MintyBoost to the “BT+” pad on the Sunnan circuit board.

Tuck the Sunnan PCB into the pocket you routed out near the goose neck in the lamp base. Tidy up any wires from the minty boost. Then close everything up! You’re done!

Connect an external solar power to the battery pack and place in sunlight to charge.

After a day of charge, you should be able to use the desk lamp as normal AND give your iPad a boost.

We’re still doing testing, but the results so far are promising. Here’s a look at the type of performance you can anticipate from these modifications:

With a 1.4W panel attached to the .5W panel of the Sunnan lamp, we can generate a peak of 1.9W. Under normal real-world conditions we can expect to produce about 1.5W average. NiMH batteries are only about 65% efficient at storing that power so we can expect that a 9.7Wh capacity battery pack like the one we’ve modified the Sunnan with will take roughly 10 hours to fully charge (9.7Wh / 1.5W / .65). Assuming that the charge transfer efficiency from the NiMH batteries via the MintyBoost into the iPad2 is roughly 70%, we can expect about a 25% boost to the iPad2’s 25Wh battery from a full charge (9.7Wh * 0.7 / 25Wh).

As far as the lamp run-time is concerned, the internal current to the LED is limited to 200mA. Assuming that the average battery pack voltage is 3.6V (1.2V * 3), we can estimate the power consumption of the LED at about 720mW (3.6V * 0.2A). From a 9.7Wh battery, we get just over 13 hours of light from a full charge (9.7Wh / 0.72W).

Notes: Discharging into an iPad 2 causes the battery pack to become warm. Although it is possible to both use the lamp feature and the charging port, it is more effective to use only one at a time.

Here’s the full post on how to build battery charging dynamo.