One Instruction To Rule Them All: C Compiler Emits Only MOV

May 21, 2021 by Al Williams 17 Comments

How many instructions do you need to successfully compile C code? Let’s see, you’d need some jump instructions, some arithmetic functions, and — of course — move instructions, right? Turns out you only need the move instruction, which — on x86, at least — is Turing complete.

While the effort is a bit tongue-in-cheek, we have to admit that if you were trying to create your own CPU, this would make for a simple architecture and might have power or complexity advantages, so maybe someone will find a practical use for it after all. If you wanted a C compiler for a simple CPU, this wouldn’t require much to emulate at a byte-code level, either.

Continue reading “One Instruction To Rule Them All: C Compiler Emits Only MOV” →

Retrotechtacular: Double For Nothing

May 21, 2021 by Jenny List 52 Comments

If you are in the market for web hosting in 2021 and you sign up with one of the cloud computing providers, you’ll soon see how the different resources are priced. Storage and bandwidth are cheap, while CPU time is expensive. This reflects the state of a modern computer, in which a typical disk drive now holds a terabyte or more and rising by the year while a new processor is becoming a bottleneck whose performance hasn’t increased as much as the manufacturers would like over models from years ago.

Twice As Much Hardware From A Bit Of Software?

In the early 1990s though it was a different matter. A 486 or early Pentium processor was pretty powerful compared to the DOS or Windows 3.1 software it was expected to run, and it was the memory and disk space attached to it that limited performance… and cost an arm and a leg. There was a period in about 1995 when a supposed fire in a chip factory somewhere sent RAM prices into the hundreds of dollars per megabyte, briefly causing an epidemic of RAM raiding in which criminals would break into offices and take only the SIMs from the computers.

A solution to this problem came perhaps surprisingly from the software industry. Disk Doubler was a DOS driver that promised more disk space, achieving this seemingly impossible feat by compressing the disk to fit more data on it. Processor power swapped for disk space was a reasonable trade at the time so it became extremely popular, and eventually Microsoft incorporated their own disk compression into DOS. In some cases it could even speed up a computer with a slow disk drive, as I found out as a student with a 286 packing an MFM drive.

Something For Nothing, Perhaps It’s Too Good To Be True.

If compression could increase disk space then couldn’t it do the same for RAM? The industry came to the rescue once more with an array of RAM doubler products, first applying the disk doubling technique to on-disk virtual memory, and then doing the same with the contents of the memory itself. The first approach worked at the expense of a system slow-down, while the second, not so much. In fact it was little more than a scam, with software products promising much but delivering absolutely nothing behind the scenes.

Continue reading “Retrotechtacular: Double For Nothing” →

Linus Åkesson’s ‘A Mind Is Born’ Commodore 64 Demo In Just 256 Bytes

May 19, 2021 by Maya Posch 36 Comments

It would be an understatement to say that the Commodore 64 demo scene is quite amazing. For those who are unaware, a ‘demo’ in this context is essentially a technological demonstration. Usually to show off particular effects or other (visual) properties that either push the limits of the platform on which it is being run, or use its hardware in a special fashion. In the case of [Linus Åkesson]’s A Mind Is Born demo, the challenge was to do as much as possible in 256 bytes, while providing an audiovisual experience.

Although at first glance 256 bytes may sound like a lot to work with, this code has to generate the entire melody that is output via the Commodore 64’s SID audio chip, while simultaneously generating an attractive visual pattern. This is quite an undertaking, as the video capture of the result (included after the break) makes clear. The secret sauce here is to make use of the C64’s SID audio & VIC-II video chips.

Driven by a 60 Hz timer interrupt, the three voices of the SID are used to play the kick drum and bass, melody and drone respectively, creating the 64 total bars of the music using a linear-feedback shift register (LFSR). This means that the melody is in a sense randomly generated, but deterministically enough to sound pleasing to the human ear.

For the visual side, the C64 runs in Extended Character Mode, using fonts along with a background color to create interesting patterns using what is essentially a cellular automaton algorithm. While there are some visual glitches due overwriting of video data, and a race condition, these end up adding to the charm. The resulting audio track is pretty catchy too, and absolutely worthy of a listen.

