I suggest you have a look! http://through.thetirestorefb.com/special-report Just the thing you need!

Colin Robinson

I’m on top of the world because of it! http://full.thebrandillusion.com/Colin_Robinson

Colin Robinson

Unbelievable!
http://contact.pronetworkservice.com/Colin_Robinson
Have you ever heard of such a thing?

Colin Robinson

http://glad.moonlightguru.ca/Colin_Robinson

Colin Robinson

http://hearingaidadvocates.com/length.php?Colin Robinson

Best regards,
Colin Robinson

What do you do on the day after a Wild Card victory?  You break out the IR camera to see what you can see, that’s what.

The camera is connected to a Raspberry Pi, an inexpensive computer.  It uses several of the input/output pins to either take an image or make a video.  The pictures below show what it looks like when I hold up a piece of paper.

Just me, holding up a piece of paper.  My face is really warm, and my nose is cold.  (So is my office).

Just me, holding up a piece of paper. My face is really warm, and my nose is cold. (So is my office).

 

My warm hand against the paper.  In the visible spectrum, you wouldn't see anything.  In the IR, you pick up the heat.

My warm hand against the paper. In the visible spectrum, you wouldn’t see anything. In the IR, you pick up the heat.

 

Inside, I am a balmy 37C.  When I breath on paper you see it heat up, but in the visible spectrum, this would be totally unremarkable.

Inside, I am a balmy 37C. When I breath on paper you see it heat up, but in the visible spectrum, this would be totally unremarkable.

 

Instructions for this are well documented in a couple other places.

One important thing to note is that you have to find a directory, according to the instructions above.  The directory has been relocated to:

/LeptonModule/software/raspberrypi_libs/leptonSDKEmb32PUB

The above instructions tell you to look for it in

/LeptonModule/software/raspberrypi_video

After you compile the code you need to cd into

/LeptonModule/software/raspberrypi_video

That little change took me an hour to figure out, but I am perpetually new at this.

Inspiration

Not long ago, I stumbled upon Ken Murphy’s amazing History of the Sky project.  The concept is simple; take a picture of the from sunrise to sunset every 10 seconds every day for a year.  He then made a mosaic of the images, and ran it as a slide show all at once.  You know what, I think its easier if I just show you what he did:

A History of the Sky from Ken Murphy on Vimeo.

Around the time I found this, I started diving in to the Raspberry Pi, and I thought that this little computer could probably reproduce Ken’s amazing project.  I thought I could update it with the Chicago Skyline.

After a series of false starts, I finally got a Raspberry Pi and camera sealed inside a sandwich container (my version of a weather-proof box).  It is currently sitting on the roof of the McGowan Science building at DePaul University.  It wakes up at 4:30AM every day, and takes a picture every 10 seconds until 8:30AM.  That is 360 pictures per hour or 1440 per day.  Another program compresses them into a movie, which gets uploaded into my DropBox account.  My project started on October 1st, 2015, so I have captured a week of Chicago sunrises.  Here is the first one:

Another Raspberry Pi downloads the movies, and breaks them into a series of stills.  When I have enough, they will be assembled into a mosaic image, and turned back into a movie.  With luck, I will have 365 movies to work with.

This Python Program is what I use to take the pictures.


import time
import picamera

VIDEO_DAYS = 1
FRAMES_PER_HOUR = 360
FRAMES = FRAMES_PER_HOUR * 3 * VIDEO_DAYS

file = "/home/pi/camera/frame_%04d.jpg"
#file = str("/home/pi/camera/" + time.strftime("%Y%m%d") + "_%04d.jpg")

def capture_frame(frame):
with picamera.PiCamera() as cam:
time.sleep(2)
cam.resolution=(1280,720)
cam.capture(file % frame)

# Capture the images
for frame in range(FRAMES):
# Note the time before the capture
start = time.time()
capture_frame(frame)
# Wait for the next capture. Note that we take into
# account the length of time it took to capture the
# image when calculating the delay
time.sleep(
int(60 * 60 / FRAMES_PER_HOUR) - (time.time() - start)
)


This code was used to turn it into a movie. It is a bash script


#!/bin/bash

DATE=$(date +"%Y%m%d")

avconv -r 10 -i /home/pi/camera/frame_%04d.jpg -r 10 -vcodec libx264 -crf 20 -g 15 /home/pi/camera/$DATE.mp4


Finally, this Python Program uploaded it to DropBox.


import time
from subprocess import call

date = time.strftime("%Y%m%d")
path = "/home/pi/camera/"+date+".mp4"
destination = date+".mp4"

