A Hacker’s Christmas Story

December 24, 2022 by Elliot Williams 11 Comments

Twas the night before Christmas, and because I decided to make everyone’s presents myself this year, I’m still working like mad to get everything done before the big deadline. Why do I do this to myself? Well, partly because I enjoy the process.

My wife had this idea that we can make the older folks some fun decorative blinky things, and picked some motives. My son then drew them out on paper, and I scanned those drawings in and traced them over in CAD. We then cut the shapes out of wood on the CNC router, which turned out to be incredibly successful. (Now that I’ve done it, I wouldn’t be surprised if all of those “quirky” decorative objects that the Swedish flat-packers sell aren’t initially sketched out by third graders.)

Then my son painted them, and it’s my job to insert the twinkling. I bought some of those three-wire “fairy lights” for the purpose, and they’re really fun to hack on. They’re like WS2812s, only instead of using four pins and shifting the data downstream, they’re on a bus, each with a hard-coded address – they know where they are in the string and each LED only listens for the Nth set of 24 bits. This means sending 200 color codes just to light up the 4 LEDs in Aunt Micki’s decorative tree, but so be it.

Last stop, and still to do as of the 23rd, route out some kind of wooden battery case, wedge in the LiPo and the charging circuits, and solder on an on/off switch. It’s down to the last minute, but isn’t that always the way?

Definitely would have been easier just to order something online. But is that the spirit of giving? No! The DIY way brings the family together, gets me some quality time with the CNC machine, and tones up my FreeCAD skills. My son even looked over my shoulder as we were coding some of the LED animations. And nothing says Christmas like hand-coded blinkies.

Happy Holidays, y’all!

GitHub ESP32 OTA Updates, Now In MicroPython Flavor

December 23, 2022 by Elliot Williams 5 Comments

Wouldn’t it be great if you could keep all of your small Internet-connected hacks up to date with a single codebase? A couple of weeks ago, we wrote up a project that automagically pulls down OTA updates to an ESP32 from GitHub, using the ESP32 C SDK. [Pascal] asked in the comments, “but what about MicroPython?” Gauntlet thrown, [TURFPTAx] wrote ugit.py – a simple library that mirrors all of the code from a public GitHub Python repo straight to your gizmo running Micropython.

[Damped] wrote in about Senko, another library that does something very similar, but by then [TURFPTAx] was already done. Bam! Part of the speed is that MicroPython includes everything you need to get the job done – parsing streamed JSON was the hard part with the original hack. MicroPython makes those sorts of things easy.

This is one of those ideas that’s just brilliant for a hacker with a small flock of independent devices to herd. And because ugit.py itself is fairly simple and readable, if you need to customize it to do your own bidding, that’s no problem either. Just be sure that when you’re storing your WiFi authentication info, it’s not publicly displayed. ([TURFPTAx], could I log into your home WiFi?)

What’s [TURFPTAx] going to be using this for? We’re guessing it’s going to be deploying code to his awesome Open Muscle sensing rigs. What will we be using it for? Blinky Christmas decorations for the in-laws, now remotely updatable without them having to even learn what a “repo” is.

Continue reading “GitHub ESP32 OTA Updates, Now In MicroPython Flavor” →

Yesterday’s Future Is Brighter Today

December 17, 2022 by Elliot Williams 31 Comments

The demoscene never ceases to amaze. Back in the mid-80s, people wouldn’t just hack software to remove the copy restrictions, but would go the extra mile and add some fun artwork and greetz. Over the ensuing decade the artform broke away from the cracks entirely, and the elite hackers were making electronic music with amazing accompanying graphics to simply show off.

Looked at from today, some of the demos are amazing given that they were done on such primitive hardware, but those were the cutting edge home computers at the time. I don’t know what today’s equivalent is, with CGI-powered blockbusters running in mainstream cinemas, the state of the art in graphics has moved on quite a bit. But the state of the old art doesn’t rest either. I’ve just seen the most amazing demo on a ZX Spectrum.

Simply put, this demo does things in 2022 on a computer from 1982 that were literally impossible at the time. Not because the hardware was different – this is using retro gear after all – but because the state of our communal knowledge has changed so dramatically over the last 40 years. What makes 2020s demos more amazing than their 1990s equivalents is that we’ve learned, discovered, and shared enough new tricks with each other that we can do what was previously impossible. Not because of silicon tech, but because of the wetware. (And maybe I shouldn’t underestimate the impact of today’s coding environments and other tooling.)

I love the old demoscene, probably for nostalgia reasons, but I love the new demoscene because it shows us how far we’ve come. That, and it’s almost like reverse time-travel, taking today’s knowledge and pushing it back into gear of the past.

Supercon 2022: Sam Mulvey Shows You How To FM Radio

December 15, 2022 by Elliot Williams 19 Comments

Sam Mulvey built his own radio station in Tacoma, WA. Is there a better way to meld ham radio practice with a colossal number of DIY electrical and computer projects? Sam would say there isn’t one! This 45-minute talk is basically the lessons-learned review of setting up KTQA 95.3 – the radio station on the hill.

