Project tutorial

Alexa, Launch a Paper Plane © GPL3+

Entertain humans and pets alike with paper planes launched by your voice.

  • 116 respects

Components and supplies

Abx00004 iso both
Arduino MKR1000
To handle the commands from alexa and start/stop the motors
12002 04
Breadboard (generic)
To connect the arduino with the motors
Fairchild semiconductor pn2222abu. image
General Purpose Transistor NPN
As a switch for the motors
11026 02
Jumper wires (generic)
To connect all the electronic components
DC motor (generic)
To make the planes fly
Fairchild semiconductor 1n4004. image
1N4007 – High Voltage, High Current Rated Diode
To protect the arduino against back voltage
Mfr 25fbf52 221r sml
Resistor 221 ohm
To restrict the current flow
Adafruit industries ada592 image 75px
USB-A to Micro-USB Cable
To power the whole system

Necessary tools and machines

stick tape
To stick things together
cardboard box
To build the structure

Apps and online services

Dp image kit 02
Amazon Alexa Alexa Skills Kit
To interpret user commands
Screen%20shot%202015 07 20%20at%206.10.26%20pm
Amazon Web Services AWS Lambda
To handle alexa requests and send them to the arduino
As a bridge between aws lambda and arduino
Ide web
Arduino Web Editor
To write the arduino code

About this project

Entertain humans and pets alike with paper planes launched by your voice.

In this project we will take a look at a combination of some old and new technologies to achieve something even older, entertainment. Maybe I won't have the timeline right but the technologies used in this projects are listed from the oldest to the newest below:

  • Paper Planes
  • Paper Plane Launcher
  • Arduino
  • Alexa Smart Home Skill

See full video here.


This is me launching a paper plane using the technology stack previously mentioned

One plane taking off via voice command

Paper Planes

I'm using this simple model for the paper plane because it's sleek, easy to make and flies very well. I'm using paper rectangles of 6.5 x 8 cm and the instructions are shown below (taken from here)

Here's an animation showing how the plane is built

Paper Plane Launcher

The Roof, the Bump and the Base

To launch a paper plane we use two motors to move two wheels separated by a small distance. The body of the plane passes between the wheels and it gets pushed as if we have launched the plane ourselves. I built something similar to what is shown in this video and added some structure so that I didn't have to use my hands to make the planes take off.

The two components are a small base and a roof with a "bump". Both components support the plane in position while it passes through the motors to get the push required to make it fly. I made a video describing the structure and you can see it in action below

To create the whole structure I used cardboard and stick tape only. I started adding small rectangles of cardboard between the motors until I found the right number that separated them just enough to allow the planes to pass through while having a good contact with the wheels.

Once the two motors were joint together, I started adding the roof and the base following a similar principleho using the same small pieces of cardboard and stick tape.

See the video of me talking about the motors' front view.

The Platform

Besides the motors we also have a platform so that we can launch several planes without using our hands. The platform holds the plains in queue to be launched. It is connected to the motors by stick tape and the vibration of the motors plus the angle of the platform help the planes to move down so that the motors can push them through.

I also made a video describing the Platform and its workings.

To create the Platform you need two sheets of carton or cardboard. You don't need exact measures but make sure to start with big pieces so that you can trim them down until you find what works better. The final shape of the Platform mimicking the plane's shape was the result of trial and error as well as the height of the supporting structure.

Now that we have a whole take-off platform let's wire the motors to make our planes fly.


The Circuits

I chose the Arduino MKR1000 because it already has WiFi support and good specs compared to other editions. The electronics of the whole system was taken from the Adafruit site where they show how to control DC Motors with an Arduino Uno R3. My circuit replicates almost exactly theirs differing in the amount of motors. In the code I removed the user input and variable speed features because the motors where going to be started by Alexa and they were going to run at full speed always.

Here's the layout, schematics and PCB of the circuit I shared in Fritzing.

There is an important warning on the Arduino Store Website

Warning: Unlike most Arduino & Genuino boards, the MKR1000 runs at 3.3V. The maximum voltage that the I/O pins can tolerate is 3.3V. Applying voltages higher than 3.3V to any I/O pin could damage the board. While output to 5V digital devices is possible, bidirectional communication with 5V devices needs proper level shifting.

