Sponsored By

MegaDot: How to Give Your Amazon Echo Dot a Bass Boost

The Amazon Echo Dot is handy for a lot of things...but not playing bass-heavy music. Joe Peck shows you how to build a “MegaDot” and add a lot more bass thump to your Echo Dot.

Joe Peck

November 8, 2018

12 Min Read
MegaDot: How to Give Your Amazon Echo Dot a Bass Boost

CLICK HERE to download a fully detailed PDF of the MegaDot build instructions.

I have a small collection of Amazon Echo Dots scattered around my house and use them for alarms, checking weather and traffic, controlling lights, and of course playing music. The built-in speaker is a little, well...tiny...and doesn’t exactly fill a room with thumping bass. I happened to have an old subwoofer and pair of speakers waiting to be thrown out or repurposed. As they sat there occupying a corner of my room, an idea came to me. MegaDot!

Could I build a supersized Echo Dot that could shake the room? The project began innocently enough: an Echo Dot; the guts from a 250W 15” subwoofer; the crossovers, mid-range speakers, and tweeters from the smaller speakers; an FPGA-based embedded controller; and a strip of individually programmable RGB LEDs. The end result? A scaled-up, 27” diameter MegaDot with crisp highs and thumping lows, while retaining the full voice control of Alexa. It even includes the four buttons on top (fully functional) and a light ring around the top.

There were four main considerations for the design:

  • Large amplified speaker subsystem

  • Faithful reproduction of the outer LED ring

  • Fully functional buttons

  • Standard Echo Dot capability, including voice control

This resulted in the following block diagram:

Everything was designed around the speaker subsystem. I carefully measured the various dimensions of a standard Echo Dot and scaled it up so that I could fit the 15” subwoofer, 4.5” mid-range speakers, and 1” tweeters. This left just enough room for the various power supplies, a mildly disassembled Echo Dot, the FPGA-based controller, and the button mechanicals.

Parts List:




Echo Dot, 2nd generation 

National Instruments 

myRIO-1900 controller 


RGB LED strip, individually programmable LEDs, 60 LEDs/meter 


LM2596 12V to 3.3V converter board 


Momentary roller lever microswitches 








4 hinges 


4 compression springs 


Extension cords 


Miscellaneous wire 


1⁄4” and 1⁄2” MDF 


1/8” plywood 


Miscellaneous wood, screws, hot glue, paint, etc. 

Cerwin Vega 

15” 250W subwoofer 

Polk Audio 

4.5”/1” stereo speakers 



Hacking the Echo Dot

1.) Disassembly

The first step was to disassemble an Echo Dot. I needed to figure out how to monitor the state of the LEDs and remotely press the buttons. The first step (which totally voids your warranty) is to peel off the rubber base that hides the screws. Pop out the screws, and everything starts to fall apart. Be careful with the subassemblies, as there are two PCBs joined by a flex circuit, and you don’t want to damage the fine pitch connectors by dangling things around. All of the signals we need access to are on the uppermost board (the one with the LEDs, buttons, microphones, etc.). To make things more manageable, I disconnected the flex circuit. Flip up the tiny, hinged hold-down and the flex circuit slips right out.
2.) Accessing the LEDs

There are 12 RGB LEDs around the perimeter of the board. My original plan was to monitor each LED directly, with the assumption that they were very likely driven by simple PWM signals. I would monitor each of the 36 LEDs (12 red, 12 green, and 12 blue) with a myRIO by making 36 simultaneous PWM measurements.

It quickly became apparent that all of the LEDs connected to a single IC, but I didn’t recognize the part labeling. I assumed there was going to be a SPI or I2C bus for controlling this IC, so I probed around some more. I found that two lines also connected to some other ICs on the board, which turned out to be ADCs. Those were well labeled, so I could find their data sheets. Victory! They were all on a shared I2C bus and I am totally capable of soldering three tiny little wires (SDA, SCL, and ground). So I used the myRIO to snoop the I2C bus.

3.) Tapping into the Buttons

The four buttons (volume up, volume down, pairing, and microphone) are simple dome switches. Pressing a button shorts the signal to ground, so I could simply put my own external switches in parallel with the dome switches. However, there wasn’t a great place to solder the fine wires to the switches themselves, so I traced them back and found they connected to some discretes (a pull-up resistor and probably a simple RC filter). Now I knew where to solder all my wires.

4.) Grinding off the Top

Ultimately, the actual Echo Dot is going to be mounted in the top center of the MegaDot, and I wanted the microphones to be as close as possible to the outer surface. So I ground off the top of the Echo Dot housing and added a cutout for my wires to pass through. The Echo Dot has a foam pad on the top surface, so I removed enough housing so that the foam would now be in direct contact with the new mounting surface. Now, everything can be held together nicely and I don’t have to worry about dangling wires. I temporarily reassembled everything to make sure the Echo Dot was still working, and fortunately it was.

Replicating the LEDs

1.) Snooping I2C

At this point, I still hadn’t actually looked at the data communication going to/from the LED driver chip. I had been using a DMM to figure out the signal connections, but now needed to switch to an oscilloscope to see the communication protocol. I quickly was able to see that there wasn’t anything unusual going on, and that this was a standard I2C bus and protocol. I would ask Alexa questions, which would cause her to cycle various colors on the LEDs, and I could see the changing I2C data in the transactions.

While I could have continued mapping transactions and reverse engineer the internal register map, I now felt I had enough information about the pinout and interface to search the Web again. I looked for LED drivers with 36 outputs and finally found what seemed to be the actual component. The pinout matched and the transactions I was seeing made sense. This could work!

2.) Monitoring and Expanding the LEDs