Sam starts out the talk by introducing you to LPFM. And maybe you didn’t know that there’s a special type of license issued by the US FCC allowing non-profit community radio stations up to 100 W, covering an radius of around 5 km. It’s like running a pirate radio station, but by jumping through a few legal hoops, made legal.

Trash on the Radio

Putting a radio station together on a budget requires a ton of clever choices, flexibility, and above all, luck. But if you’re willing to repair a busted CD player or turntable, scrounge up some used computers, and work on your own amplifiers, the budget doesn’t have to be the limiting factor.

Being cheap means a lot of DIY. For instance, Sam and friends made a custom console to support all the gear and hide all the wiring. Some hot tips from the physical build-out: painted cinderblocks make great studio monitor stands, and Cat-5 can carry two channels of balanced audio along with power, with sufficient isolation that it all sounds clean. Continue reading “Supercon 2022: Sam Mulvey Shows You How To FM Radio” →

Omniwhegs Are Awesome Times Two

December 14, 2022 by Elliot Williams 26 Comments

What’s the strangest wheel? The omniwheel. Unless you count whegs — “wheel legs” — as wheels. This research paper from Shanghai Technical University explores a mash-up of the two ideas, where the wheels roll as standard omniwheels until a servo on the axle unfurls them into their whegs configuration. The result? OmniWhegs!

The resulting vehicle is a bit of a departure from the original whegs concept, which used compliant mechanisms which passively balanced the force across the legs. Here, the omniwhegs are rigid and actually use a synchronization routine that you can see in the video embedded below.

If you can’t get enough omniwheels, you’re not alone. Here’s a rare three-wheeler, and here’s an omniwheel made of MDF. We haven’t seen enough whegs-based bots, but OutRunner is pretty astounding, and we think deserves a second look.

We’ve also seen wheels that convert to whegs before, but without the omni. And we don’t know if that one ever made it out of render-of-a-robot phase.

So kudos to the Shanghai team for taking the strangest possible wheels and actually building them!

Continue reading “Omniwhegs Are Awesome Times Two” →

After 40 Years, Adobe Releases PostScript Source V0.10 For Posterity

December 13, 2022 by Elliot Williams 28 Comments

Celebrating their 40th anniversary, Adobe released the source code of PostScript v0.10 to the Computer History Museum. But before you ask, we tried and it won’t compile with GCC out of the box – it’s missing at least except.h, but we’d bet you can hack around it with a little dedication.

PostScript is the precursor to PDF, and at the time it was revolutionary. Coming out of Xerox’s PARC, the idea was to create device- and resolution-independent documents where all the characters, symbols, and graphics are described by their shapes instead of bitmaps. PostScript’s secret sauce was in how it went back to a pixel-based representation for end use on monitors or printers. It’s no exaggeration to say that this ended up revolutionizing the print industry, and it makes sense in the CHM’s collection.

Still, on the trade-secret front, you shouldn’t get too excited. Apparently the code released here only includes a first-draft version of Adobe’s font hinting algos, as evidenced by the early version number. Nonetheless, you’re free to dig into pretty readable C. For instance, vm.c contains the virtual machine that implements PostScript’s almost Forth-like language.

Of course, if you’d just like to mess around with PostScript, downloading a modern open-source interpreter like GhostScript probably makes a lot more sense. Even so, it’s fun to see the original codebase where it all started.

Fossil Files: My .Emacs

December 10, 2022 by Elliot Williams 63 Comments

Last week, I wrote about cargo culting in a much more general context, so this week I’m going to come clean. The file that had me thinking about the topic was the worst case you’ve probably ever seen: I have a .emacs file kicking around that I haven’t really understood since I copied it from someone else – probably Ben Scarlet whose name is enshrined therein – in the computer lab in 1994! Yes, my .emacs file is nearly 30, and I still don’t really understand it, not exactly.

Now in my defence, I switched up to vim as my main editor a few years ago, but this one file has seen duty on Pentiums running pre-1.0 versions of Linux, on IBM RS/6000 machines in the aforementioned computer lab, and on a series of laptops and desktops that I’ve owned over the years. It got me through undergrad, grad school, and a decade of work. It has served me well. And if I fired up emacs right now, it would still be here.

For those of you out there who don’t use emacs, the .emacs file is a configuration file. It says how to interpret different files based on their extensions, defines some special key combos, and perhaps most importantly, defines how code syntax highlighting works. It’s basically all of the idiosyncratic look-and-feel stuff in emacs, and it’s what makes my emacs mine. But I don’t understand it.

Why? Because it’s written in LISP, for GNU’s sake, and because it references all manner of cryptic internal variables that emacs uses under the hood. I’m absolutely not saying that I haven’t tweaked some of the colors around, or monkey-patched something in here or there, but the extent is always limited to whatever I can get away with, without having to really learn LISP.

This ancient fossil of a file is testament to two things. The emacs codebase has been stable enough that it still works after all this time, but also that emacs is so damn complicated and written in an obscure enough language that I have never put the time in to really grok it – the barriers are too high and the payoff for the effort too low. I have no doubt that I could figure it out for real, but I just haven’t.

So I just schlep this file around, from computer to computer, without understanding it and without particularly wanting to. Except now that I write this. Damnit.

Featured image: “A Dusty Old Book” by Marco Verch Professional.