Adding A Laser Blaster To Classic Atari 2600 Games With Machine Vision

Remember the pistol controller for the original Atari 2600? No? Perhaps that’s because it never existed. But now that we’re living in the future, adding a pistol to the classic games of the 2600 is actually possible.

Possible, but not exactly easy. [Nick Bild]’s approach to the problem is based on machine vision, using an NVIDIA Xavier NX to run an Atari 2600 emulator. The game is projected on a wall, while a camera watches the game field. A toy pistol with a laser pointer attached to it blasts away at targets, while OpenCV is used to find the spots that have been hit by the laser. A Python program matches up the coordinates of the laser blasts with coordinates within the game, and then fires off a sequence of keyboard commands to fire the blasters in the game. Basically, the game plays itself based on where it sees the laser shots. You can check out the system in the video below.

[Nick Bild] had a busy weekend of hacking. This was the third project write-up he sent us, after his big-screen Arduboy build and his C64 smartwatch.

Continue reading “Adding A Laser Blaster To Classic Atari 2600 Games With Machine Vision”

38 Years Later, The Atari 2600 Learns To Speak

Back in the early 1980s, there was a certain fad in making your computer produce something resembling human speech. There were several hardware solutions to this, adding voices to everything from automated telephone systems to video game consoles, all the way to Steve Jobs using the gimmick to introduce Macintosh to the world in 1984. In 1982, a software-based version of this synthesis was released for the Atari 8-bit line of computers, and ever since them [rossumur] has wondered whether or not it could run on the very constrained 2600.

Fast-forward 38 years and he found out that the answer was that yes, it was indeed possible to port a semblance of the original 1982 Software Automatic Mouth (or SAM) to run entirely on the Atari 2600, without any additional hardware. To be able to fit such a seemingly complicated piece of software into the paltry 128 bytes (yes, bytes) of RAM, [rossumur] actually uses an authoring tool in order to pre-calculate the allophones, and store only those in the ROM. This way, the 2600 alone can’t convert text to phonemes, but there’s enough space left for the allophones, which are converted into sound, that about two minutes of speech can fit into one cartridge. As for why he went through the trouble, we quote the author himself: “Because creating digital swears with 1982 speech synthesis technology on a 1977 game console is exactly what we need right now.”

For this project, [rossumur] has written an incredibly interesting article on speech synthesis in order to explain the SAM engine used here. And this isn’t his first time on the website either, always cramming software where it shouldn’t fit, such as a “Netflix”-like streaming service, or 8-bit console emulators, both on nothing but an ESP32 microcontroller. Check this one out in action after the break.

Continue reading “38 Years Later, The Atari 2600 Learns To Speak”

Machine Learning Algorithm Runs On A Breadboard 6502

When it comes to machine learning algorithms, one’s thoughts do not naturally flow to the 6502, the processor that powered some of the machines in the first wave of the PC revolution. And one definitely does not think of gesture recognition running on a homebrew breadboard version of a 6502 machine, and yet that’s exactly what [Nick Bild] has accomplished.

Before anyone gets too worked up in the comments, we realize that [Nick]’s Vectron breadboard computer is getting a lot of help from other, more modern machines. He’s got a pair of Raspberry Pi 3s in the mix, one to capture and downscale images from a Pi cam, and one that interfaces to an Atari 2600 emulator and sends keypresses to control games based on the gestures seen by the camera. But the logic to convert gesture to control signals is all Vectron, and uses a k-nearest neighbor algorithm executed in 6502 assembly. Fifty gesture images are stored in ROM and act as references for the four known gesture classes: up, down, left, and right. When a match between the camera image and a gesture class is found, the corresponding keypress is sent to the game. The video below shows that the whole thing is pretty responsive.

In our original article on [Nick]’s Vectron breadboard computer, [Tom Nardi] said that “You won’t be playing Prince of Persia on it.” That may be true, but a machine learning system running on the Vectron is not too shabby either.

Continue reading “Machine Learning Algorithm Runs On A Breadboard 6502”

Converting An Atari 2600 Into A Home Computer; Did That Ever Work?

