That’ll Go Over Like A Cement Airplane

Most of us have made paper airplanes at one time or another, but rather than stopping at folded paper, [VirgileC] graduated to 3D printing them out of PLA. Then the obvious question is: can you cast one in cement? The answer is yes, you can, but note that the question was not: can a cement plane fly? The answer to that is no, it can’t.

Of course, you could use this to model things other than non-flying airplanes. The key is using alginate, a natural polymer derived from brown seaweed, to form the mold. The first step was to suspend the PLA model in a flowerpot with the holes blocked. Next, the flowerpot gets filled with alginate.

After a bit, you can remove the PLA from the molding material by cutting it and then reinserting it into the flower pot. However, you don’t want it to dry out completely as it tends to deform. With some vibration, you can fill the entire cavity with cement.

The next day, it was possible to destroy the alginate mold and recover the cement object inside. However, the cement will still be somewhat wet, so you’ll want to let the part dry further.

Usually, we see people print the mold directly using flexible filament. If you don’t like airplanes, maybe that’s a sign.

Soaring At Scale: Modular Airship Design

If you’re looking for an intriguing aerial project, [DilshoD] has you covered with his unique twist on modular airships. The project, which you can explore in detail here, revolves around a modular airship composed of individual spherical bodies filled with helium or hydrogen—or even a vacuum—arranged in a 3x3x6 grid. The result? A potentially more efficient airship design that could pave the way for lighter-than-air exploration and transport.

The innovative setup features flexible connecting tubes linking each sphere to a central gondola, ensuring stable expansion without compromising the airship’s integrity. What’s particularly interesting is [DilshoD]’s use of hybrid spheres: a vacuum shell surrounded by a gas-filled shell. This dual-shell approach adds buoyancy while reducing overall weight, possibly making the craft more maneuverable than traditional airships. By leveraging materials like latex used in radiosonde balloons, this design also promises accessibility for makers, hackers, and tinkerers.

Though this concept was originally submitted as a patent in Uzbekistan, it was unfortunately rejected. Nevertheless, [DilshoD] is keen to see the design find new life in the hands of Hackaday readers. Imagine the possibilities with a modular airship that can be tailored for specific applications. Interested in airships or modular designs? Check out some past Hackaday articles on DIY airships like this one, and dive into [DilshoD]’s full project here to see how you might bring this concept to the skies.

A Flip Digit Clock, Binary Style

Flip digit clocks are a prized piece of consumer electrical ephemera, providing as they do a digital display without significant electronics. Making your own flip digit display involves some drudgery in the production of all those flip cards, but how would it seem if the complexity was reduced? Go from base 10 to base 2 for example, and a binary flip digit display can be made from flip dot display parts. [Marcin Saj] has done just that, resulting in a timepiece that’s a few bits out of the ordinary.

Under the hood though it’s slightly more conventional, with the trusty ATmega328 and Arduino bootloader, whose software drives the dot electromagnets via a set of MOSFET drivers. It’s a nice project which if you want there’s a Kickstarter to buy one, but the files are also available from a GitHub repository if you’d like to have a go for yourself. Meanwhile you can see it in action in the video below the break.

We like this clock, as it’s different from the norm in Arduino clocks. It’s not however the first flip dot clock we’ve seen, this one has a full dot matrix display.

Continue reading “A Flip Digit Clock, Binary Style”

Mechanical Tool Changing 3D Printing Prototype

Tool changing 3D printers are hot. The idea is that instead of switching filament, you swap out hot ends or other tools. That isn’t a new idea. However, most tool changers are expensive. [Engineers Grow] has one that is simple and inexpensive, relying on the printer’s own motors and some clever mechanics.

The first step was to make a modified extruder that allowed the filament to load and unload. The first attempt didn’t work well, but that is the nice thing about 3D printing — it is easy to try again. There is only one extruder, which is good from the standpoint that you don’t need a control board with many outputs and you avoid the expense of multiple extruders.

Continue reading “Mechanical Tool Changing 3D Printing Prototype”

Art of 3D printer in the middle of printing a Hackaday Jolly Wrencher logo

3D Printering: Listen To Klipper

