Introduction: Arduino-Radio Controlled Hydrogen Blimp

This details the construction of the remote-controlled blimp I built. Here's a short video of it flying:

The blimp is controlled by a transmitter on the ground, operated by a human. There are three control levers-- one for each motor, and one for the servo that rotates the axis they're attached to. You push / pull to make the motors speed up or slow down; they're controlled individually, it's like driving a tank. You need two Arduinos - one for the transmitter and one on the blimp itself.

I generate the hydrogen through the reaction that occurs when aluminum, water, and lye (NaOH) are mixed.

I'll go through the steps of building the transmitter first, then the blimp, and finally filling it up with gas.
If you persist, you too can rule the skies of your living room.


- 1 ArduinoDuemilanove                       but really any of them would work
-Ramsey TX433 Transmitter Module                           see next slide for details / alternatives
- 3 100k Ohm potentionmeters             make sure they're the kind that rotate, you'll need to mount levers on them
- Assorted wires
- ~10 0.1" pin headers-- the standard kind that plug into Arduino sockets
-Elastic material    (?)               optional--  I used strips of elastic that they put in pant waistbands to make them stretch
-Wood                                            It comes from trees
-Right-angle joints                    I'm not sure if that's the right name--they're the metal angles that let you screw together two pieces of wood at right angles
-9v battery clip
-project board( a small one)      

-SPST switch for power                            i got mine from an ikea lamp

- 1 Arduino Nano                          
-Ramsey RX433 Receiver Module                   see next slide for details / alternatives
- Blimp envelope                    i used this one from Plantraco-- the same one the Blimpduino guys used
-Balsa Wood                      get it at Ace Hardware--I used a large flat piece plus assorted beams
-4 cotton balls                 for soft landings!
-1 7.4V 2 cell LiPo battery          I got it here -- you could absolutely use a smaller one
- 2 brushed motors w/ propellers               I used these and their corresponding propellers      ( stolen from the incredible Hummingblimp)
- 1 small servo                 I used a really tiny 2g digital servo, also from Hobbyking. I can't find it on their website, but you could use anything with a similar low weight
-Project Board               you'll need three small pieces, each around an inch to 2 inches to a side
-4 3906 PNP transistors        or similar
-10 3904 NPN transistors
1 7805 voltage regulator
-1 100 uF capacitor
-power switch
-4x 100K ohm resistor            

-2x 0.5 uF capacitor
-2 pin headers                     
-assorted wiring                   12 of the wires will need 0.1" socket endings to fit the Arduino's pins; my Nano came with them. you may not be so lucky. Another note on wiring: it adds a lot of weight to the blimp and adds up quickly, so make it as short and light as possible. Wherever possible I used those really thin grey wires that run through data bus connectors inside computers.
-1 drinking straw , coffee straw
-4 pairs of velcro pads            
they're about 1 sq. in, with adhesive on the back. I think they sell them at places like Staples

Hydrogen Production
-1 flask with a spout           mine had a spout near that top that 1/4" tubing fit over nicely
-1/4" tubing                          If you're not using some sort of buffer container, you'll probably want at least three feet
-Lye I get mine in 500g containers at Ace. For exact amounts see H2 production step
-Aluminum                        Soda cans, heating ducts--use your imagination. You'll need at least 120 grams for one fill
-Ice                                     Lots and lots of ice
- Good gloves                 Lye can and will burn you, especially if you're dumb like me. Use gloves that are intended for labs where dangerous chemicals are used.
-A rubber stopper           or other means of completely sealing your flask
- A sealed catheter bag (optional)      handy as a buffer and for controlling the flow of gas


-Soldering iron / solder                 Make sure it has a fine tip; grind it down if necessary.
-Drill press / hand drill                  for making the control levers
-A computer
- A saw

- x-acto hobby knife                  for cutting balsa
-Glue                                      It mainly needs to join balsa to balsa; any wood glue you have will probably be fine.
- A good scale                  for measuring lye and aluminum--as well as your blimp.
-Wire cutters

-oscilloscope               optional but really really useful

Below I included a zip file which contains the schematics for the transmitter and receiver, as well as the Arduino sketches for each of them -- those are the .ino's. Please note that the schematics are, well, schematic, but they won't actually map to the right parts if you try to create PCB's from them. The eagle .lbr parts are not exact, they're just diagrams that I used to help with the wiring, which I did by hand.

