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 PCBWay.com, 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 Arduino.cc 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 20x20 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 120x120 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!