PyCon 2014: 27 days out…First flight. Sort of.

As I look back on my previous post from yesterday, I realized that there were a few topics I’d missed discussing. So I want to start off by saying that I ended up carrying a tank of helium to my car on Thursday night.  It was really heavy.

Screen Shot 2014-03-16 at 12.15.19 AM

As of this morning, the remaining obstacles in the project included:

  • Use actual lifting gas
  • Mounting all of the hardware to the blimp
  • Testing of basic flight controls
  • Independently validate the autopilot algorithm
  • Implement the flight controls wit the autopilot algorithm
  • ???
  • Profit

This is about where I left off last night:

IMG_0055
The most daunting challenge from my perspective at this point is to figure out how to go about mounting a single board computer, a couple of i2c sensors, a USB GPS sensor, a webcam, an XBee module, and a USB hub all onto a blimp.  Fortunately for me, with Larry’s help and hardware, it was easy to craft a basic housing unit using some old molding materials.

photo (4)

I’d previously used a laser cutter to cut out a piece of acrylic with some carefully measured holds to screw in some mounting screws along with some nylon spacers.  This secured the singleboard computer, sensors, and XBee module to the acrlyic board, but I still needed to mount the board to the blimp and make room for the USB devices.  The solution we put together ended up looking like this:

IMG_0079

 

Now that we had everything ready to mount, we needed to fill the actual balloon with helium.  If we had used regular air, the air itself would be weighing the blimp down and creating additional stresses on the balloon and the mounting materials.  So if we recall the heroes from yesterday’s tale, we remember good Ron from SF Balloon Magic, the man who kindly supplied helium and spoke with a high pitched voice:

balloon

 

Anyway we took the helium and filled up the blimp:

IMG_0064

IMG_0065

IMG_0066

IMG_0067

IMG_0068

IMG_0069

We’d tethered the balloon before filling, and now we could mount the gondola and associated hardware:

IMG_0085

IMG_0101

IMG_0106

IMG_0110

The entire blimp was now almost entirely buoyant. Ideally, the blimp is only slightly heavier than air. In the case of lost power or lost communication, the blimp should still sink (slowly) down to the ground. As such, in the picture below I’m actually pulling down a bit in order to pull the tail of the blimp downward since the drone was forward-heavy because of the gondola.

IMG_0102

Right before mounting I’d done some last minute testing with the XBox controller. The first video demonstrates basic motor control using PWM signals and an electronic speed controller:

The second video demonstrates basic servo manipulation. In this case a servo that accept an input range and maps to a corresponding physical servo is used to control the blimp’s thrust vector.

This brings us to our final test of the night. After starting this project a year ago, we were finally able to actually get the drone off the ground. I’m ecstatic to announce that the basic flight movement did not involve a crash, nor did it start a fire. That’s a big success by my standards.


At that point, the look on Larry’s face expressed sincere indifference. Although he grinds daily with blimps, I was more excited about everything that was validated in this process. The entire flow from the XBox controller went something like this.

  • Detect and interpret the commands from an XBox controller written with some C++ code
  • Compile the C++ code to a python library that can subsequently be interpreted
  • Automatically detect the proper port for the XBee module
  • Send custom encoded commands through the XBee module to the receiving end
  • Run a single boarding computer running Linux that launches a process on startup
  • Automatically detect the proper port for the XBee module on the receiving end
  • Decode the commands through the XBee module on the receiving end
  • Relay the decoded values to a class responsible for interpreting the XBox inputs and converting them into “messages” that would be identically generated from an AutoPilot class
  • Send the messages to another class responsible for sending exact pulse width modulation duty values to all of the different motors and sensors
  • Execute all of the above actions through asynchronous tasks that each communicated with each other

More to come tomorrow! Hoping to be able to say that she was christened with a bottle of champagne and she flew from here to Lakehurst, New Jersey without incident.