Step 1: A Note About Radios

 I used a transmitter / receiver pair - the TX/RX 433 that my brother gave me that was languishing in our basement for several years. The modules are made by Ramsey electronics and are very poorly documented; I don't know if Ramsey even makes them anymore. Fortunately, I do know that they're very cheap -- I think $5 -- so buying a similar pair shouldn't set you back to much. They operate on the 433 MHz band, which you don't need a license for; be warned, though, that a lot of RC vehicles use this frequency  which could lead to interference. It took me a really long time to get these radios to operate reliably without static, because there were some small pads on the underside that were soldered together when I found them, that weren't supposed to be.  An oscilloscope is invaluable for debugging radio problems.
         This picture is of the transmitter module, soldered into a connector that I use to attach it to the controller. The radios, once you get them to work, are very simple to operate: you give them +5V and GND, and then whenever you pull the DATA pin on the transmitter high, the DATA pin on the receiver also goes to +5V. This is a very intuitive way of operating radios, and with some fine tuning of timing you can use these radios to send bytes reliably and quickly one-way. There are lots of cheap radio pairs you can buy that operate exactly like this, and with them you can use the exact same setup I did. If you feel like splurging, there are things like the Xbee which handle all of the messy timing issues for you--you give it data, and it spits it out on the other side. They are, however, very expensive.

