Rusty Nail Workshop

Internet Controlled Robotic Arm

Sat, 19 Nov 2011 20:00:08 -0600

From the Rusty Nail Workshop Lab . . .

The motivating factor for the construction of this robotic arm originally came from a tour of the Volvo factory in Göteborg, Sweden. It was during this factory tour that I first saw the massive robotic arms used to pick up car parts and weld them on to the car body. With sparks flying, these were some of the most impressive robots I had ever seen, and if you ever have a chance, take the tour!

(Photo from Volvo Car Corporation)

Fast forward one month, and I was the proud owner of my first robotic arm kit, a Lynxmotion AL-5D, with the heavy-duty wrist rotate mechanism. Oh boy did I have big plans for this arm! Having some previous experience with Arduino boards, I immediately connected an Arduino Uno to the SSC-32 servo controller that came with the arm. With a little bit of web searching, I was able to find instructions and sample code which had me sending basic commands to each servo. It took another couple of weeks, but I had finally gotten the arm to move the way I wanted.

After trying to implement the inverse kinematics code written by Oleg from Circuits at Home, I quickly came to realize that supplying the arm with x, y, and z coordinates was not the most interesting or practical way to control it. Instead, I came across Travis Smith's internet controlled robotic arm. I had actually conceived of an internet-controlled arm shortly before I purchased it, and this was the evidence needed to convince me that an arm could be controlled over the internet.

After waiting for an Ethernet shield to arrive, I proceeded to write some code that would receive individual commands in the the form of a URL string, translate those commands into an instruction for the SSC-32 servo controller, and thus move the arm in the intended manner. Using iWeb, I was able to set up a simple web site that allowed a user to click on the part of the arm that they wanted to move and watch it move by way of a video stream. The video stream is provided by an Axis M1011 camera. By the way, I highly recommend this camera, it is the best web-enabled camera I have ever used. No computer is needed, just an internet connection!

After the arm was functional, I continued to work out a few bugs where the Ethernet shield would crash if too many commands were received too fast. By allowing only one command every few seconds from the web site, this problem was eventually solved. I also added a laser pointer to help indicate the direction the arm was pointing, as well as a distance sensor (probably pulled from an automatic faucet), just for fun. The distance sensor is not linear, so I had to model the performance in a simple quadratic equation. It is fairly accurate now, although it still has limitations at far and very close distances.

I contemplated adding a second video camera to show the view from the top, but not only would this increase the project cost, this wouldn't challenge the user as much. I wanted this to be a fun experience for the users, as well as a fun construction project on my end. I eventually added some simple code to prevent the arm from moving beyond some safe limits that I set, which prevented the user from pulling out the servo cables from the servo control board.

Because I am always concerned about power consumption with my projects, I added a PowerSwitch Tail II to allow the user to turn on the arm and desk light, which only powers the arm when being used and stops the servos from humming when the power is turned off. I set it to automatically power off after a period of inactivity, which is controlled by the software code. I also set the entire arm to power on only during my waking hours so that my family would not be annoyed by the noise from the constant movement of the arm.

To prevent users from trying to put the arm through the table or floor, I picked up the inverse kinematics code again and reviewed the articles written on the web regarding forward kinematics. This was much easier than the inverse kinematics derivation, and I was able to generate a forward kinematics equation to drop into my existing code. After some changes necessitated by the orientation and performance of my arm, the forward kinematics equation is able to prevent the user from putting the end of the gripper through the table. You can see the spreadsheet I created with the equation here. You can download the Visio diagram I made here (same as the picture below).

The entire code for the Arduino board is available here. There are a number of improvements that I'd like to make to the arm, but that would only delay the release of the web site to the general public. I can't wait to see what users can do with the arm!

This was a very rewarding project, and I hope you enjoy using it. As always, drop me a line if you have any questions or suggestions.

Enjoy!

PongSat Results

Fri, 29 Apr 2011 15:55:47 -0500

