Microcontrollers

2276 Articles

Beverage Coaster Indicates Ideal Drinking Temperature

March 8, 2024 by 9 Comments

When temperatures plummet, there’s nothing like a hot beverage to keep you warmed up inside. [Palingenesis] aka [Tim] sure does fancy a nice cuppa, but only within a certain temperature range is it ideal to drink. In an attempt to signal when the time is just right, he created various iterations of a hot beverage coaster.

To be clear, this is a plywood sandwich that does not keep the beverage warm, though that would be an interesting addition to the project. Rather, it indicates when the beverage’s temperature is just right using LEDs. When it’s too hot, the red LEDs are lit. The green LEDs flash while it’s just right, and once [Tim]’s tea has gone cold, the blue LEDs take center stage.

The brains of the operation is an STM8S103F module, aka the Blue Pill, which is paired with a DS18B20 temperature sensor. [Tim]’s original coaster has one in a TO-92 package embedded in the top layer, but ultimately he went with the probe version as it reads a truer temperature by virtue of being directly in the liquid. Be sure to check out the video after the break which covers planning the original version.

If you do want to keep you drink warm, here’s an ESP8266-based solution. If you’re more into looks, check out this blinkencoaster.

Continue reading “Beverage Coaster Indicates Ideal Drinking Temperature” →

A graph from the article, showing dead zones and error bars for the ESP32 ADC

RP2040, ESP32, And An Atmega Have An ADC-Off

March 7, 2024 by 31 Comments

[Simon Monk] got frustrated with bad ADC performance when tinkering with an ESP32 board, and decided to put three of the nowadays-iconic boards to the test – a classic ESP32 devboard, a Pi Pico with an RP2040, and an Arduino Uno R3 with an ATmega328P. To do that, he took a bench PSU, added a filter circuit to it, went through the entire ADC range for each board, took a large number of samples at different points and plotted the results. The plots show us both linearity and precision, as well as ADC dead zones, and the results are quite surprising.

The ESP32 doesn’t only have the most limited ADC with maximum 1V input, it also produces the worst results out of all three, with large error bars and sizeable dead zones at both ends. The Pi Pico, despite being colloquially known for its subpar ADC, produces better results than the ESP32. However, both of them are dwarfed by the ATMega328P’s performance. If you need a dedicated ADC, it might just be a good idea to put an ATMega328P on your board.

The example code is provided, and we are wondering whether there are methodology errors. For instance, the ATMega328P code is written in Arduino-supplied C++, but ESP32 and RP2040 in particular used MicroPython, which does more than just running the code, and MicroPython for ESP32 in particular creates a WiFi access point – something known to induce noise into ADC readings. Nevertheless, this is a fun comparison, and we like when hackers do microcontroller standoffs like that – for instance, check out this review from 2017 which pits a dozen microcontrollers of the time against each other!

Automated System Keeps Camper Van Air Fresh And Warm

March 6, 2024 by 22 Comments

Air quality has become a hot topic in recent years. [Ryan Stout] was interested in improving it in his camper van, and set about doing something about it. His solution was an automated system that provided cleaner air and better comfort to boot.

The concept was simple. [Ryan]’s system is based on an Arduino clone, and uses a SparkFun SCD40 as a CO2 sensor, and an MCP9808 for temperature. When the system detects excess carbon dioxide levels, it opens the MaxxAir fan in the camper by triggering it with an infrared signal. Similarly, when it detects excessively low temperatures inside the van, it kicks on a diesel furnace for heating. In a neat addition, to avoid the fan sucking in exhaust fumes, it also closes the fan in order to avoid exhaust fumes entering the camper unnecessarily. All the hardware was then  wrapped up in a simple 3D printed enclosure.

With this setup, [Ryan] has managed to cut the buildup of CO2 in his camper at night, and he credits this with reducing morning headaches when he’s out in the camper. We’d call that a win, to say nothing of the additional comfort created by the automatically-controlled heater! If you’re interested in something similar for your home HVAC system, we’ve got you covered.

a CH32V003 Linux-bearing PCB, single-sided, hand-etched, lovely

Bring Linux To CH32V003 Through, Yes, RISC-V Emulation

March 3, 2024 by 14 Comments

Like playing around with Linux on low-power devices? You’d be hard pressed to find a better example than the [tvlad1234]’s linux-ch32v003 project. It’s not just a one-off — it’s something you could build right now, since it requires hardly any extra parts.

With help of a 8 MB PSRAM chip for RAM supplementation purposes and an SD card, plus some careful tailoring of the Linux .config parameters, you get Linux on a chip never meant to even come close to handling this much power. The five minutes it takes to boot up to a prompt is part of the experience.