That's why I power the circuit using the VCC pin that outputs 3.3v. Maybe You can use the 5V pin but I lack electronics knowledge as well as tools and I didn't want to burn my Arduino. I tested it several times, left the motors on for several minutes and everything is working fine, however bear in mind that I didn't take any precautions to protect the Arduino.

The Code

The software side of the Arduino is quite simple as it acts like a remote switch turning on or off based on an incoming message. It can be seen in here

void messageReceived(String &topic, String &payload) {
 Serial.println("Received " + topic + ": " + payload);
 // Set value to 1 if we receive "ON". Set it to 0 otherwise
 int value = payload == "ON" ? HIGH : LOW;
 // Turn on/off built-in led
 digitalWrite(led, value);
 // Turn on/off motors
 int speed = 255 * value;
 analogWrite(motorPin, speed);

The other part is the configuration to connect to the WiFi and to the MQTT server. You can take a look at the full code in here.

To send/receive messages I used the service that provided me with the infrastructure and the code to listen to messages broadcasted to a specific topic. There you have namespaces which are like isolated projects. Inside a namespace you have tokens (key/secret pairs) that are used to authenticate against the mqtt host. Here's how you connect to your namespace

client.connect(shiftrClientId, shiftrUsername, shiftrPassword)

The clientId is the name of this node in the mqtt network, in the case of the Arduino is "MKR1000" while for the lambda is "lambda". (More about the lambda later)

You can barely see the lambda because it connects and disconnects very quickly

There is also a topic in the configuration of the mqtt connection. The topic is used to send and receive messages under a namespace; the Arduino subscribes to the /launch topic so that it can receive a notification to control the motors.


The whole configuration is shown below

// MQTT Configuration
const char shiftrHostname[] = "";
const char shiftrUsername[] = SECRET_SHIFTR_USERNAME;
const char shiftrPassword[] = SECRET_SHIFTR_PASSWORD;
const char shiftrClientId[] = "MKR1000";
const char shiftrTopic[] = "/launcher";

And this is what we see in the monitor view of the arduino

Ok, so that's all from the Arduino side. Now let's take a look to the Alexa side


As you may already guess we use Alexa to turn on/off our Paper Plane Launcher. Alexa can't place the planes in position to take-off so that duty is on your side; once it's done, you can simply say

Alexa, turn on Paper Plane Launcher

And after a few seconds your planes will be feeling the air in their wings. Take a look at this 1 min demo where I show how I turn on and off the Paper Plane Launcher with my voice

One paper plane taking off

So, what do you need to do in the Alexa side?

You need to create your developer account, create the smart home skill and create a lambda to handle the directives. The following steps will help you to build you own back-end.

I wish to tell you it was easy, but it wasn't. Those 5 steps are the result of many hours figuring out how to make everything work together. I think that I spent most of my time trying to make the outdated code work; you won't have that issue if you clone my repository and start from there.

Let's dive into the lambda code to better understand how it works.


The whole code is divided in 3 files. The handler (index.js), which receives the event, the responseBuilder which builds the object that Alexa expects as a response and the broadcaster to tell the Arduino through mqtt/ that it's time to be turned on/off.


We create a response using the responseBuilder and succeed immediately if the event is not a PowerControl event. The reason is that in the case of Discovery or ReportState, we don't need to interact with the Arduino and we can just simply reply to Alexa right away.

const response = responseBuilder.buildResponseToEvent(event)
 if (!responseBuilder.isPowerControlRequest(event)) {
   return context.succeed(response)

If, on the other hand, the event is a PowerControl one we need to send the message to the Arduino so that it can turn on/off. This is done with the help of the broadcaster as shown below

 const value = responseBuilder.getPowerValue(event)
   .then(() => context.succeed(response)) 

We also inform Alexa about errors in case we have one

const type = responseBuilder.ERROR_TYPES.INTERNAL_ERROR
const response = responseBuilder.buildErrorResponse(event, type, error)


In here we create the different responses based on the incoming event. To do so, I first identify the request type and build one reply or another. This builder can create Discovery, ReportState, Error, and PowerControl responses. They all work the same with small differences in structure. Don't forget to take a look to the tests.


It has a simple task: send a message to a topic. The broadcaster connects to the host and publishes a value to the given topic; in that way we tell the Arduino to start/stop the motors of our launcher. The username and password are the same we use in the Arduino but instead of having a secret file we configure environment variables that can be read like this

const { SHIFTR_USERNAME, SHIFTR_PASSWORD } = process.env

and then used like this

var client = mqtt.connect(`mqtt://${SHIFTR_USERNAME}:${SHIFTR_PASSWORD}@${HOST}`, { clientId: CLIENT_ID })

To configure environment variables in your lambda scroll down to that section and set the values

Then, as soon as the message is sent we disconnect from the server because there's nothing else to do and because otherwise the lambda will keep on running until it's execution time has finished. Not disconnecting could cause unnecessary costs.

client.publish(TOPIC, value, error => {

If you want to test the broadcaster locally, you need to set the environment variables in the npm script like shown below


I also included some extra scripts that will help you with your lambda development. Those were added in the package.json


You can deploy your lambda just by running

npm run deploy

To do so, you need first to have configured the aws cli and also you need to change the --function-name in the update-lambda npm script.

Running the deploy command will copy all files in the src folder and the node_modules folder to a build folder. It will then zip the build folder and execute the aws lambda command that will update the function's code. Since the name of the zip file is you need to make sure the handler in the lambda is set to build.handler as shown below.

And that covers our lambda code to handle Alexa directives.


Let's see some diagrams to have a better understanding of how the pieces work together

VUI Diagram

The Voice-User-Interaction in this case is very simple because we are using the Smart Home Skill to control the paper plane launcher as a switch

Cloud Components

The communication between the parts happens as described in the image below

Closing thoughts

Building a semi-automated voice-activated paper plane launcher had a lot of obstacles in different fields. We started with our bare hands making small planes out paper, cutting and sticking together pieces of cardboard to build a launcher to then connect its motors to an unprotected circuit controlled by an Arduino that listens to messages in a /launcher mqtt topic where a lambda function posts values each time Alexa hears you saying the right words. (Phew...)

The mixture of feelings is rich in variety but the prominent one is satisfaction. There's also a lot of gratitude and I want to create a section to give thanks.

Special Thanks

I created this project to participate in The Alexa and Arduino Smart Home Challenge, however the first idea was a completely different one and there were different people helping me with each idea.

- For the Paper Plane Launcher

Christine Gaulis: For the hours of conversations and support in this project in both ideas.

Ivan Mottier from ZigoBot: Who took the time to listen to my broken french and provided me with the right components to build the paper plane launcher.

- For the sound detector (asking Alexa if the water tap was open)

From the Hackuarium Lab:

Rachel Aronoff: For connecting me with the lab and some of its members. Also for showing me her project about the DNA in the cells from the cheeks and her fluor detector.

Vanessa Lorenzo: For her help while we were in the lab, for showing me her own experiments and telling me about the music making using microorganisms.

Luc Patiny: For his time explaining me the different ways I could process the sound in order to find the information I was looking for. Also for sharing with me his experience in Cali, Colombia, my own city. He also shared with me very useful resources like C.H.I.P and the ml.js libraries

Christian Zufferey: Who by his own initiative contacted me through Vanessa Lorenzo to propose that I use a method he used back in 2007 to compare websites so that I could identify objects through the sound.

And finally, from this repo in github to

Alexandre Storelli: Who helped me by answering to my questions about audio signatures.


I hope you can learn something from what I shared here and have a lot of fun while doing it. If you build a Paper Plane Launcher or something similar please let me know.


AWS Lambda Code
Function that handles Alexa's directives to turn on or off an Arduino-controlled Paper Plane Launcher.
Arduino Code
Includes layout, schematics and code to turn on/off the motors


Layout and Schematics
Hardware components


Similar projects you might like

Alexa Robot Arm

Project tutorial by Alana Balagot

  • 21 respects

WalaBeer Tank

Project tutorial by Balázs Simon

  • 193 respects

DIY Air Humidifier with Backlight Controlled by Alexa

Project tutorial by Andrii Romanenko

  • 13 respects

Alexa BBQ/Kitchen Thermometer with IoT Arduino and e-Paper

Project tutorial by Roger Theriault

  • 12 respects

Hygge Home - Alexa Smart Bath

Project tutorial by J Howard

  • 24 respects

Smart Pool: Alexa Controlled Pool Manager

Project tutorial by Benjamin Winiarski

  • 14 respects
Add projectSign up / Login