DIY Stream Deck (3D Printing, Arduino, Electronics!)

Hi I'm Alex and welcome to Super Make Something. Today we're making a DIY Stream Deck. Let's get started! This episode is sponsored by PCBWay. Follow the link in the video description below
to order your own set of circuit boards needed to build this project! Because of the ongoing pandemic, the number
of people interested in creating livestream content has increased dramatically.

Arguably one of the best streaming tools besides
a camera, microphone, and lights is an Elgato Stream Deck, a macro keyboard with an LCD
screen behind the buttons, which allows users to program custom shortcuts to control their
streaming software and various other applications. Unfortunately this surge in interest has made
these devices either difficult to find or very expensive. Because of this, I decided to create an open
source version, which will hopefully make it easier for those interesting in streaming
to go live online, and to make it possible for individuals to create the custom Stream
Deck that best suits their streaming needs. The main idea behind this project is that
anyone can build it, even if they don't have any electroncis experience. Because of this, the design is guided by the
following rules: 1.) All electronics parts should be easily available
online from vendors where everyone already shops, like Amazon or AliExpress.

2.) The design should use pre-made electronics
assemblies wherever possible, meaning no indivdiual chips. 3.) Common parts like resistors and LEDs should
be through-hole instead of surface mount for easier soldering. 4.) The total price of all componets in the bill
of materials should cost no more than the price of an official Streamdeck. When I started this project, I didn't know
if meeting this last rule would be possible, so to keep track, a running total of the cost
of all materials in one Stream Deck will be displayed on the side of the screen.

This number may vary a bit for you depending
on where you purchase your components from and the minimum number of each type of component
you will be able to buy, since some items, like push-buttons often come in packs of 50,
which is more than enough to build one Stream Deck. Links to all components needed to build this
project can be found in the video description below. Based on these rules, the open source Stream
Deck is designed around a 3.5 inch color LCD screen and an Arduino Pro Micro microcontroller. Using this microcontroller is important, because
it is small and uses the ATmega32u4 chip, which can emulate a USB keyboard. Based on the screen's size, I decided that
my Stream Deck would have 6 programmable keys, as well as 2 rotary encoders, which the official
Stream Deck does not have.

While the encoders won't have an LCD screen
underneath them, they do each have another push-button and will be handy for me during
video editing, because they will allow me to quickly scrub through a video and adjust
audio levels. I decided to begin this project with the electronics. Because the LCD screen has no internal memory,
icons for the Stream Deck are stored on an SD card, which interfaces with the LCD screen
and microcontroller through an SD card reader. Unfortunately, the Pro Micro does not have
enough input-output pins to connect to both of these components and sense button inputs,
so I added another microcontroller, an Arduino Pro Mini, to the design in order to handle
loading icon images and displaying them on the LCD screen. This essentially separates the hardware for
this project into two parts: one which is responsible for handling all of the display
tasks, and one which simply senses button inputs and sends USB keyboard commands.

However, since I wanted the Stream Deck to
be able to store more shortcuts than the number of physical keys on the device, both microcontrollers
need to be able to coordinate when a "folder" button is pressed, which both loads a new
set of icons and changes the keyboard commands that are sent by each button. To accomplish this, one input/output pin of
each Arduino is connected together, which can be used to send signals back and forth
between the microcontrollers to coordinate what keyboard shortcuts and button icons should
currently be active. This project has a lot of interconnected components,
so it would be impractical to wire everything by hand. To make the project more robust and more easily
reproducible, I therefore decided to create a set of printed circuit boards for the Stream
Deck using the PCB design software EAGLE.

While the details of using Eagle are outside
of the scope of this video, the PCB design process essentially boils down to placing
the components that you would like to use into a schematic and connecting them together
appropriately using virtual wires. After the schematic is wired up, it's then
necessary to physically lay out the components on a virtual circuit board to describe how
the boards should be manufactured. In this design, the Arduinos, SD card reader,
and LCD screen mount to a "motherboard PCB," and the components to sense all of the inputs
are connected to a second "button PCB," which has square windows milled into it in order
to be able to see the icons displayed on the LCD screen. During the final assembly, these circuit boards
are then connected together using a wire ribbon cable. Once the physical layout of the boards was
complete, it was time to create a set of Gerber files, which would let a circuit board fabricator
know how to manufacture each board.

