Microcontrollers

2389 Articles

Laser Your Way Into Debug Mode On The RP2350

September 19, 2026 by 18 Comments

The RP2350 is actually a pretty secure chip, all things considered. It has secure boot, ARMv8’s TrustZone to split secure and non-secure execution, and you can permanently disable debug — the Pi Foundation even included glitch detection, meaning the traditional ‘zap the chip until it obeys’ technique is blocked. That’s why the [Ledger Donjon] security team went full Bond Villain and strapped everyone’s favourite fruit-flavoured microcontroller to a table with a slowly-approaching laser beam.

Continue reading “Laser Your Way Into Debug Mode On The RP2350” →

On Chip Debug For (Some) MicroPython

September 18, 2026 by 8 Comments

If you’ve used MicroPython much, you know that debugging usually amounts to printing a few things out, trying your code out, and then repeating. But [ghi-electronics] wants you to have full on-chip source-code debugging in Visual Studio. You don’t need anything special to use it — just a supported MicroPython host and the same USB cable you program with now.

The downside is that you either have to build a custom MicroPython image and flash it or use one that they include. They support several Raspberry Pi Pico versions and ESP32 chips, as well. However, at least one “odd” Pico we had lying around wouldn’t take the firmware. A stock one did, and it worked as you would expect. A little more investigation showed the odd Pico (an RP2040 GEEK) probably did take the firmware; it just produced an error during setup. There is a known problem with Linux and the ESP32-S3 having similar behavior.

Continue reading “On Chip Debug For (Some) MicroPython” →

Brain Control Your Appliance, Sort Of

September 18, 2026 by 4 Comments

We aren’t sure we subscribe to [Upside Down Labs] description that their Neuro PlayGround Lite (NPG Lite) actually constitutes brain control in the science fiction sense. However, the package can sense biopotentials, and that lets you do things like change TV channels with a blink of the eye or a muscle gesture. That’s the gist of their project example on Instructables.

Since the NPG has an ESP32 onboard, it isn’t hard to see that coupling it to an IR transceiver would be all you need to control anything with an IR remote. The real problem is reading things like eye blinks.

The simplest way to think of the Neuro PlayGround Lite is as a 3-channel instrumentation amplifier + ADC + ESP32-C6 radio, packaged for measuring very small biological voltages. The same hardware can be used for EEG, EMG, ECG, or EOG, depending mainly on where you put the electrodes and how you filter/process the resulting signal.

It is true that you can measure EEG, so maybe it is brain control if you can learn to control your EEG output. EMC for muscles or EOG for blinking is probably somewhat more practical.

The instrumentation amplifier is where the main value is. You probably can’t just hook biosensors up to an ESP-32 analog input. The software, too, does a lot of heavy lifting for signal processing. Once you have reliable indicators that an eye or muscle moved, the rest is pretty simple.

For us, we don’t want to glue sensors to our body every time we want to watch a cat video. But we know there are legitimate reasons you might want this type of interaction, and this is as good a way to dip your toe into user interfaces that use biosignals.

We’ve seen this type of tech — strangely — used to order drinks. Not to mention games.

A 3D Rasterizer For Embedded Devices

September 16, 2026 by 22 Comments

Once upon a time, doing graphics on a microcontroller was challenging, to say nothing of the concept of going into three dimensions. But modern microcontrollers are far more powerful, and you might find yourself wanting to do all sorts of graphical wizardry with one. To that end, you might find Jet useful.

Created by [CubeCoders], Jet is a compact 3D rasterizer built for modern chips like the ESP32 and STM32. It’s dependency free, relatively tiny, and is written in C++17 with an eye towards working well on memory-limited platforms. It runs entirely in software, uses only integer arithmetic, and is built around 16-bit RGB565 color — intended to make it easy to use with parts like the ST7796, ILI9488, and other similar displays interfaced via SPI.

As a point of reference, on a ESP32-S3 Jet can render around 650 on-screen triangles (post-culling) at 60 frames per second on a 480×320 display, or 1300 triangles at 30 FPS. The developers note that 3D performance lands somewhere between the Sega 32X and Sega Saturn — not bad for a microcontroller you can buy for under $20. The Wipeout-like demo shows off the capabilities of Jet rather fantastically, we think.

You’d be foolish to expect your next microcontroller project to render Crysis. However, if you want some retro 3D graphics for your next ESP32-based build, you might just consider exploring what Jet can do for you.

