Ghidra Used To Patch Fahrenheit Into An Air Quality Meter

February 15, 2021 by Maya Posch 73 Comments

Even though most of the world population couldn’t tell you what room or body temperature is in Fahrenheit, there are some places on this globe where this unit is still in common use. For people in those areas, it’s therefore a real hassle when, say, a cheap Chinese air quality measurement systems only reports in degrees Celsius. Fortunately, [BSilverEagle] managed to patch such a unit to make it display temperature in Fahrenheit.

The reverse engineering begins by finding a way to dump the firmware. It’s nice to hear that [BSilverEagle] used some the skills demonstrated in [Eric Shlaepfer’s] PCB reverse engineering workshop from Hackaday Remoticon last November to trace out the debug header and the SWD pins of STM32F103C8 MCU. After that, OpenOCD could be used to dump the firmware image, with no read protection encountered. The firmware was then reverse-engineered using Ghidra, so that [BSilverEagle] could figure out where the temperature was being calculated and where the glyph for the Celsius symbol was stored. From there this it was a straight-forward rewrite of those two parts of the original firmware to calculate the temperature value in Fahrenheit, change the glyph and reflash the MCU.

So why buy this thing in the first place if it didn’t spit out units useful for your current locale? Cost. Buying this consumer(ish) device was about the same cost as buying the individual parts, designing and manufacturing the PCB, and writing the firmware for it. The only downside for their use case was the lack of Fahrenheit. Not a problem for those who demand full control of the hardware they own.

Need a boot camp for using Ghidra? Matthew Alt put together a spectacular video series on Reverse Engineering with Ghidra.

FreeTouchDeck Upgrades Its Hardware And Its Name: ESP32 Touchdown

February 14, 2021 by Matthew Carlson 23 Comments

With many folks continuing to work from home for far longer than they ever thought, it’s no surprise that we’re seeing the rise of small DIY devices to make that video call or virtual presentation a little easier. [Dustin Watts] was interested in the functionality of the Elgato Stream Deck — a macro keyboard where each key is its own screen. But that kind of fancy hardware comes with a formidable price tag. So he built his own, and made it open source!

His first iteration — FreeTouchDeck — was built using commonly available modules but has since evolved into the ESP32 Touchdown which does it all with a single PCB. It’s a highly-customizable touchscreen macro keyboard which provide easy access shortcuts and macros for quick actions. Need a quick mute button, want to switch camera views on OBS, or maybe you want smarter shortcut keys for your CAD of choice. This will can get you there.

There a few key differences from the first version (FreeTouchDeck). The ESP32 dev board was ditched for a tidy PCB the directly integrates the module. This one has a capacitive touch controller (FT6236) rather than a resistive one as the capacitive screens deliver a far nicer user experience. A built-in battery and charger circuit (which the FreeTouchDesk didn’t have) allows for the extra bit of flexibility to stream from anywhere (within wireless range of course). Multiple case designs are available in STL form that allows it to be placed on a wall or desk with ease.

Datasheets, gerbers, kicad files, BOMs, and example firmware is provided on GitHub. The software is easily configurable so it can be set up to do any sort of macro, key combination, or action. This isn’t just limited to emulating a Bluetooth keyboard as there are examples showing how to connect to Home Assistant. All in all, this is a wonderful example of continued iteration on a project.

Thanks [Timothy Gregory] for sending this one in!

Bitbanged DVI On A Raspberry Pi RP2040 Microcontroller

February 12, 2021 by Jenny List 66 Comments

When we first saw the Raspberry Pi Pico and its RP2040 microcontroller last month it was obvious that to be more than just yet another ARM chip it needed something special, and that appeared to be present in the form of its onboard PIO peripherals. We were eagerly awaiting how the community might use them to push the RP2040 capabilities beyond their advertised limits. Now [Luke Wren] provides us with an example, as he pushes an RP2040 to produce a DVI signal suitable to drive an HDMI monitor.

It shouldn’t be a surprise that the chip can be overclocked, however it’s impressive to find that it can reach the 252 MHz necessary to generate the DVI timing. With appropriate terminations it proved possible for the GPIO lines to mimic the differential signalling required by the spec. A PCB with the RP2040 and an HDMI socket was created, also providing a couple of PMOD connectors for expansion. All code and software can be found in a GitHub repository.

The result is a usable DVI output which though it is a relatively low resolution 640×480 pixels at 60 Hz is still a major advance over the usual composite video provided by microcontroller projects. With composite support on monitors becoming a legacy item it’s a welcome sight to see an accessible path to an HDMI or DVI output without using an FPGA.

Thanks [BaldPower] for the tip.