Our PongSat ping pong ball was successfully flown on JP Aerospace flight “Away 47” on April 9, 2011 (it is the experiment on the far left above). It reached a height of 85,549 feet before the balloon carrying the ping pong balls popped and the experiment fell back to Earth.

The weight of the balloon and payload was approximately 12.5 pounds, and it climbed at an average rate of 1,300 feet per minute. The flight duration was 1 hour, 25 minutes. JP Aerospace recorded a minimum temperature of -74.4 degrees Fahrenheit. The payload was recovered 27.25 miles from the launch site, which was near Pyramid Lake, Nevada.

The two other launch vehicles used by JP Aerospace achieved heights of 101,722 and 102,949 feet respectively. We were a little disappointed our experiment did not exceed 100,000 feet, but for a free experience, we are extremely grateful for the opportunity provided by this organization.

We waited about two weeks after the flight for them to sort, organize, prepare photos and videos, and eventually package everything up and ship our PongSat back to us. During this time, we had no idea whether they had followed our instructions and turned on the PongSat before the flight (or turned it off at the end). We had tried to plan for failure modes, such as forgetting to turn the device off (it was supposed so sit there and do nothing for 49 days or until the battery ran out), but we couldn’t plan for someone forgetting to turn it on before the launch.

When it arrived, we inspected it and immediately noticed that the ping pong ball was discolored. It had faded significantly, and the writing wasn’t as sharp as before it left. Underneath the metal and duct tape, the ball was perfectly white and new looking. We suspected that this was because of the intense UV radiation at the edge of space. In any event, the sensor was still in place, and the ball looked intact, which was a good thing.

We disassembled the ball, the switch was in the off position and everything inside looked intact and all wiring was still connected. Another good sign! We disconnected the battery and connected it to the computer to dump the Arduino’s EEPROM memory. We held our breath and waited for data to appear . . .

After the initial program sequence, the screen filled with numbers - we had data!!! Now, a quick scan would tell us if they turned it on too early, or at the right time (just before the launch). It was only supposed to take data for three hours, so we were hoping it wasn’t data from the Nevada desert. Whew! A quick read told us we definitely had recorded some negative temperature values. It looked like we had realistic data!

Eventually, I plotted the data for the kids to analyze using Microsoft Excel. I highlighted the minimum and maximum temperatures to see the extreme conditions experienced. The two graphs obtained are included below.

The minimum temperature we recorded was -34 degrees Fahrenheit. The maximum temperature was 52 degrees, which seems logical for the early morning in the desert.

So what do these graphs mean? Was the experiment successful? The answer is a resounding YES! Although the data is different than what we expected, we certainly learned something from this flight.

Temperature: We expected this to be extremely cold, and were slightly surprised to see that the lowest temperature recorded was only -34 degrees. However, the STH-15 humidity and temperature sensor data sheet indicates the operating range for the temperature sensor is -40 to 249.5 degrees Fahrenheit. This means our sensor was in an error mode for a good portion of the flight. That explains the fact that we weren’t able to get to the -74.4 reading that JP Aerospace obtained. They used a mercury-type thermometer and observed the reading with a video camera. However, you can clearly see the ascent and decent from the change in temperature. We also suspect the sunlight on the sensor caused a heating effect which kept the sensor at -34 degrees or even slightly warmer.

Humidity: We had no idea what to expect here, except that humidity in space was probably near zero. When we plotted this data, we clearly saw it go down to zero, but then it even went slightly negative. From reading the data sheet, a negative humidity reading indicates a sensor error. Since we were operating outside of the specifications for temperature, this makes sense that the sensor wasn’t operating correctly. However, the spike in humidity near 110 minutes may be due to the passing of the vehicle through a cloud. At least we like to think so. In any event, the starting humidity and ending humidity looks reasonable for a desert, so we suspect the humidity sensor operated correctly when the temperature was in the normal operating range.

