38C3: Save Your Satellite With These Three Simple Tricks

December 30, 2024 by Elliot Williams 11 Comments

BEESAT-1 is a 1U cubesat launched in 2009 by the Technical University of Berlin. Like all good satellites, it has redundant computers onboard, so when the first one failed in 2011, it just switched over to the second. And when the backup failed in 2013, well, the satellite was “dead” — or rather sending back all zeroes. Until [PistonMiner] took a look at it, that is.

Getting the job done required debugging the firmware remotely — like 700 km remotely. Because it was sending back all zeroes, but sending back valid zeroes, that meant there was something wrong either in the data collection or the assembly of the telemetry frames. A quick experiment confirmed that the assembly routine fired off very infrequently, which was a parameter that’s modifiable in SRAM. Setting a shorter assembly time lead to success: valid telemetry frame.

Then comes the job of patching the bird in flight. [PistonMiner] pulled the flash down, and cobbled together a model of the satellite to practice with in the lab. And that’s when they discovered that the satellite doesn’t support software upload to flash, but does allow writing parameter words. The hack was an abuse of the fact that the original code was written in C++. Intercepting the vtables let them run their own commands without the flash read and write conflicting.

Of course, nothing is that easy. Bugs upon bugs, combined with the short communication window, made it even more challenging. And then there was the bizarre bit with the camera firing off after every flash dump because of a missing break in a case statement. But the camera never worked anyway, because the firmware didn’t get finished before launch.

Challenge accepted: [PistonMiner] got it working, and after fifteen years in space, and ten years of being “dead”, BEESAT-1 was taking photos again. What caused the initial problem? NAND flash memory needs to be cleared to zeroes before it’s written, and a bug in the code lead to a long pause between the two, during which a watchdog timeout fired and the satellite reset, blanking the flash.

This talk is absolutely fantastic, but may be of limited practical use unless you have a long-dormant satellite to play around with. We can nearly guarantee that after watching this talk, you will wish that you did. If so, the Orbital Index can help you get started.

Bringing OpenStreetMap Data Into Minecraft

December 30, 2024 by Tom Nardi 11 Comments

Over the years, dedicated gamers have created incredible recreations of real (and not so real) locations and structures within the confines of Minecraft. Thanks to their efforts, you can explore everything from New York city to Middle Earth and the U.S.S. Enterprise in 1:1: scale.

But what if you wanted to recreate your own town, and didn’t have the hundreds of hours of spare time necessary to do it by hand? Enter Arnis, an open source project from [Louis Erbkamm] that can pull in geographic data from OpenStreetMap and turn it into a highly detailed Minecraft map with just a few keystrokes.

The tool, written in Rust, can be either run via an interactive graphical interface or on the command line. In either case, you provide Arnis with the latitude and longitude for a bounding box around whatever you want to import into the game. [Louis] warns that the resulting process is fairly computationally heavy, so you should start be experimenting with small areas.

Once generated, the map can be loaded into the Java Edition of Minecraft. This refers to the original build of the game that predates the Microsoft buyout. Once Redmond took over they spearheaded a new version of the game written in C++ which was then ported over to mobile operating systems and game consoles. Long story short, if you want to wander around a Minecraft version of your home town, you’ll have to do it on your desktop computer instead of your Nintendo Switch.

While the tool is usable in its current state, [Louis] has a fairly long list of features that either still need to be implemented or could use some improvements. From the number of pull requests that have been merged in, it looks like any assistance the community can provide to make Arnis as capable as possible is welcome, so feel free to lend a hand if you’ve got that geospatial fever.

We’ve seen several examples of hackers bringing objects from Minecraft into the physical world, so it’s refreshing to see a bit of our reality sneaking into the game’s blocky universe.

Porting Dragon’s Lair To The Game Boy Color Was A Technical Triumph

December 28, 2024 by Donald Papp 5 Comments

If you remember the 80s arcade game Dragon’s Lair, you probably also remember it was strikingly unlike anything else at the time. It didn’t look or play like anything else. So it might come as a surprise that it was ported to Nintendo’s Game Boy Color, and that took some doing!

Dragon’s Lair used LaserDisc technology, and gameplay was a series of what we’d today call quick-time events (QTE). The player essentially navigated a series of brief video clips strung together by QTEs. Generally, if the player chose correctly the narrative would progress. If they chose poorly, well, that’s what extra lives (and a stack of quarters) were for.

More after the break!

Continue reading “Porting Dragon’s Lair To The Game Boy Color Was A Technical Triumph” →

When It Comes To DOS, Don’t Forget DR-DOS.

December 25, 2024 by Jenny List 44 Comments

