Making Chiptunes With 32 Bytes Of RAM

August 14, 2012 by Brian Benchoff 25 Comments

Ah, chiptunes. One of the few remaining human endeavours where less RAM, less storage space, and fewer capabilities are actually considered an improvement. [dop3joe] over at the Stuttgart hackerspace Shackspace sent in a tiny chiptune playing circuit using the most bare-bones hardware we’ve ever seen.

The Noiseplug, as [dop3joe] calls it, is based on a very, very small 6 pin ATtiny9. With 1 kB of Flash memory and only 32 bytes of RAM [dop3joe] was able to create a small device inside an RCA jack that plays chiptunes whenever it is powered by a battery.

If you’d like to make your own noise plug, [dop3j0e] put all the code up in his Git. There are two relevant pieces of software for this build: a Windows app to create the chiptunes, and the ATtiny9 firmware itself. Of course to program the tiny, you’ll have to deal with the Atmel TPI, so here’s the application note (PDF).

Oh, [dop3joe] won third place at the Evoke demoscene party last weekend with the Noiseplug. Awesome.

Chiptune Player Uses Preprocessed .MOD Files

June 27, 2012 by Mike Szczys 6 Comments

[Kayvon] just finished building this chiptune player based on a PIC microcontroller. The hardware really couldn’t be any simpler. He chose to use a PIC18F2685 just because it’s big enough to store the music files directly and it let him get away with not using an external EEPROM for that purpose. The output pins feed a Digital to Analog Convert (DAC) chip, which in turn outputs analog audio to an LM386 OpAmp. The white trimpot sandwiched between the chips controls the volume.

The real work on this project went into coding a program which translates .MOD files into something the PIC will be able to play. Because of the memory limits of the chip it is unable to directly use all of the instrument samples from these files. [Kayvon] wrote a program with a nice GUI that lets him load in his music and page through each instrument to fine-tune how they are being re-encoded. The audio track from the video after the break doesn’t do the project justice, but you will get a nice look at the hardware and software.

Continue reading “Chiptune Player Uses Preprocessed .MOD Files” →

Putting An Atari POKEY In Your Pocket

June 15, 2012 by Brian Benchoff 4 Comments

The Atari POKEY served as the main I/O chip on the venerable Atari 400/800 and XL/XE 8-bit computers. While a chip designed to get voltages from game paddles and scanning a matrix of keyboard switches wouldn’t normally be remembered 30 years later, the POKEY had another function: generating very, very distinctive music and sound effects for those old Atari games. [Markus Gritsch] wanted a portable version of the POKEY, so he emulated one on a modern microcontroller. Now he’s able to take those old Atari chiptunes where ever he goes.

The build uses the Another Slight Atari Player by emulating a 6502 and POKEY chip inside [Markus]’ PIC32MX-based microcontroller. There’s not much physical hardware [Markus] had to deal with – the board is built on a QFP proto board [Markus] picked up with a few buttons and a jack added for some simple I/O.

This isn’t [Markus]’s first attempt at portabalizing chiptunes – last year, we saw a truly awesome portable SID player that used the same PIC32 microcontroller and an emulated 6502. Between the Atari SAP Music Archive and the High Voltage SID Collection, [Markus] has more than enough chiptunes for days of listening pleasure.

Putting Every Chiptune Ever In An FPGA

June 7, 2012 by Brian Benchoff 21 Comments

Finally one device combines the power of the Commodore 64 SID, Atari ST YM2149, and Amiga MOD audio into one awesome box. It’s called the RetroCade Synth, and there’s a Kickstarter that is perfect for starting your chiptune composing journey.

[Jack]’s RetroCade synth is connects directly to the Papilio One 500k FPGA. All the classic chiptune ICs can be emulated in this FPGA including the Commodore 64 SID chip, and an Amiga MOD player. Being a follow-up to [Jack]’s previous FPGA YM2149 project, he also threw that chip into the project for good measure. While the RetroCade doesn’t ship with every old chiptune IC – there isn’t support for NES, Atari, GameBoy, or SN76489-based chiptunes yet – that is something [Jack] will add once the Kickstarter is completed.

