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.
Ahh, in the background of the picture. Something I so so longed to have at the peek of my career … a “phoneless cord”. Damn that callout.
On a lighter note, are we close to getting an online development environment for this in JavaScript.
I never did the 6502 as a hobby. I did it in EE but never got good at it. I was in the Z80 camp.
For those who are interested in old Atari 2600 development there is a video series on YouTube called Stella at 20. it’s quite interesting in talking about the hardware and the challenges in developing for it back in the day from the original hardware and software developers.
Always had a soft spot in my hear for the Atari 2600 and all the way up to the Jaguar.
Thanks for the nice article. I remember using a Supercharger to play all the 2k and 4k games I could download off the internet. I put them on a cassette tape and played them in a walkman.
If you are interested in assembly language atari 2600 dev here is some more info:
Online Develpment IDE: https://8bitworkshop.com/v3.3.0/?=&platform=vcs&file=examples%2Fhello
And subsequent book: https://8bitworkshop.com/
The book is a really good read with a nice progression. All in assembler.
If you can’t find a supercharger or it is too expensive, less than $50 gets you a Harmony Cart: https://harmony.atariage.com/Site/Harmony.html Which is basically a ROM emulator cartridge that will allow you to put games on SD card or upload them via USB.
Or you can try the UnoCart https://github.com/robinhedwards/UnoCart-2600 which can be found for sale on Ebay occasionally.
A site with some great programming info and links: http://www.randomterrain.com/atari-2600-memories-tutorial-andrew-davie-01.html
And if you can’t quite do the assembly language thing there is a basic like language called Batari Basic: http://atariage.com/forums/forum/65-batari-basic/
Thanks for the info!
So, is the rotary phone used to input numeric values?
Actually, believe it or not, the rotary phone is plugged into a Grandstream ATA, and that ATA connects to Asterisk, and then Project MF via a IAX2 connection, so you can bluebox phone calls and call numbers in the C*NET as well.
Maybe I missed it but why did we need the whole extra PC? (I’m guessing issues with the Wave program in DosBox or something?)
We don’t need the whole extra PC to be honest. I’ve gotten it all working, but it’s certainly a process. I would not use Dosbox for this, I’d use a real MS-DOS (or higher) VM.
heard — definitely understand how these things can twist and turn! thanks!
For an easier development path, look up Batari Basic. It’s Atari 2600 development simplified.
I believe I have the 6502 assembler catridge for my Atari 800 in the garage. I’ll just use that if I get the itch for assembly.
Wow programming an Atari 2600 with a 386, it’s retro in retro, kinda like a retro turducken or retroducken. Nice.
silly me has just been using a STM32 as a sd flash cart and a modern computer
https://github.com/robinhedwards/UnoCart-2600
Hello! Guy-who-wrote-hello-world.asm here! :-D
First of all, great video, thaks for sharing! Nice that you only used things available at the 386 time. Hope you have fun with the C64 (I would suggest Apple II, but that is personal choice, I guess :-) ).
About the size: the actual code takes less than 300 bytes (and it could be further trimmed down by at least a third, but it was built for a presentation on Atari programming – https://www.slideshare.net/chesterbr/atari-2600programming – so I wanted to keep it simple). I built it as a 4K cart since this is the actual maximum of a non-bankswitched cart.
But you can easily make it a 2K cart by changing `ORG $FFFA` near the end to `ORG $F7FA`, or even a 1K cart by changing it to `ORG $F3FA`. Keep in mind that 1K carts weren’t actually manufactured back then (AFAIK), so the Supercharger may not recognize that size (I don’t have one, I usually test on Harmony cart / Stella emulator, and now I’m curious…)
All the best!
Thanks for your reply! Your presentation was really cool, and I did end up going over it after I found your hello world code and had compiled it up oddly enough! At first I was going through the stellla programming guide and quickly realized that there certainly is more then meets the eye when it comes to coding this machine, and I wasn’t just going to be able to simply toss out a 3-10 line hello world example cold turkey! Doing it all without Dedicated Video RAM is certainly a departure from my normal way of thinking! Keeping interest in these systems and the way we used to do things is certainly on my mind as these limitations often inspired creativity and different ways of approaching problems that would never even be considered, should not a massively strange restriction exist! Now that this “thing” works and is built, it means I get to use it all for what I had initially intended: Learning 6502 assembler by trial, error, and hammering code out until weird things happen! I’ve always been more of a hardware guy than a software guy (old school stereotype I know!), and love putting stuff together that was never ever meant to work together, so this was a super fun project for me.
you can use a c64 as the editor (turbo assembler) etc and send code direct to the machine also.. video on youtube shows it
Thanks! Do you happen to have a link to the said video?