The battery appeared to perform perfectly, even down to -74.4 degrees Fahrenheit. We are very impressed, and consider this experiment to be a wild success. Thank you JP Aerospace, you did an excellent job, even when the vehicle was upside down!

PongSat Experiment

Sat, 9 Apr 2011 12:54:57 -0500

Today, our first PongSat experiment will be launched to the edge of space! JP Aerospace, a group located in California, offers to fly student experiments that fit inside of a ping pong ball to the edge of space, often over 100,000 feet above the surface of the Earth. Did I mention that they do this at no cost to the experimenter? To get started, you only need to send an e-mail to jpowell@jpaerospace.com.

With the help of my two boys, we created a ping pong ball experiment to measure the temperature and humidity over the course of the ascent and descent of the balloon used to carry the balls up to space.

Our PongSat was built in March of 2011. It contains an Arduino Pro Mini running an ATmega368 microprocessor at 8 MHz (0.5% tolerance). It is a 3.3 volt low voltage board weighing less than 2 grams. The total cost of this board (from Sparkfun) was $18.95.

The board is powered by a single 1/2 AA Lithium Thionyl Chloride 3.6 volt 1.2 Ah battery. Lithium Thionyl Chloride batteries have a unique property in that they will function in very cold conditions, down to -55 degrees Celsius. The battery cost us only three dollars.

Connected to the Arduino board is a Sensirion SHT15 digital CMOS humidity and temperature sensor. 512 temperature and 512 humidity values will be stored to the Arduino’s EEPROM memory over a course of three hours. The boys selected readings to be taken about every 21 seconds, so we should fill the available memory locations during the flight.

We wrapped as much of the ball in metal tape to try to deflect as many cosmic rays as possible. We weren’t sure what would happen if we didn’t protect it, but after looking at images of other satellites, we determined they covered the devices in a gold colored film. We used what we had on hand, which happened to be metal tape.

The source code for the Arduino board can be viewed (and used) here. Feel free to use this for future experiments, and hopefully improve on what we have done.

To view the PongSat experiment results, please see the results page.

Delicious Homemade Bread

Sat, 22 Jan 2011 16:26:55 -0600

Every once in a while, I find something that I haven’t used in a while and it suddenly catches my interest. In this case, it was an automatic bread maker (machine) which had been sitting in a cupboard unused for the past several years.

After taking it out and dusting it off, I ran to the store and found a bread machine box mix, which just required the addition of water to make a fresh homemade loaf of bread. I dumped in the mix, added the water, turned on the machine, and waited for the magic to happen.

About three hours later, the house was filled with the wonderful scent of fresh bread. When the machine finished, I opened the cover and was immediately disappointed. The bread had risen, but then apparently caved in on itself. What I had was, at best, called a bread bowl instead of a nice fluffy loaf of bread. I ended up tasting it, but it was pointless to cut up and eat.

Not to be deterred, I pulled up this recipe online, and immediately set out to try my own recipe. After purchasing my own bread flour and yeast, I was set. By the way, I tried not just one packet of yeast, I came home with three different kinds. I plan to test them all out and choose the best one going forward. Nevertheless, my second attempt using the above-mentioned recipe turned out fantastic! A nice, fluffly loaf!

I quickly realized that to stop the bread from caving in on itself, I should cut down on the amount of yeast used (I now use 4/5 of the yeast packet) and add a pinch of salt (above what the recipe calls for) to stop the yeast from becoming too active.

I’ve now successfully made several kinds of white bread, and one cinnamon loaf. If you haven’t smelled cinnamon bread baking, you haven’t lived. This has got to be one of the best things to experience in life.

Here’s to our bread machine. It allows me to make wonderful bread!

70 cm Yagi Antenna for Direction Finding

Sun, 17 Oct 2010 16:32:43 -0500

Every once in a while, we happen to lose something around the Rusty Nail Workshop. In most cases, if we wait a while, it will simply turn up again without us having to look very hard. Unfortunately, that isn’t always the case, and sometimes a better solution is needed.