Hands-On: The RISC-V ESP32-C3 Will Be Your New ESP8266

February 8, 2021 by Elliot Williams 78 Comments

We just got our hands on some engineering pre-samples of the ESP32-C3 chip and modules, and there’s a lot to like about this chip. The question is what should you compare this to; is it more an ESP32 or an ESP8266? The new “C3” variant has a single 160 MHz RISC-V core that out-performs the ESP8266, and at the same time includes most of the peripheral set of an ESP32. While RAM often ends up scarce on an ESP8266 with around 40 kB or so, the ESP32-C3 sports 400 kB of RAM, and manages to keep it all running while burning less power. Like the ESP32, it has Bluetooth LE 5.0 in addition to WiFi.

Espressif’s website says multiple times that it’s going to be “cost-effective”, which is secret code for cheap. Rumors are that there will be eight-pin ESP-O1 modules hitting the streets priced as low as $1. We usually require more pins, but if medium-sized ESP32-C3 modules are priced near the ESP8266-12-style modules, we can’t see any reason to buy the latter; for us it will literally be an ESP8266 killer.

On the other hand, it lacks the dual cores of the ESP32, and simply doesn’t have as many GPIO pins. If you’re a die-hard ESP32 abuser, you’ll doubtless find some features missing, like the ultra-low-power coprocessor or the DACs. But it does share a lot of the ESP32 standouts: the LEDC (PWM) peripheral and the unique parallel I2S come to mind. Moreover, it shares the ESP-IDF framework with the ESP32, so despite running on an entirely different CPU architecture, a lot of code will run without change on both chips just by tweaking the build environment with a one-liner.

One of these things is not like the other

If you were confused by the chip’s name, like we were, a week or so playing with the new chip will make it all clear. The ESP32-C3 is a lot more like a reduced version of the ESP32 than it is like an improvement over the ESP8266, even though it’s probably destined to play the latter role in our projects. If you count in the new ESP32-S3 that brings in USB, the ESP32 family is bigger than just one chip. Although it does seem odd to lump the RISC-V and Tensilica CPUs together, at the end of the day it’s the peripherals more than the CPUs that differentiate microcontrollers, and on that front the C3 is firmly in the ESP32 family.

Our takeaway: the ESP32-C3 is going to replace the ESP8266 in our projects, but it won’t replace the ESP32 which simply has more of everything when we need it. The shared codebase and peripheral architecture makes it easier to switch between the two when we don’t need the full-blown ESP32. In that spirit, we welcome the newcomer to the family.

But naturally, we’ve got a lot more to say about it. Specifically, we were interested in exactly what the RISC-V core brought to the table, and ran the module through power and speed comparisons with the ESP32 and ESP8266 — and it beats them both by a small margin in our benchmarks. We’ve also become a lot closer friends with the ESP-IDF SDK that all of the ESP32 family chips use, and love how far it has come in the last year or so. It’s not as newbie-friendly as ESP-Arduino, for sure, but it’s a ton more powerful, and we’re totally happy to leave the ESP8266 SDK behind us.

Continue reading “Hands-On: The RISC-V ESP32-C3 Will Be Your New ESP8266” →

The Right Tools For The Job

February 6, 2021 by Elliot Williams 16 Comments

We’re knee-deep in new microcontrollers over here, from the new Raspberry Pi Pico to an engineering sample from Espressif that’s right now on our desk. (Spoiler alert, review coming out Monday.) And microcontroller peripherals are a little bit like Pokemon — you’ve just got to catch them all. If a microcontroller doesn’t have 23 UARTS, WiFi, Bluetooth, IR/DA, and a 16-channel 48 MHz ADC, it’s hardly worth considering. More is always better, right?

No, it’s not. Chip design is always a compromise, and who says you’re limited to one microcontroller per project anyway? [Francesco] built a gas-meter reader that reminded to think outside of the single-microcontroller design paradigm. It uses an ATtiny13 for its low power sleep mode, ease of wakeup, and decent ADCs. Pairing this with an ESP8266 that’s turned off except when the ATtiny wants to send data to the network results in a lower power budget than would be achievable with the ESP alone, but still gets his data up into his home-grown cloud.

Of course, there’s more complexity here than a single-micro solution, but the I2C lines between the two chips actually form a natural division of work — each unit can be tested separately. And it’s using each chip for what it’s best at: simple, low-power tasks for the Tiny and wrangling WiFi on the ESP.

Once you’ve moved past the “more is better” mindset, you’ll start to make a mental map of which chips are best for what. The obvious next step is combination designs like this one.

Open-Source Thermostat Won’t Anger Your Landlord