After zipping everything up, I headed to,
who I used to make these circuit boards, and uploaded my files to their online system. PCBWay offers various types of PCB fabrication
services for any budget depending on the options you choose when you upload your file. Because my boards had an exposed logo and
I wanted to show them off in the final build, I opted for a black soldermask and an ENIG
finish, which covers all of the exposed contacts with a thin layer of gold. In case you're interested in ordering these
boards for yourself, a link to the Gerber files can be found in the video description
below. The video description also contains a link
to the PCBWay Community "Shared Projects" store, where you can order the exact same
boards that I used for this build with a single click. Less than a week after submitting my order,
I received my boards in the mail, and the quality was AWESOME. The silkscreen text describing each connection
was super crisp and the gold plated Super Make Something logos came out perfectly.

After about 30 minutes of soldering, I had
two awesome looking circuit boards that were ready for programming. While I waited for the circuit boards to arrive,
I designed and 3D printed the Stream Deck's mechanical components. The cool thing about EAGLE is that it's made
by Autodesk, who also make the Fusion 360 3D modeling software. Because of this, full 3D models of the assembled
circuit boards can be imported into Fusion 360, which made it incredibly easy to design
an enclosure around the project's electronics. In my Stream Deck design, an LCD screen is
located underneath the button PCB. Each Stream Deck key is made up of a 3D printed
button frame with a clear acrylic insert. These each sit on top of four pushbuttons
on the button PCB, which creates a rugged, simple mechanical button mechanism without
needing to purchase other components like springs. The four buttons underneath each key are wired
in parallel to ensure that input will register no matter how a Stream Deck key is pressed.

To make the Streamdeck look a little cooler,
I used Fusion 360's Voronoi Sketch Generator to cut a cool pattern into all of the surfaces
of the enclosure I designed, which not only saved some material, but also made everything
print a little faster. In case a normal box is more your style, I
also created a model without holes that you can use instead. Once I was happy with the overall design,
I exported each model as an STL file and opened them in Cura, a free 3D slicing program, which
generates instructions for a 3D printer about how to create each part. After configuring all of the print options,
I sliced each model, which generated the print instructions in a format known as "G-Code"
and saved these to an SD card. All of the files are printed on an ET4 Pro,
a desktop 3D printer made by Anet. The printer comes as a kit that is mostly
pre-assembled, which can be out of the box and up and running in less than 10 minutes. The printer has a 220x220x250mm build volume,
and includes multiple advanced features like silent stepper motor drivers, automatic bed
leveling, filament runout detection, and power loss resume functionality.


Sticking with the open source nature of this
project, the printer can now also run the open source Marlin printer firmware, which
is awesome for advanced users to further customize their machine. Best of all, the printer is often available
online for under $200. For those looking for a machine with a larger
build volume, Anet also makes the ET5 Pro, which has the same features as its smaller
sibling, but can print models up to 300x300x400mm. Be sure to check out both of these machines
by following the links in the video description below.