[Tony] posted an interesting video where he looks at the Atari 2600 and the way many companies tried to convert it into a real home computer. This reminded us of the ColecoVision, which started out as a video game but could expand to a pretty reasonable computer.

It might seem silly to convert a relatively anemic Atari video game into a computer, but keep in mind that computers were pretty expensive in those days. Not to mention, the Atari itself was a fair investment back then, too.

Continue reading “Converting An Atari 2600 Into A Home Computer; Did That Ever Work?”

An Atari Graphics Chip, Ready For You To Build

The most notable of the home computer and console hardware from the 8-bit golden era didn’t get their impressive sound and graphics from off-the-shelf silicon, instead they relied on secretive custom chipsets to get the edge over their competitors. Unfortunately for vintage gaming aficionados, those chips are now long out of production and in many cases there’s little information to be had about their operation.

Which makes discovery of the schematics (PDF link) for the “Tia Maria” graphics chip found in the Atari 7800 console an unusual occurrence, and one which should be of special interest to the emulation community. They can be found alongside the rest of the Atari Museum’s 7800 information.

That such a useful document is available at all is due to a lucky find in a dumpster following the demise of Atari, when a treasure trove of documents was discarded. It seems that the existence of these schematics has been known within the Atari community for some time, and we expect before long this information will find its way into FPGA implementations of the 7800; especially since the system features nearly complete backwards compatibility with the massively successful Atari 2600.

When that happens we hope we’ll be able to bring it to you, but it’s not the first time someone’s made an Atari on an FPGA.

Via RetroRGB

Header image: Bilby [CC BY 3.0]

Entombed Secrets Partially Unearthed As Researchers Dissect Clever Maze-Generating Algorithm

If you look at enough of another developer’s code, you will eventually say, “What were you thinking, you gosh-darn lunatic?” Now, this exchange can precede the moment where you quit a company and check into a padded room, or it can be akin to calling someone a mad genius and offering them a beer. In the case of [Steven Sidley]’s 1982 game Entombed, [John Aycock] and [Tara Copplestone] found a mysterious table for generating pseudo-random mazes and wrote a whitepaper on how it all works (PDF). The table only generates solvable mazes, but if any bits are changed, the puzzles become inescapable.

The software archaeologists are currently in a labyrinth of their own, in which the exit is an explanation of the table, but the path is overgrown with decade-old vines. The programmer did not make the table himself, and its creator’s name is buried somewhere in the maze. Game cart storage was desperately limited so mazes had to be generated on-the-fly rather than crafted and stored. Entombed‘s ad-hoc method worked by assessing the previous row and generating the next based on particular criteria, with some PRNG in places to keep it fresh. To save more space, the screen was mirrored down the center which doubles the workload of the table. Someday this mysterious table’s origins may be explained but for now, it is a work of art in its own right.

Aside from a table pulled directly from the aether, this maze game leaned on pseudo-random numbers but there is room for improvement in that regard too.

Via BBC Future.

Get Coding With This Atari 2600 Development Suite

Sometimes the urge strikes to get busy coding for an old retro system, but unfortunately the bar to entry can be high. There’s a need to find a workable compiler, let alone trying to figure out how to load code onto original vintage hardware. It doesn’t have to be so hard, though. The team at [HeatSync Labs] built an Atari 2600 development station so hackerspace members can simply rock up and get to work.

With this rig, development is a multi-step process. A paper manual is on hand to provide detail of how to code for the Atari. An IBM PC is then on hand to allow the budding developer to code in assembly. This text file is then compiled into an Atari ROM, which is then passed through a special utility to convert it to an audio file. This is to allow it to be used with a Starpath Supercharger, which allows games to be loaded onto the Atari via cassette tape, or in this case, raw digital audio. By playing the audio file on the PC, connected to the Supercharger cartridge, it’s possible to run arbitrary code on the Atari 2600.

Programming in 6502 assembly isn’t the easiest mountain to climb for an absolute novice, but experienced coders will likely appreciate the no-fuss development environment. It makes for an easy gateway into the world of retro console programming, and there’s nothing like the fun of seeing your code running on original hardware.

We love a good story of retro development – like this tale of fixing a 37-year-old bug in an Apple II game. Video after the break.

Continue reading “Get Coding With This Atari 2600 Development Suite”