February 6, 2021 by Anool Mahidharia 51 Comments

[Nathan Petersen] built a Hackable Open-Source Thermostat to smooth out temperature fluctuations caused by the large hysteresis of the bimetallic strip thermostat in his apartment. While it may be tempting to adjust the “anticipator” to take care of the problem or even replace the bimetallic thermostat with an electronic version, building your own thermostat from scratch is a good way to add to your project portfolio while making your way through college. Plus, he got to hone his hardware and software design chops.

The hardware is designed around the STM32, using a cheap, minimal variant since the device just needs to sense temperature and control the furnace in on-off mode. The TMP117 high-accuracy, low-power, temperature sensor was selected for temperature measurement since accuracy was an essential feature of the project. Dry-contact output for the furnace is via a normally-open solid state relay (opto-isolator). For the user interface, instead of going the easy-route and using an I²C/SPI OLED or LCD display, [Nathan] used three 7-segment LED displays, each driven by an 8-channel constant current driver. The advantage is that the display can be viewed from across the room, and it’s brightness adjusted via PWM. Temperature set-point adjustment is via a simple slide potentiometer, whose analog voltage is read by the micro-controller ADC. To remind about battery replacement, a second ADC channel on the micro-controller monitors the battery voltage via a voltage divider. The PCB components are mostly surface mount, but the packages selected are easy enough to hand solder.

[Nathan]’s Github repo provides the hardware and firmware source files. The board is designed in Altium, but folks using KiCad can use either the awesome Altium2KiCad converter or the online service for conversion. (The results, with some minor errors that can be easily fixed, are quite usable.) Serendipitously, his PCB layout worked like a charm the first time around, without requiring any rework or bodge wires.

The firmware is a few hundred lines of custom bare-metal C code, consisting of drivers to interface with the hardware peripherals, a UI section to handle the user interface, and the control section with the algorithm for running the furnace. [Nathan] walks us through his code, digging into some control theory and filtering basics. After making a few code tweaks and running the thermostat for some time, [Nathan] concludes that it is able to achieve +0.1°F / -0.5°F temperature regulation with furnace cycles lasting about 10-15 minutes (i.e. 4-6 cycles per hour). Obviously, his well insulated apartment and a decent furnace are also major contributing factors. Moving on, for the next version, [Nathan] wants to add data collection capabilities by adding some memory and SD card storage, and use an RTC to allow seasonal adjustments or time-based set-points.

This is his first attempt at a “functional’ useful project, but he does love to build the occasional toy, such as this POV Top.

Youngster’s ESP32 Jukebox Uses RFID To Queue Tunes

February 2, 2021 by Tom Nardi 14 Comments

Though kids today have an incredible knack for figuring out modern phones and tablets, there’s still something to be said for offering a simple physical user interface for little hands. To that end, [Martin Hierholzer] has put together a whimsical jukebox that his two year old daughter can use to listen to her favorite songs. With just a few simple buttons, no display to read, and the ability to stop and start songs using RFID tags embedded into 3D printed figures, it’s a perfect interface for tiny humans just getting the hang of interacting with technology.

While the Raspberry Pi might have been the more obvious choice to base this project around, [Martin] decided to go the ESP32 route for improved energy efficiency. The popular microcontroller is more than powerful enough to play MP3s, and its integrated WiFi connectivity allows the player to download new tracks from the network occasionally. He added a micro SD slot to provide some mass storage, a PCM5102 I2S DAC with a PAM8403 amplifier to handle the audio side of things, and a MFRC522 RFID receiver that can pick up tags placed on the top of the player. Power is provided by parts salvaged from a USB battery bank, and everything is housed on a custom PCB.

The relatively low power requirements of the ESP32 means the jukebox can keep the party going for many hours (perhaps even days) when in active use. When the RFID token is removed and there are no songs to play, some clever coding kicks the chip into low-power mode to greatly extend the player’s standby time. [Martin] says it can sleep for months without having to be recharged, and considering some of the impressive feats of battery-sipping we’ve previously seen from the ESP32, we don’t doubt it.

Even if you don’t have any young music lovers at home, the documentation [Martin] has put together for this project is absolutely worth a look. Whether its how he configures the server side to push songs and firmware updates to the player, how he wrangled the ESP32’s Ultra-Low Power coprocessor (ULP), or the woodworking tips used to produce the charming enclosure, you’re sure to pick up a trick or two.

The children of hackers and makers always seem to get the coolest stuff, and we’re looking forward to seeing what [Martin] comes up with next. After all, kids grow up fast and pretty soon his daughter is going to need something new to entertain her.