For example, we are interested in high powered model rocketry. Along with these rockets come very big and powerful rocket engines. Engines powerful enough to cause our rockets to soar to great heights. Naturally, with even the slightest breeze blowing, the rockets tend to drift on the way down and can often travel large distances over land (a mile or two). If there happens to be a forest or corn field in the rocket’s landing area, finding the rocket can be a very big challenge. This is a problem when some of the rockets start to cost a lot of money and when you’ve invested a lot of time in their paint jobs.

The solution is simple. We need a radio beacon. Everyone should be familiar with tracking collars they place on wolves, bears, and birds. This concept is very similar, except the beacon is small enough to place inside the nose cone of a model rocket. The particular transmitter I purchased came from BigRedBee LLC. The model is their BeeLine TX (not the 100 mW version, since that consumes more battery power and has a shorter life). You need an amateur radio license to use one of these transmitters, but they are not very difficult to obtain. Lucky for us, I happen to have a license!

I needed a 70 cm Yagi antenna to use with this transmitter. Instead of simply buying an antenna, I decided to make one. The plans I followed can be found here.

I purchased the supplies from a local hardware store and put the antenna together in about an hour.

The hardest part was cutting the brass rods, but I used a small cut-off tool with good results. Using a blowtorch to bend the brass really made it a lot easier than simply bending it by hand. Just make sure you use a vice to hold the 13” portion of the driven element to keep it from bending.

I now need to pick up some co-axial cable and a BNC connector for the end. The total cost for this project was about $20.

One final word of warning. After building my antenna, I realized my HT radio (Yaesu Vertex VX-150) was not capable of receiving on the 70 cm band. This means I needed to pick up a new radio. I eventually chose the Yaesu VX-8R.

I purchased a three foot BNC to BNC cable, made of RG-58 from Universal-Radio (part number 4616). I also purchased a BNC to SMA adapter so that I could connect the cable to my Yaesu radio. I then cut one end off of the RG-58 cable, and soldered it to one of the brass rods.

When I finished, it was simply a matter of connecting it to the radio and testing the transmitter. It worked! Now I just need to have the kids hide the transmitter to see if I can find it again.

E-ink Sign (or Wireless E-mail Count Display)

Sat, 21 Aug 2010 19:46:37 -0500

After using the Arduino microprocessor board for the past year or so, there are often projects that pop into my head unexpectedly that would be perfect for the Arduino. One such project was a desire to display the number of e-mail messages I had received on some type of electronic sign, which happened to be away from my computer. Thus, I needed a wireless way to display information.

It was about this time that I found the Google Radish project. For those that do not know, the Google Radish project was an attempt to display calendar data on conference room doors. The display updated automatically, and used solar power with a wireless connection back to a computer to pull the data. I figured I could replicate this in a slightly modified form with an Arduino.

First, I purchased an Arduino Duemilanove from SparkFun. I’ve used this board in the past, and it is very easy to work with and the code is very easy to learn. I also needed a display for my data and a pair of radios to set up a wireless link. After much searching, I settled on a 240 x 160 Kent Display ChLCD screen. At almost $80, buying this display without much sample code was a big risk, but one I was willing to take. After all, great reward follows great risk - and buying electronics is hardly a big risk when you consider everything else in life.

In order to transmit my data from my computer to my Arduino board, I needed a pair of radios. The Google Radish project used 802.15.4 radios, otherwise known as Zigbee radios. As it turns out, SparkFun also sells these, under the brand name of XBee. I also found someone who used Bluetooth to transfer data from a computer, in a project similar to what I wanted to do. However, since Bluetooth is prohibited where I work (and where I wanted to set up my display), I purchased an XBee kit, which contained two series 1 radios, both at 1 mW output with a chip antenna. I didn’t want to get into antenna theory, and I knew that the distance I needed to cover was less than 80 feet, so the chip antenna was more than adequate.