As usual with [tvlad1234]’s projects, there’s a fun twist to it! Running Linux on this chip is only possible thanks to [chlohr]’s mini-rv32ima project, which, as you might remember, is a RISC-V emulator. Yes, this runs Linux by running a RISC-V emulator on a RISC-V chip. The main reason for that is because the MCU can’t map the PSRAM chip into RAM, but if you use an emulator, memory mapping is only a matter of software. Having applied a fair amount of elbow grease, [tvlad1234] brings us buildroot and mainline Linux kernel configs you can compile to play with this — as well as a single-layer-ready KiCad board project on GitHub. Yep, you could literally etch a PCB for this project from single-sided copper-clad FR4 with a bit of FeCl3.

While the CH32V003 is undoubtedly a more impressive target for Linux, the RP2040 Linux project might be more approachable in terms of having most of the parts in your parts box. At least, up until we start valuing the CH32V003 for all the cool stuff it can do!

Sometimes It’s The Little Things

March 2, 2024 by 16 Comments

I had one of those why-didn’t-I-think-of-it moments this week, reading this article about multiplexing I2C on the ESP32 microcontroller. The idea is so good, and so simple, that it’s almost silly that it’s not standard hacker practice. And above all, it actually helps solve a problem that I’ve got. This is why I read Hackaday every day.

I2C is great in that it lets you connect up multiple devices to a pair of wires using a very bus architecture. Every device has its own address, the host calls them out, and hopefully all other devices keep quiet while just the right one responds. But what happens when you want to use a few of the same sensors, where each IC has the same address? The usual solution is to buy a multiplexer chip.

But many modern microcontrollers, like the ESP32, have an internal multiplexer setup that lets you map the pins with the dedicated hardware peripherals, usually at initialization time. Indeed, I’ve been doing it as an “init” task so long, I never thought to do it otherwise. But that’s exactly the idea behind [BastelBaus]’s hack – if you dynamically reassign the pins, you can do the I2C multiplexing with the chip you’ve got. This should probably work for any other chips that have multiple assignable pins for hardware peripherals as well.

Cool idea, but really simple. Why hadn’t I ever thought of it? I think it’s because I’ve always had this init / mainloop schema in my mind, which for instance the Arduino inherited and formalized in its setup() and loop() functions. Pin mappings go in the init section, right?

So what this hack really amounts to, for me, is a rethinking of what’s static and what’s dynamic. It’s always worth questioning your assumptions, especially when you’re facing a problem that requires a creative solution. Sometimes limitations are only in your mind. Have you had your mind opened recently by a tiny little hack?

This article is part of the Hackaday.com newsletter, delivered every seven days for each of the last 200+ weeks. It also includes our favorite articles from the last seven days that you can see on the web version of the newsletter. Want this type of article to hit your inbox every Friday morning? You should sign up!
A breadboard showing a tiny ESP32 board and two HMC5883L sensors connected to it on different pins

Avoid I2C Address Conflicts On ESP32 By Pin Muxing

February 28, 2024 by 20 Comments

Using hardware I2C on an ESP32? Do you need to connect multiple I2C devices with the same address? Normally, you wouldn’t be able to do that without extra parts, but on the ESP32, [BastelBaus] has found a nice hack — just connect your devices to different pins and slightly abuse the ESP32 GPIO muxing, no extra hardware required!

Initially, they tried separating SDA and SCL completely, and after a bit of tinkering, that’s worked out wonders! For this method, [BastelBaus] provides example Arduino code you could easily integrate into your project, and shows logic analyzer captures that demonstrate there’s barely any overhead. Later, they’ve also found out that you could multiplex only one of the pins, specifically, SDA, having the SCL line be common! As far as we see, this could also work out with split SCL, but do let us know if that doesn’t sound right.

Typically, such a problem is solved with an I2C multiplexer, and we’ve highlighted projects with them before. However, this simple method could also work on chips like the RP2040 or even the Raspberry Pi 4 — just a bit more limited, since the GPIO muxing for I2C has less available ports! Also, if you’re not using a chip with such a comfortable GPIO mux and you must use devices with overlapping addresses, check out the comment section under our I2C ecosystem article – there’s a fair few other methods you can use. And, if this method ever malfunctions for you, there’s a bunch of very straightforward ways you could debug your bus!

ESP32 Weather Station Looks Great With Color E-Paper Display

February 28, 2024 by 20 Comments

[educ8s.tv] has built weather stations before, but his latest is his best yet. It’s all thanks to its low-power design, enabled by its e-paper display.

The build is based around an ESP32 microcontroller, combined with a BMP180 sensor for measuring barometric pressure, and a DHT22 sensor for measuring temperature and humidity. By taking these values and feeding them into the Zambretti algorithm, it’s possible to generate a rudimentary weather forecast.

The weather station looks particularly impressive thanks to its six-color e-paper display. It’s brightly colored and easy to read, and displays graphs of temperature, pressure, and humidity over time. Plus, by virtue of the fact that it only draws power when updating, it allows the project to last a long time running solely on battery power.

As far as DIY weather stations go, this is an attractive and clean design that offers plenty of useful data to the user. We’ve seen some other neat builds in this vein before, too.

Continue reading “ESP32 Weather Station Looks Great With Color E-Paper Display” →