Step 2: How It Works: Transmitter

 The transmitter Arduino reads voltage levels from the three potentiometers on the controller levels, divides them by the reference voltage (5V), and comes out with an 8-bit value (for example, if the potentiometer is turned exactly halfway, it will return 128, because 128/256 = 1/2). A one - byte value is 8 bits, or 8 places in base two. The transmitter takes the potentiometer value and sends it the radio module, one byte every 0.5 ms ( the radio's max transmission rate is 2000 bps). For example, if the value is 200, the Arduino would pulse:

1 1 0 0     1 0 0 0

Where a 1 is "high" on the TX data line for 0.5ms, and 0 is "low" on the line for 0.5ms. Before it sends this, though, the radio transmits a 'start code':

1 0 1 0     0 1 0 1

This is what the Arduino on the other side is "looking for" -- it needs to see this value before it starts recording data packets, or else it might start recording in the middle of a packet and then everything would get thrown off. So, this is one complete data packet that the ground Arduino transmits ( it sends them out once every 10ms) :

[ start code ] [ motor #1 byte ]  *   [ motor #2 byte ]  *  [ servo byte]  *

The * indicates a HIGH pulse for 0.5 ms -- these are needed because the radio gets a lot of interference if you leave it sitting LOW to long.

You can see the levers and connectors leading to the Arduino and radio in the picture.

Step 3: How It Works: Receiver

Once the transmitter goes high or low, so does the receiver's data line, so to send data packets all you have to know is the distance between the pulses, and where the data packet starts.  When the RX line goes high, the Arduino's interrupt is triggered, and it starts reading data. It waits 0.5 ms, checks if it's high or low, waits again, and so on; high = 1, low =0, like before. The bytes are sent in descending order, so each bit carries half the value of the previous one. If it reads a start code, it will continue reading data; otherwise, it quits. After it has stored all the new data, it quits the interrupt and spends the next 10ms updating and running the servo and motors until the next packet arrives.

You can see in the code that every time the Arduino successfully recognizes the start code, it blinks the LED that comes pre-installed on pin 13. This makes it easy to see it your radio is transmitting properly -- the white light should be flickering on pretty much continuously.

         The Arduino scales the motor values to be higher the further the potentiometer is from 128, with a maximum amplitude at 0 and 255 (raw values). The direction (reverse / forward) is determined by the two digital inputs that go into the H-bridges ( the motor driver circuits -- I used the design from Mark Tilden's site). Pull one side high, it goes reverse, and the other side makes it go forward. That might sound mysterious, but look at the schematic with all the transistors laid out nicely and it'll make sense. The H-bridges I built can be seen in the picture.

Anyway, the motors draw a relatively large amount of current, so you can't power them directly from the 7805 -- they draw from the 7.4V battery through transistors. The servo and radio, however, do run off the voltage regulator. You can see all of the receiver parts connected together above. It is a bit of a mess, in the name of reducing weight.

Step 4: Making the Transmitter

Start by building the wooden base for the controller. I used two rectangular pieces of plywood, separated by four wooden pylons. The reason for this is that originally, when I was using PIC chips, the transmitter board was much larger and needed somewhere to go (you can see the old one above). The one use currently is the first picture, with the Arduino in frame. Yours can be way smaller, especially the handles -- I just like having really big levers to push around. In fact, if you use smaller levers, you won't need the elastic to hold them in up and in place. In my case, the weight of the handles means that they fall down without support. It is really nice to have an nice elastic response that zeroes the motors, as it makes the blimp much easier to control.
      Anyway, cut and sand your wood, then put together some sort of a square base. Once you have that, screw in your metal angles, and space them out as much as possible across the base. Screw in pieces of wood that stand up vertically. Watch the screw length, too -- in my case, the only ones I had were too long, so now I keep stabbing myself because they poke through the wood.
      Get your potentiometers out. The shaft diameters of the ones I got were 1/4", but when I drilled 1/4" holes in the handles they slipped and didn't hold firm. If this happens, you have a choice: glue the potentiometers in directly, or do what I did and fit a plastic straw around each shaft: it gives a good fit without slipping. Also make sure that your potentiometers are turned halfway when the lever is vertical; a small deviation can be corrected in software later, but if it's way off you won't be able to turn it in one direction.
      Once you've got the first one in position, grab your trusty glue and fix your potentiometer to the vertical piece. Make sure to hold firmly for a bit. Do this for the other two, and then solder wires onto the three attachment points of each pot. I gathered these together and soldered them into a pretty standard connector so that they can be detached easily from the rest of the transmitter components.
      Now get your elastic. Screw it into one side of a lever, screw it to the base, and then fix it to the other side at your desired firmness. This step took me a lot of tweaking, but it's worth it in the end when you have a smooth, automatic response.
   Now you have the controller base, so you need to put together the board that connects it and the radio to the arduino. You can do this however you want by following the general schematic; I like things that are easily detachable, so I used a lot of connectors between components. I used the board in the picture above as a hub to bring all the wires together, and then used a row of pin headers to connect everything to the appropriate pins of the arduino. The picture above is missing the 9V battery clip, which I added later.

       If you've reached this point, attached all the bits per the schematic, and haven't broken everything, I would suggest uploading the transmitter code and looking for the telltale series of square pulses on the radio's data line with an oscilloscope. If you can see it, and can see it change when you move the levers, you're in good stead.

Step 5: Building the Blimp Frame

Start with the blimp's frame, made of balsa. Mine was 6" x 12", which left me with a lot of space where I want put more things later. You could probably get away with 6" x 6". Anyway, once you've cut that out, glue a balsa beam ( mine were 1/4" wide) underneath the flat piece, one at the front and one at the back, in a direction perpendicular to the grain. The fibers of the balsa wood can and will split apart if you don't do this. You can see these beams in the "head-on" views.

Now you need legs for your blimp. I had the Apollo moon lander in mind when I did mine, and trust me, they're worth it -- they protect your precious equipment from impact damage, and balsa is so light that the weight added is practically negligible. Mine are 6" long, at an angle of about 45 degrees below horizontal. Cut / file the ends of each leg so that when the 'foot' is flat on the ground, the leg is at 45 degrees, and the 'top foot' is parallel to the horizontal. Now glue each leg into place so that they stick out to the sides, with the feet more or less flat (you're going to glue cotton balls to them, so it doesn't need to be perfect).

You'll need triangular supports for the legs, otherwise they'll bend out and snap under weight. Cut them to the same angle as the legs, with each of the smaller sides 1" long, and glue them onto the legs and the larger frame. Your blimp should be able to stand up now, so glue some cotton balls to the feet for soft landings.

One more thing to add in this step: the battery box. The battery is by far the heaviest component, so you want it to be exactly centered. Measure the dimensions of your battery, then use these to measure from the sides and sketch a box in the center. Make sure your battery fits before you glue the balsa, and leave a small gap for the wires to poke out.

Step 6: Adding the Servo Axis

Start with a long, thin beam of balsa - the longer the better, up until it starts bending with the motors. Mine is about a foot long. Next, cut two struts of balsa, about 2", and glue little cylinders of plastic to the end of each. Slide the long beam through the cylinders and keep it there. Now, build little cradles out of balsa to hold the motors on the end of the beam -- you can see these in the overhead shot . They should be a tiny bit less wide than the motors, so that the motors are gripped firmly once in place. Glue one strut to each side of the frame, at the back -- see the picture. Once those are secure, glue little knobs of balsa onto the beam, on the inside of the plastic cylinders, so that the beam can't move side-to-side from its centered, stable position.

Once the glue has dried, it's time to add the shaft mechanism. Get a 2" beam of balsa and glue a tiny piece ( 1 cm ) of coffee-stirring straw to the end. Whittle down a bit of balsa until it fits through, then slip it through the straw and cut it down so there's a little bit sticking out each side. Glue each end to a 1cm piece of balsa, oriented perpendicular to the straw and the shaft, and glue each piece to the long beam below. Let it dry. If you did this right, you should have a shaft fixed to a joint on the beam; when you push and pull the shaft, the beam should rotate one way and then the other. This is really important: make sure that the shaft is fixed to the top part of the beam when the motors are correctly oriented, facing away from the main blimp frame.

Finally, the servo. Create a 'cradle' that fits around the servo like the one seen in the picture, and make sure the bits above and below the servo are made of plywood or another hard wood; I glued them to a third balsa piece. Drill one hole into each of these strong sections, then thread a thin wire through each hole and though the mounting holes on the servo. Twist the wires tight so that the servo doesn't move during operation. Glue or otherwise affix a little piece of wire to the end of the shaft mechanism that's nearest to the blimp frame, then fit the wire into one of the small holes that come pre-drilled in the servo arm. It should fit snugly but be free to rotate. Finally, glue the wooden servo mount to the main frame, and you've finished the servo assembly.

Here are a couple videos of the servo mechanism in action:


Be aware that you may have to fine-tune the length of the push-rod to get the range of motion you need. Anything above 45 degrees of rotation will probably be enough, because putting the motors in reverse will effectively double that range.

Step 7: Wiring the Blimp

I have included some pictures of the wiring on mine, but it'll be a lot easier if you just go by the schematic.
I originally used a lot of heavy wiring and connectors in the name of neatness and convenience, but gave it up after I saw how much weight I had added. The result is a slightly tangled but very functional layout.

You should start by building your h-bridges -- if you haven't already, look at Mark Tilden's website for an excellent diagram. You'll probably want to build them on little boards so you can test them with your motors individually before soldering them in.

Once you've got those, you should start thinking about powering your circuits. I cut off the connector the battery came with -- you should too, it saves you 10 grams -- and replaced it with light wires ending in 0.1" sockets, so it can still be easily removed for charging. It plugs into pin headers that I soldered onto the through-hole board. I also put the 7805 on the board, so the power wires for the servo, radio, and Arduino originate from there. The two NPN transistors that the motors draw from (and that the Arduino PWM's ) are also in the board, with the "collector" pin connected directly to the 7.4V of the battery. Again, see the diagram.

Using the socket wires, I connected the Arduino to the h-bridges, radio, servo, and motor transistor. That green chip turned on its side is the TX module. The location for the h-bridges is pretty obvious -- one on either side of the servo. If you get the orientation of the motors wrong (for example, you push forward and it goes back), remember that it's really easy to change by swapping direction pins on the Arduino, or just by changing a line of code.

Step 8: Mounting Braces

Now that your blimp is working ( and hopefully you've tested it by now to make sure that it is), you need a way to attach it to your soon-to-be-inflated envelope. Cut 4 strips of balsa beam, about 2" long, and on the end of each glue a square of balsa just big enough to fit a velcro patch. Glue one of these struts to each corner of the blimp frame. They too will need some triangular supports, so cut out 16 of these - mine were right triangles, with the short legs about 1/2" long. On each strut, glue two to support the square and two to support the column at its base, as seen in the picture. Finally, press a velcro patch onto the pad of each column, and its adhesive should hold it there nicely.

You've built the 'gondola' of the blimp. Now you just have to get it airborne.

Step 9: Aluminum and Lye

To make H2 lifting gas for this project, I used the following reaction:

2 Al + 2 NaOH + 2 H2O → 2 NaAlO2 + 3 H2

This exothermic reaction occurs when you mix NaOH (lye) solution with solid aluminum metal -- the lye strips off the oxides on the surface of the metal and lets the water react with the metal to produce hydrogen gas. A lot of heat is released in the process, and increased temperature increases the reaction rate, which leads to increased temperature, and so on...depending on the amount of water you put in the reaction vessel, things can get out of hand very fast. The first picture shows one of the reaction vessels  used immersed in an ice bath (which had melted by the time I took the picture).

As I mentioned previously, lye is a strong base and will burn you pretty badly if you let it. Wear gloves, and always set up one of these reactions in a place where nothing will be damaged if the vessel overflows.

If you have a beefy DC power supply and want to get your gas by electrolysis, go for it, but I think you'll find it hard to match the reaction rate and volume of gas produced by the aluminum-lye method.

Step 10: Hydrogen Production

You can do the math yourself and figure out how many grams of each reactant you need, but it's hard (or at least time-consuming) to estimate the volume of an envelope. I've found I get the best results with about 120g Al and 170 g NaOH -- the exact figures are 116g and 172 g respectively, but you won't notice the difference. When producing gas. you have three main concerns: generating the necessary volume, controlling reaction rate/ temperature, and preventing atmospheric contamination (letting air seep into your hydrogen gas). The less pure your gas is, the less its buoyant force. I always fill the reaction vessel up to about an inch below the spout, so that when the reaction begins there are only a few cubic inches of air left at the top, which you can let bleed out before filling. In my case, this means a lot of water-- several liters -- so the reaction starts slowly at first as the water absorbs the heat. It will get out of control if you let it. It might take a bit of of trial and error depending on the size of your container, but always err on the side of using more water, and always bring more ice than you think you need, and one or two large plastic basins. Maybe you cool it too much, and you have a slow, boring fill, but it's much better than having your basement floor plastered in steaming hot caustic slime releasing clouds of hydrogen gas all at once ( yes, I'm speaking from experience here). Personally, I like a long, cool "slow burn" reaction with lots of ice -- it takes hours, but you minimize the amount of water vapor that might enter your envelope and maximize the purity of your gas.
     Anyway, with the amounts of reactants previously mentioned, you should get enough gas to fill up your envelope completely -- maybe you need a little less, or a little more. If it's your first time, halve the number of ingredients and use a lot of water to get a feel for it before you go for the full amount. If you want to store the excess gas, be aware that any sort of container you put it in (hospital pouches, in my case), if it's not made of mylar or material of a similar quality, will leak relatively quickly and will not maintain the purity of the gas. In general, it's best to make only as much as you need.

When setting up your reaction, you should consider putting in some sort of buffer between the reaction vessel and the envelope -- mine is the pouch with the two tubes in it. If you start the reaction with the water line close to the spout, even at low temperatures, the sheer volume of bubbles produced will cause water to bubble into the tube leading from the spout. This is normal, and will not do any serious harm as long as you sufficiently separate your balloon from the reaction.

Never leave a reaction unattended, and check the temperature regularly -- if you let it get too hot, your envelope could be ruined.

Set up your reaction like in the two pictures: add the aluminum first, then water. At this point, attach your rubber tubing to the spout, and when you're ready, add the lye. Wait for about ten seconds to see how many bubbles form -- if the water level rises too much, just pour a bit out into your basin. Once you've got the level right, wipe the inside of the neck of the vessel with a rag to remove moisture (otherwise your plug will slip out) and then plug it with a rubber stopper. Use duct tape if necessary.

Within a few moments, you should feel/see a flow of gas from your tube.

Step 11: Fill the Envelope

The pictures show the envelope at several stages of filling. Make sure to duct tape a string or two onto your envelope before you fill, so you have something to anchor it with. I use clamps to hold down my anchor strings when filling.

Your balloon should fill up nicely if you use enough reactants, but don't be surprised if it takes five or six hours. The reaction will start to die off exponentially, and all the little bits of aluminum will float to the surface because they've lost so much mass. At this point, you can leave it for another day to collect all the last bubbles, or just pop off the lid and be done with it.

During filling, use a wet finger to check the one-way valve where your tube enters the envelope for gas leaks -- If you find any, apply duct tape. I have this problem, as the valve on my balloon has a rip in it, so once the envelope is done filling I press a piece of duct tape firmly over the filling hole and that holds the gas nicely.

If you have a buffer bag, put a clamp on the end and let it collect the excess gas -- if it turns out you need more, you'll have some.

Here's a video of the envelope filling (I know there's no cooling basin, I added one later):

Step 12: Final Preparations...

At this point, you should have a full envelope and a completed blimp frame. Find the frame's center of mass -- it should be just behind the battery -- and line that up with the central crease in the envelope ( it comes nicely folded). Now lower your envelope until it's touching the four pylons; anchor it and make sure it's symmetrical around the long axis. Take four velcro patches and press them firmly onto the envelope, directly above the pylons, so that you can sort of pinch the velcro on the mylar onto the corresponding patch on the pylon. Do this for each pylon, and the frame should be securely fixed to the full envelope.

Now, the moment of truth. Release the anchors, keeping one hand on a string at all times. If you're lucky and you kept the weight down (my frame is just under 130g, you can get by with 140g), the whole blimp will slowly rise up. If it does, congratulations! Add some payload to get to your desired buoyancy and take to the skies.

If your blimp fails to rise, do not give up hope. It took me six months to get my blimp fully airborne, you shouldn't feel bad if you don't get it right the first time. Weigh your frame, and do whatever you have to get it 130 grams. If that doesn't do it, your gas is contaminated with air, and you need a fresh run with a better seal between your tube and envelope. Make sure there is no gas leaking from your reaction vessel or tubing.

On an unrelated note, my envelope as seen below is speckled and partially translucent because I spilled some lye solution on it, not because of some error committed by the envelope manufacturer. I'm an idiot. Don't be an idiot.

Step 13: Liftoff!

Enjoy your command of the skies! Here's another video:

And another one, where it's slightly less than neutrally buoyant:


My motors and servo twitch and move erratically.
You have timing issues between the transmitter and receiver -- one of them takes slightly longer than the other to pulse / measure pulses. Try adjusting the initial delay -- the first thing that happens within the interrupt. You can also try adjusting the time (500 us) that the receiver waits between checking the data line, but I've had little success with that. If you're more competent at writing code than I am -- and you are -- try eliminating overhead from all the clumsy functions I use.

One of the motors won't move.
Check to find a wire loose. Also make sure your H-Bridges are solid. Fair warning -- the motors are great, but the wires they come with are really flimsy. The wire on one of mine snapped off, and I had to pop off the plastic cap and put in my own brushes.

My Arduino isn't blinking -- I don't think it's picking up radio signals.
Find an oscilloscope and make sure your transmitter is pulsing correctly. Jiggle your antenna. Check for bad solder joints on the receiver. Make sure you didn't add a function in the interrupt that clogs it up -- functions don't do well in interrupts. Pray to Philip The God Of Radios Working Properly. Sacrifice your firstborn son.

I sacrificed my firstborn son and now he's dead and my radio still doesn't work. Help?
I had the same problem-- your receiver probably isn't getting power. Check the wiring.

I'm having trouble keeping the reaction cool.
Try a couple rags soaked in ice water -- wrap them around the top half of the the vessel, where it gets the hottest. Make sure you've got in a basin of ice water.

How should I shed weight?
Avoid thick wires at all costs, make them as short as possible. Don't worry too much about the balsa.

My hands feel like they're burning.
You got lye on them, wear gloves.

How should I store my envelope when it's not in use?
If it's just for a day or two, I just leave it attached to the frame and some extra weights so it doesn't go anywhere. For long term storage, I separate the envelope from the frame and just leave it lying up against my ceiling.

What should I do with my salty aluminium oxide water?
I pour it on weeds. It's not hazardous.

I left my reaction unattended because I'm an idiot and now there's explosive steam billowing everywhere and I can't breathe and my envelope exploded and my table is melting and my house is burning down because I'm an idiot.
You're an idiot.