After about 19 hours the printer made 11 parts. 1 Stream Deck base, 1 Stream Deck spacer insert,
1 Stream Deck top cover, 2 encoder knobs, and 6 button frames. With all of the parts done printing, it was
now time to program the electronics. I began by heading to and downloading
and installing the Arduino programming environment. I next headed to the Super Make Something
Github site, where I then went to the open source Stream Deck page and downloaded all
of the project code as a ZIP file. After extracting the contents of this folder,
I copied the 'LCDWIKI_GUI' and 'LCDWIKI_KBV' folders into the directory shown on-screen. I then copied the 'arduinoTFT_icons' and 'streamDeckKeyboard'
folders onto my hard-drive, where I could easily find them later. As stated earlier, the Streamdeck uses separate
Arduinos to emulate a keyboard and display icons on the LCD screen, so they must be programmed
separately. After plugging the Arduino Nano into my computer
with a mini-USB connector, I first opened the `arduinoTFT_icons.ino' file to program
the Arduino driving the LCD screen.

In the Arduino IDE, I then headed to 'Tools'
-> 'Board' and made sure that the 'Arduino Nano' option was selected, and then went to
'Tools' -> 'Processor' and made sure that the 'ATmega328P (Old Bootloader)' option was
checked. After verifying that the right COM port was
selected, I then clicked the 'Upload' button, which compiled the code and uploaded it to
the Arduino Nano. Next, it was time to program the Arduino Pro
Micro. For this, I first connected the microcontroller
to my computer using a micro-USB cable, and then opened up the 'streamDeckKeyboard.ino'
file. Next, I headed to 'Tools' -> 'Board' and selected
the 'Arduino Leonardo" option. After verifying that I had selected the correct
COM port, I again clicked upload, which compiled the code and uploaded it to the Arduino Pro
Micro. One thing to note is that the power lines
of both Arduinos are connected together, so it's only necessary to plug in the micro USB
cable into the Arduino Pro Micro to connect the Stream Deck to the computer after assembly. Now that the Arduinos were fully programmed
it was time to put everything together. I first attached the SD card reader to the
3D printed base using two M2 screws.

Next, I carefully inserted the motherboard
PCB into the base and attached it using three M3 screws. I then carefully inserted the pins of the
LCD screen into the female header pins on the motherboard PCB in the orientation shown
on-screen. I then inserted the spacer insert into the
matching recess in the base, and then attached the keyboard PCB to it using four more M3
screws. After this, I gently pressed the 20×20 mm
square acyrlic pieces that I had purchased online into each button frame, and then laid
them over each of the button slots as shown.

After this, I placed the top cover over the
buttons to keep everything together, which attached to the 3D printed base with four
more M3 screws and finally pressed the two 3D printed knobs onto the encoders, after
which the Stream Deck assembly was complete! The final step was to create icons that would
be displayed on the LCD screen. For this, I created a Photoshop template,
which can be downloaded from the Super Make Something Github page. Each icon is 120×120 pixels and can be filled
however you want, as long as the icon files are saved as 24-bit BMP files. Because of the screen orientation inside of
the Stream Deck, the icons also need to be rotated onto their side.

The file name of each icon corresponds to
which Stream Deck key they will display under, with numbers larger than six indicating that
this icon will be displayed on a second page. To add more pages, simply modify the Arduino
code by copying the corresponding if statements and changing the file names and desired keyboard
shortcuts. Be sure to check out the Arduino code for
an example of how to do this.

After creating all of the icons, I saved the
files to an SD card and inserted it into the SD card reader on the bottom of the Streamdecks
base, after which the only thing that was left to do was to map the keyboard strokes
sent by the device into OBS, Streamlabs, or any other software that I wanted to use it
with. I actually used the Stream Deck to edit this
video in Sony Vegas and it worked extremely well, because the encoders were handy for
quickly and precisely scrubbing through my editing timeline. The final price also came in at less than
an official Streamdeck, while adding more functionality, so this project was a huge
success. Since I've built this project, the DIY Streamdeck
has been a permanent fixture on my desk and I use it for many of my tasks including streaming,
video editing, and gaming. Overall, I'm very happy with how the open
source Stream Deck turned out, but there are several ways that this project could be improved. First, the clock speed of the Arduino is a
bit low, which means that it takes several seconds for all of the icons to redraw on
the LCD screen after a folder button is pressed.

Switching it out with a different microcontroller,
like the "STM32 Blue Pill" board, could help speed up this process significantly. Using a microcontroller with more IO pins
would also make it possible to build this project with a single board and allow the
SD card reader integrated on the back of the LCD screen to be used, both of which would
make the DIY Stream Deck smaller. However, trade-offs exist, because other boards
can be harder to program than an Arduino, which would make it more difficult for people
who aren't familiar with electroncis to build one of these Stream Decks for themselves.

A big shout out to PCBWay and Anet for supplying
many of the materials that I needed to build this project. All of the design files for this project are
available for free at the links in the video description so that you can make your own
DIY Stream Deck. My hope is that others will use these files
to create evolutions of the design and that the DIY Stream Deck will grow into an open
source project that is widely supported by the electronics community. If you liked this build and found it useful,
please consider giving the video a like, sharing it with your friends, and subscribing to my
channel. If you want to support future builds like
this please also consider becoming a Patron. Well, that's all there is to this episode! Thanks for watching! Now go Super Make Something!.

As found on YouTube

Leave a Reply