photofile = "/home/pi/Dropbox-Uploader/dropbox_uploader.sh upload "+path+" "+destination

call ([photofile], shell=True)


It isn't very difficult, and this is the best way to really see the days getting longer and shorter, and connecting that to the Earth's tilt as it goes around the sun.

On Saturday, June 6th I had the pleasure of doing a tethered balloon launch as part of the STEM Launches Program at the Illinois Institute of Technology. This activity is funded by the Office of Naval Research (ONR) under the Critical MASS grant which supports STEM education and service for college bound high school students.

Our goal was to have students build some simple sensors that they would put into a Styrofoam box that will be attached to a rubber balloon and flown at a height of about 100 feet.  That was goal when I proposed the project, and that was the goal on the morning of the launch.  We were excited and ready to get to work.

There were a total of 17 students from a few CPS Schools (Michelle Clark, Sarah Goode, Lakeview, and Rickover Naval Academy).  There was also help from IIT and the City Colleges of Chicago.

Sensors

Team leader, Heather Nelson, led a group of 8 students on the construction of the BMP180 pressure/temperature/altitude sensor.  Her goal was to get it connected to an Arduino, and have it log data on a microSD card that was connected using an Ethernet shield.  In about 2 hours, all of Heather’s students built their circuits, and were ready to fly them.

Heather Nelson building pressure/temperature/altitude sensors.  All of them worked!

Cameras

Every time we fly a balloon we we want to take advantage of the opportunity to take beautiful pictures.  Recent IIT graduate (and future physics teacher extraordinaire) Ryan Kamphuis led a group of 8 students on building Raspberry Pi cameras that would take pictures of the Chicago skyline.  He also worked on USB Infragram camera that would take pictures of plants, and give us information on their photosynthetic activity.  We had some issues with the cameras and Pi’s that were going to take some time and attention to resolve, so in the end we built one camera using the visible Pi Camera board, and it was ready to fly.

Ryan working on getting the cameras up and running with students from Corliss.

Pods

When we fly these sensors, they need to be secure and protected.  We also wanted to show the students how we built foam boxes using 1.5″ thick insulation from Home Depot.  Agu Uzoma from the City Colleges of Chicago lead a group of students who built a total of four pods.  These were hot glued together and reinforced with carbon fiber rods.  They would hold the sensors during the flight.

Making pods out of foam, and measuring the lines (6 feet each).

Flight Part One

We used a 200g balloon from Kaymont.  It was relatively small, and would not need a lot of helium to fly.  When we connected the pods and made sure that everything was on and working, we started to fill the balloon with helium.  Our first problem was that the tank did not have enough helium in it to provide enough lift.  This was a strange problem, because we thought we were dealing with a brand new tank.  We sent the students to lunch while we got a second tank from the lab.  When it was hooked up, there was more than enough helium to get the balloon and pods off the ground.

When the balloon got to a height of about 40 feet, the wind picked up, and the zip ties that were securing the payload and tethering lines to the balloon failed, and payload fell to the ground and the balloon went up in to the sky on its way to parts unknown.

Undeterred and with the students still at lunch, we prepared a second balloon.

Flight Part Two

We salvaged the working sensors and cameras from our previous pods and consolidated them down to one pod.  Ryan quickly got another camera up and running, and Heather & Uzoma did all the logistics for preparing a second balloon.

With everything working we filled the second balloon, and saw that we would have plenty of lift.  The zip ties were secure, and we had no problem flying at a height of about 100 feet.  We wanted to go much higher, but the ground wind brought the tethering lines close to some trees, and so we went with a shorter and lower flight over all.

Results

If our goal was to fly a camera, and a sensor, we succeeded  on both accounts.  The pictures below show some of the better images we got.  The camera was programmed to take a picture every 10 seconds, and save everything locally.  The BMP180 took a reading every second and recorded it on a micro SD card.   You can see the pictures.  Graphs will be there soon.

 

The balloon flying overhead at a height of about 100 feet.

 

Looking down on the Green Line at IIT.

 

Looking north to downtown from above IITs campus.

 

West or south.

Thoughts

This was a lot of fun, and we could see that the students were enjoying themselves.  Obviously it was embarrassing to have the first balloon fail, but it seemed to be part of the process.  We assessed our mistakes, regrouped and got a second balloon in the air.  There has got to be a lesson about resilience and perseverance in there somewhere. In the end, students were happy to see what they got, and were asking when they could try this again.

I have been a vocal proponent of the Raspberry Pi and Arduino and their use in education.  Programming a computer on the ground, and seeing that it worked in the air is the closest thing to magic that I have seen a long time.