Honoring Chuck Peddle; Father Of The 6502 And The Chips That Went With It

Chuck Peddle, the patriarch of the 6502 microprocessor, died recently. Most people don’t know the effect that he and his team of engineers had on their lives. We often take the world of microprocessor for granted as a commonplace component in computation device, yet there was a time when there were just processors, and they were the size of whole printed circuit boards.

Chuck had the wild idea while working at Motorola that they could shrink the expensive processor board down to an integrated circuit, a chip, and that it would cost much less, tens of dollars instead of ten thousand plus. To hear Chuck talk about it, he got a cease-and-desist letter from the part of Motorola that made their living selling $14,000 processor boards and to knock off all of the noise about a $25 alternative.

In Chuck’s mind this was permission to take his idea, and the engineering team, elsewhere. Chuck and his team started MOS Technologies in the 1970’s in Norristown PA, and re-purposed their work on the Motorola 6800 to become the MOS 6502. Lawsuits followed.

Continue reading “Honoring Chuck Peddle; Father Of The 6502 And The Chips That Went With It”

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]

Atari Tape Drive Turned Security DVR

We know that a lot of our beloved readers don’t take kindly to abuse of vintage hardware, so the Atari fans in the audience may want to avert their eyes for this one. Especially if they’re particularly keen on spinning up their Jawbreaker cassette on authentic hardware, as [iot4c] has gutted an Atari XC12 Program Recorder to turn it into an enclosure for a Raspberry Pi video storage device.

Step one of this conversion was, as you might expect, removing all the original hardware from the cassette recorder case. From there, [iot4c] fitted the Raspberry Pi, a USB hard drive, and a YDS-5A DC-DC converter to power them. Depending on what the drive setup looks like, it might also make sense to add a USB powered hub. A length of Ethernet cable was left hanging out the back of the Atari XC12 so it could be plugged into the network, but a panel mount RJ45 connector could spruce things up a bit.

Of course, gutting an old piece of hardware and sticking a Pi into it isn’t exactly breaking any new ground at this point. But we did appreciate that [iot4c] went the extra mile to wire it up so the “Save” LED now doubles as a network activity indicator. Which pretty much brings it full circle in terms of functionality for a network-attached video recorder.

Earlier in the year [iot4c] converted a 65XE into a USB keyboard with the help of an Arduino Leonardo, but the vintage Atari aficionados will be happy to note that at least in that case the donor machine remained fully functional.

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.

Doing What Id Couldn’t: Returning Music To Jaguar Doom

While the rest of the world has by and large forgotten the Atari Jaguar, the generously marketed console still has a fan base, and even some dedicated hackers prodding away at it. [Cyrano Jones] is one of them, and he managed something many considered unthinkable: restoring in-game music to the Jaguar port of Doom.

The Jaguar version of the classic shooter was developed by id Software themselves, and is generally considered one of the better console ports. For example, the large number of buttons on the Jaguar controller allowed players to select weapons directly rather than having to cycle through them. Unfortunately, the complete lack of music during gameplay was a glaring omission that took several points off of an otherwise fairly solid presentation.

The common culprit blamed for this was that the Jaguar’s DSP was already being used for math processing, so it didn’t have any cycles left for music playback. Coupled with a tight deadline, id probably cut their losses and released it without in-game music rather than try and spend more time engineering a solution. To compensate for the lack of in-game music, id did include the famous soundtrack in the intermission screens rather than entirely strip it out.

As [Cyrano] found out by studying the source code that’s been available since 2003, sound effects in the Jaguar version of Doom are played using something called a “ring buffer”: a cyclical fixed-length data buffer which constantly gets outputted as audio. With a patch of unused memory he could fit a second ring buffer in, rendering the music to it with close to no performance hit elsewhere in the code and then mixing both buffers for the final audio output. It looks as though id already had some of this solution in place, but with enough issues that forced them to abandon the idea in order to release the game on time.

Software hacks are not the only things that the Jaguar fan base can do though, and a fine example of a hardware one is this custom mod showing what it could’ve looked like with the CD add-on in an integrated unit.

Continue reading “Doing What Id Couldn’t: Returning Music To Jaguar Doom”

Vintage Atari Becomes Modern Keyboard

The modern keyboard enthusiast is blessed with innumerable choices when it comes to typing hardware. There are keyboards designed specifically for gaming, fast typing, ergonomics, and all manner of other criteria. [iot4c] undertook their own build for no other reason than nostalgia – which sounds plenty fun to us.

An Arduino Leonardo is pressed into service for this hack. With its USB HID capabilities, it’s perfectly suited for custom keyboard builds. It’s built into a working Atari 65XE computer, and connected to the keyboard matrix. The Keypad and Keyboard libraries are pressed into service to turn keypresses on the 80s keyboard into easily digseted USB data.

There’s plenty of room inside the computer for the added hardware, with the USB cable neatly sneaked out the rear. [iot4c] notes that everything still works and the added hardware does not cause any problems, as long as it’s not used as a computer and a keyboard at the same time.

It’s possible to do a similar hack on the Commodore 64, too. If you’re doing tricky keyboard builds yourself, you know where to send ’em.

SVG Rendering Comes To 8-bit Atari Computers

Bringing modern protocols and techniques to vintage computers is a favorite pastime for hackers, and over the years we’ve seen some absolutely incredible hardware and software projects designed specifically to do what most people would consider impossible. They’re very rarely practical projects, of course. But that’s never really the point.

The product of 45 minutes of work.

Today we present another excellent entry into this niche avenue of hacking: Renderific, a tool to render SVGs on 8-bit Atari computers by [Kevin Savetz]. The MIT licensed program is written in Turbo-BASIC XL and allows computers such the 1200XL and 800XL to not only render the image on screen but output it to an attached plotter. There are a few niggling issues with some files, and apparently the plotter draws the image upside-down for some reason, but on the whole we can now add “SVG Rendering” to the list of things you can do with a nearly 40-year-old computer.

Of course, those who are familiar with these 1980’s machines might wonder how their limited CPUs can possibly cope with such a task. Well, that’s where the impracticality comes in. According to [Kevin], you can be in for quite a wait depending on the complexity of the image. In his tests, some SVGs took up to 45 minutes to fully render on the screen, so you might want to have a snack handy.

If you’re interested in lending a hand with the project, it sounds as though [Kevin] could use some assistance in figuring out why the Atari 1020 plotter doesn’t like the output of his program. There’s also a few SVG functions and forms of Bézier curves that need some work if you’ve got your Turbo-BASIC XL programming books handy.

Will you ever have a need to view SVG files on an Atari 1200XL? No, probably not. You might not have a desire to play Spotify on the Macintosh SE/30 either, but that hasn’t stopped hackers from figuring out how you can do it. As long as these old machines are still up and running, we’re confident that the community will continue to teach them new tricks.