In order to get my project working, I needed to start in stages. I knew nothing about wireless radios, and I knew even less about ChLCD displays. So I started with the radios. I found a cool piece of software from Shigeru Kobayashi called XBeeConfigTool. This tool let me set up my radios without having to learn a lot about Zigbee parameters. Once I had them both configured and set to the same baud rate, I started on my Arduino software to make the radios talk to each other. One radio was installed on an XBee shield on my Arduino board, and the other radio was connected to an XBee Explorer which was in turn connected to my computer with a USB cable. In the end, the two radios essentially made a serial link between each other and enabled the Arduino Serial Monitor to send commands which were received by the remote XBee/Arduino setup just as if it was connected by a cable to my computer (but it wasn’t). Once I was able to send numbers like “123” to the remote Arduino, I knew this part was done. Here’s a tip, make sure the XBee shield is set to “UART” and take the shield off when programming the Arduino board or it won’t upload correctly.

Above: I used the Physical Pixel example sketch to test if I was sending data correctly using the XBee modules. When I sent an “L” the LED went off. When I sent an “H”, it went on. It worked!

Next, I needed to find a way to display data on the Kent Display. This took a long time since it did not appear that anyone else had solved this problem, and source code certainly was not available which displayed text or images. Eventually I found a way to convert images to hex values, then uploaded those hex values to the display, and it worked! For more information, see my post here. Getting a font to render was very, very difficult. In the end, I simply created images for large numbers (each 40 x 60 pixels) and stored those in PROGMEM in the Arduino. Then when I wanted to write the numbers, I called each one line by line, drawing a row across the screen. You can see that in my code, which I’ve linked to here.

Once I had the XBee modules and the display working, I purchased a Pololu switch so I could cut power to the Arduino with the software. These are cool switches, and if you haven’t used one, you really should try them out. Now I simply needed a way to power the circuit I made. Originally, I purchased a 2.5 Watt solar panel (about 7” x 5”). This produced 9V, but almost zero current, so it was a complete waste of time. I considered using a solar engine to charge a super capacitor, which would then power the Arduino for the 5-7 seconds I needed, but the solar panel was too weak to do this. (As a side note, I did prove that a 5F/5V capacitor can easily power the Arduino board and XBee shield for ~30 seconds or more, once fully charged.)

I eventually settled on batteries, but I needed a way to wake the Pololu switch up electronically once every 10 minutes or so. I stopped by my local Radio Shack and picked up a TLC555CP timer chip (a low power 555 timer). I wired this up as an astable timer, using a 470 uF capacitor, 1m Ohm resistor with a second 22k resistor. This produced a logic high pulse of about 6 minutes, with a logic low pulse of 7 seconds. The 7 seconds was all I needed to power the Arduino board to wake up, get the serial data (or number of e-mail messages), and then it would cut the power. It turns out that I ended up using the Pololu switch in a way they didn’t intend. When the logic low (0 volts) was applied to one side of the “switch” contacts on the Pololu switch, the switch turned on. When the 555 went high (5 volts), the switched automatically turned off. Thus, I was using it similar to a transistor to supply power to the entire Arduino/XBee boards with just a simple logic pulse. (There is probably a better way to do this, but it worked!) With no power to the Arduino/XBee boards, I was using only 0.1 mA of power from my batteries to run the 555 timer. Wow! With the Arduino/XBee boards running, I was using about 80-100 mA to refresh the screen (but only for 7 seconds at a time). If I turn this off at night, I estimate the batteries (2000 mAh) to last for 3.8 months. Perhaps I can use my solar cell after all (but that’s for another time).

This is a diagram of the TLC555CP timer circuit that I used. R1 = 1m Ohm, R2 = 22k Ohms, and C = 470 uF.

I mounted the boards, batteries, and display on a piece of acrylic. I then wrote a small VBA script to run in Microsoft Outlook to count and write the number of e-mails I had received to a text file on my computer. I then wrote a small Python script to send the number from the text file out over the serial port (really a USB port) to the XBee module I had plugged into my computer. If you want to count the number of messages directly from Gmail, you can use this script. If you download this code, just change the extension to “.py” and it will work with Python. Once this was sent, my display would wake up, get the data, update the display, then go to sleep.

