TechyMagThings

Space may truly be the final frontier, but maybe that frontier can be closer than you thought. Pictures of nebulae and planets bring the colorful sights of deep space right to your screen. You may even have models of some of the rockets used for those missions on a shelf. However, did you know that you could even have a model of those nebulae or planetary surfaces from [NASA]?

While we have covered some distributed models from [NASA] here before, the catalog has expanded far past what 2016 had in store. Additionally, the catalog has been sorted into a more user-friendly, filterable interface than a simple GitHub repository. Most models even have a description attached, giving some basic background information on what the Crab Nebula is, for example.

There could always be more; there don’t appear to be many models of the space shuttle or some other expected files, but what is there is incredible. Some non-3D model files can also be found from star maps to full planetary maps.

While this file repository is cool and all, it’s not all [NASA] does. When not sending rockets deep into space for cool pictures, [NASA] has to make sure the Moon doesn’t explode. Was that a possibility at some point? Of course it has been!

Some projects take great care to tuck away wire hookups, but not [Roberto Alsina]’s Reloj V2 clock. This desktop clock makes a point of exposing all components and wiring as part of its aesthetic. There are no hidden elements, everything that makes it work is open to view. Well, almost.

The exception is the four MAX7219 LED matrices whose faces are hidden behind a featureless red panel, and for good reason. As soon as the clock powers up, the LEDs shine through the thin red plastic in a clean glow that complements the rest of the clock nicely.

[Roberto]’s first version was a unit that worked similarly, but sealed everything away in a wedge-shaped enclosure that was just a little too sterile, featureless, and ugly for his liking. Hence this new version that takes the opposite approach. Clocks have long showcased their inner workings, and electronic clocks — like this circuit-sculpture design — are no exception.

The only components, besides the Raspberry Pi Zero W and the LED matrices, are the 3D-printed enclosure with a few hex screws and double-sided tape. Design files and code (including the FreeCAD project file) are available should you want to put your own spin on [Roberto]’s design.

With ever increasing sizes of various programs (video games being notorious for this), the question of size optimization comes up more and more often. [Nathan Otterness] shows us how it’s done by minifying a Linux “Hello, World!” program to the extreme.

A naive attempt at a minimal hello world in C might land you somewhere about 12-15Kb, but [Nathan] can do much better. He starts by writing everything in assembly, using Linux system calls. This initial version without optimization is 383 bytes. The first major thing to go is the section headers; they are not needed to actually run the program. Now he’s down to 173 bytes. And this is without any shenanigans!

The first shenanigans are extreme code size optimizations: by selecting instructions carefully (and in a way a C compiler never would), he shaves another 16 bytes off. But the real shenanigans begin when he starts looking for spaces in the ELF header that he can clobber while the program is still accepted by Linux: now he can move his already tiny x86_64 code into these “vacant” spaces in the ELF and program headers for a final tiny ELF file weighing in at just 120 bytes.

P.S.: We know it is possible to make this smaller, but leave this as an exercise to the viewer.

It’s likely that Hackaday has a readership with the highest percentage of oscilloscope ownership among any in the world, and we’re guessing that most of you who fit in that bracket have a modern digital instrument on your bench. It’s a computer with a very fancy analogue front end, and the traces are displayed in software. Before those were a thing though, a ‘scope was an all-analogue affair, with a vacuum-tube CRT showing the waveform in real time. [Joshua Coleman] has made one of these CRT ‘scopes from scratch, and we rather like it.

Using a vintage two inch round tube, it includes all the relevant power supplies and input amplifiers for the deflection plates. It doesn’t include the triggers and timebase circuitry you’d expect from a desktop instrument though, so unless you add a sawtooth on its X input it’s only good for some Lissajous figures. But that’s not the point of a project like this one, because it’s likely even the cheapest of modern ‘scopes way exceeds any capabilities it would have even if it were fully formed. It’s a talking point and an attractive demonstration of a bit of early-20th-century physics, which probably many of us would appreciate if it were ours.

