Wi-Fi Sensor For Rapid Prototyping

February 19, 2023 by Bryan Cockfield 4 Comments

There might seem like a wide gulf between the rapid prototyping of a project and learning a completely new electronics platform, but with the right set of tools, these two tasks can go hand-in-hand. That was at least the goal with this particular build, which seeks to use a no-soldering method of assembling electronics projects and keeping code to a minimum, while still maintaining a platform that is useful for a wide variety of projects.

As a demonstration, this specific project is a simple Wi-Fi connected temperature monitoring station. Based around an ESP32 and using a DS18B20 digital temperature sensor, the components all attach to a back plate installed in a waterproof enclosure and are wired together with screw-type terminal breakout boards to avoid the need for soldering. The software suite is similarly easy to set up, revolving around the use of Tasmota and ESPHome, which means no direct programming — although there will need to be some configuration of these tools.

With the included small display, this build makes a very capable, simple, and quick temperature monitor. But this isn’t so much a build about monitoring temperature but about building and prototyping quickly without the need for specialized tools and programming. There is something to be said for having access to a suite of rapid prototyping tools for projects as well, though.

ESP32 Web Updater Allows File System Management And OTA Updates

February 17, 2023 by Lewin Day 10 Comments

Earlier versions of the Arduino IDE made uploading files to an ESP32’s SPIFFS filesystem easy via the ESP32FS plugin. Sadly, that’s no longer possible under the rewritten Arduino 2.0 IDE. Thankfully, [myhomethings] has stepped up to solve the problem with a new tool that also adds some new functionality.

The tool in question is the ESP32 Web Updater and SPIFFS File Manager. It features a web interface courtesy of the ESPAsyncWebServer library. Simply dialing into the ESP32’s IP address will grant one access to the interface. Once connected files can be uploaded to the ESP32, or deleted at will. Text files can be created and populated through the interface as well, and the SPIFFS file system can also be formatted if required. Plus, as a bonus, the interface allows for handy over-the-air firmware updates. One need only export a compiled binary from the Arduino IDE, and then load the resulting *.bin file into the ESP32 via the web interface. It does come with the caveat that if new firmware is uploaded that doesn’t include the ESP32 Web Updater itself, there will be no way to do further firmware updates in this manner.

For those working on projects that may need regular file system management, the tool may be very useful. Alternatively, if you just need to do OTA updates on an ESP32, we recently featured a way of doing them through GitHub.

Puya PY32: The Cheapest Flash Microcontroller You Can Buy Is Actually An ARM Cortex-M0+

February 16, 2023 by Maya Posch 26 Comments

There’s a bit of a contest going on when it comes to which is the cheapest microcontroller, yet most of the really cheap ones have one big trade-off in that they have one-time programmable (OTP) memory, generally requiring the use of an (expensive) device emulator during development. This raises the question of what the cheapest reprogrammable MCU is, which [Jay Carlson] postulates is found in the Puya PY32 ARM Cortex-M0+ based series.

Although [Jay] has previously mentioned that these cheap OTP (like the 3-cent Padauk PMS150) MCUs make sense for large volume production) it’s also easy to see that for small volumes and for hobbyists it’s much easier and cheaper to just reflash the firmware in the same cheap MCU rather than using an expensive in-circuit emulator. This is where the Puya PY32 comes into play, with parts ranging from 8 cents a pop (basic PY32F002A) to $0.74 for the more full-featured models on LCSC, and packages ranging from a miniscule DFN, to LQFP and hand soldering friendly SOIC. Continue reading “Puya PY32: The Cheapest Flash Microcontroller You Can Buy Is Actually An ARM Cortex-M0+” →

Hobnobbing With The Knob

February 15, 2023 by Al Williams 23 Comments

The scroll wheel might be the best thing that happened to the computer mouse since, well, the computer mouse. But sometimes you want something a little more tangible. For example, with a software-defined radio setup, it doesn’t feel right to scroll your mouse to change frequencies. That’s where [Wagiminator]’ USB knob would come in handy. Marrying a 3D printed case, some addressable LEDs, a rotary encoder, and a CH552E microcontroller, the knob appears to the host operating system as a normal USB keyboard. That means most programs can use it without any special drivers or software.

There’s honestly not much to the hardware. A custom PCB holds two WS2812’s, the tiny CPU, the encoder, and the USB plug. There are a few random discrete components, too, but not many. Everything you need is on the project page. The PCB layout, the software, the schematics, and the 3D print files. The code that does the main work is extremely simple. The USB code is a bit more complex (look in the include directory) but honestly, it isn’t as bad as most USB examples we’ve seen.