Despite the latest and greatest Intel-derived computers having multi-core 64-bit processors and unimaginably fast peripherals, at heart they all still retain a compatibility that goes back to the original 8086. This means that they can, in theory at least, still run MS-DOS. The venerable Microsoft 16-bit OS may now be long discontinued, but there is still enough need for DOS that the open-source FreeDOS remains in active development. The Register are here to remind us that there’s another open-source DOS on the block, and that it has a surprising history.

SvarDOS is an open source DOS distribution, and it’s interesting because it uses a derivative of the DR-DOS kernel, an OS which traces its roots back to Digital Research’s CP/M operating system of the 1970s. This found its way briefly into the open source domain courtesy of the notorious Caldera Inc back in the 1990s, and has continued to receive some development effort ever since. As the Reg notes, it has something FreeDOS lacks, the ability to run Windows 3.1 should you ever feel the need. They take it for a spin in the linked article, should you be curious.

It’s something which has surprised us over the years, that aside from the world of retrocomputing we still occasionally find FreeDOS being distributed, usually alongside some kind of hardware maintenance software. Even four decades or more later, it’s still of value to have the simplest of PC operating systems to hand.

It’s worth pointing out that there’s a third open-source DOS in the wild, as back in April Microsoft released MS-DOS version 4 source code. But as anyone who used it will tell you, that version was hardly the pick of the bunch.

Header: Ivan Radic, CC BY 2.0.

Faster Integer Division With Floating Point

December 22, 2024 by Al Williams 24 Comments

Multiplication on a common microcontroller is easy. But division is much more difficult. Even with hardware assistance, a 32-bit division on a modern 64-bit x86 CPU can run between 9 and 15 cycles. Doing array processing with SIMD (single instruction multiple data) instructions like AVX or NEON often don’t offer division at all (although the RISC-V vector extensions do). However, many processors support floating point division. Does it make sense to use floating point division to replace simpler division? According to [Wojciech Mula] in a recent post, the answer is yes.

The plan is simple: cast the 8-bit numbers into 32-bit integers and then to floating point numbers. These can be divided in bulk via the SIMD instructions and then converted in reverse to the 8-bit result. You can find several code examples on GitHub.

Continue reading “Faster Integer Division With Floating Point” →

Custom Firmware For Even Cheaper Bluetooth Thermometers

December 21, 2024 by Tom Nardi 33 Comments

Readers may recall when we first covered the $5 Xiaomi LYWSD03MMC temperature and humidity sensor back in 2020. Prolific hacker [Aaron Christophel] wrote a custom firmware for the affordable gadget that was so capable and well implemented that it kicked off a whole new community.

It’s recently been brought to our attention that the Xiaomi thermometer has become so popular that clones have started popping up. Often sold under the Tuya brand, these versions look very similar to Xiaomi’s offering but can be had for as little as $1 each from the usual Chinese importers. Even better, they’ve got their very own open-source custom firmware.

The firmware comes from [pvvx], who also helms the most active fork of [Aaron]’s original firmware for the Xiaomi thermometer. Doing a bit of spot-checking between the repositories, it’s not immediately clear that any meaningful code is shared between the two projects. However, once installed, they offer similar capabilities to the user, such as integration with Home Assistant. Perhaps the most significant difference between the two projects is that, at least for the initial flash, you need to hook the Tuya units up to your computer with a USB serial adapter. Considering that one of the highlights of the Xiaomi custom firmware was its exceptionally easy wireless installation, this is a considerable step backward.

Below is a video from a few months back that [Maker’s Fun Duck] put together, where he takes apart one of these clones and shows the installation process for the custom firmware. Our overall impression is that it’s probably worth the few extra dollars to get the original Xiaomi hardware, although the display on the clone seems much brighter. In any event, we’re always happy to see the community coming up with free and open-source firmware for an otherwise locked-down gadget.

Continue reading “Custom Firmware For Even Cheaper Bluetooth Thermometers” →

Better C Strings, Simply

December 19, 2024 by Al Williams 62 Comments

If you program in C, strings are just in your imagination. What you really have is a character pointer, and we all agree that a string is every character from that point up until one of the characters is zero. While that’s simple and useful, it is also the source of many errors. For example, writing a 32-byte string to a 16-byte array or failing to terminal a string with a zero byte. [Thasso] has been experimenting with a different way to represent strings that is still fairly simple but helps keep things straight.

Like many other languages, this setup uses counted strings and string buffers. You can read and write to a string buffer, but strings are read-only. In either case, there is a length for the contents and, in the case of the buffer, a length for the entire buffer.

Continue reading “Better C Strings, Simply” →