It has the same Lego gear and axle assembly as the previous vectoring thrusters, although I changed the gear ratio to 2:1. I used Lego rods at the motor mount beams, extending out 50% more than the toy blimp to get better turning leverage.

But the really cool thing is that I added RC control to the Blimpduino's autonomous control. That way I can fly the blimp manually to test different motor and vectoring strategies and otherwise understand the blimp's aerodynamics.

The way it works is that under RC control, I connect the RC receiver's channel 1 (steer right/left) to the ultrasonic sensor port, and the channel two (steer up/down) directly to the vectoring servo. I'm writing some Arduino code to read the channel 1 PWM on the ultrasonic port pin and convert that into signals to the Blimpduino's two motor driver chips. Basically that ultrasonic sensor port now has dual functions, depending on which program I'm running.

When I want to fly autonomously, I just take off the RC receiver and have Blimpduino control both the vectoring servo and the motors itself, connecting the ultrasonic sensor back to its regular port.

The Li-Po battery (the red thing underneath the receiver at the back of the board) powers Blimpduino and also the RC receiver, via the channel 1 port.

Other parts needed:

• Two N20 motors
• Two props
• Blimpduino board
• A 52" envelope
• Either a small 7.4v Li-Po battery, or a 4xAAA battery holder

Here's a close up from the side:

As those who have been following along with our "minimum blimp" project to create the cheapest possible autonomous aerial robot (by adding an open source autopilot to a toy RC blimp), maintaining altitude in the face of air currents and temperature gradients has been a continuing challenge. The main problem with the toy RC blimps we start with is that they have a single tiny vertical motor and prop to control altitude, and unless you've trimmed the blimp exactly right and conditions don't change, that's not enough to reliably keep the blimp off the floor and away from the ceiling.

The best way to increase the vertical "authority" or control power is to get the two differential thrust props on each side to also do some vertical work, by tilting up or down along with their usual job of driving the blimp forward, back and right and left. Such tilting props are called "vectoring thrusters" and they're what the expensive blimps use. But on the cheap toy blimps that we start off with, the shaft that holds the two horizontal thrusters is glued and screwed into place.

No fear. Converting this shaft into one that can rotate is a simple matter of five pieces of Lego and a small RC servo. You can see it work in the video above, but here are some shots to show how to make it.

Before (typical toy blimp gondola, with RC equipment stripped out):

That's it! Needless to say in the autonomous version the onboard autopilot will drive that servo, not a RC transmitter. But you get the idea. If the two vectoring thruster do the trick of altitude hold, I may remove the vertical thuster entirely to save weight (and two I/O pins). If I need even more vertical control, I'll keep all three going.

It looks like there may be as many as 10 teams using PicoPilots in the Outback Challenge this year. Plus many using other commercial and DIY autopilots, no doubt. This year, the contest's second, promises to be far more competitive than last year. Anybody going who wants to file a report for DIYDrones?

Here's what it is:

A custom PCB with an embedded processor (ATMega168) combined with circuitry to switch between RC control and autopilot control (that's the multiplexer/failsafe, otherwise known as a "MUX"). This controls navigation (following GPS waypoints) and altitude by controlling the rudder and throttle. These components are all open source. This autopilot is fully programmable and can have any number of GPS waypoints (including altitude) and trigger camera or other sensors

As with the Basic Stamp autopilot, to make a fully autonomous aircraft you need to combine this navigation autopillot with a stabilization system, for which we turn to our old friend, the FMA Co-Pilot (off-the-shelf infrared sensors and control board to keep the plane flying level), which controls the ailerons and elevator.

By using Jordi's MUX, which allows us to switch from autopilot to manual RC control in hardware, we gain several advantages over the Basic Stamp:

1) Because the switching isn't handled by the processors, we don’t need to drive servos in real time, which means we don't need stand-alone servo driver chips (thus a simpler board)

2) We also don't need “mirroring” subroutines to pass through servo commands in RC mode (simpler code)

3) Don’t need power regulator, since we’re using regulated output from the RC receiver (simpler board)

4) The built-in MUX failsafe is cheaper and simpler than using a stand-alone one.

I've taken a quick pass at the schematic and PCB (Eagle 5.0 format) for ArduPilot, although this will evolve as we go through the hardware testing cycle: Schematic, PCB board. You can buy the board here. Arduino code coming soon in alpha now.

All together, this can be the basis of a sub-$500 UAV:

Autopilot:

--ArduPilot PCB: $10

--Boarduino kit + FTDI cable: $35 (subtract $17.50 if you already have a FTDI cable)