This project is ripe for hacking. The software is simple enough to modify easily. The 3D printed case wouldn’t be hard to spruce up or print in different colors. Following the example, this would make a reasonable core for a custom keyboard peripheral that used exotic keys instead of a rotary encoder.

Knobs can be simple or complex. If you want our take on the odd volume control, we used sonar.

Ploopy Builds Open Source RP2040-Powered Headphones And You Can Too!

February 15, 2023 by Dave Rowntree 16 Comments

We’ve seen many DIY headphones projects on these fair pages over the years, but not many that are quite as DIY as the Ploopy Headphones. What makes this project interesting is the sheer depth of the construction, with every single part being made from what we might call base materials. Materials such as 3D printer filament, foam and felt, and the usual metallic vitamins.

The electronics are fairly straightforward, with an RP2040 functioning as the USB audio interface and equalizer function. Audio samples are emitted as I²S into a PCM3050 24-bit stereo codec which generates a pair of differential output audio signals. These are then converted from differential to single-ended signals and passed on to the coil drivers. The coil drivers consist of no fewer than eight-paralleled opamps per channel. All of this is powered by the USB-C connection to the host computer. Whilst a kit of parts is available for this, you can make your own if you wish, as the full source (Altium designer needed for tweaks) is available on the Ploopy headphone GitHub.

Many DIY headphone builds would likely be using off-the-shelf speaker units, with large parts of the ear cups being taken from spare parts kits for commercial offerings. But not the Ploopy. The drivers are constructed from flex PCB coils with a standard TRRS jack on each side. Magnets for these coils to react against are held in a 3D-printed frame that is attached to the outer cover. The coils are aligned with a special jig and bonded to the ‘driver foam’ with some 3M VHB tape.

The ear cups are constructed with some 3D printed rings, foam pieces, and simple woven material. The resonator plates push into the inner side of the cup, and the assembly simply screws to the driver assembly. The incredibly detailed assembly wiki makes it look easy, but we reckon there are a few tricky steps in there to trip the unwary. The headband again consists of printed spring sections, some woven material, and foam with a few metallic vitamins thrown in. That makes it sounds simple, but it isn’t.

On the whole the build looks fantastic, but what does it sound like? The Ploopy team has tested them against a pair of Sennheiser HDRXX giving a broadly comparable response, but we’re no audio experts, and the proof, as always, is in the wearing. This project seems to be the ultimate in audio tweakability, with the punchy RP2040 capable of running six audio filters at the full 48 KHz, 16-bit audio, though, the PCM3050 is capable of more.

Want to build some headphones, but need a Bluetooth interface? We got you covered. Can 3D printed headphones ever compare to the big names? We’ll see.

Dungeons And Dragons Board Game From The 1980s Holds A TMS1100

February 12, 2023 by Matthew Carlson 10 Comments

Today is a little tour back to the early 1980s when Mattel released the DUNGEONS & DRAGONS Computer Labyrinth Game. [Cameron Kaiser] was dealing with a few boxes of old stuff when he came across the game. Luckily for us, he decided to do a complete teardown and a comprehensive review more than 40 years after it came out.

The game itself is pretty simple. You and a friend are characters on the board, navigating an eight-by-eight maze. As you move through the labyrinth, a microcontroller emits twelve audio cues telling you what you’ve run into (walls, doors, treasure, and so on). The eight buttons on the side allow you to hear the different tones to know what they mean, as we imagine even the most well-written manual might struggle to describe that. In addition, the pieces are diecast metal, which allows the game to detect where the pieces have been placed. Continue reading “Dungeons And Dragons Board Game From The 1980s Holds A TMS1100” →

MicroPython ESP32 IDE Makes Life Simpler

February 7, 2023 by Al Williams 49 Comments

In theory, using MicroPython on the ESP32 is easy — just flash an image and connect using a serial port. But that leaves a lot of things you still have to do. You need to move files between the two platforms. You’ll want to manage network configurations. You might want better editing and assistance, too. So there are a number of IDEs made to help you and one we recently noticed was MPY-Jama.

The IDE provides source code editing, of course. But it also allows you to do things like pull information about the network using a dashboard or connect to a WiFi network easily. You can even create your own AP with a simple interface.

Although the front part of the README mentions it is for Windows or Mac, if you scroll down you’ll find instructions for installing under Linux. The IDE is extensible using “Jama Funcs” and can handle the flashing operation from inside the IDE.

Of course, there is an IDE from Arduino (but not the Arduino IDE) that handles MicroPython. You can also find a rundown of several similar alternatives online. If you need some inspiration for a MicroPython project, perhaps you’d like to play a game?