I recently wrote about using Klipper to drive my 3D printers, and one natural question is: Why use Klipper instead of Marlin? To some degree that’s like asking why write in one programming language instead of another. However, Klipper does offer some opportunities to extend the environment more easily. Klipper runs on a Linux host, so you can do all of the normal Linux things.

What if you wanted to create a custom G-code that would play a wave file on a speaker? That would let you have custom sounds for starting a print, aborting a print, or even finishing a print.

If you recall, I mentioned that the Klipper system is really two parts. Well, actually more than two parts, but two important parts at the core. Klipper is, technically, just the small software stub that runs on your 3D printer. It does almost nothing. The real work is in Klippy, which is mostly Python software that runs on a host computer like a Raspberry Pi or, in my case, an old laptop.

Because it is Python and quite modular, it is very simple to write your own extensions without having to major surgery or even fork Klipper. At least in theory. Most of the time, you wind up just writing G-code macros. That’s fine, but there are some limitations. This time, I’m going to show you how easy it can be using the sound player as an example.

Macros All the Way Down

Normally, you think of gcode as something like: G1 X50 Y50. Some of the newer codes don’t start with G, but they look similar. But with Klipper, G1, M205, and MeltdownExtruder are all legitimate tokens that could be “G-code.”

For example, suppose you wanted to implement a new command called G_PURGE to create a purge line (case doesn’t matter, by the way). That’s easy. You just need to put in your configuration file:

[gcode_macro g_purge]
gcode:
# do your purge code here

The only restriction is that numbers have to occur at the end of the name, if at all. You can create a macro called “Hackaday2024,” but you can’t create one called “Hackaday2024_Test.” At least, the documentation says so. We haven’t tried it.

There’s more to macros. You can add descriptions, for example. You can also override an existing macro and even call it from within your new macro. Suppose you want to do something special before and after a G28 homing command:

[gcode_macro g28]
description: Macro to do homing (no arguments)
rename_existing: g28_original
gcode:
M117 Homing...
g28_original
M117 Home done....

Continue reading “3D Printering: Listen To Klipper”

Running Game Boy Games On STM32 MCUs Is Peanuts

Using a STM32F429 Discovery board [Jan Zwiener] put together a Game Boy-compatible system called STM32Boy. It is based around the Peanut-GB Game Boy emulator core, which is a pretty nifty and fast single-header GB emulator library in C99. Considering that the average 32-bit MCU these days is significantly faster than the ~4 MHz  8-bit Sharp SM83 (Intel 8080/Zilog Z80 hybrid) in the original Game Boy it’s probably no surprise that the STM32F429 (up to 180 MHz) can emulate this 8-bit SoC just fine.

Since Peanut-GB is a library, the developer using it is expected to provide their own routines to read and write RAM and ROM and to handle errors. Optional are the line drawing, audio read/write and serial Tx/Rx functions, with the library providing reset and a host of other utility functions. Audio functionality is provided externally, such as using the provided MiniGB APU. Although fast, it comes with a range of caveats that limit compatibility and accuracy.

For STM32Boy, [Jan] uses the LCD screen that’s on the STM32 development board to render the screen on, along with a Game Boy skin. The LCD’s touch feature is then used for the controls, as can be elucidated from the main source file. Of note is that the target GB ROM is directly compiled into the firmware image rather than provided via an external SD card. This involves using the xxd tool to create a hex version of the ROM image that can be included. Not a bad way to get a PoC up and running, but we imagine that if you want to create a more usable GB-like system it should at least be able to play more than one game without having to reflash the MCU.

Recycling Tough Plastics Into Precursors With Some Smart Catalyst Chemistry

Plastics are unfortunately so cheap useful that they’ve ended up everywhere. They’re filling our landfills, polluting our rivers, and even infiltrating our food chain as microplastics. As much as we think of plastic as recyclable, too, that’s often not the case—while some plastics like PET (polyethylene terephthalate) are easily reused, others just aren’t.

Indeed, the world currently produces an immense amount of polyethylene and polypropylene waste. These materials are used for everything from plastic bags to milk jugs and for microwavable containers—and it’s all really hard to recycle. However, a team at UC Berkeley might have just figured out how to deal with this problem.

Continue reading “Recycling Tough Plastics Into Precursors With Some Smart Catalyst Chemistry”