I’m sure a few of you will recognize that 846 is an unrealistic number of e-mail messages to receive. In the process of testing this, I randomly saved numbers to a text file to see if they would upload correctly. They did! (I also blurred out the background in the photo above since it contains some work-specific information.)

I’m sure I could optimize this further, but I already have about 50 hours into this project and I want to move on to the next project. If anyone has suggestions, please let me know.

Oh, and here is my Arduino source code if you would like to replicate this. It’s filled with comments, which should make your life easier than mine! I replaced my work-specific background with an image I used to test the display. You’ll want to include your own background image (in the form of a large hex array). Enjoy!

Arduino Powered Kent Display

Mon, 9 Aug 2010 18:48:45 -0500

While working on a project where I needed to display some data, I came across a cholesteric liquid crystal display (ChLCD) from Kent Displays, sold by SparkFun Electronics (LCD-09560, 240 x 160). The unique aspect about this display is that the image is persistent, meaning it has the ability to retain the image on the screen even when the display is no longer powered. This means the device can save power by shutting down the display until the next time an update is needed. The down side is that the display’s refresh time is on the order of two to three seconds. Therefore, it is not suitable for animated graphics, just static images.

After purchasing the display, I attempted to use the sample code provided by SparkFun Electronics. With a minor modification, I was soon able to display alternating vertical bands of black and white bars which proved the display functioned correctly. Now I needed to display my own images.

Since I am using an Arduino Duemilanove to control this display, I needed some custom code to upload images. After much reading, I found out the images are loaded to the display as a hexadecimal array, one hex value at a time. These hex values are stored in the display’s onboard image RAM (memory), and then a command is used to read the image RAM and update the screen. The memory for my particular display was large enough to hold three full screen images.
To generate an image, I needed to convert a monochrome bitmap (.bmp) file into the hex array. The image was created using Photoshop Elements, and saved as a bitmap file with one bit per pixel.

