Search options (Page 17 of 21)

Thinking on what and how to do an Arduino specific 1-bit engine.

Feature set does not seem too important. It could be something like a scaled up Tritone or Phaser, with more channels, with ability to play tone or noise. It needs to support things that are difficult in ZX engines, such as clean vibrato, portamento, and maybe 'instruments' (fx tables) in general.

There is a major issue that stops me at the moment, the authoring tools. We can't really make music for engines with any complex instruments system using an XM converter. We can't really emulate Arduino to hear authentic sound while making music - well, we could make a whole dedicated tracker with AVR emulator, but that's a ton of work just to start. An VSTi can be made that will generate more or less similar sound, but this would kind of defeat the whole point, because such VSTi would be self-sufficient and the sound won't fully match.

One idea is to make MIDI interface, just as people asked, and control the Arduino with a MIDI-enabled DAW, to be able to use existing tools for composing and hear fully authentic sound in the process. This, however, requires to have the hardware and two MIDI interfaces (on the PC and Arduino's MIDI Shield, which is barely obtainable here and costs more than Arduino, by the way).

Yet another idea is a VSTi again, but this time one that would just emulate AVR and loaded firmware with the engine. Again, lots of work, but at least the whole Arduino thing won't be redundant in this case.

Any MIDI-related approach also makes it difficult to create instruments, it has to be done with SysEx and a custom tool. Or just limit a composer to use pre-defined patches.

Now we're getting into something tricky and less straightforward that is not transferring to the Arduino and C well. That's the Tritone engine.

The main feature of the engine is the uneven volume balance, giving virtual volume control without the usual PWM'ish artifacts. It was achieved by using the standard interleaving technique, but assigning time slots of different length for each of the channels. I.e. longest slot gives loudest sound, shortest slot gives quitest sound. That's easy to achieve with the timed code, but in C on Arduino we don't have such luxury.

It (probably) can't be done with just a single fixed-frequency timer interrupt at a sample rate as high as half of the shortest slot (to be able to align output sequence to 2,3,4 samples to keep the original volume balance) - that would give over 200 KHz, and that's likely too much, just the interrupt call/return will hog most of CPU time.

A better approach that I come up with is to set a train of interrupt handlers, each sets up the timer to another value. The hardware interrupt handler function only contains call of the actual handler by a function pointer. There is three actual interrupt handling functions that gets called with the timer interrupt in a circular sequence. Each one sets up the next timer value, outputs current slot, calculates whathever is needed, and sets up the pointer to the next handler function. This gives steady sample rate just like the original Tritone had (actually 22988 Hz, due to the timer prescaler, which is not far from the original 22875 Hz), with proper interleaving slots aligment.

Drums were another tricky part. As the original code sure does not translate to the timer interrupt-driven approach well, I decided to do it lazy way this time - as 1-bit samples of the original sounds. There is fourth interrupt handling function that sets up the timer to doubled sample rate (45977 Hz) and plays sample while keeping the sync with parser thread. Once sample is done playing, the handler reverts to the tone synth handlers loop. Samples of the drums were captured from Unreal Speccy at 96 KHz, downsampled to the desired rate, amplified a lot to get hard clipping, so they're mostly max or zero volume, converted to 8-bit, then processed with a custom tool written in Python. To save Flash memory I used a RLE-like packing that only records how many samples there were between changes 0 to 1 or vice versa (I think that's what Speak Easy uses on ZX Spectrum), that's what the tool doing, besides of finding individual drum shots in a single WAV file.

Yet again, you can compile Tritone songs for the Arduino port with Beepola, exporting them as BIN without player. The test song is by garvalf - 'Bourrasques'.

Alright, I had enough of crappy sound coming from an old trasistor radio that has been used for testing for Octode and Phaser1 ports, which made quite difficult to judge if the sound is even correct. It became apparent that I need a better control, especially if something more complex or tricky than these engines considered, so I came up with a very simple schematics that may come handy if you need something like this too. Note that I'm not an EE, it may have mistakes in the design, but at least it something that works. It can be used to connect headphones (volume is not too bad even without amplifier), line input, or an amplifier.

R1 and C2 here are the low pass filter, the values calculated for ~16 KHz cutoff to avoid possible hiss artifacts that is typical for the 'interleaving' 1-bit enignes.

C1 is a coupling capacitor to block the DC offset. Potentiometer R2 allows to change the output level. The values for these were chosen just because I didn't have anything else. These together actually act as a high pass filter, but the cutoff is ~1.5 Hz, so it should not affect the sound. Volume range is good as well, smooth transition from zero to max.

Also, some tech porn:

http://shiru.untergrund.net/temp1/ardui … _out_1.jpg
http://shiru.untergrund.net/temp1/ardui … _out_2.jpg

Continuing the least imaginative way, here is second port of a ZX beeper engine to Arduino, in C.

This time it is an interleaving type engine. Porting approach is totally naive, just a timer interrupt at the bit output frequency, similar to the Octode implementation, but doubled because of the interleaving, with two alternating code paths. It easily works on its original sample rate of 23972 Hz (47945 Hz interrupts), and actually can work even at 44100 Hz (88200 Hz interrupts!). Didn't try higher rates because it was near the timer resolution limit with selected prescaler.

The most difficult part in the porting process was the Phaser1 format itself, it is quite tricky as you know. I chose the Beepola version, so you can just compile Phaser1 songs in Beepola and export them as BIN without player. Just don't forget that if you change the compile address in Beepola, you have to change the COMPILE_ADR in the C code too. Only the 'digital drums' version is implemented.

The song in the demo build is Mister Beep's Greetings to C64.

As for code tricks, nothing special here. The only tricky moment was catching the carry for 16-bit addition. It was done by checking if the value become lesser than it was before addition (normally should become greater), like that:

add hl,bc
jr c,...

n=acc;
acc+=add;
if(acc<n) ...