CourseLover
$10/per page/Negotiable
spelling , grammar and everything in report
I. Executive Summary
II. Introduction
Background
Solar Cell Theory
The group was given the task to maximize the efficiency of a solar panel facility. This would be achieved by increasing the amount of sunlight intensity into each solar panel. When light hits a solar panel, the electrons in the doped solar cell, n-type doped and p-typed doped, break away from their bonds and create an electric current. The electric current then is transferred to the metal contacts within the panel to allow the energy created to be used outside the panel.
Figure 1. Representation of Light Hitting Solar Cell
In all renewable energy, the efficiency output will never be 100%. Most solar panels operate at only 11-15% efficiency when positioned in a stationary position. The low efficiency is due to many different factors. Before the light ever hits the panel it loses more than 30% of efficiency. This loss of energy is created by the scattering of molecules due to Earth’s atmosphere, the scattering of molecules due to aerosols and dust particles, and absorption of the molecules within the atmosphere and gasses in the air.
Even after the light intensity is weakened by over 30%, more losses can occur once the light hits the solar panel. When the lightcomes in contact with the panel, the light is reflected off the panel and the rest of the light is transmitted through the material. The energy within the transmitted light can be absorbed by the solar cell if the energy is high enough. The energy absorbed causes electrons to break from their respective bonds and the movement of the electrons creates an electric field. Within the panel, the light that is absorbed can also be lost due to recombination of electron-hole pairs.
The efficiency can be increased by changing the angle and orientation of the panels with the sun. Maximum power is outputted by the panels when the array is 90 degrees relative to the sun. Being exactly perpendicular to the sun all day gives the panel the maximum solar intensity at every second of the day, no matter what the efficiency losses occur.
Overview of Solar Power
The current layout of the solar facility is stationary arrays. The stationary arrays are placed in a position such that the maximum amount of energy is captured throughout the year.
The focus of the group was designing and building an effective way to capture the maximum amount of light intensity. This is achieved by maximizing the solar panel’s orientation to the sun during the year, particularly throughout the day. Improving panel orientation will increase the amount of sunlight captured by the panel, which will in turn increase solar energy production and increase the client’s profits.
World solar energy usage has grown substantially over the years. This growth is due to the cost of installation decreasing drastically. When solar energy first came about, the cost of installation and operation was far greater than its savings. With modern technology the cost has reduced, therefore increasing the frequency of use. Not only is this good for the consumers, but also plays a role in conserving earth’s non-renewable resources and cutting out pollution.
Over the last several weeks, the group has spent time working independently as well as collectively. The work performed was researching alternatives in order to develop a final design that will increase the overall efficiency of the solar facility. The tasks completed by the group are as follows: developing constraints, brainstorming for alternative solutions, developing selection criteria, narrowing the solutions to three preliminary designs, assigning the selection criteria a weighted value, narrowing the preliminary designs down to one final design, and planning the general direction the group is heading when entering Senior II the following semester.
Figure 1 below is the current solar facility that is being renovated by the group. The panels are set in a stationary position on top of a single pole stand. The panels are facing 170 degrees south with a 60-degree azimuth angle. The panels are able to be adjusted manually by removing the bolts that hold the bracket together and positioning them to the desired angle. A change of 5 degrees per set position may be selected. With several arrays making up the solar facility this process can be quite cumbersome. An automated system would free the time that would be required to perform such a task. This time could be used for more constructive tasks that need to be completed in the facility.
Figure 2. Solar Facility
Constraints
Constraints act as requirements on the system given as guide lines for the system to meet in order for the system to operate almost flawlessly. Typically, the constraints are set by either a governing operation or by whomever is requesting the design. As a result of the group evaluating many different scenarios and the risks that could occur the group has come up with the following constraints.
1. Human safety (high voltages),
2. The size of the solar facility,
3. Size of the array,
4. The landscape and geography of the location,
5. Weight of array,
6. Surrounding environment (wildlife and plant life safety),
7. Dirt and dust on panels,
8. Heat induced on the panels,
9. The weather affecting the system in different locations,
10. Reflection cannot affect motorist.
Research from Senior I
III. Safety
Solar safety provides information to help develop safe work practices for typical solar panel projects; it requires the ability to evaluate unique situations to actively create safe work practices. solar panel and must resist harsh weather. A faulty setup can lead to the device falling from the post and injuring passersby. The battery must also secure neatly and away from human intervention. Tampering with the battery or microcontroller causes bodily damage and device damage. The device design considers safety to other species as well. The design eliminates exposed wiring or sharp edges that could damage animals interfering with the device. This manual prescribes the following process to minimize workplace hazards:
1. Evaluate and identify hazards.
2. Eliminate or remove hazards.
3. Control hazards that cannot be eliminated.
4. Recover from accidents.
Photovoltaic Systems (PV) shell be permitted to supply a building or other structure in addition to any other electricity supply systems. Identification and grouping. (PV) source circuits and PV output circuits shall not be contained in the same raceway, cable tray, outlet box. PV system conductors shell be identified and grouped as required.
The safety program is listed as the electrical safety in principles, controls, and procedures.
Electrical Safety Program (Principles)
1. Inspect the project equipment.
2. Maintain the electrical equipment’s insulation and enclosure integrity.
3. Plan every job and document first-time procedures
4. Anticipate unexpected events
5. Identify and minimize the hazard
6. Protect the employee from shock, burn, blast, and other hazards due to the working environment
7. Use the right tools for the job
8. Assess people’s abilities
9. Audit these principles
Electrical Safety Program (Controls)
1. Every electrical conductor or circuit part is considered energized until proven others
2. No bare-hand contact is to be made with exposed energized electrical conductors or circuit parts above 50 volts to ground. Unless the “bare-hand method” is properly used.
3. Deenergizing an electrical conductor or circuit part and making it safe to work on is in itself a potentially hazardous task.
4. Use procedures as “tools” to identify the hazards and develop plans to eliminate the hazard
5. Train employees to qualify them for working in an environment influenced by the presence of electrical energy
6. Use logical approach to determine potential hazard of task
7. Identify and use precautions appropriate to the working environment
Electrical Safety Program (Procedures)
1. Purpose of task
2. Qualifications and number of employees to be involved
3. Hazardous nature and extent of task
4. Limits of approach
5. Safe work practices to be utilized
6. Personal protective equipment involved
7. Insulation materials and tools involved
8. Special precautionary techniques
9. Electrical diagrams
10. Equipment details
11. Sketches/pictures if unique features
12. Reference date
And here are some pictures that prove the group members were so careful and using the safety tools.
IV. Structural
For the fabrication and testing the group spent many hours not only constructing an array, but also spent countless hours testing if what had been built was functional and would continue to work for the duration of testing. In testing the group was also responsible for collecting data that would determine if building a dual axis system was actually worth the expenses, meaning it would increase the efficiency enough to save enough money to pay itself off and then last long enough to make a substantial difference in money saved over its lifetime.
Fabrication
The fabrication of the array all started with the group buying the material and then predetermining desired lengths of certain members. Once all the members had been sized the next step was to begin cutting the material and putting it together. The first part of the array to be built was the base so that the group would have something to hold the array while working on it in the immediate future. Once the base had been completed the group began work on the moving parts of the array. The north and south movement of the array was achieved by mounting a single piece of tubing inside the main column and pinning it in place using a single bolt but leaving it loose enough to still allow for rotation. The next main part was determining a way to rotate the array about a horizontal axis or the east and west movement. At first the group thought they could achieve this by building two hinges by binding two separate pieces of steel into U shape and then putting together using rivets. The problem with this design was that the rivets were too tight and would not allow the array to move freely enough. Luckily the group was working in the shop one night and found a set of hinges design the same as the previous and had a much more free range of motion and the group decided to use these hinges instead. On top of the hinges the group place another piece of tubing in the same direction as north and south movement piece, and then bolted two pieces of aluminum L running perpendicular to that member. The solar panel was placed directly on top of these members. In order for the group to achieve the necessary movement needed a 14 inch stroke actuator was attached to the main column and the north and south member to rotate the array around the vertical axis. For the horizontal rotation the group attached another piece of aluminum tubing coming off of the north and south member at a 90° angle down and the attached an 18 inch stroke actuator to that member. The actuator also attached to one of the L-shaped pieces that the solar panel that is attached to. The final piece of the fabrication was to plug the actuators into the control box and the then hook the control box to a battery.
V. Data Recording
Once the array structure was complete, the next step was to record the output of the panel for different orientations. One method to complete this task was using the already owned Raspberry Pi. This device is a powerful microcontroller that meets the needs of the group. The Pi is a mini computer with the ability to communicate with several sensor modules and connect with a local network. In addition to utilizing the abilities of the Pi, the group thought it would be best to have an additional tool to measure the output of the panel. After a bit of research, the group found an energy multimeter with an LCD display. The two were used together to ensure accurate data was received.
Wiring
Energy Meter
The first step the group took for recording the array output was connecting the three E-meters. These meters were used to monitor the panel output, the battery intake and output, and the controller’s intake. Figure . below shows the E-meters installed under the lid of the battery box.
Figure . Battery Box Lid
For the battery, the e-meter was connected in such a way that a positive current denotes charging and a negative denotes discharging. The figure below shows the wiring diagram for connecting the meters to the panel and battery. As can be seen in the image, these meters contain what is called a shunt. The purpose of the shunt is to protect the meter from high currents. With the shunt, the meter reads the voltage drop across it which will be in millivolts. Each millivolt drop is directly equivalent to the amperage flowing through the system.
Figure . Panel and Battery E-meter
With such a low amperage going to the tracking controller, a meter with a shunt resistor was unnecessary. This meter was simply wired in between the battery and the controller in the configuration seen in the figure below.
Figure . Controller E-meter
Not only do these meters display the voltage and current, but also displays the output power along with the accumulated power. Figure below shows an example output reading of the E-meter. The panel and battery meters’ measure voltages between 6.5 and 100 volts, up to 100 amperes, up to 10 kilowatts, and up to 9999-kilowatt hours. The controller e-meter is very similar except it can only measure up to 2 kilowatts, and has a limit of 20 amperes. Both sizes of e-meters take 2 readings per second and have an accuracy of 1%.
Figure . Example Reading
Raspberry Pi
The second piece of equipment that the group used to collect data from the panel was the Raspberry Pi. The group chose the Pi over other microcontrollers such as the Arduino, because of the versatility that it supplies the user. The Raspberry Pi is basically a mini computer, not only can it monitor several different inputs at once but it also interfaces well with the user. The code can be written, compiled, and executed within the Pi, all that is needed is a monitor, keyboard, and mouse. Additional features found on the Pi include; wired and wireless connection to the internet, HDMI output, SD card with software, USB ports, touch screen display connect, and camera connection. Having the ability to store all the code on the Pi and connect to the internet, the user can easily download and update any library within the command terminal.
With the Pi, the group purchased a few different sensor modules to aid them in recording daily data. The group used a light intensity sensor, a temperature sensor, and a power meter sensor. Each of these three sensors was used to monitor daily variables to normalize the recorded data.
The main sensor used by the group was the INA3221 breakout board which measures the voltage and current at a point. Figure below shows the module and Figure . shows the wiring diagram.
Figure . INA3221 Breakout Board
Figure . INA3221 Wiring Diagram
The INA3221 is a very useful module with the ability to take readings at three different locations simultaneously. The downside to this sensor is the inability to read high current levels. The board has an installed 0.1-ohm shunt resistor and can read up to 2 amperes safely. This only means that the group was required to use a larger off board shunt resistor. The group elected to use a 10A/75mv shunt. Before being able to use this shunt, the on board 0.1-ohm resistor trace had to be cut. Figure below shows how to remove the onboard shunt and figure shows how to connect the sensor to the load using both configurations. For this project, the group is required to use the configuration shown at the bottom of the figure. Changes to the INA3221 code was also required and will be elaborated upon in the next section.
Figure . INA3221 Shunt removal
Figure . INA3221 Shunt Setup
The next piece of monitoring equipment the group used was the DS18B20, an analog temperature sensor manufactured by Sunfounder. As previously stated, temperature and efficiency of a solar panel are proportional to one another. Knowing this, the group thought it would be best to record the temperature throughout each day to normalize the data for each configuration. Figure and figure below show the sensor and the wiring diagram to the Raspberry Pi.
Figure . Temperature Sensor
Figure . DS18B20 Wiring Diagram
The final sensor the group used to aid them in their analysis was the BH1750FVI digital light intensity sensor module. This sensor will take light intensity readings of the sun thought the day similar to the temperature sensor, this will allow the group to compare daily readings. For example, a day when the group performs dual axis tracking the sun may not be as powerful as a day when the group does single axis tracking. They wanted to ensure the data was as accurate as possible so nothing was misinterpreted. The applied module and wiring diagram can be seen in the two figures below.
Figure . BH1750FVI Light Intensity Sensor
Figure . BH1750FVI Wiring Diagram
Maybe include figures here or in appendix once sensors are installed on panel
Code
The code used for this project can be found in Appendix . For this section, key areas in the code will be addressed with changes that were required to meet the needs of the project. The first change made to the code by the group was adjusting the INA3221 module configurations to account for the off board shunt resistor. Figure below shows where this change had to be made.
Figure . INA3221 Module Code Configuration
The change was made in the INA3221 module code on line 163. Initially, this line of code did not contain the 7.5, but with using the 10A/75mV off board shunt, the shunt voltage had to be divided by 7.5. The shunt value 10A/75mV means that for every 7.5mV read by the sensor, that is equivalent to 1A. So, if the voltage drop across the shunt was 15 mV, the current through that shunt would be 2A.
The section of code seen below in the figure contains a couple of key section. Lines 33 through 42 contains code that asks the user how long they wish for the program to remain in the while loop and how often they wish the program to take output readings. Line 38 calculates and stores the runtime of the program in seconds and line 41 ask the user how often in seconds they wish to take readings. Next, lines 45 through 48 open an Excel document and stores the variable titles.
Figure . Prompt User
This section of code writes the data read by the sensor to a file. Lines 184 through 189 writes the data to the file and determines the order in which the data will be saved and line 200 closes the file. Line 197 and line 198 checks to see if the code has looped the number of times determined by the user, and line 199 controls how long the code pauses before restarting the loop. The final section of the code is lines 204, 205, and 206 which send a notification text message and the excel sheets to the defined address. This section of code can be seen in the figure below. The code for the notification text message and emails can be seen in the appendix.
Figure . Create and Send File
Figure below shows the main section of code for reading the temperature and light intensity. This section of code creates an additional excel file to store the readings. Similar to the INA3221 code lines 50 and 51 create an excel document, and lines 62 through 64 write the data into the excel sheet. Lines 55 through 61 are used to determine the current temperature and convert it to degrees Fahrenheit. Also, like before, lines 54, 66, and 67 control the while loop and 68 determines the pause before the next reading takes place. The code in its entirety can be found in the appendix.
Figure . Light and Temperature
VI. Controller Circuit
A microcontroller (MCU) is a small computer on a single integrated circuit containing a processor core, memory, and programmable input/output peripherals. A microcontroller can be considered a self-contained system with a processor, memory, and peripherals. It can also be used as an embedded system. Therefore, the group chose DarkStar 2.0 because it is one of the best controller in the market that will provide superior performance and contribute greatly to the quality of our group project. This controller features dual axis remote controlled solar tracker, remote sensor, and Bluetooth support with an integrated Android application that gives unprecedented control over tracking parameters. This Android application can display current status information including actuator position, photo-sensor values, manual control of motors, and customization of all tracking parameters is also supported.In addition, it can discriminately utilize pulse-feedback positioning on both primary and secondary axes. This means that if pulses are detected during the start-up motor test, then the controller will enable all of the features which require pulse-feedback for operation, such as stall protection and customizable park position. Therefore, the controller is compatible with any dual-axis mount based on an altitude-azimuth, equatorial, or Polar geometry. Also, it is compatible with most linear actuators and slew drives that are equipped with direct current (DC) brushed permanent magnet motors. Despite that, there are some restrictions for this controller such as the maximum voltage is 40-volt DC as well 10 Ampere for the current, fuse protected and reverse polarity protected.
VII. Analysis
Results
Scaling
Alternative Design
Throughout this process, the students have analyzed multiple types of designs for individual solar panels which can be scaled and used in the overall solar facility. The main designs researched were the stationary solar panel, movement of a solar panel on a single-axis system, movement of a solar panel on a dual-axis system, and a stationary panel angle against a reflective panel. Each of these designs has its perks and faults.
Stationary Panel
The stationary panel system is in a fixed position that the panel is faced in a specific direction and at a specific angle to create the maximum energy output. The direction of the panel should face due south if the facility is in the northern hemisphere and the panel should face due north if the facility is southern hemisphere. The panel is positioned this way, in order, that the panel is perpendicular to the sun at mid-day. The angle of the panel is changed for the four different seasons. The equations to calculate the angle of the panel for the different seasons can be seen below.
Spring: 
) (Equation 1)
Summer: 
(Equation 2)
Fall: ) (Equation 3)
Winter: 
(Equation 4)
For the analysis done by the students, the latitude of Jonesboro, Arkansas, is 35.84°. The time of the analysis was done during the fall season. So the panel was faced due south and the angle of the panel was positioned to be 33.34°.
(Will add analysis and pro/cons here)
Single-Axis Tracking System
The single-axis solar panel tracking system contains one linear actuator, a LED tracking sensor, solar panel, structure, and a microcontroller. The panel would be faced due south and the linear actuator would change the angle of the panel east to west so the panel would stay close to perpendicular with the sun. This would give the panel more light intensity than the stationary system, but it would still not be exactly perpendicular due to the fact the Earth tilts 23.5° north/south when looking from the equator.
(Will add analysis and pro/cons here)
Dual-Axis Tracking System
The dual-axis solar tracking system contains two linear actuators, a LED tracking sensor, solar panel, structure, and a microcontroller. The solar panel would have a park position when there is no visible sun. The park position should face due south bu at the lowest angle possible for the tracking system to be closest to the sun when it rises above the horizon. The linear actuators would be placed in such a fashion to alter the angle of the north/south axis for different times of the year and to alter the east/west axis throughout different periods of the day. The dual-axis system should cause the panel to be perpendicular, 90°, to the sun at all times of the day which will create the maximum amount of light intensity at all periods of the day.
(Will add analysis and pro/cons here)
Stationary Reflective Mount
In this system, the panel would be mounted at a specific angle throughout the year. A reflective panel would be positioned in front of the solar panel in order to increase the light intensity throughout the entire day. The solar panel and the reflective panel would be positioned and the side view would look like a ‘V’. The solar panel would be faced towards the west and the reflective mirror would face west which would create the maximum amount of sunlight intensity into the panel throughout the day.
(Will add researched analysis and pro/cons here)
Recommended Modification and Additions
VIII. Conclusion
IX. List of References
1. Early, Mark W., and Jeffrey S. Sergeant. "Article 690." NFPA 70 Nec. 2011 ed. N.p.: n.p., n.d. 1108-1140. Print.
2. NFPA 70E: Standard for Electrical Safety Requirements for Employee Workplaces. Quincy, MA: NFPA, 2004. Print.
3. "Solar Construction Safety" http://www.coshnetwork.org/sites/default/files/OSEIA_Solar_Safety_12-06.pdf. Web.
4. "OSHA Solar Panel". Web.
5. "Arc Flash Safety" web. https://en.wikipedia.org/wiki/Arc_flash
6. "Bayite DC 6.5-100V 0-100A LCD Display Digital Current Voltage Power Energy Meter Multimeter Ammeter Voltmeter with 100A Current Shunt." Amazon. N.p., n.d. Web. 13 Nov. 2016. <https://www.amazon.com/bayite-6-5-100V-Display-Multimeter-Voltmeter/dp/B013PKYILS/ref=sr_1_5?m=A1T3LOAKNUUM9N&s=merchant-items&ie=UTF8&qid=1479094850&sr=1-5>.
7. "Grove/Pin Version of INA3221 3 Channel Current Measurement Breakout Board – SwitchDoc Labs." SwitchDoc Labs. N.p., 26 Mar. 2016. Web. 13 Nov. 2016. <http://www.switchdoc.com/2016/03/grove-version-ina3221-3-channel-current-measurement-breakout-board/>.
8. "THREE-CHANNEL CURRENT AND VOLTAGE I²C MONITOR." Notes on the Raspberry Pi. N.p., n.d. Web. 13 Nov. 2016. <http://www.noveldevices.co.uk/rp-3-channel-i2c-monitor>.
9. "REUK.co.uk." REUKcouk. N.p., n.d. Web. 13 Nov. 2016. <http://www.reuk.co.uk/wordpress/raspberry-pi/ds18b20-temperature-sensor-with-raspberry-pi/>.
10. "Lesson 23 Digital Temperature Sensor." Lesson 23 Digital Temperature Sensor. N.p., n.d. Web. 13 Nov. 2016. <https://www.sunfounder.com/learn/Sensor-Kit-v2-0-for-Arduino/lesson-23-digital-temperature-sensor-sensor-kit-v2-0-for-arduino.html>.
11. https://homecsp.com/store/index.php?id_cms=4&controller=cms
Appendix A
(Code)
---------------------------------------------------------------------------------------------------------------------
INA3221 MODULE CODE
---------------------------------------------------------------------------------------------------------------------
#!/usr/bin/env python
# SDL_Pi_INA3221.py Python Driver Code
# SwitchDoc Labs March 4, 2015
# V 1.2
#encoding: utf-8
fromdatetimeimportdatetime
importsmbus
# constants
#/*=========================================================================
# I2C ADDRESS/BITS
# -----------------------------------------------------------------------*/
INA3221_ADDRESS =(0x40)# 1000000 (A0+A1=GND)
INA3221_READ =(0x01)
#/*=========================================================================*/
#/*=========================================================================
# CONFIG REGISTER (R/W)
# -----------------------------------------------------------------------*/
INA3221_REG_CONFIG =(0x00)
# /*---------------------------------------------------------------------*/
INA3221_CONFIG_RESET =(0x8000)# Reset Bit
INA3221_CONFIG_ENABLE_CHAN1 =(0x4000)# Enable Channel 1
INA3221_CONFIG_ENABLE_CHAN2 =(0x2000)# Enable Channel 2
INA3221_CONFIG_ENABLE_CHAN3 =(0x1000)# Enable Channel 3
INA3221_CONFIG_AVG2 =(0x0800)# AVG Samples Bit 2 - See table 3 spec
INA3221_CONFIG_AVG1 =(0x0400)# AVG Samples Bit 1 - See table 3 spec
INA3221_CONFIG_AVG0 =(0x0200)# AVG Samples Bit 0 - See table 3 spec
INA3221_CONFIG_VBUS_CT2 =(0x0100)# VBUS bit 2 Conversion time - See table 4 spec
INA3221_CONFIG_VBUS_CT1 =(0x0080)# VBUS bit 1 Conversion time - See table 4 spec
INA3221_CONFIG_VBUS_CT0 =(0x0040)# VBUS bit 0 Conversion time - See table 4 spec
INA3221_CONFIG_VSH_CT2 =(0x0020)# Vshunt bit 2 Conversion time - See table 5 spec
INA3221_CONFIG_VSH_CT1 =(0x0010)# Vshunt bit 1 Conversion time - See table 5 spec
INA3221_CONFIG_VSH_CT0 =(0x0008)# Vshunt bit 0 Conversion time - See table 5 spec
INA3221_CONFIG_MODE_2 =(0x0004)# Operating Mode bit 2 - See table 6 spec
INA3221_CONFIG_MODE_1 =(0x0002)# Operating Mode bit 1 - See table 6 spec
INA3221_CONFIG_MODE_0 =(0x0001)# Operating Mode bit 0 - See table 6 spec
#/*=========================================================================*/
#/*=========================================================================
# SHUNT VOLTAGE REGISTER (R)
# -----------------------------------------------------------------------*/
INA3221_REG_SHUNTVOLTAGE_1 =(0x01)
#/*=========================================================================*/
#/*=========================================================================
# BUS VOLTAGE REGISTER (R)
# -----------------------------------------------------------------------*/
INA3221_REG_BUSVOLTAGE_1 =(0x02)
#/*=========================================================================*/
SHUNT_RESISTOR_VALUE =(0.1)# default shunt resistor value of 0.1 Ohm
classSDL_Pi_INA3221():
###########################
# INA3221 Code
###########################
def__init__(self,twi=1,addr=INA3221_ADDRESS,shunt_resistor= SHUNT_RESISTOR_VALUE ):
self._bus=smbus.SMBus(twi)
self._addr=addr
config = INA3221_CONFIG_ENABLE_CHAN1 | \
INA3221_CONFIG_ENABLE_CHAN2 | \
INA3221_CONFIG_ENABLE_CHAN3 | \
INA3221_CONFIG_AVG1 | \
INA3221_CONFIG_VBUS_CT2 | \
INA3221_CONFIG_VSH_CT2 | \
INA3221_CONFIG_MODE_2 | \
INA3221_CONFIG_MODE_1 | \
INA3221_CONFIG_MODE_0
self._write_register_little_endian(INA3221_REG_CONFIG, config)
def_write(self, register, data):
#print "addr =0x%x register = 0x%x data = 0x%x " % (self._addr, register, data)
self._bus.write_byte_data(self._addr, register, data)
def_read(self, data):
returndata=self._bus.read_byte_data(self._addr, data)
#print "addr = 0x%x data = 0x%x %ireturndata = 0x%x " % (self._addr, data, data, returndata)
returnreturndata
def_read_register_little_endian(self, register):
result =self._bus.read_word_data(self._addr,register)&0xFFFF
lowbyte=(result &0xFF00)>>8
highbyte=(result &0x00FF)<<8
switchresult=lowbyte+highbyte
#print "Read 16 bit Word addr =0x%x register = 0x%x switchresult = 0x%x " % (self._addr, register, switchresult)
returnswitchresult
def_write_register_little_endian(self, register, data):
data = data &0xFFFF
# reverse configure byte for little endian
lowbyte= data>>8
highbyte=(data &0x00FF)<<8
switchdata=lowbyte+highbyte
self._bus.write_word_data(self._addr, register,switchdata)
#print "Write 16 bit Word addr =0x%x register = 0x%x data = 0x%x " % (self._addr, register, data)
def_getBusVoltage_raw(self, channel):
#Gets the raw bus voltage (16-bit signed integer, so +-32767)
value =self._read_register_little_endian(INA3221_REG_BUSVOLTAGE_1+(channel -1)*2)
if value >32767:
value -=65536
return value
def_getShuntVoltage_raw(self, channel):
#Gets the raw shunt voltage (16-bit signed integer, so +-32767)
value =self._read_register_little_endian(INA3221_REG_SHUNTVOLTAGE_1+(channel -1)*2)
if value >32767:
value -=65536
return value
# public functions
defgetBusVoltage_V(self, channel):
# Gets the Bus voltage in volts
value =self._getBusVoltage_raw(channel)
return value *0.001
defgetShuntVoltage_mV(self, channel):
# Gets the shunt voltage in mV (so +-168.3mV)
value =self._getShuntVoltage_raw(channel)
return value *0.005
defgetCurrent_A(self, channel):
#Gets the current value in A, considering the config settings and current LSB
#Reads the current in Amps the 7.5 is due to the shunt being a 10A/75mA or 1 amp per 7,5mV
valueDec=self.getShuntVoltage_mV(channel)/7.5
returnvalueDec;
---------------------------------------------------------------------------------------------------------------------INA3221 EMAIL CODE
---------------------------------------------------------------------------------------------------------------------
#This program is used to email the recorded data to the user
#prompting for the user's email could be used
importsmtplib
fromemail.MIMEMultipartimportMIMEMultipart
fromemail.MIMETextimportMIMEText
fromemail.MIMEBaseimportMIMEBase
from email import encoders
fromaddr="donald.french@smail.astate.edu"
toaddr="donniefrench_12@hotmail.com"
msg=MIMEMultipart()
msg['From']=fromaddr
msg['To']=toaddr
msg['Subject']="Excel Sheet with Project Data"
body ="The following message contains an attachment with the array's daily data."
msg.attach(MIMEText(body,'plain'))
filename ="/home/pi/Desktop/Sr_Design/data_log.csv"
attachment =open("/home/pi/Desktop/Sr_Design/Power_data_log.csv","rb")
part =MIMEBase('application','octet-stream')
part.set_payload((attachment).read())
encoders.encode_base64(part)
part.add_header('Content-Disposition',"attachment; filename= %s"% filename)
msg.attach(part)
server =smtplib.SMTP('smtp.gmail.com',587)
server.starttls()
server.login(fromaddr,"**********")
text =msg.as_string()
server.sendmail(fromaddr,toaddr, text)
server.quit()
---------------------------------------------------------------------------------------------------------------------
TEMPERATURE AND LIGHT INTENSITY CODE
---------------------------------------------------------------------------------------------------------------------
#!/user/bin/python
importsmbus
importos
import time
from time import sleep
fromdatetimeimportdatetime
# Define some constants from the datasheet
DEVICE =0x23# Default device I2C address
POWER_DOWN =0x00# No active state
POWER_ON =0x01# Power on
RESET =0x07# Reset data register value
# Start measurement at 4lx resolution. Time typically 16ms.
CONTINUOUS_LOW_RES_MODE =0x13
# Start measurement at 1lx resolution. Time typically 120ms
CONTINUOUS_HIGH_RES_MODE_1 =0x10
# Start measurement at 0.5lx resolution. Time typically 120ms
CONTINUOUS_HIGH_RES_MODE_2 =0x11
# Start measurement at 1lx resolution. Time typically 120ms
# Device is automatically set to Power Down after measurement.
ONE_TIME_HIGH_RES_MODE_1 =0x20
# Start measurement at 0.5lx resolution. Time typically 120ms
# Device is automatically set to Power Down after measurement.
ONE_TIME_HIGH_RES_MODE_2 =0x21
# Start measurement at 1lx resolution. Time typically 120ms
# Device is automatically set to Power Down after measurement.
ONE_TIME_LOW_RES_MODE =0x23
#bus = smbus.SMBus(0) # Rev 1 Pi uses 0
bus =smbus.SMBus(1)# Rev 2 Pi uses 1
defconvertToNumber(data):
# Simple function to convert 2 bytes of data
# into a decimal number
return((data[1]+(256* data[0]))/1.2)
defreadLight(addr=DEVICE):
data =bus.read_i2c_block_data(addr,ONE_TIME_HIGH_RES_MODE_1)
returnconvertToNumber(data)
defmain():
file = open("/home/pi/Desktop/Sr_Design/Light_data_log.csv","w")
i=0
ifos.stat("/home/pi/Desktop/Sr_Design/Light_data_log.csv").st_size==0:
file.write("Date,Time,Light Level (lx),Temp(F)\n")
whileTrue:
i=i+1
tempfile= open("/sys/bus/w1/devices/28-031590bc20ff/w1_slave")#Opens sensor data
thetext=tempfile.read()
tempfile.close()
tempdata=thetext.split("\n")[1].split(" ")[9]
temperature = float(tempdata[2:])#Records the data from the DS18b20 teperature sensor
temperature = temperature /1000#keeps from going right three places in the decimal
degreesFahrenheit= temperature *9/5+32#Converts temp for degrees C to Degrees F
file.write(str(time.strftime("%m-%d-%Y"))+
","+str(time.strftime("%H:%M:%S"))+
","+str(readLight())+","+str(degreesFahrenheit)+"\n")
printi
ifi==20:
break
time.sleep(1)#Time between readings
if __name__=="__main__":
main()
---------------------------------------------------------------------------------------------------------------------
TEMPERATURE AND LIGHT INTENSITY EMAIL CODE
---------------------------------------------------------------------------------------------------------------------
#This program is used to email the recorded data to the user
#prompting for the user's email could be used
importsmtplib
fromemail.MIMEMultipartimportMIMEMultipart
fromemail.MIMETextimportMIMEText
fromemail.MIMEBaseimportMIMEBase
from email import encoders
fromaddr="donald.french@smail.astate.edu"
toaddr="donniefrench_12@hotmail.com"
msg=MIMEMultipart()
msg['From']=fromaddr
msg['To']=toaddr
msg['Subject']="Excel Sheet with Project Data"
body ="The following message contains an attachment with the array's daily data."
msg.attach(MIMEText(body,'plain'))
filename ="/home/pi/Desktop/Sr_Design/data_log.csv"
attachment =open("/home/pi/Desktop/Sr_Design/Light_data_log.csv","rb")
part =MIMEBase('application','octet-stream')
part.set_payload((attachment).read())
encoders.encode_base64(part)
part.add_header('Content-Disposition',"attachment; filename= %s"% filename)
msg.attach(part)
server =smtplib.SMTP('smtp.gmail.com',587)
server.starttls()
server.login(fromaddr,"*********")
text =msg.as_string()
server.sendmail(fromaddr,toaddr, text)
server.quit()
---------------------------------------------------------------------------------------------------------------------
TEXT NOTIFICATION CODE
---------------------------------------------------------------------------------------------------------------------
#This program sends the user a text notifying that the program is complete
importsmtplib
fromemail.MIMEMultipartimportMIMEMultipart
fromemail.MIMETextimportMIMEText
fromaddr="donald.french@smail.astate.edu"
toaddr="8707510350@vtext.com"
msg=MIMEMultipart()
msg['From']=fromaddr
msg['To']=toaddr
body ="The sensor data has been collected and a table of the outputs has been sent to your email"
msg.attach(MIMEText(body,'plain'))
server =smtplib.SMTP('smtp.gmail.com',587)
server.starttls()
server.login(fromaddr,"***********")
text =msg.as_string()
server.sendmail(fromaddr,toaddr, text)
server.quit()
---------------------------------------------------------------------------------------------------------------------
INA3221 MAIN CODE
---------------------------------------------------------------------------------------------------------------------
# This program writes the Output readings of the array and temperature into an Excel file
# The program is set to "a" for amending the file (line 10) Change to "w" to Overwrite file with new Data
# This program can be edited to add additional sensor data to the file.
# This program also has the ability to notify the user via text message and email when the program has finished its execution
importos
import sys
import time
importdatetime
from time import sleep
fromdatetimeimportdatetime
import random
import SDL_Pi_INA3221
ina3221 = SDL_Pi_INA3221.SDL_Pi_INA3221(addr=0x40)
# the three channels of the INA3221 named for SunAirPlus Solar Power Controller channels (www.switchdoc.com)
PANEL_CHANNEL =1
BATTERY_CHANNEL =2
CONTROLLER_CHANNEL =3
#Creates a file where the data will be stored
file = open("/home/pi/Desktop/Sr_Design/Power_data_log.csv","w")
#Variables
i=0#Loop Counter
num=0#Number of loops determined by the user
time_elapsed=0#Keeps track of how long the program has been running
run_time=0#Stores the duration of the loop
#This section prompts the user to enter the duration of the readings
print"How long do you wish the program to run? (hh:mm:ss)"
hours=input("Hours: ")
minutes=input("Minutes: ")
seconds=input("Seconds: ")
#3600 seconds in an hour 60 seconds in a minute, gives runtime in seconds
run_time=(hours *3600)+(minutes *60)+ seconds
#Prompts the user to configure the frequency of readings in seconds
freq=input("Frequency of readings in seconds: ")
num=run_time/freq#Number of loops the program will execute
#Opens the file and creats the rows in the excel sheet
ifos.stat("/home/pi/Desktop/Sr_Design/Power_data_log.csv").st_size==0:
file.write("Date, Time, Panel Voltage (V), Panel Current (A), Panel Power (W),"+
"Battery Voltage (V), Battery Current (A), Battery Power (W),"+
"Controller Voltage (V), Controller Current (A), Controller Power (W)\n")
#Records the start time of the loop
start_time=time.time()
#The loop will remain true until i is equal to num
whileTrue:
#------------------------------------------------------------------------------------------------------#
#Initiates the panel readings to zero to ensure no old data is still stored for that variable
panel_shuntvoltage1 =0
panel_busvoltage1 =0
panel_current_A1 =0
panel_loadvoltage1 =0
panel_power=0
#For each reading an if statement is present to null any unwanted data
#Determines the Bus voaltage of the panel
if(ina3221.getBusVoltage_V(PANEL_CHANNEL)<=0.999):
panel_busvoltage1 =0
else:
panel_busvoltage1 = ina3221.getBusVoltage_V(PANEL_CHANNEL)
#Determines the Shunt Voltage of the panel
if ina3221.getShuntVoltage_mV(PANEL_CHANNEL)<=0.999:
panel_shuntvoltage1 =0
else:
panel_shuntvoltage1 = ina3221.getShuntVoltage_mV(PANEL_CHANNEL)
#Determines the Current of the panel
if ina3221.getCurrent_A(PANEL_CHANNEL)<=0.0999:
panel_current_A1 =0
else:
panel_current_A1 = ina3221.getCurrent_A(PANEL_CHANNEL)
#Calculates the Load Voltage of the panel by adding the bus and shunt voltages
panel_loadvoltage1 = panel_busvoltage1 +(panel_shuntvoltage1 /1000)
#Calculates the power supplied by the panel
panel_power= panel_loadvoltage1 * panel_current_A1
#This section is only needed for reviewing data in real time and will only be seen on the PI display
print"Panel Bus Voltage: %3.4f V "% panel_busvoltage1
print"Panel Shunt Voltage : %3.4f mV "% panel_shuntvoltage1
print"Panel Load Voltage : %3.4f V"% panel_loadvoltage1
print"Panel Current : %3.4f A"% panel_current_A1
print"Panel Power : %3.4f W"%panel_power
#-----------------------------------------------------------------------------------------------------#
#Initiates the battery readings to zero to ensure no old data is still stored for that variable
battery_shuntvoltage2 =0
battery_busvoltage2 =0
battery_current_A2 =0
battery_loadvoltage2 =0
battery_power=0
#For each reading an if statement is present to null any invalid data
#Determines the Bus voaltage of the battery
if(ina3221.getBusVoltage_V(BATTERY_CHANNEL)<=0.999):
battery_busvoltage2 =0
else:
battery_busvoltage2 = ina3221.getBusVoltage_V(BATTERY_CHANNEL)
#Determines the Shunt Voltage of the battery
if ina3221.getShuntVoltage_mV(BATTERY_CHANNEL)<=0.999:
battery_shuntvoltage2 =0
else:
battery_shuntvoltage2 = ina3221.getShuntVoltage_mV(BATTERY_CHANNEL)
#Determines the Current of the battery
if ina3221.getCurrent_A(BATTERY_CHANNEL)<=0.0999:
battery_current_A2 =0
else:
battery_current_A2 = ina3221.getCurrent_A(BATTERY_CHANNEL)
#Calculates the Load Voltage of the battery by adding the bus and shunt voltages
battery_loadvoltage2 = battery_busvoltage2 +(battery_shuntvoltage2 /1000)
#Calculates the power supplied to the battery / if negative the battery is supplying power)
battery_power= battery_loadvoltage2 * battery_current_A2
#This section is only needed for reviewing data in real time and will only be seen on the PI display
print"Battery Bus Voltage : %3.4f V "% battery_busvoltage2
print"Battery Shunt Voltage : %3.4f mV "% battery_shuntvoltage2
print"Battery Load Voltage : %3.4f V"% battery_loadvoltage2
print"Battery Current : %3.4f A"% battery_current_A2
print"Battery Power :%3.4f W"%battery_power
#-----------------------------------------------------------------------------------------------------#
#Initiates the controller readings to zero to ensure no old data is still stored for that variable
controller_shuntvoltage3 =0
controller_busvoltage3 =0
controller_current_A3 =0
controller_loadvoltage3 =0
controller_power=0
#For each reading an if statement is present to null any invalid data
#Determines the Bus voaltage of the controller
if ina3221.getBusVoltage_V(CONTROLLER_CHANNEL)<0.999:
controller_busvoltage3 =0
else:
controller_busvoltage3 = ina3221.getBusVoltage_V(CONTROLLER_CHANNEL)
#Determines the Shunt Voltage of the controller
if ina3221.getShuntVoltage_mV(CONTROLLER_CHANNEL)<0.999:
controller_shuntvoltage3 =0
else:
controller_shuntvoltage3 = ina3221.getShuntVoltage_mV(CONTROLLER_CHANNEL)
#Determines the Current of the controller
if ina3221.getCurrent_A(CONTROLLER_CHANNEL)<0.00999:
controller_current_A3 =0
else:
controller_current_A3 = ina3221.getCurrent_A(CONTROLLER_CHANNEL)
#Calculates the Load Voltage of the controller by adding the bus and shunt voltages
controller_loadvoltage3 = controller_busvoltage3 +(controller_shuntvoltage3 /1000)
#Calculates the power supplied by the controller
controller_power= controller_loadvoltage3 * controller_current_A3
#This section is only needed for reviewing data in real time and will only be seen on the PI display
print"Controller Bus Voltage : %3.4f V "% controller_busvoltage3
print"Controller Shunt Voltage : %3.4f mV "% controller_shuntvoltage3
print"Controller Load Voltage : %3.4f V"% controller_loadvoltage3
print"Controller Current : %3.4f A"% controller_current_A3
print"Controller Power :%3.4f W"%controller_power
#-----------------------------------------------------------------------------------------------------#
#This section writes all the data to the excel file. The voltage, current and power of each along with
# the date, time, and temperature of the reading
file.write(str(time.strftime("%m-%d-%Y"))+", "+str(time.strftime("%H:%M:%S"))+
", "+str(panel_loadvoltage1)+", "+str(panel_current_A1)+", "+str(panel_power)+
", "+str(battery_loadvoltage2)+", "+str(battery_current_A2)+", "+str(battery_power)+
", "+str(controller_loadvoltage3)+", "+str(controller_current_A3)+", "+str(controller_power)+
"\n")
file.flush()
#This is also for Pi display to runtime, amount of readings left to take, and time remaining
print"Time elapsed :%3.4f S"%time_elapsed
print"Number of readings left to take: "+str(num-i)
print"Time Remaining: "+str(run_time-time_elapsed)+"Seconds\n"
#When the counting variable reaches the desired number of readings the program breaks the loop and closes the file
ifi==num:
break
time.sleep(freq)
file.close()
#This calls the program that emails the Data in an attached file
#The two programs need to be located in the same folder
os.system("python Power_Data_to_email.py")
os.system("python Light_Data_to_email.py")
os.system("python NotificationText.py")