A Few Of My Favorite Things: Amateur Radio

January 21, 2021 by Jenny List 50 Comments

Hackaday has among its staff a significant number of writers who also hold amateur radio licenses. We’re hardware folks at heart, so we like our radios homebrew, and we’re never happier than when we’re working at high frequencies.

Amateur radio is a multi-faceted hobby, there’s just so much that’s incredibly interesting about it. It’s a shame then that as a community we sometimes get bogged down with negativity when debating the minutia. So today let’s talk about a few of my favourite things about the hobby of amateur radio. I hope that you’ll find them interesting and entertaining, and in turn share your own favorite things in the comments below.

Continue reading “A Few Of My Favorite Things: Amateur Radio” →

The Origin Of Cut, Copy, And Paste

January 20, 2021 by Al Williams 90 Comments

I’m always fascinated that someone designed just about everything you use, no matter how trivial it is. The keyboard you type on, the light switch you turn on, even the faucet handle. They don’t just spontaneously grow on trees, so some human being had to build it and probably had at least a hazy design in mind when they started it.

Some things are so ubiquitous that it is hard to remember that someone had to dream them up to begin with. A friend of mine asked me the other day why we use Control+X and Control+V to manipulate the clipboard almost universally. Control+C for copy makes sense, of course, but it is still odd that it is virtually universal in an industry where everyone likes to reinvent the wheel. I wasn’t sure of the answer but figured it had to do with some of the user interface standards from IBM or Sun. Turns out, it is much older than that.

Continue reading “The Origin Of Cut, Copy, And Paste” →

Hackability Matters

January 16, 2021 by Elliot Williams 42 Comments

The Unix Way™ provides extreme hackability. The idea is that software should be written as tools to accomplish discrete tasks, and that it should be modular, extensible, and play well with others. It’s like software as a LEGO set — you can put the blocks together however you want, within limits, and make stuff that’s significantly cooler than any of the individual blocks alone.

Clearly this doesn’t work for all applications — things like graphics editors and web browsers don’t really lend themselves to being elegant tools that integrate well with others, right? It’s only natural that they’re bloaty walled gardens. What happens in the browser must stay in the browser, right?

But how sad is it that the one piece of software you use all day, your window into cyberspace, doesn’t play well with the rest of your system? I’d honestly never really been bothered by that fact until stumbling on TabFS. It’s an extension to Chrome that represents the tabs on your browser as if they were files on your local system — The Unix Way™. And what this means is that any other program that can read from or write to a file can open tabs, collect them, change webpages on the fly, and so on. It opens up the browser to you.

This is tremendously powerful. Don’t like the bookmarking paradigm of your particular browser? Writing your own would be a snap in Python — and you could do cleverer things like apply a little machine learning to handle putting them in categories. Want to pop open (or refresh) a set of webpages at a particular time every day? Cron, or its significantly more complicated counterpart systemd, and a couple lines of code will do that. Want to make a hardware button that converts dark mode to light mode and vice-versa for every website starting with “H”? Can do.

I’m picking on browsers, but many large pieces of software are inaccessible in the same way — even if they’re open source, they don’t open up channels for interaction with user code or scripts. (Everything “in the cloud” or “as a service”, I’m looking at you! But that’s a further rant for another day.) And that’s a shame, because most of these “big” pieces of software actually do the coolest things.

So please, if you’re working on a big software package, or even just writing a plug-in for one, do think about how you can make more of its abilities available to the casual scripter. Otherwise, it’s just plastic blocks that don’t fit with the rest of the set.

The Shell And The Microcontroller

January 9, 2021 by Elliot Williams 104 Comments

One of the nicest amenities of interpreted programming languages is that you can test out the code that you’re developing in a shell, one line at a time, and see the results instantly. No matter how quickly your write-compile-flash cycle has gotten on the microcontroller of your choice, it’s still less fun than writing blink_led() and having it do so right then and there. Why don’t we have that experience yet?

If you’ve used any modern scripting language on your big computer, it comes with a shell, a read-eval-print loop (REPL) in which you can interactively try out your code just about as fast as you can type it. It’s great for interactive or exploratory programming, and it’s great for newbies who can test and learn things step by step. A good REPL lets you test out your ideas line by line, essentially running a little test of your code every time you hit enter.

The obvious tradeoff for ease of development is speed. Compiled languages are almost always faster, and this is especially relevant in the constrained world of microcontrollers. Or maybe it used to be. I learned to program in an interpreted language — BASIC — on computers that were not much more powerful than a $5 microcontroller these days, and there’s a BASIC for most every micro out there. I write in Forth, which is faster and less resource intensive than BASIC, and has a very comprehensive REPL, but is admittedly an acquired taste. MicroPython has been ported over to a number of micros, and is probably a lot more familiar.

But still, developing MicroPython for your microcontroller isn’t developing on your microcontroller, and if you follow any of the guides out there, you’ll end up editing a file on your computer, uploading it to the microcontroller, and running it from within the REPL. This creates a flow that’s just about as awkward as the write-compile-flash cycle of C.

What’s missing? A good editor (or IDE?) running on the microcontroller that would let you do both your exploratory coding and record its history into a more permanent form. Imagine, for instance, a web-based MicroPython IDE served off of an ESP32, which provided both a shell for experiments and a way to copy the line you just typed into the shell into the file you’re working on. We’re very close to this being a viable idea, and it would reduce the introductory hurdles for newbies to almost nothing, while letting experienced programmers play.

Or has someone done this already? Why isn’t an interpreted introduction to microcontrollers the standard?

Amazon’s Custom T-Shirt May Rub You The Wrong Way

January 6, 2021 by Kristina Panos 49 Comments