Continue reading “A 3D Rasterizer For Embedded Devices” →

Running Linux 6.11 On The ESP32-S3 With A Few Tweaks

September 15, 2026 by 16 Comments

With the Xtensa Lx7 twin CPU cores in the ESP32-S3 running at a relatively zippy 240 MHz and accompanying PSRAM of up to 16 MB, you might find yourself wondering whether it could run Linux. As [Paulneja] demonstrates with Linux kernel 6.11, the answer is a ‘yes’, though with the usual caveats.

What complicates matters with the ESP32-S3 is that it lacks certain amenities that spoiled OSes like Linux have come to take for granted, such as a Memory Management Unit (MMU). To deal with this, the NOMMU Linux configuration was used, along with a custom fork() implementation. Although the previous 0.7 version sort-of worked, the current 0.8 release is the first that manages to actually boot reliably and has a usable amount of RAM available after boot.

You can see the comparison between the two versions in the header image, with v0.8 having a blistering 3.7 MB available after booting and with overall resource usage and performance having improved massively. Note that only one core is available to Linux, with the other used by the typical FreeRTOS ESP-IDF stack to provide WiFi and Bluetooth.

This was all run on an ESP32-S3 with the N16R8 configuration, meaning 16 MB Flash that’s also used for writable storage and 8 MB of octal PSRAM. As for practical applications, it’s noted by [Paulneja] that this is a research project, though one could imagine this being an embedded Linux project along the lines of a network router running something like BusyBox.

CircuitPython Goes Turbo With Precompiled Functions

September 14, 2026 by 18 Comments

It would not be at all original to declare that Python is the new BASIC. Like BASIC, it has been the first programming language for a whole generation of coders, and its main advantage is that it’s quick and easy to write in. Like BASIC it is an interpreted language, and thus rather slow to execute.

Thus while CircuitPython can be very useful for beginners and quick projects, it hits the limitations of the hardware far sooner than it needs to — unless you can pre-compile critical parts of the code, which you now can, thanks to CircuitPython Turbo by [Mikey Sklar] with some help from Anthropic’s Claude LLM.

Now if that sounds a lot like MicroPython’s ‘Viper’ and machine-code compiler, that’s because it is. CircuitPython is a fork of MicroPython with some handy extras on Adafruit boards, but Viper wasn’t one of them until now. Before the Turbo version, CircuitPython only ran in interpreted mode.

Like MicroPython, using CircuitPython Turbo you can flag sections to run as ‘native’, where instructions are compiled but values stay as python objects, which gets you about a 3X speedup. A little more rewriting to declare your variables and pointers and you can use ‘viper’ mode, which can — depending on what you’re up to — result in a 20x to 70x speedup. In Adafruit’s documentation, they demonstrate a Metro RP2040 calculating the Mandelbrot set 3x faster in Native and 19.7 times faster with Viper than normal Python bytecode.

The one thing that we miss from BASIC that CircuitPython Turbo doesn’t give is inline assembly– though interestingly enough, that is in the upstream MicroPython implementation, so perhaps its day will come here too. Not every job is suited to the use of Python on microcontrollers, but we’ve seen it used for everything from e-bikes to a Winamp-inspired music player.

Lara Croft On A Microcontroller

September 10, 2026 by 16 Comments

Once upon a time, you had to carefully budget your microcontroller’s resources if you wanted to do something as simple as flash a bunch of LEDs. These days, they’re powerful enough to humiliate the game consoles of yesteryear. [alexkid77] demonstrates this well, having the ESP32-P4 run Tomb Raider.

Now, [alexkid77] hasn’t gone so far as to create a PlayStation emulator on the ESP32 or anything quite like that. Instead, this is a port—and not of the original Tomb Raider release, either. [alexkid77] started with OpenLara—the classic game running in an open-source engine. With the ESP32-P4 having two cores running at 400 MHz each, there was plenty of processing power on tap to run the engine with a software renderer at 320×240, which is hardware scaled up to 1024×600 via the Pixel Processing Accelerator (PPA) built into the chip. There’s also stereo audio with an ES8311 codec hooked up, while input is via a USB HID keyboard.

It’s funny to think that it could actually be cheaper and quicker to get Tomb Raider running on an ESP32 and a cheap LCD display versus actually going out to buy a PlayStation and an original game disc. But that’s the way the cookie crumbles in 2026. At least you don’t have to play it on an S3 Verge. Continue reading “Lara Croft On A Microcontroller” →