The AY-3-8910 and its variations were widely used in classical machines like for example the Sinclair ZX Spectrum, Amstrad CPC and Atari ST. It can produce up to three different squarewave sounds simoultaneously, and it also has one noise-generator and one envelope generator.

Allthough it has its limitations, there are tricks to get around a few of them:
1. Fast arpeggios to emulate chords on one chanel.
2. Software envelopes to get around the limitations of the single envelope generator.
3. Matching the hardware envelope to a played tone's frequency for a more sawtooth-like sound.
4. Software tone sweep
5. Using the volume controlls and certain settins to emulate a DAC for digital audio.

The fifth one is more of a hack, so the synth implements point 1-4. There is one software envelope and one tone-sweep parameter for every channel, and overall one noise-sweep parameter and one arpeggiator.

I'm still in the proccess of testing everything, but it should in theory work fine. I just hope that the 4MHz Z80 in my Tiki-100 computer is fast enough to handle 125 updates of the synth per second. Here is the documentation:

Code:

Next step will be to make a music player or real-time sequencer that uses this in some way or another.

How are you interfacing with it? This seems like it could be interesting to attempt something similar with the TI z80 calculators.

The interface of the chip is just a call to AYdrv (see the shutup subroutine above for an example). Register number in A, register operation in B and data in C. The idea is that anybody using the synth will insert their own module there, tailor made for their hardware. The start of the module is just some code that identifies and performs the right operation based on B. The actual hardware interface can be anything.

I'm planning to use this with the Tiki-100, where the chip is at I/O address $16 (register select) and $17 (data). Here is the code in tiki100ay.asm:

Code:

Oh cool, so you're actually designing your program in a hardware-agnostic fashion!

Can't wait to see some demos when you get things up and running.

Spendt some time yesterday to test everything in a convenient Amstrad CPC emulator. Ruled out a few bugs, and now it works just as expected. I also added the possibility to hold the envelope for some time on the attack peak since I thought the decay rate was a bit sharp with the exponential volume levels.

I've written a music sequencer/player that uses the synth, and I'm about halfways at plotting in a test-tune I've composed:
https://www.dropbox.com/s/fmg1or1qtf8yp2m/a.ogg?dl=0
(this is output from the Amstrad emulator, and timing is not perfect as I'm using a loop of nops for delay rather than a timer/interrupt)

The tunes are written with commands like "play 0 A4" and "wait 24", and I have coded a simple java-program that translates the text file to the binary sequencer-format.

I completed the simple music player, and now it runs on real hardware:

Wow.

Next up is the theme from the Mad Monster Manson level of Banjo-Kazooie.

Each tune is anywhere from 1k to 10k depending on complexity and lenght. The tune in the video is about 7k. The player and synth together is slightly less than 4k.

This tune is about 7k as well.

Wow, that's really cool stuff!

That was a lot of fun to listen to, and I can only imagine how much effort went into learning to interface with it. Out of curiosity, was that a song that you tracked yourself, or did you port an existing song to the particular format this synthesizer uses? Either way, I'm very impressed.

Thanks!

I tracked the song myself using a bytecode-translation tool I made in Java. The song is stored as commands in a textfile, like "play 0 C4", "wait 13", "release 2", "playarp 1 C4 E4 G4 2" and so on. This textfile is converted to a *.tkt bytecode data file. The player works directly with physical tracks (0, 1 and 2), which has turned to be a bit of a limitation.

I plan to write an improved version with virtual tracks, and certainly more than 3, together with a list defining the translation between the virtual channels and the physical channels. It will make things simpler, and easier to use as well. Instead of a designated arpeggiator function, you can play the tones you want in separate virtual channels and set up the translation list to swap between the virtual channels on one physical channel.