Thanks for the tip, Johannes!

(That banner image? That _is_ the whole code.)

Continue reading “Linus Åkesson’s ‘A Mind Is Born’ Commodore 64 Demo In Just 256 Bytes” →

Make Android’s New Power Menu Work On Your Terms

May 14, 2021 by Tom Nardi 7 Comments

Introduced in Android 11, the power menu is a way to quickly interact with smart home gadgets without having to open their corresponding applications. Just hold the power button for a beat, and you’ll be presented with an array of interactive tiles for all the gadgets you own. Well that’s the idea, anyway.

[Mat] of “NotEnoughTech” wasn’t exactly thrilled with how this system worked out of the box, so he decided to figure out how he could create his own power menu tiles. His method naturally requires quite a bit more manual work than Google’s automatic solution, but it also offers some compelling advantages. For one thing, you can make tiles for your own DIY devices that wouldn’t be supported otherwise. It also allows you to sidestep the cloud infrastructure normally required by commercial home automation products. After all, does some server halfway across the planet really need to be consulted every time you want to turn on the kitchen light?

The first piece of the puzzle is Tasker, a popular automation framework for Android. It allows you to create custom tiles that will show up on Android’s power menu, complete with their own icons and brief descriptions. If you just wanted to perform tasks on the local device itself, this would be the end of the story. But assuming that you want to control devices on your network, Tasker can be configured to fire off a command to a Node-RED instance when you interact with the tiles.

In his post, [Mat] gives a few examples of how this combination can be used to control smart devices and retrieve sensor data, but the exact implementation will depend on what you’re trying to do. If you need a bit of help getting started, our own [Mike Szczys] put together a Node-RED primer last year that can help you put this flow-based visual programming tool to work for you.

Continue reading “Make Android’s New Power Menu Work On Your Terms” →

Sinclair BASIC For Today

May 10, 2021 by Al Williams 29 Comments

If you are of a certain age, your first exposure to computer programming was probably BASIC. For a few years, there were few cheaper ways to program in BASIC than the Sinclair ZX series of computers. If you long for those days, you might find the 1980-something variant of BASIC a little limiting. Or you could use SpecBasic from [Paul Dunn].

SpecBasic is apparently reasonably compatible with the Spectrum, but lets you use your better hardware. For example, instead of a 256×192 8-color screen, SpecBas accommodates larger screens and up to 256 colors. However, that does lead to certain incompatibilities that you can read about in the project’s README file.

Continue reading “Sinclair BASIC For Today” →

Using CanoPy To Visualize The CAN Bus

May 8, 2021 by Stephen Ogier 11 Comments

As cars have become more sophisticated electronically, understanding the CAN bus that forms the backbone of automotive digital systems has become more and more important for hacking cars. Inexpensive microcontroller CAN interfaces have made obtaining the raw CAN bus traffic trivial, but interpreting that traffic can be pretty challenging. In order to more easily visualize CAN traffic, [TJ Bruno] has developed CanoPy, a Python tool for visualizing CAN messages in real time.

A basic PC CAN interface simply dumps the bus’s message traffic into the terminal, while more sophisticated tools organize messages by the address of their intended recipients. Both of these approaches digitally lift the hood and let you examine what your car is thinking, but the wall-of-numbers approach makes finding the patterns that hold the keys to reverse engineering difficult. Automatically plotting the data with CanoPy makes finding correlations much easier, after which the text-based tools can be used to focus in on a few specific addresses.

Continue reading “Using CanoPy To Visualize The CAN Bus” →

AVR Bare Metal With Lisp

May 4, 2021 by Al Williams 21 Comments

There are two kinds of programmers: those who don’t use Lisp, and those who need new parenthesis keycaps every six months. Lisp is one of those languages you either really love or really hate. If you love it, you may have checked out ulisp, which runs on Arduino boards of the AVR and ARM variety, as well as ESP chips, RISC-V, and others. A recent update allows the language to insert assembler into AVR programs.

We probably don’t need to convince anyone reading Hackaday why adding assembler is a good thing. It seems to integrate well with the environment, too, so you can write assembler macros in Lisp, which opens up many possibilities.

Continue reading “AVR Bare Metal With Lisp” →