Stratospheric Solar Balloon Flight

It took three years and several false starts, but we finally got a solar balloon with a video camera on board to take off successfully.  Not only that, but the balloon reached an elevation of over 22,000 meters (72,000 feet), well into the stratosphere!  Then, it suffered what Elon Musk calls a “rapid unscheduled disassembly,” sending the payload into a 22 kilometre free fall that ended in the muddy banks of a cow pond.  Despite this, the photos, video, and GPS track were all recovered.  Here’s the flight video:

The balloon envelope consisted of a 19 foot diameter sphere of 0.31 mil clear plastic paint drop cloth.  Since the drop cloth comes in 12 x 400 foot sheets, we constructed the envelope from 5 gores that were 12 feet wide at the equator.  We attached the gores together using clear shipping tape and darkened the interior of the balloon with black paint pigment.  Each gore seam had a string attached to the bottom with black duct tape.  The opening at the bottom of the balloon is about 6 feet across, allowing two people to inflate it by hand (check out the full inflation and launch video).

The solar balloon in flight just after launch.  Image credit: Mary Lide Parker

The solar balloon in flight just after launch. Image credit: Mary Lide Parker

The payload consisted of a SPOT satellite tracker for recovery, an Arduino Uno with Adafruit High Altitude GPS Shield for trajectory determination, and a Raspberry Pi with camera module for video and stills.  The system was powered using a lithium battery pack meant for recharging cell phones (10 ampere hours).  All this was contained in a Tupperware box with a small hole to admit the camera lens.  We attached it to the balloon using four strings taped onto the box with white duct tape.  The four strings led to a fishing swivel to keep the payload from spinning too much.  We clipped it to the strings on the envelope using a black carabiner. Total payload weight was 800 grams (1.75 lbs).

payload

Payload with the lid off, showing flight instrumentation (left) and payload just before launch (right).

We kept an eye on the wind profiles for about 5 months, since most of the time winds in the troposphere blow out to sea.  Finally, we waterproofed the payload and decided to risk a flight even if some winds were going east.  On May 29, the winds in the troposphere were pretty low (max 10 m/s or so) and with varying azimuth.  The stratosphere had a steady breeze going west, so we figured if we made it that high, we’d head back over land.  However, we had a much faster ascent rate and reached a much higher altitude than we anticipated, so we ended up not flying very far from the launch site.  You can download the trajectory data in text format here or Google Earth KML here.

trajectory

Ground flight path (left), launch site is the origin. Altitude versus time (centre), local time was GMT – 4. Ascent rate versus time (right), local time was GMT – 4. I obtained the ascent rate by calculating a 1 minute moving average and dividing elevation by time.

The photos and video were very good quality considering that we were using the Raspberry Pi camera module (not the world’s most advanced camera).  The troposphere was pretty misty, and it seems like we even passed through a haze layer on the way up.  However, it could be that the lens fogged up temporarily.  Once we entered the stratosphere, the pictures are much better:

00670

The view from 22 kilometres in the sky.

You can watch a slide show of all the photos here, and all the video clips stitched together here.

Just as we approached neutral buoyancy, the payload unexpectedly separated from the envelope and fell back down to Earth.  We kept GPS tracking until about 18 kilometres elevation, and as far as I can tell the box was falling at about 320 km/hr (200 mph).  The Arduino kept track of time even after losing GPS fix, continuing to record until the moment of impact.  Thus, we know that the payload fell the remaining 18 km in about 12 minutes.  The impact speed was probably less than 100 km/hr (60 mph).  The Tupperware payload box was cracked, and everything except the SPOT tracker stopped working.  Had we landed 10 centimetres or so west, we would have splashed down in a pond.  Luckily, we hit the mud on the pond’s edge (and missed the cows that were in the area).

CGasLNHUQAAnDHG

The payload box at the impact site in Snow Camp, North Carolina.

We consider this flight mostly successful.  Our main objectives were to launch, recover, and extract data from an instrument package lifted with a solar balloon.  Furthermore, we wanted to inflate the solar balloon by hand.  Both of these objectives were reached. Our secondary goals were to fly until sunset, not land in the ocean, and make it to the stratosphere.  The flight was only about 2.5 hours, so we did not fly all day as we hoped.  However, we made it well into the stratosphere and were never in danger of ending up in the ocean.

We had a slightly tense launch when the payload got snagged on the eaves of a nearby building, but the balloon built up enough lift to detach itself in about 20 seconds.  The SPOT tracker did not record any positions during flight, so we did not know where the balloon was and were not even sure if the tracker was working.  In fact, it did not record positions until about an hour and a half after impact. The unexpected flight termination was upsetting as we did not anticipate having the payload detach from the envelope.  We assumed that either the envelope would rupture due to sun-induced heating at altitude or that it would deflate at sunset.  In either case, the payload would have had a large plastic streamer to slow it down to safe velocities.  Instead, it appears that the black duct tape we used to attach the payload strings to the envelope got too hot in the intense sunlight at 22 km.  This caused the payload to come loose from the balloon.  The lesson we learned from this is to never use dark coloured tape if there’s a chance the flight system will make it to extreme elevations.

Advertisements

Persistence of Vision Frisbee

The first time I saw a persistence of vision (POV) clock I thought: “Wouldn’t that be cool on the side of the frisbee?”. It is a fun weekend project to make one. Here is an action shot of the POV frisbee I made:

IMG_4897

It looks better in person – this picture is the best we could do with a Canon camera held on a level surface. The frisbee is spelling out ‘bovine aero’. Below is a picture of a test in a darkened room:

IMG_4863

This is the perfect project for Adafruit’s tiny, lightweight Arduino compatible Trinket. The total cost of the materials was around $30:

