LÆMEUR'S (ABORTED) ATARI SYNTHESIZER PROJECT

THE PLAN (in words)

Some time in 2009 I was overtaken by an urge to exploit the musical potential of my Atari 800XL home computer. This was neither new nor novel, as there has long existed a community of dedicated, highly skilled, and talented artists who work with the Atari 8-bit series of computers. Their work is not to be missed, and is easy to find on sites such as Pouet.net. However, the work of chip/scene artists tends towards purism by nature — it is an exercise in maximizing artistic expression within the capabilities and limitations of a single device or system — while my aim was less principled. I simply thought the Atari produced some very interesting sounds, and I wanted to augment the computer in a way that would enable me to extemporaneously perform music with it as a component of a larger system of sound generating/shaping tools and interface media.

More specifically, I wanted the Atari to interface to a modular synthesizer [1]. I wanted it to synchronize to an external clock pulse, to change state based on a variety of analog and digital inputs, and to output gate/clock pulses as well as audio, and I wanted a nice little piece of software running on the Atari that let me orchestrate all of this in real-time. In more conventional terms, I wanted the Atari to be a sort-of integrated sequencer & tone generator, though that description fails to articulate the extensibility I had in mind.

A five-stage plan coalesced in my mind [2], and I set myself to accomplishing the following:

  1. Modify an Atari 800XL home computer to accept a +5v clock signal. [3]
  2. Write an interrupt handler on the Atari to execute some program code and update the state of the sound chip (POKEY) on receipt of the external clock signal.
  3. Build a breakout-box with switches, knobs, and patch-jacks to allow me to utilize all of the I/O facilities of POKEY, via the Atari's joystick ports. This would facilitate not only operator input, but provide an interface between the Atari and external synthesizer modules.
  4. Write additional software to allow an operator to interactively compose complex audio and I/O behaviours.
  5. Make beautiful music.

I never completed the project, but I made some interesting progress. There are some artefacts of that progress below.

MEDIA

I admonish myself frequently for not having better documented this project while it was active. As all of the hardware and software for this project is stowed-away many miles distant, I have only a few audio recordings and a scant two photographs to show:

Sounds


Sync test 1 — The earliest recording of a working interrupt handler. At this stage, all that happened in the Atari when the clock pulse came in is that POKEY's pitch control registers would be randomized, and the clock pulse would be re-sent from one of the joystick ports to trigger an external envelope generator. I was using a Boss DR-55 to provide the clock signal, and its drum sounds are mixed into the audio of this recording.


Sync test 2 — This recording was made after I had begun to build the software front-end in Turbo-BASIC XL. I had some concerns about latency at this point, and did a quick bit of noodling around with the very rudimentary sequencer I had kludged, and then drove it as fast as the DR-55's clock would go to see if the Atari could keep up. It kept up.




Test Tape, parts 1, 2, and 3 — You'll have to pardon the tape hiss in these recordings. My old  Akai GX-620 developed a noisy left-channel. This "Test Tape" was just a half-hour vamp, more for testing out a control-surface I had cobbled-together to manipulate the virtual analog modules running on my PC than for testing the Atari software. Nevertheless, it is the last recording I made of the Atari synth rig.

Pictures

Figure 1. My Atari running an early version of the sequencer software. It is disappointing that none of the other parts of the system are visible.
Figure 2. A macro picture of the sequencer/performance software on my Commodore 1702 monitor. The software made use of a custom font which let me display the numbers 1 through 32 inside a single character cell.

FAILURE ANALYSIS

Like so many of my pet projects, this one was abandoned in its cradle. After a short initial burst of progress, I was forced to take a pause as the connectors, switches, and jacks for my breakout box arrived in the mail (I was living in a small town at the time, where such things were not readily available, so I had to order them online). During that short waiting period, I did make some attempt to continue work on the software, but I grew to feel that the language I was developing it with (Turbo-BASIC XL) was not up to the task. I decided that I would prefer to proceed in MOS 6502 assembly language ...which I had not yet learned [4] .

Some months after I aborted this project, I did, in fact, learn 6502 assembly and wanted to get back to developing the Atari Synth very badly, but by that time I had moved to a new city, and most of my things were in storage, and I had enrolled in art school which, for better or worse, altered my trajectory for several years.

NOTES

1. This end has been partially attained quite elegantly by the POKEY.synth, a synthesizer module which allows direct manipulation of the Atari's sound & I/O chip without the computer attached. See: http://www.analogbytes.org

2. This is, of course, a lie. It's only in retrospect that I can see the form of a plan. At the time, I simply had an end in mind, and made uncoordinated incremental gestures toward that end. This is how I work on all of my projects.

3. The clock-input port and interrupt handler were, as I recall, done in a night. I drilled a small hole in the back of the Atari and installed a 1/8" TRS jack which was wired-up to a transistor which, in turn, was wired-up to the SYSTEM RESET key circuit — this gave me a hardware interrupt vector from which to launch my code. Of course, hijacking that interrupt vector meant that the computer could only be rebooted "cold", but that really wasn't a concern for me.

4. Yes, the interrupt handler was written in machine code, which I had a rudimentary grasp on, but I hadn't yet made the leap to assembly.

comments powered by Disqus