instructables

The Arduino Launch Control System (LCS)

by Austin_Aerospace_Education

The Arduino Launch Control System is a model rocket launch controller for a single rod launch pad. This was the rst
Arduino rocketry project that I wanted to design and build, having just started into learning about electronics and the
Arduino less than 6 months prior. There are a number of Arduino model rocketry launch projects available on the
Internet, and they did provide inspiration for this project. Yet while they provided some great ideas, I wanted to
approach this launch control system from a di erent angle.
Focus on Research

If you look around my web site ( https://rocketryjournal.wordpress.com), you know that I often discuss how model
rocketry can be used to explore both science and technology. One great way to combine these is to use model rocketry
as part of a science or technology fair project.
If you are using a model rocket in a research project, no doubt weather will be a part of your data collection e orts. To
help meet this need the launch control system provides the user with several weather data points, including:
Temperature
Humidity
Barometric Pressure

In e ect, the project has a small, built-in weather station.

Focus on Safety

Safety is always an important consideration in rocketry. As I was designing the Arduino Launch Control System (LCS) I
wanted to make sure that it would be safe to operate. The LCS provides a ten-second countdown and I wanted to be sure
that when the counter hit zero, the Launch Control O cer still wanted the rocket to launch. In order for the countdown
to start and power to be supplied to the launch pad, I decided that several things must be accomplished.
The LCS has two independent power supplies and both must be turned on. The power must be turned on to the launch
pad or there will not be any power at the igniter clips. Second, the key switch must have the key inserted and turned on.
Without the key, the switch will not turn on. Without the switch being turned on, power will not ow from the launch
battery to the relay and on to the launch pad. The key switch LED also indicates if there is continuity to the igniter in the
rocket.
However, if you only turn on power to the launch pad you will nd that the continuity lamp will operate but the re and
safety buttons are inoperative. You must also supply power to the Arduino. The system will not re without the Arduino
being powered up, as it reads the signals from the re and safety buttons, which sends the signal to the relay. The relay
allows the power to ow to the launch pad.
Finally we come to the Fire and Safety buttons. To start the countdown both buttons must be pressed down.
Additionally, they must remain pressed down during the countdown. If either button is released, the countdown will
stop and the launch is aborted.
You will notice that the re and safety buttons are located at opposite ends of the LCS. This design decision helps negate
The Arduino Launch Control System (LCS): Page 1
the possibility of an item falling on the re button leading to an accidental launch. The use of the key switch, dual power
supplies and the requirement for both buttons being continuously pressed all brings additional layers of safety into the
system to help prevent accidental launches.
Focus on Usability

I wanted the system to be easy to use and portable. If it is not easy to take out to the ying eld, no one will use it. I tried
to keep the cost low and while it does cost more than a plain Estes launch controller, it does a lot more too!
I especially wanted this system to be something that middle or high school students could build as part of an overall
science and technology project. I wanted it to be more than just a launch controller; I wanted it to be a learning
experience. I wanted it to have the ability to spark interest in rocketry, electronics, research and more.
I also thought of this as the baseline system. Over time it could be expanded with additional sensors or other options.
The LCS presented here shouldn’t be the end, but rather the beginning.
Finally, it had to look cool. If it doesn’t look cool, well, it just has to look cool!!
Supplies:

Hyper Tough 13-inch Tool Box

Nano Board CH 340/ATmega+328P
Panel Mount Type Mini USB 5Pin Male to Female Extension Adapter Cable
2 Pin Metal Male Female Panel Connector 12mm GX12-2P Silver Aviation Plug
Cabinet Pull Polished Chrome 3 inch (76 mm) Center to Center
SPST Momentary Push Button Switch
One Black
One Red
Keyswitch Keylock Switch with Keys
BMP180 Barometric Pressure Temperature Sensor Module
PCB Prototype Boards
1 Channel Relay Module Board
SPST Latching Type ON/OFF Push Button Switch
4-Digit Tube LED Segment Display Module
4 AA Battery Holder with Leads
9V Battery Connector
LCM1602A LCD Screen
DHT11 sensor
15mm Carbon Potentiometer
LEDs 5mm RL5-R5015 - Super-Red LED
LEDs 5mm RL5-G8020 - Super-Green LED
DS1307 Real Time Clock
Piezo Buzzer
510 ohm resistor
1K ohm resistor

The Arduino Launch Control System (LCS): Page 2

Step 1: Designing the Prototype

The prototype Launch Control System (LCS) was developed in sections using a breadboard. I worked on one section at
a time, making sure the component was working as desired before moving on to the next section. This included both the
electrical connections and the coding.
The drawing shows the layout of the electrical components on the breadboard along with a schematic drawing. The next
drawing shows the pin assignments for an Arduino Nano controller. If you are using an Arduino Uno the pin assignments
will be the same.
Code Repository

Once I had a new section working properly, I would save the Arduino code as a separate le. The le name includes the
date so I have a chronological listing of the les. This allows me to go back to a previous working version if I run into
issues.
Keeping Notes

In addition to maintaining and updating the fritzing drawings and Arduino coding, I also keep a small notebook on my
projects. This allows me to write notes about what was going on during the development process. I make sure I write
about problems I encountered and how I solved them.
Even more importantly, I was able to write notes about how I might change things, add new things, or do things
di erently. Not having the experience of working in this eld, I didn’t know what I didn’t know. These notes led to
conducting research on how to do certain things, and to see what other options might be available.
As I stated earlier, I was new to electronics and the Arduino. By building this project in a step by step process, it was much
easier for me to gure out the cause of an issue when a problem inevitably occurred. By keeping notes and drawings of
my progress, I could refer back to them as needed. This was a learning process – and I was learning a lot.

The Arduino Launch Control System (LCS): Page 3

The Arduino Launch Control System (LCS): Page 4
The Arduino Launch Control System (LCS): Page 5
The Arduino Launch Control System (LCS): Page 6
Step 2: Writing the Code

As I started to put the electrical components together, I knew I would needed to write the code to make it do things and
to test that code. I also wanted the code to “make sense” so that I could come back later (days, months, maybe years later)
and understand what I wrote. This is all part of “documenting the code” as you create it.
Documenting the Code

A major reason for documenting your project is to record what the code you write is supposed to perform. This is a habit I
learned long ago when I rst started writing BASIC programs on the Commodore 64. It is important that you include
enough notes in the code that describes what the code is doing and why. If you come back a year from now and look at
the code, the notes in the code should be adequate to tell you what you were doing at the time. If you are asking
yourself “Should I add a note here?” go ahead and add it. I have never heard another programmer complain that the code
they were reviewing had too many comments. The common complaint is that the previous programmer didn’t add
enough comments.
Layout

As you start to write your code you should develop a particular style. Even if you are just writing code for yourself, you
The Arduino Launch Control System (LCS): Page 7
will nd that there are certain things that you will do for each project. Once you have a style you like, it can be useful to
create a template. A template allows you to document each project in pretty much the same way each time. Its habit
forming and that's a good habit to have.
Using Functions

As you review the code you will nd it makes extensive use of functions. In the main loop you may see a single line that
calls another function. The code jumps to that function, executes the instructions, and then returns back. The use of
functions helps with organizing your code, makes debugging the code easier, and often allows you to use these
functions in other projects - either as is or with some slight modi cations. Not having to "reinvent the wheel" for each
project saves a lot of time and allows you to focus on new coding challenges. It also prevents you from having to scroll
up and down through long code listins looking for a particular section. That can be time consuming and frustrating.
Breaking the code into logical functions with descriptive names will be bene cial in the long run.
Multiple Tabs

One of the other characteristics in the code for the LCS is that it uses multiple tabs in the Arduino IDE. Most of these tabs
consist of a single function that we discussed in the above paragraph. Multiple tabs can help you organize your
programs. It also breaks down long, complicated programs into easy to digest chunks. It also makes it easier to nd stu .
If you haven't used functions and tabs in your previous projects I would encourage you to give them a try.
Attached Files

Each of the 17 Arduino les are an individual tab within the program. Make sure all of the les are in a single folder. Name
the folder "Launch_Controller_1.0.0.ino". You can open any le and all of them will open in the Arduino IDE as a single
project, with the rst tab "Launch_Controller_1.0.0" This rst tab contains the declarations, setup and main loop.

The Arduino Launch Control System (LCS): Page 8

 Download

https://www.instructables.com/FTZ/GMBX/LCDDVYQC/FTZGMBXLCDDVYQC.ino

Download

https://www.instructables.com/F8A/1MBW/LCDDVYQD/F8A1MBWLCDDVYQD.ino

Download

https://www.instructables.com/FE5/Z2X4/LCDDVYQE/FE5Z2X4LCDDVYQE.ino

Download

https://www.instructables.com/F33/TCJN/LCDDVYQF/F33TCJNLCDDVYQF.ino

The Arduino Launch Control System (LCS): Page 9

 Download
https://www.instructables.com/FQN/K6RW/LCDDVYQG/FQNK6RWLCDDVYQG.ino

Download

https://www.instructables.com/FFI/EEAL/LCDDVYQH/FFIEEALLCDDVYQH.ino

Download

https://www.instructables.com/F8W/82IF/LCDDVYQI/F8W82IFLCDDVYQI.ino

Download

https://www.instructables.com/FB1/5ZOU/LCDDVYQJ/FB15ZOULCDDVYQJ.ino

Download

https://www.instructables.com/FHG/AQN7/LCDDVYQK/FHGAQN7LCDDVYQK.ino

Download

https://www.instructables.com/F74/0SOB/LCDDVYQL/F740SOBLCDDVYQL.ino

Download

https://www.instructables.com/FAR/NT9O/LCDDVYQM/FARNT9OLCDDVYQM.ino

Download

https://www.instructables.com/F0D/J5HJ/LCDDVYQN/F0DJ5HJLCDDVYQN.ino

Download

https://www.instructables.com/FUF/NW3G/LCDDVYQO/FUFNW3GLCDDVYQO.ino

Download

https://www.instructables.com/FN1/D7I8/LCDDVYQP/FN1D7I8LCDDVYQP.ino

Download

https://www.instructables.com/FBV/613J/LCDDVYQQ/FBV613JLCDDVYQQ.ino

Download

https://www.instructables.com/F5S/GBFL/LCDDVYQR/F5SGBFLLCDDVYQR.ino

Download

https://www.instructables.com/FZJ/8EI5/LCDDVYQS/FZJ8EI5LCDDVYQS.ino

Step 3: Selecting the LCS Box

At this stage of the development process I had created a working system on a breadboard and written and tested the
code. Everything is working as expected. It is time to transition the project from the breadboard to an actual box that you
can take with you to the ying eld.
There are a number of options that you can look at. There are electrical project boxes that can be purchased through
Amazon or electrical supply stores. You can also try the local hardware store’s electrical section to see what they have
available.
Another option is to look at something like a pelican case or other hard sided weather-proof case. A 3D printed case is an
option, either one downloaded from a web site or one that you design yourself. In this case, I decided to go to my local
Walmart and pick up a 13-inch toolbox for under $7.00. The tool box is the smallest one carried at our local Walmart. It
has two small compartments on the top, with the one on the right side divided into two compartments. It has a nice
handle, with a single latch on the front.
When the box is open it has a single lift-out tray. The tray is deep enough to mount the buttons for the launch system. The
box is also small enough that it ts nicely into my hands with my thumbs in the upper corners (this is where the Fire and
Safety buttons will be mounted.
With the tray removed there is enough open space in the bottom of the box to mount all of our sensors and our Nano
The Arduino Launch Control System (LCS): Page 10
board.

The Arduino Launch Control System (LCS): Page 11

The Arduino Launch Control System (LCS): Page 12
Step 4: Designing the Control Panel

The lift-out tray in the top of the box is where all of the action will take place. It will contain the re and safety buttons,
the clock, the LCD screen, buttons and more. But before we can begin to layout any of this, we have to get rid of the
handle in the center of the tray.
There are a number of ways you can do this, but we decided to use a Dremel tool with a cutting wheel. It made quick
work of getting rid of the handle, but it was also a bit rough around the edges. It also leaves a pretty big hole in the
center of the tray. However, we had a plan for that.
Our next step is to take a piece of poster board and create a template of the inside of the tray. Take your time doing this
as everything else during the design of the items in the tray will be based o of this template. The initial template of the
inner part of the tray is then transferred to a piece of 1.5mm chipboard.
Chipboard is found at Hobby Lobby, Michael’s and other craft stores. While it is thicker than card stock it is still fairly easy
to work with. After cutting out the chipboard template it was time to start laying out our pieces.
Most of the items in the tray are symmetrical, and so this helps with the layout. We divided the template into sections
using a T-square and a triangle. Holes for the buttons and lights were drawn using a circle template. When we were
happy with the layout, we cut out the openings for the main components.
When building you launch controller, you don't have to follow the same pattern I chose. You can move things around to
where they work best for you. Our only caveat is that you keep the Fire and Safety buttons separated to provide that
extra layer of safety.
After cutting out the openings on the template, I would set it in the tray to see how these items would be positioned on
the remaining plastic of the tray. It also let us see what components would need to be secured to something other than
the tray itself.

The Arduino Launch Control System (LCS): Page 13

Satis ed with the layout, the chipboard template was transferred to a smooth plastic sheet. This plastic sheet will be the
top of the tray and will hold all of the components. The general shape was cut out and then t tested in the tray. Care was
taken to ensure a good t. Once I am satis ed with the t, the main openings are cut out.
With the plastic in place, I could see how the center opening on the tray would impact the layout of the components. I
found that I needed to remove some additional material from the tray to allow the clock to sit properly. The same was
true of the LCD screen. In the pictures you can see the nylon stand-o s that hold the prototype boards in place.
With the tray properly trimmed to size, it was now time to test t all of the components. This included adding in the
prototype boards under the tray. These were attached using 2.5mm nylon screws and stand-o s. We also added two
chrome pull handles to give the project a cooler look. In the one picture you can see all of the components installed prior
to painting. The small black ‘dots’ are the nylon screws. Pleased with the results, it was time to add some paint.
All of the components, screws and stand-o s are removed from the plastic. The plastic received a light sanding of 800-
grit sandpaper and the plastic is washed o . It is then painted bright yellow. Allow this to dry for at least 24 hours.
With the paint completely dry, it is time to mask o the stripes and add the lettering. Chart tape was used to mask the
stripes and 1/4-inch stick-on letters are used to mark the components. This is then sprayed a dark grey. The masks were
removed and it sat for another 24-hours to completely dry.
With the painting done, it is time to assemble the components into the tray. With everything in place I was very happy
with the overall look of the control panel. In hind sight I probably should have taken some additional time with the
lettering to make it a bit neater.
Now I can begin work on the main body of the box, installing components & getting things wired up.

The Arduino Launch Control System (LCS): Page 14

The Arduino Launch Control System (LCS): Page 15
The Arduino Launch Control System (LCS): Page 16
Step 5: Base Components

With the command panel components in place, it is time to start putting the components in the base section of the box. I
will return to the command panel after mounting the base components in place.
Mounting the Arduino

The rst item to be added to the base is the Arduino Nano controller. However, the Nano can’t be mounted directly to the
base. We need some type of mount and were able to use our 3D printer along with a pattern from Thingiverse. The
designer “emccarron” (Ed) posted a Nano bracket back in December 2014 (https://www.thingiverse.com/thing:596400).
This is just one of 28 designs he has posted.
This bracket works perfectly for us. It holds the Nano tightly and allows room for access to the header pins. It also
provides four mounting points to hold the bracket to the base. In the picture you can see the bracket on the left, and
with the Nano inserted on the right.
I need it to be easy to connect the computer to the Nano. This can be for updating the software or to send the collected
data back to the computer. I purchased a USB mini extension cable through Amazon that had a mounting bracket on one
end (https://www.amazon.com/gp/product/B06Y1PWSY7). In order to determine where to position the Nano in the base
we attached the cable and placed it in the base of the box.
A small opening was cut into the side of the box to attach the USB bracket. The cable was then looped around the inside
of the box and back towards the center of the box. We knew we wanted the Arduino to be near the center of the box, but
o set to the rear to allow better placement of the remaining components.
Distribution Panel

With the Nano and USB cable in place it was time to turn to our distribution panel. I have a number of sensors and
components that require 5 volts to operate. I also have several that use I2C for communication. I also knew that at some
point in the future I may want to expand the capabilities of the system. With this in mind I used a small prototype board
to create a distribution panel.
The panel is 14 holes wide and 20 holes long with four mounting holes. I decided to create four rows of connectors in the
long axis. To create the distribution panel I soldered four rows of header pins to the panel. Each row ran the length of the
panel. To give me room for my fat ngers, each row of headers skipped a row of holes. I start by soldering each pin in
The Arduino Launch Control System (LCS): Page 17
place. Then I soldered (bridged) pairs together, and nally the pairs are bridged together. You can see the pins in di erent
stages of soldering in the picture.
The distribution panel is mounted next to the Nano and a set of connecting wires is soldered to the panel and run to the
Nano. You don’t need to solder these wires if you don’t want to. You can use wires with female DuPont connectors on
each end to make the connections if desired.
Launch Pad Connector

The next step is to install the pad connector. This two-pin connector is installed with the female end attached to the box.
The one pin contained two wires, with one going to the continuity lamp on the panel. This plug needed to be located
close to the continuity lamp and key switch, close to the relay for allowing full power to go to the pad, and where it
wouldn’t interfere with anything else in the box. This resulted in the plug being located on the same side of the box as
the continuity lamp.
The male end carries the wires out to the launch pad. This allows us to remove and replace the cables if necessary. I also
decided to install a drawer handle on the rear to act as a holder for the wire. There wasn’t any place we could store the
disconnected wire within the box, so the next best thing was to wrap it outside the box. The picture shows the wrapped
cable and the USB cable on the rear of the box.
Installing the Remaining Components

With the major items now installed, we can install the rest of the components in the bottom of the box. This includes the
relay, the Real Time Clock (RTC), the BMP180 and the DHT11 sensors. The relay is positioned close to the pad connector
to keep all of the pad ring components in the same general area.
The weather sensors (DHT11 and BMP180) are located on the opposite side. The BMP180 did come with a single
mounting hole that we are able to utilize however the DHT11 did not. To attach the sensor to the box, I simply hot glued
the DHT11 sensor to a scrap piece of foam board. A couple mounting holes were punched into the board to provide the
sensor a nice solid mount.
The Real Time Clock (RTC) also came with mounting holes which I made use of. The RTC was located where it really didn’t
get in the way of any of the other components.
One thing that I did use with the DuPont connector was labels. You will notice that each connector has a label that
identi es the connection. The distribution panel also has a label attached to the oor of the box identifying the purpose
of each row. The connections on the Nano are also marked, although they really can’t be seen in the picture at this angle.
This type of labeling helps you make the right connections when you need to replace or repair a component a year or
two later, or when a wire comes loose and you’re not sure exactly where it goes. This completes the bottom of the box.

The Arduino Launch Control System (LCS): Page 18

The Arduino Launch Control System (LCS): Page 19
The Arduino Launch Control System (LCS): Page 20
The Arduino Launch Control System (LCS): Page 21
The Arduino Launch Control System (LCS): Page 22
The Arduino Launch Control System (LCS): Page 23
Step 6: Tray Connections

There were a number of connections that needed to be made on the tray. The location of these components was
determined by the functions of the device and resulted in the layout seen in the picture.
To allow this layout to work we need to use a combination of attachments. Some of the buttons are attached directly to
the tray, while others are attached to prototype boards which attach to the tray. Finally, a number of connections are
required to traverse the depth of the box and connect directly to the Nano. The result was the layout seen in the picture.
In the picture you can clearly see the three separate prototype boards that we used. This was the area that gave us the
most trouble putting together. It is also the area that has some of the weakest connections – especially those wires that
hang down and connect to the Nano.
On the center prototype board I did try to use both a common power connection and ground connection. I did use
connectors where I could, but this section resulted in the most soldering of components.
This area is de nitely one that I should have given more thought to, both for the routing of the wiring and to strengthen
the connections. I should have made sure that the tray could be removed easily. While it can be removed, it is not easy.
While the top panel is busy, I believe better care and forethought would have made this a stronger component of the
entire Launch Control System.

Step 7: Power and Storage Compartments

The top of the box has two storage compartments with a cloudy white/clear cover. The compartment on the right was
divided into two separate sections.
To make the covers match the rest of the box, they were removed and painted satin black. However, instead of painting
the outside of the covers I painted the inside. This reduces the chance of the covers getting scratched and chipped.
The compartment on the left side was selected to store the batteries used to power the system, while right side would
hold our accessories – the USB cable and the safety key.
A four-slot AA battery holder t perfectly in the left compartment with room to spare. This would power the launch pad.
There was also enough room to t in either a 9-volt battery or a LiPo battery below the AA battery holder.
A small hole was drilled in the back corner to allow the wiring from both battery connections to enter into the main box.
To provide room for the wires to travel as well as allow both holders to be extended outside the box, a set of plastic rails
was glued into the compartment under the AA battery holder. The AA battery holder sits on top, and this provides free
movement of the wires underneath. The AA battery holder is not glued to the rails.
The USB cable and the safety key both t perfectly in the right compartment. Nothing needed to be done there.

The Arduino Launch Control System (LCS): Page 24

Step 8: Finishing the Box

I wanted to let folks know that this was not just another plain old tool box, but rather something unique.
The Arduino Launch Control System (LCS): Page 25
To give the inside of the box a more “high tech” look instead of looking like a tool box, I attached some “protective foam”.
The foam does provide some protection to the components in the tray, but its real reason for being there is to hide the
plastic molding of the lid. It also hides the wires running from the battery compartment down into the bottom of the
box. Our “high tech foam” is just a foam air conditioner lter cut to size.
On the top compartments I used our 1/4-inch white labels to identify the “Power” compartment and the “Extras”
compartment (“Accessories” was too long to t in the space). The raised edge of the cover made aligning the letters very
easy.
On the front of the box, we used our Cricut to cut the vinyl lettering for “Launch Control System” as well as the AAEN
logo.

The Arduino Launch Control System (LCS): Page 26

Step 9: Tactics to Improve the LCS

If you have followed along from the beginning, you should now have a working, launch control system that tells time,
provides weather information and can be hooked up to a computer to monitor the status of the system. However, this is
just the beginning. In this section I am going to look at some of the changes, updates and improvements that can be
made to the system.
Hardware Updates

There are a number of components that are utilized in the LCS. Some of the components are selected because they are
available or they are cost e ective. Other components are selected because I already had them in our local stock. Like
any project, it can always be improved. Here are just a few things that can be done di erently on the hardware side of
the LCS.
Replace the DHT11 and BMP180 Sensors with a Single BME280 Sensor
This single sensor will do the work of the two sensors in the current system. It is also rather small, so it isn’t going to take
up a lot of space. Finally, it uses the I2C communications protocol, the same as the BMP180. This frees up the pin used by
the DHT11 allowing it to be used for something else.
Replace the LCD Screen
There are a couple of improvements that can be done here. The rst item would be to use an LCD screen that also uses
the I2C communications protocol. The LCD screen in our project uses 6 pins to communicate with the Arduino. Replacing
that screen with one that uses I2C would open up all 6 of those pins to be used for other sensors or equipment.

The Arduino Launch Control System (LCS): Page 27

The second option with the LCD screen is to purchase a larger screen. The one in our project is 16 x 2. However, you can
purchase LCD screens that are 20 x 4. While slightly larger than our 16 x 2 screen, you can display signi cantly more data.
Add a MicroSD Card
One of the issues with the current setup is that the data is displayed on the Serial Monitor, but there is no method of
saving that data. Adding a MicroSD card module would help solve that. They use the SPI communication protocol, which
makes use of some of the pins used by our current LCD screen.
Replace Male Header Pins with Female Header Sockets
On both the Nano and the distribution board I soldered male header pins as connection points. I used the male pins
because this is what I had on hand. Looking back, it would probably be better to use female sockets instead. Using the
male pins leaves these connection points open to anything that may get into the box area. This could include debris or
loose wires falling down. Anything metal could nd itself falling on the pins and shorting out the circuit.
Eliminate the Gap between Rows on Distribution Panel
When I created the distribution panel I left a gap between each row. While this worked ne for individual lines, it meant
using larger DuPont block connectors when attaching wires in pairs or groups of four. For example, to use a four wire
connection (power, ground and both I2C cables) it took a 7-pin connector block, with three of the seven pins empty. This
turned out to be a waste.
Wire Management
This is something that I should have given more thought to. How you run your wiring and the connectors you use can
make the project easy or di cult to maintain. I should have put more thought into making the hardware as modular as
the software, making it easier to remove and replace hardware or upgrade components.
Replace the Arduino Nano
There are several options available here. Given the space available in the box you could look at using an Arduino
Mega2560 board. There is a big di erence in the number of pins available. The Mega2560 has 54 digital pins and 16
analog pins, while the Uno/Nano has only 14 digital pins and 6 analog pins. This would o er you signi cantly more inputs
for things like an add-on weather station, radio telemetry, and even more options at the launch pad.
Replacing the Nano with an Arduino Uno really doesn’t o er any hardware improvements over the Nano. However,
because of its larger size it is often easier to work with. If you are having trouble with the Nano due to its small size, then
switching to the Uno may be a viable option for you.
Another option would be to look at a completely di erent board such as the ESP32. This board comes with WiFi, Blue
Tooth and a MicroSD Card Reader/Writer already built in to the board. It also has over 30 I/O pins for you to use. This is a
big step-up from the Nano. However, there are some downsides.
The ESP32 uses 3.3-volt logic, and there are a number of sensors that simply won’t work properly unless they have 5-
volts. If you decide to try an ESP32 board be sure to think through the sensors and modules you intend to use.
These are just a few of the hardware updates you could perform on this system. Other thoughts include things like a
battery charging system, a system to allow various power sources for the launch pad, maybe a wireless relay to the pad,
or recorded announcements from a real space launch to replace the buzzer.
Software Updates and Changes

One of the fun things about the Arduino is that we can improve a project by rewriting parts of the software without
changing any of the hardware. Additionally, the Arduino can "talk" to other computers and computer programs
programs. We see that through the use of the Serial Monitor and the Serial Plotter within the Arduino IDE. These features
can allow us to expand the role of the system and how it can be used.
Computer Dashboard
One of the initial things that could be done is to create a dashboard to be displayed on a laptop connected via the USB
cable. Instead of having the Arduino calculate results, the raw data could be sent to the laptop through the USB
The Arduino Launch Control System (LCS): Page 28
connection. The laptop could take this information and post it on a continuously update dashboard display. This would
also be more usable than the current method of scrolling through the data on the Serial Monitor.
In addition to the data, the laptop could interface with the Launch Control System. This would allow the laptop to control
the launch. For a research project that would need certain tasks performed at various times during a countdown, the
laptop could track all of this, inject ‘holds’ to countdown as needed, and save all of the data for review at a later time.
Settings Section
The LCS has several variables that need to be set before the program can run. This includes the current elevation of the
launch pad (the variable baseElevation) and the LED brightness (the variable clockDisplay.setBrightness(5)). The baud
rate for communications with the serial monitor is hard coded at 9600 baud. If you want it faster, you currently have to
change the code.
You could include the number of seconds you want to start the countdown – ten seconds, ve seconds, 30 seconds?
Having the user be able to input basic settings instead of actually changing the code can be very bene cial to the user.
Interface with a Portable Weather Station
Many Nanos/Unos/Mega256/ESP32 boards have been pressed into service to run portable weather stations (here is a
picture and a link to a posting on Instructables – https://www.instructables.com/DIY-Weather-Station-With-ESP32). Such
weather stations could be incorporated into the LCS, providing additional environmental data. The Arduino could be
programmed to abort a launch if wind speeds above a certain range are encountered.
Time Synchronization
It is quite possible that the LCS will be used as part of a research project. It also possible that the launch vehicle will have
an electronic payload on board. The ability to have a laptop synchronize the time between the electronic payload and
the LCS will be necessary to align data points on the ground versus data points in ight, and perhaps even video time
sync.
Allow Users to Bypass Non-working Sensors
The current programming of the LCS checks all of the sensors during the boot phase of the Arduino. If it discovers a
problem with a sensor, it will display an error message and the program stops.
Additional programming could be crafted to allow the user to bypass the shutdown and ignore the bad sensor. The re
button, safety button and LCD screen select button could be used to accept user inputs (the Reset button is wired
directly to the Arduino reset pin and so could not be used).
Software Updates Dependent on Hardware Updates
There are a number of other updates that can be performed as hardware is changed and updated. For example, the
switch to a 4-line LCD would require a programming update to take advantage of the additional screen space. Switching
to a BME280 would require a rewriting of the current sensor code.
The use of WiFi or other wireless transmitters could allow for remote ring of the launch pad, removing the need for a
long cable between the LCS and the pad.
Continuing on the wireless path, a payload with a wireless transmitter/receiver could be sent commands from the LCS to
turn parts of the electronic payload on or o , as needed. You could even implement near real time telemetry from rocket.
The use of a Raspberry Pi also brings with it other options. As the Pi has 40 General Purpose Input Output (GPIO) pins
that can be programmed in much the same way as the Arduino, it can allow you to write software that interacts with the
launch system, the rocket’s electronic payload, and any accessories around the launch pad (such as cameras).
There are a number of new and exciting things that you can implement in your LCS. That's a big part of the fun and
challenge of making the system yours!

The Arduino Launch Control System (LCS): Page 29

Step 10: If You Enjoy Rocketry, Consider Joining the NAR

If you enjoy model rocketry and projects such as the Arduino Launch Control System, then consider joining the National
Association of Rocketry (NAR). The NAR is all about having fun and learning more with and about model rockets. It is the
oldest and largest sport rocketry organization in the world. Since 1957, over 80,000 serious sport rocket modelers have
joined the NAR to take advantage of the fun and excitement of organized rocketry.
The NAR is your gateway to rocket launches, clubs, contests, and more. Members receive the bi-monthly magazine
"Sport Rocketry" and the digital NAR Member Guidebook—a 290 page how-to book on all aspects of rocketry. Members
are granted access to the “Member Resources” website which includes NAR technical reports, high-power certi cation,
and more. Finally each member of the NAR is cover by $5 million rocket ight liability insurance.
For more information, visit their web site at https://www.nar.org/

The Arduino Launch Control System (LCS): Page 30

The Arduino Launch Control System (LCS): Page 31