A video of the device is below the break, meanwhile we’ve taken a look in the past at the prehistory of the oscilloscope.

Have you ever wanted to see the computers behind the first (and for now only) man-made objects to leave the heliosphere? [Gary Friedman] shows us, with an archived tour of JPL building 230 in the ’80s.

A NASA employee picks up a camcorder and decides to record a tour of the place “before they replace it all with mainframes”. They show us computers that would seem prehistoric compared to anything modern; early Univac and IBM machines whose power is outmatched today by even an ESP32, yet made the Voyager program possible all the way back in 1977. There are countless peripherals to see, from punch card writers to Univac debug panels where you can see the registers, and from impressive cabinets full of computing hardware to the zip-tied hacks “attaching” a small box they call the “NIU”, dangling off the inner wall of the cabinet. And don’t forget the tape drives that are as tall as a refrigerator!

We could go on ad nauseum, nerding out about the computing history, but why don’t you see it for yourself in the video after the break?

Thanks to [Michael] for the tip!

We haven’t seen an instrument panel quite like [bluesyann]’s, which was made by curing UV resin directly onto plywood with the help of a 3D printer and a bit of software work. The result is faintly-raised linework that also makes hand drilling holes both cleaner and more accurate.

The process begins by designing the 2D layout in Inkscape, which has the advantage of letting one work in 1:1 dimensions. A 10 mm diameter circle will print as 10 mm; a nice advantage when designing for physical components. After making the layout one uses OpenSCAD to import the .svg and turn it into a 3D model that’s 0.5 mm tall. That 3D model gets loaded into the resin printer, and the goal is to put it directly onto a sheet of plywood.

To do that, [bluesyann] sticks the plywood directly onto the 3D printer’s build platform with double-sided tape. With the plywood taking the place of the usual build surface, the printer can cure resin directly onto its surface. Cleanup still involves washing uncured resin off the board, but it’s nothing a soak in isopropyl alcohol and an old toothbrush can’t take care of.

[bluesyann] has a few tips for getting the best results, and one of our favorites is a way to make drilling holes easier and cleaner. Marking the center of a drill hit with a small donut-shaped feature makes a fantastic centering guide, making hand drilling much more accurate. And adding a thick ring around the drill hole ensures clean edges with no stray wood fibers, so no post-drilling cleanup required. Don’t want the ring to stick around after drilling? Just peel it off. There’s a load of other tips too, so be sure to check it out.

A nice front panel really does make a project better, and we’ve seen many different approaches over the years. One can stick laminated artwork onto an enclosure, or one can perform toner transfer onto 3D printed surfaces by putting the design on top of the 3D printer’s build surface, and letting the heat of molten plastic do the work of transferring the toner. And if one should like the idea of a plywood front panel but balk at resin printing onto it, old-fashioned toner transfer works great on wood.

In our modern society, we have started to take the humble camera for granted. Perhaps because of this, trendy standalone cameras have started to take off. Unfortunately, most of the time these cameras are expensive and not any better than those in our everyday smartphones. If only there were some open-source solution where you could build and customize your own standalone device? [Yutani] has done just that with the SATURNIX.

Simple microcontrollers and cameras meant for Raspberry Pis are a dime a dozen these days. Because of this, it’s no surprise to hear that the SATURNIX is based on recognizable hardware, a Raspberry Pi Zero 2W and an Arducam 16MP sensor. The Pi Zero powers both the sensors’ capture abilities and the interactive LCD display.

With a simple visual design, the device could certainly fit into the same market we see so many other standalone cameras. Pictures from the camera look great without or with the included filter options if you want a more retro look. While currently there do appear to be some speed improvements needed, the best part of open source is that you yourself can help out!

We always love ambitious open source projects that look to build a true base for others to work on, and this seems like no exception! If you want similarly impressive feats of optical trickery, look no further than using scotch tape as a camera lens!