Fusion For STM32: Development Board With Debugging And Programming Via WiFi

Clearly profiling itself as the Lamborghini or Ferrari of the STM32 development board world, MikroElektronika’s current (8th) revision of their Fusion development board was released last year with support for not only flashing but also debugging the attached STM32 MCU via the onboard WiFi module. The Serbian company’s pricing for the bare board without MCU modules or any other peripherals appears to be around 300 USD/Euro. Additional MCU boards cost between $28 – $60 each.

As the official product page explains, the board is combined with the CodeGrip software to manage the board either via USB-C (driver-free) – which also allows one to configure the WiFi option – and via WiFi. Peripheral boards are added via the 5 onboard MikroBUS expansion slots, either with existing boards, or custom MikroBUS boards. The power supply is also onboard, powered via USB, a barrel jack connector, or an external battery.

The use of WiFi to connect to the board would allow for it to be easily managed and debugged when it’s in a less convenient location than one’s desk, which would seem like a major boon.

Obviously it’s not a cheap board, and the MCU cards each cost about as much as a Nucleo or Discovery board from ST would cost, making it hard to justify purchasing it for anything but a professional environment. However, the tantalizing thing here is probably that so much of the design details are available, from the expansion bus to the pin-out and schematic of the MCU cards (STM32F767ZG version).

The MCU cards use the Hirose FX10A-168S-SV and FX10A-168P-SV(71) connectors, all readily available. This opens the possibility of developing compatible MCU cards. An MCU card template project can for example be found here.

A Hot Printer For Cool Selfies

Randomly buying some hackable gadgets just because they are cheap and seem potentially interesting for future projects is something that most of us can relate to. It also happened to [fruchti] when he bought five thermal printer modules without any specific purpose for them in mind. It was not until several years later that he put them to good use for his inverse thermal camera project.

The name perfectly summarizes the device’s function which is to convert images to heat instead of the other way around. To put it in a less cryptic manner, [fruchti] built a selfie camera that instantly prints out pictures on thermochromic paper. The project would have been easy to implement on a Raspberry Pi but instead, he chose a more minimalist approach by using an STM32 microcontroller. This involved some challenges because the MCU didn’t have enough RAM to store an entire frame and the camera module came without a FIFO buffer. To capture and store the image data [fruchti] applied a line-by-line dithering algorithm which is described in detail in his accompanying blog post while the corresponding code is available on GitHub. Even though the case was improvised from scrap PCB materials the finished device still looks great. In particular, the fuse holders that are being used to hold the paper roll make it almost steampunk.

Naturally, this is not the first time we have seen thermal printers being used for instant picture taking and it probably won’t be the last.

CPAP Firmware Hack Enables BiPAP Mode; Envisions Use As Temporary Ventilator

Operating under the idea that a Constant Positive Airway Pressure (CPAP) machine isn’t very far removed electrically or mechanically from a proper ventilator, [Trammell Hudson] has performed some fascinating research into how these widely available machines could be used as life support devices in an emergency situation. While the documentation makes it clear the project is a proof of concept and is absolutely not intended for human use in its current state, the findings so far are certainly very promising.

For the purposes of this research, [Trammell] has focused on the Airsense S10 which currently retails for around $600 USD. Normally the machine is used to treat sleep apnea and other disorders by providing a constant pressure on the lungs, but as this project shows, it’s also possible for the S10 to function in what’s known as Bi-level Positive Airway Pressure (BiPAP) mode. Essentially this means that the machine detects when the user is attempting to inhale, and increases the air pressure to support their natural breathing.

Reflashing the firmware on the S10 CPAP

Critically, this change is made entirely through modifications to the S10 firmware. No additional hardware is required, and outside of opening up the device to attach an STM32 programmer (a process which [Trammell] has carefully documented), there’s nothing mechanically that needs to be done to the machine for it to operate in this breathing support function. It seems at least some of the functionality was already included via hidden diagnostic menus which can be enabled through a firmware patch.

As many of these CPAP machines feature cellular data connections for monitoring and over-the-air updates, [Trammell] believes it should be possible for manufacturers to push out a similarly modified firmware on supported devices. Of course, the FDA would have to approve of something like that before the machines could actually be used as emergency, non-invasive ventilators. They would also need to have viral filters installed and some facility for remote control added, but those would be relatively minor modifications.

Learn more about the efforts being put into ventilators right now. Start with this excellent hardware overview called Ventilators 101 and then take a look at some of the issues with trying to build a ventilator from scratch.

Thunder Pack Is A Bolt Of Lightning For Wearables

