Introduction: HyperDuino-based CubeSat

About: I am a life-long tinkerer whose interest in the science, technology, engineering and math (STEM) fields started with the launch of Sputnik in 1957.

My interest in space exploration started in October, 1957 with the launch of Sputnik. In 1961 I did a science fair project based on an instrument package I designed, built and sent aloft with a weather balloon.

Today, the task is a lot easier, and this Instructable shows how you can make your own small demonstration satellite (based on the CubeSat design) that can even be sent aloft with a balloon. My goal is to get you started with a project you can expand to your heart’s content.

CubeSats ( are small satellites 10 cm on a side that typically are put into low earth orbit. If you are a student or teacher, you will want to check out the Ardusat site ( where students are currently running experiments in space on their real satellites zipping around at over 400 km above Earth. This amazing project has democratized space exploration by making it affordable to schools worldwide. Ardusat also has sponsored a contest ( you might enjoy. If the contest is still open when you build your satellite, you might want to enter a modification done by your team (this contest is for teams of people.)

In this Instructable, though, you will build your own demonstration CubeSat, from which you will learn a lot about the design of orbiting satellites and set the stage for expanding the ideas in any direction you wish.

This intermediate level project lets you explore all aspects of the satellite design process from the building of the CubeSat model itself, to programming the Arduino-based electronics and reading data from onboard sensors for light and temperature. This is a cool project, even if it never leaves your desktop!

If you’re a kid, an expansion of this project might make a great science fair entry. As I mentioned, I did something similar in 1961, and that launched my career! If you’re not a kid, you’ll learn how to build a system to make measurements that can be sent to programs you can write on your own computer.

Be sure and leave me feedback and contact me directly at with any questions. If you are a teacher, we have workshops to help you incorporate this project into your STEM (science, technology, engineering, mathematics) curriculum.

Step 1: Stuff You'll Need


  • 1 Satellite housing made with a 3D printer ― all the STL files you need are here. Contact the author at if you don’t have a 3D printer and he can make the parts for you.
  • 12 ea. 4-40 x ⅝” machine screws ― any hardware store should have these. Inexpensive bulk purchases of screws and nuts can be made from Bolt Depot.
  • 4 ea. 4-40 x 1 ¼” machine screws.
  • 24 ea. 4-40 nuts
  • HyperDuino starter kit ( includes Arduino, HyperDuino shield, misc. parts and cables.)
  • 10 cm Arduino female to female jumper cables ― Amazon has lots of these at low prices.
  • 1 Arduino battery cable and 9V battery (Included with HyperDuino kit along with sensors for light and temperature)
  • If you want, I can provide an entire kit of parts for you. Write me at for details. In a future Instructable we’ll show how to provide wireless access to your CubeSat,


  • If you are using Windows, you will need to install the Arduino drivers using the Arduino software and following accompanying directions at Mac and Chromebook users don’t need this step!
  • Install the Chrome browser (this will let you communicate with your satellite from any computer ― Mac, Windows, or Chromebooks!
  • Install the HyperDuino for Chrome apps following instructions that came with the HyperDuino kit. Install Snap4Arduino

Tools (you probably have these already):

  • Screwdriver for your 4-40 screws
  • Wrench for 4-40 nuts
  • Velcro adhesive tabs (from any hardware or hobby store)
  • Straight pin or fine dental pick for cleaning small holes in 3D printed base parts. Dental-style picks can be found at Amazon. Just don’t use these on your friend’s teeth!
  • Glue gun
  • Duct tape (of course)

Step 2: Assembling the Satellite Housing

(This s a project for your 3D printer. If you don’t have a 3D printer available, write me at and I can make them for you.)

I got the original art for the outer housing from Ardusat. Next, I added two plates to hold everything inside the satellite. You’ll need to make two housing end parts, two housing side parts, and two base plates. The artwork for your 3D printer is in a zip file connected to this step.

The base plate has four very small holes in it near the center for a photocell and temperature probe. These may be pretty filled in when the plates are made, but you can easily open the holes with a straight pin or a dental pick. The holes are only needed in the top base plate.

Assemble the outer housing first by snapping the four parts together. Next, using eight of the ⅝” 4-40 screws and nuts, bolt everything together. Don’t over tighten! You don’t want to break the tabs on the parts, although superglue can fix any accidents you have. The picture shows what it looks like when the housing is finished.

Next, mount one base plate on an end part using four 1 ¼” screws and 12 nuts. The idea is to position the base plate near the end of the screws so there is plenty of room on both sides.

Finally, install the second base plate (with the tiny holes opened) underneath the top end plate using four ⅝” screws and nuts. This finishes the complete housing for your demonstration CubeSat!

Step 3: Assembling the Arduino and Hyperduino

Users of the Instructables site are likely familiar with the Arduino hardware interface card that connects your computer to the real world. This powerful board can gather data from sensors, and turn on devices like motors and lights. The main problem with this board is that you’ll typically need a bunch of extra parts (usually resistors) to allow your lights and sensors to work properly. While this is OK for people who love getting into the wiring of stuff, it can slow down the folks who just want the Arduino interface to get out of their way while they get to the meat of their projects.

This challenge has been addressed elegantly with the addition of the HyperDuino shield. This board plugs onto an Arduino and eliminates the need for extra components while adding some new features you might enjoy! The HyperDuino starter kit comes with an Arduino, a HyperDuino board, and lots of cables, lights and sensors. It even comes with a battery connector and a battery! With this kit, there is nothing to stand in the way of your project. The same system can be used for myriad projects, of which our satellite is just one!

In the original world of Arduino, connecting to sensors and actuators (lamps, motors, etc.) requires lots of additional parts ― resistors, capacitors, transistors ― as well as the sensors and actuators themselves. These parts are often connected to each other using a special block called a “breadboard.” A breadboard contains rows of metallic connectors that allow various components to be connected to each other.


As the picture shows, this can be quite messy! In our traditional Arduino workshops, we found that the challenge of working with lots of things plugged into a breadboard can be intimidating. It also makes the diagnostic process required to help students and others much more difficult.!

Any way you look at it, the Arduino has been one of the major drivers of the maker movement, even considering its use of a complex programming language, and the need for lots of components to connect it to projects that interact with the physical world. One can imagine how much more powerful it would be if it was easier to program, and easier to connect to sensors and actuators. For one thing, the age at which kids could make neat projects would drop to the elementary grades without the loss of the ability to make sophisticated projects at any age ― even by adults! Second, by simplifying the software and hardware interface, students can remain focused on their project, not on the mechanical details of getting everything to work.

And that is exactly the function of HyperDuino!

The HyperDuino itself is a circuit board (called a “shield” in Arduino-speak) that plugs into an Arduino to simplify connections to sensors and actuators by eliminating the need for extra parts, including the breadboard.

The starting point in our endeavor is to set up the Arduino itself. If your Arduino came as part of the HyperDuino starter kit, it is probably labeled as something else. No matter what it’s called, it is similar to the Arduino Uno model, the most popular of the units on the market.

The circuit board has connections on both sides, and you’ll want to protect the exposed connections on the bottom so the board doesn’t short out if you set it on a metallic surface. The starter kit contains a piece of foam tape that covers the bottom of the circuit board. An alternative is to make a custom Arduino holder with your 3D printer. The artwork for a nice one is included in the files that contained the CubeSat housing. Once printed, the base can be glued to the bottom of the Arduino using a glue gun.

The next step is to connect the HyperDuino shield to the Arduino itself. This can be a little tricky, but you only have to do it once. The Arduino has two rows of sockets near the edges of the board. The bottom of the HyperDuino has two rows of pins extending down from these sockets through the bottom of the board. Each row of pins needs to be plugged into the corresponding socket row on the Arduino so all the pins are in the right holes, and none of the pins is bent. Once the pins are in the right holes, gently (but firmly) press both boards together so the pins are fully seated in place. If one of the pins misses a hole and gets bent, unplug both boards, straighten the bent pin, and repeat the process. The likelihood is that you’ll get things together properly on your first try.

The HyperDuino is connected to your computer using the included USB cable. The next step is to make sure that your setup has the right software installed on your Arduino. Programs installed on the Arduino are called “sketches.” I don’t know why this is, any more than why plug-in boards are called “shields.” At least the shield fits over the Arduino board, shielding it from something (I guess.) As for “sketch,” this is probably less intimidating than “C++ Executable.” Oh, well. these are the terms people use, and we’ll use them also.

The software loaded on the Arduino’s chip is designed to let your computer receive information from sensors, and to send signals to the HyperDuino to control objects (lights, etc.) connected to it. The software on your computer passes information back and forth to the software on the Arduino ― and this is why you need to be sure your assembled HyperDuino is connected to a USB port on your computer. The USB cable also provides the power needed to run the HyperDuino.

By the way, if you are connecting your Arduino to a Windows computer, you will need to install the drivers before anything will work. Use this link to download and install the Arduino driver for Windows:

If you are using parts from a starter kit, the correct software for your HyperDuino can easily be downloaded. First, install the HyperDuino apps for Chrome. Instructions for installing these apps are found with your HyperDuino starter kit.

To install the right Arduino software (HyperDuino Firmata), Launch the HyperDuino App and connect your HyperDuino to your computer with a USB cable. Click on the Settings menu and choose the Serial port option. Depending on your computer (Chromebook, Macintosh or Windows) the name of this port will be different. For example, here are the port names for my computers ― yours might be different.

Chromebook: /dev/ttyACM0

Macintosh: /dev/cu.usbmodem1411

Windows: COM4

Now select the serial port associated with your Arduino: (in my case, on the Macintosh the port is /dev/tty.usbmodem1411.)

Next, click on the Personalilities menu. This will bring up a screen showing various options for the software downloaded to the Arduino. When you click on the the HyperDuino for Playlists v2 the Arduino will be loaded with the software it needs.

Whew! That was a lot of work. You should take a break before continuing to the next step.

Step 4: Putting All the Hardware Together

Looking at the top of the HyperDuino shield, you’ll see two black connectors, one blue connector and a white one. The black connectors are used for digital outputs ― for example, LED’s. We won’t be using these, so if you want to learn how they work, the HyperDuino website provides all the assistance you need. The bottom white connector is designed for touch sensors that signal when a person has touched a metallic surface connected to any of these pins. Normally, you can use 12 touch sensors in a single project. Again, we won’t be using these in our CubeSat, unless you want to know if someone in a parachute coming past your balloon-launched satellite has grabbed your device!

That leaves the blue connector which is where you’ll add your analog sensors for light and temperature. In particular, we’ll use analog input A0 (the right-most pins) and A1 (the two pins next to these.)

Installing everything for the base is pretty easy. First, assuming you are using the Arduino 3D-printed frame, be sure the HyperDuino shield is mounted on the Arduino. The plastic frame containing everything just fits on the top of the bottom plate between the 4-40 nuts. It should snap in place. Once you’ve done that, use a glue gun to hold everything to the baseplate.

The space under this baseplate is where you would put your battery if you are using a wireless connection to your computer. If you are connecting through a USB cable, no battery is needed since the Arduino and HyperDuino get their power from the cable.

The photocell and thermistor each have 2 wires. The thermistor looks like a small black plastic bead, and the photocell has a metallic pattern on top. Place the leads for each of these through the holes in to top plate and spread the wires apart to hold these components in place.

Now this is where your duct tape comes in handy! Use a small strip of this to hold the wires to the plate, leaving the wire ends free.

Now we need to connect these sensors to the HyperDuino. To do this, take four 10 cm female to female jumper cables. Put one end of each on the four wires from the sensors. The wires from the photocell are thick enough to make a good connection, but the wires from the thermistor may be loose. If this is the case, push each wire in as far as it will go, and tape the connection to the baseplate. If you want to get fancy, use female to male jumper wires, and solder the male pins to the wires on the thermistor. The female sides will go to the Hyperduino.

Now for the final step! Take the loose ends of the photocell jumpers and plug one into the right-most bottom pin of the blue connector. Next, plug the other wire into the pin just above that one. This connects the photocell to the analog connection, A0. Repeat this process with the two jumper wires from the thermistor, connecting them to the pins just to the left of the pins you used for the photocell. This connects the thermistor to analog connection A1.

Except for connecting a battery and wireless capability to your CubeSat (to be explored in a later Instructable), you’re done assembling the hardware!

Step 5: Writing the Program

The next step is to collect data from the two sensors ― light and temperature ― on the CubeSat. There are several programming languages you can use to do this task, and the one I’ve chosen is called Snap ( This language is similar to another language you may know ― Scratch. Snap has some features I like, and comes with a special version (Snap4Arduino) that works with the HyperDuino fairly well ( The original Snap has great documentation you can read if you want to learn the language in detail. What you will need to do is install the latest version of Snap4Arduino on your computer. Available for Mac, Windows, Linux and a web-based version that works with Chromebooks. While buggy, it works perfectly for our application, and it is under active development. Your first step is to download the relevant version of Snap4Arduino from

If you want to use the Chromebook version, here are special directions to get you started. First, you will need a Chrome plug-in to communicate with the HyperDuino. Instructions can be found here:

Next, once this is done, launch the Snap4Arduino prototype in Chrome from this website: As for the language itself, programs are written by snapping blocks together ― a fairly intuitive process. For example, if you want to draw a square on the display screen, assemble the following blocks by dragging the components from the left column. There are different block libraries ― one for motion of the drawing tool (which is called a “Sprite”.) Other categories have blocks for the pen, control, operators, etc.

This simple program starts by putting the pen down so it will draw a line as it moves. Next, we repeat two commands four times: moving forward by 100 steps, and turning to the right by 90 degrees. If we click the mouse on our program, the image of a square shows up in the graphics window.

The sprite image (the arrowhead) is also visible, although it can be hidden if you want. As you can imagine, mastery of Snap is a big project ― well outside the scope of this Instructable. We’re going to start with a program I’ve already written for our CubeSat using Snap4Arduino. You can modify and extend this program on your own.

To load the program, log in to Snap4Arduino (you will have to create a free account if this is your first time). The advantage of having an account, is you can save your projects in the cloud where you can download them from any computer!

In our case, you’ll start with a program I wrote ― CubeSat program.xml. Choose Import… from the document icon to the left of the cloud at the top of the Snap4Arduino window. Navigate to your downloaded version of this file, and you’ll have the program ― ready to run.

The program runs by pressing the “space” key (you can change this if you want.) The program itself is fairly easy to read. The first few commands set up the screen. When you get to the “repeat” command, the real work starts. First, the value of a user-defined variable, “brightness” is set to 100 minus the HyperDuino analog reading from A0 divided by 4. This makes sure that the resulting value fits on the graphic screen. Next, the sprite location is set to the proper values of x and y. The sprite “costume” is set to the value “light” and the “stamp” command stamps a picture of this costume on the screen. Costumes can be designed using the built-in editor and the Snap manual shows how to do this.

Next, this whole process is repeated for the “temp” variable, and the process waits for a tenth of a second before continuing. While the program is running, you can change the values of the sensor reading by passing your hand over the photocell, and touching the thermistor. The resulting graph is a record of the light and temperature data. A new graph is generated every time the program is run. You can save an image of the graph by right-clicking your mouse on it and selecting pic... This opens a new window with your picture that you can save.

If you want to modify this program (and you should!) add a nice box around the graph, provide scales for the results (for example, dim to bright for the light, and cool to hot for the temperature. If you want to get even fancier, see if you can find a way to export the sensor data to a text file on your computer! This is a nifty project that may keep you up at night.

Step 6: Expanding the Project Yourself! (add Your Own Ideas)

There are a tremendous number of modifications you can make to your project. For example, while your CubeSat won’t be launched into space, you can send it up in a weather balloon. Of course, if you want to gather data, you’ll need a radio ― instructions for which I’ll give in my next Instructable.

One low-power radio to use is a bluetooth transceiver, but the range is only about 100 meters. You can increase your range to several kilometers using a higher powered radio from Xbee. And, if you are ambitious enough, you can add the ability to capture data on a memory card for you to download once you find your balloon.

If you don’t want to wait for me, there is an easy way for you to get started right away. Ardusat ( has a powerful cool tool called the DemoSat. This nifty device has a bunch of sensors, a good radio, and the ability to save data on a microSD card. How nice is that!

Now for the balloon. Our first launch (shown in the movie) used two one-meter balloons, which gave barely enough lift for take off. I’d recommend you using a two-meter diameter balloon. You can get a balloon and other tools for filling your balloon from High Altitude Science (

Choosing a launch site can be tricky. First, you want plenty of open space. Second (and very importantly, you want to stay legal. This means staying out of the way of aircraft ― a challenging task in big cities! While laws may vary from place to place, keeping the payload under the weight of a Canada goose is generally going to make life easy. (You really don’t want to know why.) It is always good to let ATC (air traffic control) know your plans before launching, and they might even give you some times for your launch. Our first launch only resulted with one visit from the police who wanted to know that our balloon was tethered so it would stay less than a kilometer from the ground, but this was in downtown Toronto near a flight path to the international airport. To see how busy your area is, go to

As for other projects, we’ve only included two sensors (light and temperature). A quick search on the Internet reveals other sensors you can use - barometric pressure, humidity, magnetic force, and the list goes on!

The opportunities are limitless! Once you start adding your own modifications to your CubeSat (a camera, for example,) you'll find whole new perspectives on your world you can share with others!