After two days of trying to make this image into the correct array and display on the screen, I realized I needed software to render the array by reading the image horizontally, not vertically. This means the Arduino KS0108 graphical LCD library would not work for my purposes. The KS0108 library contains a program to create arrays from monochrome bitmap images, but it only encodes vertically. In the end, I ended up using the software provided here (http://en.radzio.dxp.pl/bitmap_converter/) to generate the hex array because it allows you to select the direction of encoding. I then simply cut and pasted only the hex values from the resulting array (after saving it to a text file) into my Arduino code. I stored the array in progmem because the array was very large. If you end up storing lots of full screen images in your code, make sure you are not facing memory issues with the Arduino.

The code I used to display an image on this screen is included below. Please note, this code is not very clean, but it works. I’m sure someone else out there will take it and make it a lot more efficient and clean (feel free!).

Download the .pde Arduino file: Kent Display Sample Code

It will only generate a full screen image (for a 240 x 160 screen size) from the hex array included in the code. The hex array included is for the image shown above. If you are driving a larger sized screen, you will need to update the image array (with a larger sized image) and the following line in the code to indicate the byte size of your array (my byte size was 4800, which is also shown on the Kent Display data sheet for this display).

for(int j = 0x00; j < 0x12C0; j++){

In this line, the “0x12C0” equals 4800 in hex, which is the last byte in my display. If you purchase the larger display, you will need to update this to read the hex value for your last byte. The display turns each hex value into a binary value, then displays dark and light pixels based on the binary ones and zeros. Thus, each hex value is turned into eight pixels, starting with the upper left of the screen and ending in the lower right. 240 x 160 = 38,400 pixels. If you divide this by eight (eight pixels per byte), then you get 4,800 bytes.

Finally, here’s an image to prove I could write to it!

Now, take this information and make something useful out of it. Then make sure you tell everyone so we can continue to make neat things!

The Solar Powered Cell Phone Experiment

Sun, 21 Feb 2010 15:31:00 -0600

Question: Is it possible to power a cell phone (specifically, my iPhone 3G) with just solar power without the need for huge, permanent solar panels?

Background Research: In order to determine if this was possible, I needed to do some research. First, I tried to find out if anyone had attempted this before. A quick web search told me that a few people had powered their cell phones while camping using some portable solar panels, but nobody had apparently attempted to do what I was hoping to do.

My next step was to determine what solar panels (or solar cells) were available. Very quickly I determined that there are two types of solar panels: (1) those with an integrated Lithium battery pack which the solar cells charge; and (2) those without a battery pack which only charge your phone when both your phone and the solar cells were in the sun. I chose the solar panels with the battery pack since this meant I could leave the solar cells in my car all day while I worked, and charge my cell phone at night.

A quick bit of research found the following solar cells, all of which were suitable for my purpose:
‣ Solio Mag
‣ SolarMio 31
‣ Brunton SolarRolls

I initially chose the SolarMio 31 since it offered better charging in low light (cloudy) conditions, but it did not have as large of a battery pack as the Solio Mag. The SolarMio was also less expensive than the Solio Mag. The Brunton SolarRolls did not have an integrated battery, so those were out of the question. However, when I arrived at my local REI store, I found they were offering a Brunton Freedom charger. This charger used a Lithium battery and was half the price of the SolarMio! The battery is a 2,200 mAh battery, which is more than enough to charge my iPhone, and well over double what is offered with the SolarMio (900 mAh). The photo to the left is the Brunton Freedom.

Hypothesis: If I try to use only a portable solar cell or panel, I should be able to power my iPhone 3G without the need for any supplemental power from an outlet or car charger.

Experiment: I plan to hang my Brunton Freedom in my car window every day while I am at work (roughly 9 a.m. to 5 p.m.) facing South. I will then use the Freedom to charge my iPhone. I will not use any other supplemental power.

Data Collection: I placed the cell phone in my car window while I was at work, starting on Monday, February 22, 2010. I left it there until I left for home each day.

Analysis: The Brunton Freedom was able to fully charge my cell phone on Monday night. This was likely due to the full battery in the Brunton device, since I had pre-charged it before Monday using a wall charger.

Monday, February 22, 2010

On Tuesday evening, the Brunton solar panel battery was only able to charge my device to 80%. This was probably due to the fact that the device only had 50-75% of the battery charge remaining, which was not sufficient to fully recharge my depleted cell phone battery. Unfortunately, it was mostly cloudy or overcast on Tuesday, so the Brunton device was not able to fully recharge.

Tuesday, February 23, 2010

After work on Wednesday, the third day of the experiment, I had to stop the test. My cell phone battery was at 25%, and the solar cell battery did not have enough of a charge to charge my cell phone at all. What was especially disappointing was that the solar cell on the Brunton Freedom was insufficient to even charge the internal battery over 25% after the device was left in the full, bright sun for eight hours. I would have expected it to be at least half full, but it wasn’t.

In case anyone is wondering, I have included the graphs showing the solar intensity each day. Except for a few tiny dips, the sun was shining clearly the entire day on Wednesday.

Wednesday, February 24, 2010

I have subsequently found out that Brunton offers the same model solar panel with two 100 mA solar cells, which would presumably charge the internal battery twice as fast. Even with this second panel, I have my doubts that it would have charged the internal battery sufficiently to fully charge my cell phone.

Conclusion: It is not possible to charge an iPhone (3G) with a small, portable solar panel as the only source of power for the phone. Supplemental power will be necessary or the phone use must be extremely limited.

Finally, if you plan to buy a Brunton Freedom, make sure you understand it’s limitations. If I had a week to leave it in the sun, this might have been a different story.

Energy Conservation

Fri, 12 Feb 2010 19:15:37 -0600

Unless you have been living under a rock, you can’t help but notice that lately everyone seems to be eager to conserve or reduce their energy consumption and increase the efficiency of the items they purchase. Not only is it the popular thing to do, most consumers expect substantial savings by spending less on the energy needed to power our lives. I suspect, however, that very few people actually measure how much energy they are saving.

In fact, there is an effect called the Jevons Paradox that states that as consumers save energy, this naturally results in the cost of energy becoming cheaper. This then causes economic growth and consumers use even more energy than before! Still, the argument exists that you cannot understand or begin to control your energy consumption until you actually examine the data. Knowing your usage will lead to, hopefully, more responsible choices going forward.

To begin to understand my energy consumption, I started by collecting my historical energy usage from old electric bills. I even contacted the local electric company to ask for copies of missing bills so I could fill out my data.

I also did the same thing for my natural gas usage. Everything I collected went into an Excel document for further analysis.

This allowed me to generate some graphs showing the electricity and natural gas usage as a function of the average monthly temperature.

I used the average monthly temperature as the X-axis since a monthly plot does not take into account one month which happens to be an above or below average temperature for that year.

When the furnace needed to be replaced, I added a heat pump to the setup. The heat pump was sold to me on the basis that the cost per million BTUs was about one-third as much as a natural gas furnace. Sounds like energy efficiency, right? Now that it has been running for a while, how do I prove that I’m saving money? I know that a heat pump uses more electricity, so that cost should have gone up.

The month with the heat pump is on the left above. The right image shows a typical month with gas heat from two years prior. Notice the two numbers above were taken from two different months with the same average temperature. This is important to see if my usage at a given temperature has gone up or down.

I also know that using a heat pump means I’m not burning as much (or any) natural gas, so that cost should have gone down.

The image on the above left is the natural gas used with heat provided by the heat pump. The image on the right is a typical month with gas heat about two years prior. If I combine the two numbers and compare it to historical data, I should be paying less. When I compared the total invoice cost of operating a heat pump for heat versus a natural gas furnace for heat, I found that I was saving $14.15 last month ((New electric bill + New natural gas bill) – (Old electric bill + Old natural gas bill)). So the installation of a heat pump has actually started to pay off! Granted, this is only one month of data and a little lower than I expected, but I fully expect this savings trend to continue. At least now I know how to measure it. Knowledge is power!

Jawa Eyes

Sat, 12 Dec 2009 16:35:36 -0600

For Halloween this year, my boys decided they wanted to be a Jawa from Star Wars. One of the requirements was that they have glowing eyes. Not just any glowing eyes, but orange glowing eyes. This is how I created some realistic Jawa eyes with just a few dollars of materials.

First, to get the orange glow, I purchased some high intensity orange LEDs (part number 404-1097-ND) from Digi-Key. They were only $0.71 each. I also purchased a 9-volt battery clip (part number BS12I-HD-24AWG-ND) for $0.33. To control the current going to the LEDs, I purchased a 500 ohm potentiometer (part number 3386W-501LF-ND) for $1.29.

I wired everything up on a breadboard to test out the LEDs. (Ignore the extra components on this breadboard, they were from a different project).

I then purchased a pack of cheap ping-pong balls from Amazon.com. I took a ball, cut it in half with a razor blade, and held it over the LED.

The light was too focused. So I ended up trying a bunch of material, and settled on some batting (fluffy white quilting stuff that comes in sheets) from my wife’s sewing supplies. I folded over a few layers over and tucked them inside the ping-pong ball eye, securing them with some hot glue.

My wife purchased some eye masks from a craft store (in black) and had some black fabric that we could use to cover the faces of the boys. I used some wire I had from a previous project, and wired up the LEDs according to the schematic provided by the LED Wizard web site.

I cut out eye holes in the fabric that I glued to the eye mask so the boys could see, and I mounted the LED covered ping-pong balls halves just below the eye holes.

When everything was done, we had a great Jawa costume. Here is a photo taken during the daytime, and then one at night.

And here is a photo taken with the lights on at night.