View All Posts
Want to keep up to date with the latest posts and videos? Subscribe to the newsletter
HELP SUPPORT MY WORK: If you're feeling flush then please stop by Patreon Or you can make a one off donation via ko-fi

Dive into the fascinating process of building a minimal ESP32-based dev board, beginning with the ESP32-S3 Wroom module, and eliminating unnecessary components. Through soldering, wire connecting, and voltage testing, we reach a product that's compact, efficient and fully functional.

Related Content

[0:00] I’ve been designing an ESP32-based board recently and I got to thinking. What’s the
[0:05] minimum you can get away with and still have a working module?
[0:09] The ESP32-S3 Wroom module is particularly interesting. It only needs a few components
[0:14] to make a complete, fully functioning dev board.
[0:18] What’s nice about the S3 modules is that you don’t need to have a USB UART bridge
[0:22] chip. You can connect it directly to the USB data lines. But just how minimal can we make
[0:27] things and still have something that works?
[0:30] Well, let’s have a look at the recommended schematic and see what we can chop out and
[0:34] what is definitely required.
[0:36] So obviously something we definitely can’t do without is a ground connection. There are
[0:40] annoyingly two ground pins, we could probably just connect one, but we’ll do both for now.
[0:46] We’re also going to need 3.3 volts. Unfortunately for this, we will need an external component,
[0:52] a Low Dropout Regulator. We get 5 volts out from the USB connection and if we use
[0:57] that directly, it will fry our ESP32.
[1:00] For this initial test, I’m going to use this handy module that has an AMS117 3.3V regulator
[1:07] along with the required capacitors. If we wanted to go even more minimal, we could try
[1:12] just dropping the voltage over a few diodes to get it down to a safe level. Three diodes
[1:16] in series would get us down to around 3.2 volts, which would be acceptable to an ESP32.
[1:23] If it was a low power device, we could probably get away with a Zener diode or even a resistor
[1:28] divider. But the ESP32 can spike up to a lot of power, especially when you’re using
[1:32] Wi-Fi or Bluetooth.
[1:35] Given that we’ve got some capacitors on the regulator board and we’re going to play
[1:38] fast and loose with this proof of concept, we can just cross out these decoupling capacitors
[1:42] from the schematic.
[1:44] For the enable pin, we can just connect it directly to 3.3 volts, so we can ignore this
[1:49] little RC circuit. The recommended values are 10K and 1uF, and it’s intended to stop
[1:55] the ESP32 from running until the supply voltage has stabilized. Since we’re connecting it
[2:00] directly to 3.3 volts, we can also do away with this push button. We can drop this crystal
[2:05] and capacitors. This is only required if we want to use an external oscillator for keeping
[2:09] accurate time during deep sleep. The last thing we need are the data lines for USB.
[2:15] On the schematic, there are a couple of zero-ohm resistors, so we can just ignore those. There’s
[2:20] also a couple of capacitors. These are completely optional. They can help with very noisy signals,
[2:26] but they aren’t required, so we’ll just get rid of them as well.
[2:28] IO19 goes to the D-minus pin, and IO20 goes to the D-plus pin.
[2:34] Now if you’re using a brand new fresh module straight out of the factory, you may need
[2:38] to connect the IO0 pin to ground to manually put the ESP32 into download mode. My experience
[2:44] is that you only need to do this the first time you program the module. However, your
[2:48] mileage may vary. It does seem to be quite fussy, and the internet is full of people
[2:53] complaining that they can’t program their modules. We can cross out this connection
[2:57] from the exposed pad to ground. This is completely optional. It can help with heat dissipation
[3:02] from the module, but it’s not required. Check the datasheet for details.
[3:07] And finally, we can cross out the UART connector. We’ll get our serial output over the USB
[3:13] and we’re not going to use JTAG debugging, so that can go as well.
[3:17] Well it seems like we’ve crossed out quite a lot of components. What does our circuit
[3:21] actually look like? Well we’ve got the ESP32-S3 module, we can’t really do without that.
[3:27] And we’ve got our USB connection, with 5V, D-minus, D-plus and ground.
[3:32] We need to take the 5V through a regulator to give us our 3.3V connection. We’ll hook
[3:37] the EN pin directly to that. And we’ll hook up the ground connections.
[3:41] D-minus connects directly to IO19 and D-plus connects directly to IO20.
[3:46] I’m also going to add a resistor and an LED to GPIO2. There’s no point doing anything
[3:52] if we can’t run a blink sketch.
[3:54] Let’s get some wires soldered onto a module. I’ve got a couple of modules that are connected
[3:59] to some prototype boards that I can salvage. I just need to heat up the PCB using my mini
[4:03] hot plate and we can pluck them off. The nice thing about this being pre-soldered is that
[4:07] all the pins are now nicely plated, so connecting wires to them should be easy.
[4:13] But of course soldering the ground wires is always slightly annoying. There’s a lot
[4:16] of copper connected to the pins and I really should have bumped up the temperature of my
[4:20] soldering iron, but it goes on eventually. The 3.3V pin and the enable pin are both very
[4:27] easy. And so are the two data pins, IO19 and IO20.
[4:32] And finally, we hook a wire up to IO2 for our LED.
[4:38] So that’s the soldering all done. I’ve hooked everything up to a USB breakout board. Let’s
[4:42] see if it actually works.
[4:44] Well, initially this is quite promising. We’ve got a light on our voltage regulator, so we’ve
[4:49] got 5V coming from the USB port and it should be creating 3.3V, so our ESP32 should be getting
[4:55] power. And if we look on our computer, we can see that we’ve got a USB device showing
[5:00] up. So far, so good.
[5:03] I’ve got a very simple sketch here. Let’s see if it uploads. I’m using PlatformIO
[5:07] as I found the Arduino IDE to be quite unreliable, especially when uploads fail. It seems to
[5:12] lock up the USB device and it even crashed my computer a couple of times.
[5:16] We’ll hit the upload button. Our code compiles.
[5:20] And it’s a miracle. The code is being uploaded to the module.
[5:24] And it’s flashing the LED.
[5:27] If we open up the serial monitor, we can see our messages coming through as well. I did
[5:31] need to add these funny pre-processor definitions to get output to come out from the serial
[5:35] port. If you know what they mean, then let me know in the comments.
[5:39] Now at this point, most sensible people would call it a day. We’ve proved a point. We’ve
[5:43] shown you don’t need many components. It’s very cool.
[5:46] Or maybe they’d think, I could make a really nice small PCB for a dev board. I could get
[5:51] it manufactured by the channel sponsor PCBWay. They’d do a really great job and give me a
[5:55] fantastic board. But not me. I got to thinking, there’s a surprising
[6:00] amount of space on the back of the module. We could probably fit the USB socket and the
[6:04] voltage regulator on it. The circuit is not very complicated. How hard can it be?
[6:10] I’ve covered up the EPad with Kapton tape so we don’t short anything out. We need
[6:14] our voltage regulator and our USB connector. We’ll add in the voltage regulator decoupling
[6:19] capacitor between the output and ground, and another one between 5 volts and ground.
[6:24] So that’s where we want our components, and in theory we have a very simple circuit.
[6:29] We’ve got ground coming from the USB socket. We can just connect to one of the ground pins
[6:32] on the module, and we need to connect it to one side of the input capacitor. And we need
[6:36] to connect it to the ground pin of the voltage regulator. We need 5 volts from the USB socket
[6:41] to the input of the regulator, and we need to connect the regulator output to the 3.3
[6:46] volt pin and the enable pin. Finally, we just need to connect the two data
[6:50] lines D-pin 19 and D-pin 20. It should be pretty straightforward.
[6:56] So I’ve superglued the two main components, the voltage regulator and the USB socket in
[7:00] place. In the hopes of making my life slightly easier, I’m using a micro USB socket which
[7:06] has slightly more accessible pins than a USB-C socket. We can tack the capacitors in place
[7:11] with some solder. It’s not the nicest job, but they are connected and they are not going
[7:16] anywhere. This seems to be going surprisingly well.
[7:19] My initial plan was to try and make most of the connections using stripped solid core
[7:23] wire. My thinking was this could easily be bent into shape and would be quite neat. Obviously,
[7:28] the best laid plans of mice and men, this did not work very well. The wire is far too
[7:33] springy, and it’s quite hard to get it to bend into the right shape. So I tried just
[7:38] using straight bits of wire. This did work slightly better, and I was able to get the
[7:42] initial ground connection done. For the next connection, I switched over to more flexible
[7:47] cable. This was a lot easier to work with, and we are able to connect up the output from
[7:51] the regulator to the 3.3 volt pin and the enable pin. It’s just not particularly tidy.
[7:57] We need the 5 volt supply from the USB socket. I managed to get this soldered on, but it’s
[8:02] getting increasingly hard to get into the USB connector pins and the superglue is not working
[8:06] very well on this component. The last thing we need is the ground connection
[8:11] for the voltage regulator. At this point, I thought I’d better test things and see
[8:15] if we can actually get 3.3 volts, and it actually worked. The last two connections broke me.
[8:21] Getting the D minus and D plus pin soldered proved to be a step too far. I just could
[8:25] not get into the USB pins to solder them effectively, and I kept desoldering the other wires. The
[8:31] USB socket was also not very secure. There’s no way it would survive being plugged into
[8:35] multiple times. So I decided to swallow some pride, and I glued a USB breakout board in
[8:40] its place. This was a lot easier to solder the wires onto, and it’s still pretty compact,
[8:46] and it should let me plug it in out multiple times.
[8:49] For the piece de resistance, I added an LED to one of the more accessible pins. It’s
[8:53] not pretty, the wires could be made much shorter, but it works, I’m pretty pleased. We can
[9:00] run our little blink sketch, and after modifying the pin number, it works really well. Now,
[9:05] would I do this again? Probably not, but it was fun to try and see what was possible.
[9:10] Now go and watch this much more sensible video about Raspberry Pi’s and wireless power.

HELP SUPPORT MY WORK: If you're feeling flush then please stop by Patreon Or you can make a one off donation via ko-fi
Want to keep up to date with the latest posts and videos? Subscribe to the newsletter
Blog Logo

Chris Greening

> Image


A collection of slightly mad projects, instructive/educational videos, and generally interesting stuff. Building projects around the Arduino and ESP32 platforms - we'll be exploring AI, Computer Vision, Audio, 3D Printing - it may get a bit eclectic...

View All Posts