Now that I had access to the I2C bus and knew the protocol, I needed a way to monitor it, replicate the appropriate portions of the register map, and expand from the 12 RGB LEDs in the Echo Dot to the 128 RGB LEDs surrounding the MegaDot. I had been using my NI ELVIS III for its DMM and oscilloscope functionality to analyze how the Echo Dot worked internally. Now, I could use the RIO portion of the NI ELVIS III to prototype these controller functions. It includes an FPGA and control IO that can be programmed using LabVIEW FPGA, which made it easy to prototype a quick solution. Using two digital inputs and an easy to follow diagram, I implemented digital filtering on SDA and SCL, a state machine to detect I2C accesses to the driver IC, arrays to hold the LED values, and the control logic to drive the LED strip (described in the next section).

Of course, I didn’t want to embed my NI ELVIS III into MegaDot. So once I had all of the logic working, I deployed the final solution to a myRIO. The myRIO is meant for embedded applications and runs the same LabVIEW FPGA diagrams, so it was a trivial thing to move over.

3.) Programming the LED Strip

The LED strip I chose has individually programmable RGB LEDs based on the WS2812B driver IC. Each RGB LED is programmed with a 24-bit word, with 8 bits for each color. It is programmed with a simple one-wire protocol. Each driver IC has one data line in and a data line out. The output of one is connected to the input of the next one in the strip. You shift the data one bit at a time. Once you shift 24 bits, any additional bits cause data to be shifted into the next LED. So if you shift out 72 bits, you would be programming three RGB LEDs. For MegaDot, I have to shift out 3,072 bits in order to program all 128 RGB LEDs.

You have to generate a pulse for every bit, and the width of the pulse determines if it is a 0 or 1. A short pulse corresponds to a 0 and a long pulse corresponds to a 1. After shifting out all of the bits, you drive the line low for an extended period to apply the shifted data to the actual LEDs. It is easy to meet the timing requirements with LabVIEW FPGA, which allows you to create hardware timed custom digital protocols. I verified the signal behavior with the oscilloscope. The LED strip is powered from 3.3V, so I bought a 12V to 3.3V converter to go with the 12V supply I already had on hand.

Making Giant Buttons

The Echo Dot has four buttons for volume up, volume down, pairing, and disabling the microphones. In order to keep the right scale, these have to be a little over 4.5” in diameter. For some odd reason, I couldn’t find anyone that sold buttons in this size—let alone with the right symbols on them. So I had to make my own. My solution consisted of four parts: a round piece of MDF for the button face, attached to a hinged piece of MDF to let it move up and down; a 3D printed frame to act as a stop and hold a compression spring; and finally a microswitch mounted to the 3D printed frame.

Pressing the button face swings the arm down. It stops against the frame and, when you release the button, the spring returns it to the original position. The location of the microswitch is set so that it activates near the end of the button travel. The microswitches get wired to the screw terminal previously attached to the Echo Dot.

Amplifiers and Speakers

I took apart an older 15” 250W Cerwin Vega subwoofer that I had. While 250W might not sound like a lot of power for a 15” subwoofer, this speaker was from a time when that was a quality 250W. Internally, there was a sizeable power transformer, extensive heatsinking, and an all around robust implementation. I had to cut and extend some of the wires, as I didn’t have a simple place to locate the components in the new round enclosure. I then disassembled a pair of speakers I had to scavenge the mid-range speakers, the crossovers, and the tweeters. These weren’t powered, so I ordered a simple stereo amplifier board to drive those. I had a 12V power supply hanging around and dedicated that to power this amplifier.


I had actually expected hacking into the Echo Dot, figuring out the protocols, and implementing the FPGA controller to be the most time-consuming part of this project. However, I spent just as much, if not more time, working on the mechanical construction. I really wanted to keep the scale accurate, but optimize the size to just fit the speakers. This made it pretty tricky to pack everything into the round enclosure.

Base and Speaker Enclosures

I started with the base that would hold the five speakers. I decided to create three sealed chambers. In order to fit these, they couldn’t be simple squared-off boxes. In order to make the curved chambers, I took apart an old bookshelf. I kerfed the pieces with a radial arm saw so that I could bend them. Using shelf pieces was great, because the plastic laminate helped prevent the pieces from snapping at the sharper bends. I used a combination of hot glue and screws to hold all of the pieces together.

Once the base was assembled, I could mount the speakers and amplifiers. The speakers dropped right into the holes and were screwed in. The amplifiers, power supplies, and cross overs were harder, as they had to be fit into the odd shapes left around the speaker enclosures.

Outer Skin

I had debated how to make the outer cylindrical skin. I was originally going to kerf a long piece of MDF, but decided that I didn’t have a great way of supporting it while making all the kerfs. The next thought was to try wrapping it with a thin piece of plywood. I built a basic frame to support the skin, then tried bending a sample piece of plywood around it. As it got to about twice the radius, it needed to be snapped in half. So next, I tried soaking a piece in water for about 20 minutes. It didn’t start to snap until it was really close. My final attempt (which was good that it was final, because it was my last piece of plywood) involved soaking the wood for an hour, then trying. Success! I bent it fully around the frame and clamped and screwed it in place. I let it set overnight to dry in that position, then redid the screws and epoxied the small gap where the ends met.

Top Surface and Buttons

There was no practical way to make the top portion by hand and have it come out looking right. It needed the four large holes for the buttons, 84 oblong holes on the perimeter, and a series of small holes in the center to provide access to the Echo Dot microphones and light sensor. Fortunately, I was able to borrow time on a CNC machine and have these all carved out for me.

All of the non-speaker-related electronics were mounted to the underside of the top surface, along with the button assemblies. A variety of little wooden brackets and mounts were made to hold it all together.

Final Assembly

Here is an image of the first time it was all put together:

[All images courtesy Joe Peck]

Sign up for the Design News Daily newsletter.

You May Also Like