After the break you can see [Jack] jamming out on his RetroCade project playing a YM2149, SID, and Amiga MOD sounds simultaneously. For $100, it’s comparable to the venerable MIDIbox SID, but also allows anyone to play whatever genre of chiptunes they desire.

Continue reading “Putting Every Chiptune Ever In An FPGA” →

Building An Arduino Chiptunes Project Inside An FPGA

April 20, 2012 by Mike Szczys 2 Comments

From time to time we find ourselves in the mood for some Chiptunes. You know, the music that accompanied all of the best 8-bit console games? These days there are a lot of projects that use the audio chips of yore to recreate the sounds, but you’re always faced with the issue of sourcing those parts. [Jack Gassett] took some inspiration from one of those projects, but solved the rare hardware dilemma by building his own Chiptunes MIDI device in an FPGA.

He saw one of our features on an Arduino controlled YM2149 programmable sound generator. He realized that you can already find FPGA libraries out there that mimic this sound generation hardware, and he’s already done extensive work with an Arduino soft processor. Why not combine the two?

He’s using a Papilio FPGA with a wing that includes a MIDI connector and audio-out jack. As you can hear in the clip after the break this sounds just like the real thing. And he’s got plans to roll as many different types of sound generating chips into the mix as possible. You know, one FPGA synth to rule them all.

Continue reading “Building An Arduino Chiptunes Project Inside An FPGA” →

Playing Chiptunes With A YM2149 And Optimizing An Arduino

April 10, 2012 by Brian Benchoff 19 Comments

[Oryx] grew up with the bleeps and bloops of an Atari ST, so it comes as no surprise he would want to relish in his nostalgia by playing with the YM2149 sound generator he recently picked up on eBay. Like most of us, [Oryx] went to his old standby, the Arduino, when it came to connect this bare chip to his computer. The first circuit didn’t work, so after a lot of poking around the firmware, [Oryx] discovered the benefits of hand-optimizing software.

There are a lot of sound files available for the YM2149 floating around on the Internet. These files are just dumps of the 16 registers at 50Hz, so it’s very easy to send these from a computer to an Arduino over a serial connection. Unfortunately, when [Oryx] got his breadboard set up nothing happened. After breaking out the ‘scope, he discovered the Arduino was switching pins 100 times slower than the YM2149 data sheet called for.

[Oryx] remembered seeing a great blog post going over the speed at which the digitalWrite() function changes pin states. We’ve seen this before, and the fastest way to change pin states on the Arduino is with the ugly bitwise manipulation. After changing a few lines of code, [Oryx] was switching two pins nearly simultaneously.

Now that the YM2149 chip is working correctly, [Oryx] is planning to make a MIDI synth out of his project. You can get an idea of how that will sound with the demo video he put up after the break.

Continue reading “Playing Chiptunes With A YM2149 And Optimizing An Arduino” →

Adding Visuals To Chiptune Performances

January 30, 2012 by Brian Benchoff 4 Comments

If you’ve never been to a chiptune show – yes, they exist – you’ve noticed the awesome visuals behind the performers that are usually displayed with a glitching NES. If it’s a really good show, that 8-bit visualization will be in sync with the music and may actually serve as a lo-fi spectrum analyzer. [Andy] came up with his own visualization system for a Sega Genesis or Megadrive. With 16 bits behind his build, we’ll say if far surpasses the lowly NES.

For his visualization, [Andy] feeds audio into an ATMega328 and the ever-popular MSGEQ7 seven-band graphic equalizer IC. The output from the EQ goes straight to the second controller input of a Sega Nomad [Andy] had lying around that is running a custom ROM for his show. The ROM is programmed in tandem with the microcontroller project to serve as a spectrum analyzer for his shows.

You can check out [Andy]’s visualization with the chiptunes of Danimal Cannon after the break. We would prefer a demo featuring An0vA and the code for the microcontroller, but it’s still a very nice demo indeed.

Continue reading “Adding Visuals To Chiptune Performances” →