How far would you go in pursuit of the perfect black t-shirt? Would you let Amazon build a virtual double of your body? They already know so much about you, so what’s a body scan or two between customer and company?

So here’s the deal — Amazon is trying to launch a brand of bespoke clothing called Made for You, and they’re starting with custom solid color t-shirts. Here’s how it works: you give them $25 along with information about your height, weight, and skin tone. Then you upload two pictures of your torso to their app, and these get turned into a 3D model of your body. Once your avatar is built to match, you design your shirt to fit the model. In theory, you get a really good idea of how it will fit.

You can choose from two different fabrics and eight colors, and can customize the neckline, the shirt length, and the sleeve length. If you want to, you can put your name on the tag. Then your perfect t-shirt gets made in the US from imported fabric — either lightweight or medium weight pima cotton. We’re not sure if robots or people are making them, but our money is on people. After all, Amazon is the company that created Mechanical Turk to form a pool of humans available to do on-demand work via the Internet. This is along those lines but with tailors sewing to your specifications. The big questions are what do you get, how does the technology make these better than off-the-rack, and do you give up your privacy in return?

One-Size Fits One

To say that these are custom t-shirts is a bit of a stretch. Oh you don’t need to worry about the t-shirts being skin-tight and showcasing your spare tire — if it’s a relaxed fit you want, that’s one of the options. But the current options are limited.

Continue reading “Amazon’s Custom T-Shirt May Rub You The Wrong Way” →

Label Your Shtuff!

December 19, 2020 by Elliot Williams 18 Comments

Joshua Vasquez wrote a piece a couple of weeks ago about how his open source machine benefits greatly from having part numbers integrated into all of the 3D printed parts. It lets people talk exactly about which widget, and which revision of that widget, they have in front of them.

Along the way, he mentions that it’s also a good idea to have labels as an integrated part of the machine anywhere you have signals or connectors. That way, you never have to ask yourself which side is positive, or how many volts this port is specced for. It’s the “knowledge in the head” versus “knowledge in the world” distinction — if you have to remember it, you’ll forget it, but if it’s printed on the very item, you’ll just read it.

I mention this because I was beaten twice in the last week by this phenomenon, once by my own hand costing an hour’s extra work, and once by the hand of others, releasing the magic smoke and sending me crawling back to eBay.

The first case is a 3D-printed data and power port, mounted on the underside of a converted hoverboard-transporter thing that I put together for last year’s Chaos Communication Congress. I was actually pretty proud of the design, until I wanted to reflash the firmware a year later.

I knew that I had broken out not just the serial lines and power rails (labelled!) but also the STM32 SWD programming headers and I2C. I vaguely remember having a mnemonic that explained how TX and RX were related to SCK and SDA, but I can’t remember it for the life of me. And the wires snake up under a heatsink where I can’t even trace them out to the chip. “Knowledge in the world”? I failed that, so I spent an hour looking for my build notes. (At least I had them.)

Then the smoke came out of an Arduino Mega that I was using with a RAMPS 1.4 board to drive a hot-wire cutting CNC machine. I’ve been playing around with this for a month now, and it was gratifying to see it all up and running, until something smelled funny, and took out a wall-wart power supply in addition to the Mega.

All of the parts on the RAMPS board are good to 36 V or so, so it shouldn’t have been a problem, and the power input is only labelled “5 A” and “GND”, so you’d figure it wasn’t voltage-sensitive and 18 V would be just fine. Of course, you can read online the tales of woe as people smoke their Mega boards, which have a voltage regulator that’s only good to 12 V and is powered for some reason through the RAMPS board even though it’s connected via USB to a computer. To be honest, if the power input were labelled 12 V, I still might have chanced it with 18 V, but at least I would have only myself to blame.

Part numbers are a great idea, and I’ll put that on my list of New Year’s resolutions for 2021. But better labels, on the device in question, for any connections, isn’t even going to wait the couple weeks until January. I’m changing that right now.

PS2 Emulation On The Xbox Series S: A Story Of Walled Gardens

December 15, 2020 by Maya Posch 25 Comments

It’s hardly a secret any more at this point that today’s game consoles from Microsoft and Sony are essentially AMD gaming rigs packed up into a custom package and with tweaked system software. So it’s not too surprising that enterprising hackers got the Playstation 2 emulator of RetroArch running on an Xbox Series X|S game console despite Microsoft’s attempts to stop them. (Video, embedded below.)

It’s possible to sneak the RetroArch app past Microsoft’s security checkpoints by shelling out $19 for a Microsoft Developer Account, setting up Developer Mode on the XBox console, and getting the Universal Windows Platform (UWP) port of RetroArch from the official website. This has the advantage of it being a blessed-by-the-Redmond-gods approach. But one cannot play retail games in Developer Mode and large games due to a 2 GB limit.

More recently, a hacker by the name of [tunip3] found a flaw in the Xbox app distribution system which allows one to download a ‘retail’ version of RetroArch. This involves marking the RetroArch app as ‘private’, allowing it to skip a review by Microsoft. People whose email address is on a whitelist are then granted download permission for that app on their Xbox console. The advantage of this ‘retail’ approach is that it does not feature the 2 GB filesize limits. The disadvantage is that Microsoft is free to take the app down and ban [tunip3]’s developer account.

My Way Versus the Highway

A lot about this comes down to a simple question of ‘why?’. Why even jump through these hoops to set up a limited, possibly ToS-breaking emulator on what is ultimately a gaming PC running Windows 10? Why not use that Raspberry Pi 4 or NUC system that’s been giving you sad eyes for the past months from where it’s been stuffed into a dusty corner?

Continue reading “PS2 Emulation On The Xbox Series S: A Story Of Walled Gardens” →