--PicoSwitch: $20 (we'll probably build this in the board in the next rev)[UPDATE: Jordi's now incorporated that into the board above. It's a TinyAVR chip ("IC3", $2.75) and its associated programming interface jumpers ("ISP")]

--EM-406 GPS module: $60

--Multiplexer chip : $1

--8 Samtec TSW-108-25-G-T-RA right angle servo connectors (available as a free sample): $0

(That's a $110 autopilot, thanks to the open source hardware. By comparison, the Basic Stamp version of this, with processor, development board and failsafe board, would run you $300, and it's not as powerful)

Stabilization:

--FMA Co-Pilot: $70

Plane and RC equipment:

--Hobbico SuperStar (includes motor, battery and ESC): $109

--6-Channel radio system (with proportional control for channel 6, to calibrate FMA system): $109

--Three servos: $45

For very small UAVs, especially those used indoors, an interesting way to navigate is using a technique called "optical flow". Basically, it's the way flies see: they detect motion rather than resolve images. As you move, the objects closest to you appear to move the fastest, which for a camera chip means pixels shifting position faster.

The video above is from a Swiss team that have used optical flow to steer indoor blimps and microlight aircraft (video here). They've got pretty fancy equipment and lots of money--but is there a way to do the same on the cheap? Yes. It turns out that the sensor on an optical mouse (you probably have a few laying around) can do the job. Here are instructions on how to take the chip from an old mouse and connect it to a Basic Stamp (an Arduino would work even better) and create a low-budget optical flow sensor. Taking the dx, dy information from that and using it to drive the airplane's servos or actuators to move in the opposite direction from the highest optical flow should be a pretty easy matter. The only tricky thing is integrating the mouse chip and processor into a package no larger and heavier than the RC receiver that this optical autopilot replaces. The schematic on the mouse chip to Basic Stamp circuit is below:

Along with sharing some imaging technology with our UAVs, FPVs often use autopilots because they can fly further away than you can see from the ground. When pilots get lost or lose the wireless connection (and thus their view), the autopilots can bring the planes back into range.

The initial kit, which costs $549, has the basics and looks like quite a good deal (Hobby Lobby has a great reputation, and the company that makes the equipment, Intelligent Flight, is one of the best in the business). But if you happen to be independently wealthy, you might want to wait for some forthcoming accessories that will complete the full FPV experience: a pan-tilt camera mount, which can be connected to a gyro in your video goggles so the camera will turn where you're looking; an On Screen Display that integrates telemetry data into the video stream (and has a basic "return home" GPS-only autopilot for very stable aircraft), and a directional antenna that can greatly increase the range.

I wouldn't be surprised if all that together runs over $1,000, so it's a bit out of our range. But if you can afford it, this is the ultimate RC experience.

From the description: "The PICO-GS program performs four basic functions: 1. Provides a graphical view of your waypoints on the map image. 2. Permits "point-n'click" waypoint programming on the map image. 3. Provides realtime GPS tracking and flight data on the map image ( requires a radio modem ) 4. Includes the standard PICOPILOT line item editor." It costs $100 for a CD and a license key for a single installation. They're sending me a review copy, so I'll give you a hands-on report as soon as I get it.

I'll be showing this at Maker Faire tomorrow and Sunday. Below is the bottom side of the old (left) and new (right) boards. Differences include putting all the chips inside the gondola ("top") and just the IR sensors, the on/off and reset switches and the FTDI programming port on the outside ("bottom")

The BASIC Stamp product line will continue to be developed by Parallax. But most of the improvements we make to the product line pertain to documentation, operating speed and memory, and the addition of commands. You won't be seeing a floating point library built into the BASIC Stamp.

If you want to have true simultaneous processing with another high-level language, my suggestion is to use the Propeller. You seem to already know that processor so I'll skip listing the specifications. We aim to make the Prop very easy to use by publishing our educational tutorials (see Propeller Education on this page). The forums supporting the Propeller are very active. Supporting the growth of the Propeller is a big priority for Parallax and we back our position by responding to customer requests. In this case, you've got a complete floating point library to use. There's also a BS2 library for the Propeller in case the user wants to continue using something they've already learned.

He and I also had a good phone chat where we talked more about the options. Here's my bullet-point report from that, and summarizing the comments above:

• The Basic Stamp platform continues to be staple of electronic education in schools and will be for years to come. It's still growing in terms of its usage base.
• That said, the technology is not going to evolve much more. The things we want, such as floating point, C-like variable handling and significant increases in memory, are not planned for the Basic Stamp architecture.
• Instead, Parallax recommends that we shift to the Propeller chip, which has both everything we need and reflects the direction that Parallax as a company is going.
• Although Propeller is not currently as easy to learn as the Basic Stamp, Parallax is working hard to improve that. One thing in particular that will help a lot is a forthcoming serial debug window facility like that of the Basic Stamp. This will let you use the PC as a display screen for the chip's output and otherwise get real-time data on variables and program operation. Finally, it will be possible to write a simple "hello world" program for the Propeller and see "hello world" on your screen, rather than just a blinking LED.

As a result, this is what I propose for DIYDrones:

1. We complete the Basic Stamp autopilot so that it works perfectly as it is, both as a teaching tool and for those who currently have the Basic Stamp hardware and want to keep it.
2. After that is done, however, we will not develop it further.
3. We will instead port the Basic Stamp autopilot code to the open source Arduino platform. All future development of our "entry-level DIY autopilot" will be on that platform
4. After that, we will port the code to the Propeller platform and then encourage better programmers than me to help collectively build an open source "pro-grade" autopilot project on it. This is a big job (just ask Dean Goedde, who used the Propeller for his awesome AttoPilot commerical autopilot), so I'm looking for volunteers to help take it on. Anybody out there want to try their hand at the future of embedded computing (8-core, 32-bit, object-oriented parallel processing)?
5. To that end, Parallax has kindly offered to donate $500 worth of Propeller gear to DIYDrones. If you want it and can make a public commitment to starting and sharing an autopilot project here (and can demonstrate that you've got the coding experience to pull that off), I'll work with Parallax to give you the gear of your choice up to that dollar limit. Please respond in the comments.