Assembly is as simple as hooking up an LED & resistor in series to each digital out pin, writing some code to blink the lights in the correct order (see below), and attaching the circuit to the frisbee. Below are some pictures taken during assembly:

IMG_20141013_142138647_HDRIMG_20141013_142156068_HDR

Some insights, if anyone else tries this:

  • I considered using a load sensor to determine the rotation rate of the frisbee (a = v^2/r). If you know the rotational speed of the frisbee, you can time the LED outputs to write more consistently spaced letters. However, it turns out the POV illusion looks OK if you use a fixed letter writing rate (I used an ‘on’ time 1 ms per vertical column of letter).
  • To mount the LEDs on the frisbee, I drilled holes in the side and covered them with electrical tape. Punching the LEDs through the tape provided a stable mount for the LEDS.
  • I used letters made up of 5×5 pixel blocks. A better POV display could use more vertically stacked LEDs, or even multicolored LEDs.

Click below to see the code I used:

int B[25] = {1,1,1,1,1, 1,0,1,0,1, 1,0,1,0,1, 0,1,0,1,0, 0,0,0,0,0};
int O[25] = {0,1,1,1,0, 1,0,0,0,1, 1,0,0,0,1, 0,1,1,1,0, 0,0,0,0,0};
int V[25] = {1,1,1,1,0, 0,0,0,1,0, 0,0,0,0,1, 0,0,0,1,0, 1,1,1,1,0};
int I[25] = {0,0,0,0,0, 1,0,0,0,1, 1,1,1,1,1, 1,0,0,0,1, 0,0,0,0,0};
int N[25] = {1,1,1,1,1, 0,1,0,0,0, 0,0,1,0,0, 0,0,0,1,0, 1,1,1,1,1};
int E[25] = {1,1,1,1,1, 1,0,1,0,1, 1,0,1,0,1, 1,0,1,0,1, 0,0,0,0,0};
int A[25] = {0,1,1,1,1, 1,0,1,0,0, 1,0,1,0,0, 0,1,1,1,1, 0,0,0,0,0};
int R[25] = {1,1,1,1,1, 1,0,1,0,0, 1,0,1,1,0, 0,1,0,1,1, 0,0,0,0,0};
int S[25] = {0,1,0,0,1, 1,0,1,0,1, 1,0,1,0,1, 1,0,0,1,0, 0,0,0,0,0};
int P[25] = {1,1,1,1,1, 1,0,1,0,0, 1,0,1,0,0, 0,1,0,0,0, 0,0,0,0,0};
int C[25] = {0,1,1,1,0, 1,0,0,0,1, 1,0,0,0,1, 1,0,0,0,1, 0,0,0,0,0};
int space[25] = {0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0};

int letter_time;
int write_time;

void setup() {
  //use pins 0-4 for output
  pinMode(0, OUTPUT);
  pinMode(1, OUTPUT);
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);

  letter_time = 2; //delay between letters (ms)
  write_time = 1; //how long a led is activated for (ms)
}

//Write an letter to the POV display
void write_letter(int * letter) {
  //write letter, column by column
  for(int i = 0; i < 5; i++) {
    for(int j = 0; j < 5; j++) {
      digitalWrite(j, letter[j+i*5]);
    }
    delay(write_time);
  }

  //write space after letter
  for(int i = 0; i < 5; i++) {
    digitalWrite(i, 0);
  }
  delay(letter_time);
}

void loop() {
  write_letter(B);
  write_letter(O);
  write_letter(V);
  write_letter(I);
  write_letter(N);
  write_letter(E);
  write_letter(space);
  write_letter(A);
  write_letter(E);
  write_letter(R);
  write_letter(O);
  write_letter(space);
}

GPS Balloon Cutdown

This post goes over how to make a GPS based cutdown for your high altitude weather balloon. FAA regulations (FAR 101) require that unmanned balloons have two methods of flight termination. While balloon burst at high altitude is usually a very reliable way to end your flight, if there is any risk of the balloon reaching neutral buoyancy, such as with launches designed maximize elevation, a secondary cutdown is useful.

For our cutdown we used a ‘thermal knife’ made of 30 gauge nichrome wire (a type of wire also used in toasters).  To trigger the cutdown we used an Arduino Uno board and the “ultimate GPS” from Adafruit. The Arduino checks the GPS coordinates every 60 seconds, and if the GPS has crossed some preset line (for example, the balloon is 30 miles from an ocean or great lake) sends the cutdown signal. Alternatively, you could use a limit on time aloft to trigger the cutdown.  The Arduino cutdown signal triggers a transistor to switch on a reed relay, which completes a circuit with the nichrome wire and a battery pack. The reed relay is needed because the large amount of current that flows through the cutdown circuit loop would fry the transistor! A circuit diagram (created with Circuit Lab) is shown below:

Cutdown circuit diagram

Cutdown circuit diagram

And picture of the circuit soldered on perf board:

Cutdown Circuit

Cutdown Circuit

We used a battery pack with 4AAs to power the cutdown, which provides sufficient current to get the nichrome wire glowing red hot:

Glowing Hot Nichrome Wire

Glowing Hot Nichrome Wire

For balloon flight, the nichrome cutdown wire was coiled around the line between the balloon and the payload and sheathed in heat shrink tubing.  The setup is shown below:

cutdown_setupAs a first test of our cutdown mechanism, we launched a balloon with the Arduino set to trigger the cutdown at 20,000 m. Our blog post about the launch is here, and pictures from that cold snowy day are here. As show below the cutdown worked perfectly, terminating the ascent at 20,082 m:

Elevation recorded by GPS during flight.

Elevation recorded by GPS during flight.

The Arduino sketch that we made to do all of this is based on the Adafruit Ultimate GPS Library, and is available here.