Do you need portable power that packs a punch? Sure you do, especially if you want to light up the night by mummifying yourself with a ton of LED strips. You aren’t limited to that, of course, but it’s what we pictured when we read about [Jeremy]’s Thunder Pack. With four PWM channels at 2.3 A each, why not go nuts? [Jeremy] has already proven the Thunder Pack out by putting it through its paces all week at Burning Man.

Click to embiggen!

After a few iterations, [Jeremy] has landed on the STM32 microcontroller family and is currently working to upgrade to one with enough flash memory to run CircuitPython.

The original version was designed to run on a single 18650 cell, but [Jeremy] now has three boards that support similar but smaller rechargeable cells for projects that don’t need quite as much power.

We love how small and powerful this is, and the dongle hole is a great touch because it opens up options for building it into a wearable. [Jeremy] made a fantastic pinout diagram and has a ton of code examples in the repo. If you want to wade into the waters of wearables, let whimsical wearables wizard [Angela Sheehan] walk you through the waves.

Breaking Into A Secure Facility: STM32 Flash

In a perfect world, everything would be open source. Our current world, on the other hand, has a lot of malicious actors and people willing to exploit trade secrets if given the opportunity, so chip manufacturers take a lot of measures to protect their customers’ products’ firmware. These methods aren’t perfect, though, as [zapb] shows while taking a deeper look into an STM microcontroller.

The STM32F0 and F1 chips rely on various methods of protecting their firmware. The F0 has its debug interface permanently switched off, but the F1 still allows users access to this interface. It uses flash memory read-out protection instead, which has its own set of vulnerabilities. By generating exceptions and exploiting the intended functions of the chip during those exceptions, memory values can be read out of the processor despite the memory read-out protection.

This is a very detailed breakdown of this specific attack on theses controllers, but it isn’t “perfect”. It requires physical access to the debug interface, plus [zapb] was only able to extract about 94% of the internal memory. That being said, while it would be in STM’s best interests to fix the issue, it’s not the worst attack we’ve ever seen on a piece of hardware.

Open-Source ARM Development Simplified

The ARM series of processors are an industry standard of sorts for a vast array of applications. Virtually anything requiring good power or heat management, or any embedded system which needs more computing power than an 8-bit microcontroller is a place where an ARM is likely found. While they do appear in various personal computers and laptops, [Pieter] felt that their documentation for embedded processors wasn’t quite as straightforward as it could be and created this development board which will hopefully help newbies to ARM learn the environment more easily.

Called the PX-HER0, it’s an ARM development board with an STM32 at its core and a small screen built in. The real work went in to the documentation for this board, though. Since it’s supposed to be a way to become more proficient in the platform, [Pieter] has gone to great lengths to make sure that all the hardware, software, and documentation are easily accessible. It also comes with the Command Line Interpreter (CLI) App which allows a user to operate the device in a Unix-like environment. The Arduino IDE is also available for use with some PX-HER0-specific examples.

[Pieter] has been around before, too. The CLI is based on work he did previously which gave an Arduino a Unix-like shell as well. Moving that to the STM32 is a useful tool to have for this board, and as a bonus everything is open source and available on his site including the hardware schematics and code.

Bus Sniffing Leads To New Display For Vintage Casio

Despite his best efforts to repair the LCD on his Casio FX-702P, it soon became clear to [Andrew Menadue] that it was a dead-end. Rather than toss this relatively valuable device in the trash, he wondered if would be possible to replace the LCD with a more modern display. Knowing that reverse engineering the LCD panel itself would be quite a challenge, he decided instead to focus his efforts on decoding the communications between the calculator’s processor and display controller.

With his logic analyzer connected to the Casio’s four bit bus [Andrew] was able to capture a sequence of bytes during startup that looked promising, although it didn’t quite make sense at first. He had to reverse the order of each nibble, pair them back up into bytes, and then consult the FX-702P’s character map as the device doesn’t use ASCII. This allowed him to decode the message “READY”, and proved the concept was viable.

Of course a calculator with a logic analyzer permanently attached to it isn’t exactly ideal, so he started work on something a bit more compact. Armed with plenty of display controller data dumps, [Andrew] wrote some code for a STM32 “Blue Pill” ARM Cortex M3 microcontroller that would sniff and decode the data in near real-time. In the video after the break you can see there’s a slight delay between when he pushes a button and when the corresponding character comes up on the LCD below, but it’s certainly usable.

Unfortunately, the hardware he’s created for this hack is just slightly too large to fit inside the calculator proper. The new LCD is also nowhere near the size and shape that would be required to replace the original one. But none of that really matters. While [Andrew] says he could certainly make the electronics smaller, the goal was never to restore the calculator to like-new condition. Sometimes it’s more about the journey than the destination.

Continue reading “Bus Sniffing Leads To New Display For Vintage Casio”