Battlezone with lasers

This is a project I've had simmering on the back burner for a while. Still at the early stages but thought it might be fun to keep track of each step here

A few months back I got a 20kps laser scanner galvo set off ebay with the intention of making my own laser projector and a vision of using it to play some old vector arcade games... particularly my old fave Atari Battlezone. The arcade game bit seemed pretty easy, since you can play BZ on the open source MAME emulator so I thought I could hook into the vector terminal emulation.

I found the asynchronous UART on an Arduino board was not quite fast enough to cope with the data... dropping bits all over the place, so I started looking at a USB conneciton to a PIC2455. As a SourceBoost C user I was not able to find any easy to understand USB CDC (Communication Device Class, a.k.a serial port) implementations for the PIC - so I decided to make my own, leaning heavily on sample code I found online.

Well I finally got to the point where my PIC would connect via USB show up as a COM port and be easy to access from a Windows program. Then I hooked up an 12-bit SPI dual DAC and connected it to the galvo setup and tried the first random hacking into MAMEs vector module.

I didn't expect it to work first time, and didn't! but my impatient hacking did produce some interesting squiggles at about 2 fps. I needed to use a long exposure photograph to actually make sense of it, but eventually I recognised a couple of parts of the display and got quite excited that the concept was proved!

The coordinate handling is obviously messed up and the image is wrapping on itself multiple times, also there is no attempt at blanking yet - so there are stray lines all over. The big job will be to find some way to optimise the render list to stop throwing the galvos all over the place and improve on the 2 fps refresh!

As you can see I have a long way to go!

Here is the plot showing the bits I recognised

Here is an actual MAME screen showing what it should look like

If things improve I will post an update!

Pre programmed PICs

Following some requests, I have listed pre-programmed PICs on ebay for a couple of my projects. If there is much interest (and its not all a massive hassle) I might also look into getting some PCBs made up and putting kits together
For now here are the PICs http://cgi.ebay.co.uk/ws/eBayISAPI.dll?ViewItem&item=150426687494

POKEY sound chip experiments

The Atari POKEY was the classic soundchip in the Atari 8-bit home computers and many 1980's arcade games. This clip shows some of my experiments in driving a POKEY from MIDI. A PIC receives MIDI data and two 74HC595 shift registers are used to assemble the 12 lines of bus data for the POKEY so it can be driven from a humble 14 pin PIC16F688. A 6N139 isolator is placed between MIDI in from PC and the PIC's serial input. The POKEY is clocked at 2MHz from the PIC's internal clock output.

I am using REAPER to sequence some MIDI files I found on the internet. Credit goes out to the authors of these MIDI files.. also to YouTube member little-scale, whose clips inspired me to poke about with the POKEY in the first place, and Bryan Edewaard, whose crib sheet I could not have done this without.

Here is the schematic for the circuit as built on breadboard (I am working on neater, stripboard based version)



And the source code for SOURCEBOOST C on the PIC16F688

#include <system.h>

#include <memory.h>



// PIC CONFIG (_INTRC_OSC_CLKOUT is needed so we output clock

// clock signal on pin 3)

#pragma DATA _CONFIG, _MCLRE_OFF & _WDT_OFF & _INTRC_OSC_CLKOUT

#pragma CLOCK_FREQ 8000000

typedef unsigned char byte;



// define the pins

#define P_DATA portc.0

#define P_SHCK portc.2

#define P_STCK portc.1

#define P_POKEY portc.3



// define "pure" tone sound mode. Other settings

// of bits 4-7 will add varying levels of distortion

#define POKEY_SOUNDMODE 0b10100000



// MIDI defs

#define MIDIMSG(b) ((b)>>4)

#define MIDICHAN(b) ((b)&0xf)

#define MIDIMSG_NOTEON 0x09

#define MIDIMSG_NOTEOFF 0x08



// structure for managing channel info

typedef struct

{

byte midiNote; // triggered MIDI note

byte note; // POKEY divider value

byte volume; // volume (bits 0-3)

byte count; // playing duration counter

} CHANNEL;



// Buffer to hold state of 4 POKEY voice channels

CHANNEL chan[4] = {0};



// MIDI message registers

byte runningStatus = 0;

byte midiParams[2] = {0};

byte numParams = 0;

byte thisParam = 0;



// Divider values for POKEY channels

byte notes[48] = {

250, // C#2

236, // D2

222, // D#2

210, // E2

198, // F2

187, // F#2

177, // G2

167, // G#2

157, // A2

148, // A#2

140, // B2

132, // C3

125, // C#3

118, // D3

111, // D#3

105, // E3

99, // F3

94, // F#3

88, // G3

83, // G#3

79, // A3

74, // A#3

70, // B3

66, // C4

62, // C#4

59, // D4

56, // D#4

52, // E4

50, // F4

47, // F#4

44, // G4

42, // G#4

39, // A4

37, // A#4

35, // B4

33, // C5

31, // C#5

29, // D5

28, // D#5

26, // E5

25, // F5

23, // F#5

22, // G5

21, // G#5

20, // A5

19, // A#5

18, // B5

17 // C6

};



////////////////////////////////////////////////////////////

// INITIALISE SERIAL PORT FOR MIDI

void init_usart()

{

pir1.1 = 1; //TXIF

pir1.5 = 0; //RCIF



pie1.1 = 0; //TXIE no interrupts

pie1.5 = 0; //RCIE no interrupts



baudctl.4 = 0; // SCKP synchronous bit polarity

baudctl.3 = 1; // BRG16 enable 16 bit brg

baudctl.1 = 0; // WUE wake up enable off

baudctl.0 = 0; // ABDEN auto baud detect



txsta.6 = 0; // TX9 8 bit transmission

txsta.5 = 1; // TXEN transmit enable

txsta.4 = 0; // SYNC async mode

txsta.3 = 0; // SEDNB break character

txsta.2 = 0; // BRGH high baudrate

txsta.0 = 0; // TX9D bit 9



rcsta.7 = 1; // SPEN serial port enable

rcsta.6 = 0; // RX9 8 bit operation

rcsta.5 = 1; // SREN enable receiver

rcsta.4 = 1; // CREN continuous receive enable



spbrgh = 0; // brg high byte

spbrg = 15; // brg low byte (31250)



}



////////////////////////////////////////////////////////////

// RECEIVE MIDI MESSAGE

// Return the status byte or 0 if nothing complete received

// caller must check midiParams array for byte 1 and 2

byte receiveMessage()

{

// loop until there is no more data or

// we receive a full message

for(;;)

{

// buffer overrun error?

if(rcsta.1)

{

rcsta.4 = 0;

rcsta.4 = 1;

}

// poll for a MIDI byte

if(!pir1.5)

{

// no data ready

return 0;

}



// read the character

byte q = rcreg;

pir1.5 = 0;



// is it a channel msg

if((q&0x80)>0)

{

numParams = 0;

thisParam = 0;

switch(q&0xf0)

{

case 0x80: // Note-off 2 key velocity

case 0x90: // Note-on 2 key veolcity

case 0xA0: // Aftertouch 2 key touch

case 0xB0: // Continuous controller 2 controller # controller value

case 0xC0: // Patch change 2 instrument #

case 0xE0: // Pitch bend 2 lsb (7 bits) msb (7 bits)

runningStatus = q;

numParams = 2;

break;

case 0xD0: // Channel Pressure 1 pressure

runningStatus = q;

numParams = 1;

break;

case 0xF0: // (non-musical commands) - ignore all data for now

runningStatus = 0;

return q;

}

}

// else do we have a channel message?

else if(runningStatus)

{

// fill in next command parameter

midiParams[thisParam++] = q;

if(thisParam>=numParams)

{

// return the command

thisParam = 0;

return runningStatus;

}

}

}

return 0;

}



////////////////////////////////////////////////////////////

// DRIVE DATA OUT TO SHIFT REGISTERS

// m is a bit mask to highest bit in the data

void dataOut(byte d, byte m)

{

while(m)

{

// shift clock low

P_SHCK = 0;



// data out

P_DATA = (d&m)?1:0;



// shift clock high

P_SHCK = 1;



// shift the mask

m>>=1;

}

}



////////////////////////////////////////////////////////////

// WRITE ADDRESS AND DATA TO POKEY

void writePokey(byte address, byte data)

{

// store clock low

P_STCK = 0;



// fill the shift regs

dataOut(address,0x08);

dataOut(data,0x80);



// store clock high

P_STCK = 1;



// pulse POKEY chip enable line

P_POKEY = 0;

delay_us(100);

P_POKEY = 1;

delay_us(100);

}



////////////////////////////////////////////////////////////

// POKEY RESET SEQUENCE

void resetPokey()

{

// fill all locations with 0

for(int i=0;i<16;++i)

writePokey(i, 0);

// reset sequence

writePokey(0x0f, 3);

writePokey(0x09, 1);

}



////////////////////////////////////////////////////////////

// HANDLE MIDI NOTE TRIGGER (ON OR OFF)

// MANAGES THE 4 VOICES

void handleNote(byte midiNote, byte midiVelocity)

{

int iAlreadyPlaying = -1;

int iFree = -1;

int iSteal = -1;

int iUpdatePOKEY = -1;

int iLongestPlay = -1;



// map 7-bit MIDI velocity to 4-bit POKEY volume

byte volume = midiVelocity >> 3;



// scan through the 4 channels

for(int i=0;i<4;++i)

{

// incremement play duration counter for this

// channel. we use this counter to detect which

// note has been playing longest if we need to

// steal a channel

chan[i].count++;



// check if the note is already playing on channel

if(chan[i].midiNote == midiNote)

{

iAlreadyPlaying = i;

}

// else is channel spare?

else if(!chan[i].midiNote)

{

iFree = i;

}

// else is channel the longest playing channel?

else if(chan[i].count > iLongestPlay)

{

iLongestPlay = chan[i].count;

iSteal = i;

}

}



// already got a channel playing this note?

if(iAlreadyPlaying > 0 )

{

// need to stop a note?

if(!volume)

{

// turn a note off

chan[iAlreadyPlaying].midiNote = 0;

chan[iAlreadyPlaying].note = 0;

chan[iAlreadyPlaying].volume = 0;

chan[iAlreadyPlaying].count = 0;

iUpdatePOKEY = iAlreadyPlaying;

}

}

// else check we have a nonzero volume. We will ignore

// zero volume requests against any note that is not already

// playing

else if(volume>0)

{

// convert from MIDI note to index in the notes[] array

byte note = midiNote;

while(note<37) note+=12; // 37 is lowest MIDI note we map

while(note>84) note-=12; // 84 is highest MIDI note we map

note-=37; // convert to array index value



// got a free channel?

if(iFree>0)

{

// use it

chan[iFree].midiNote = midiNote;

chan[iFree].note = notes[note];

chan[iFree].volume = volume;

chan[iFree].count = 0;

iUpdatePOKEY = iFree;

}

// else steal a channel from another note

else if(iSteal>0)

{

chan[iSteal].midiNote = midiNote;

chan[iSteal].note = notes[note];

chan[iSteal].volume = volume;

chan[iSteal].count = 0;

iUpdatePOKEY = iSteal;

}

}



// do we need to tell the POKEY anything?

if(iUpdatePOKEY > 0)

{

// make it so!

writePokey(0 + iUpdatePOKEY*2, chan[iUpdatePOKEY].note);

writePokey(1 + iUpdatePOKEY*2, POKEY_SOUNDMODE|chan[iUpdatePOKEY].volume);

}

}



void main()

{

// osc control / 8MHz / internal

osccon = 0b01110001;



// timer0... configure source and prescaler

cmcon0 = 7;



// configure io

trisa = 0b00010000;

trisc = 0b00110000;

ansel = 0b00000000;



// initialise MIDI comms

init_usart();



// reset the POKEY

resetPokey();



// loop forever

for(;;)

{

// get next MIDI note

byte msg = receiveMessage();



// handle note on/off (transpose down 1 octave)

if(MIDIMSG_NOTEON == MIDIMSG(msg))

handleNote(midiParams[0]-12, midiParams[1]);

else if(MIDIMSG_NOTEOFF == MIDIMSG(msg))

handleNote(midiParams[0]-12, 0);

}

}

Hand-cranked MIDI sequencer from a baked bean can

One empty baked bean tin, some lego and a stack of little magnets... stick magnets on the tin and slide them about to 'program' the sequencer, then grab hold of the 'transport control' and crank away.... The breadboard contains 5 hall-effect switches and a PIC16F688 to generate MIDI note on/off information. This is piped to Reason in the first half of the clip and to a Dave Smith Mopho synth in the second half.
I reckon with a baked bean tin about 16ft in diameter and about 25,000 magnets you could dump your sequencer software.. and you'd be getting some good aerobic exercise to boot :o)



Here is the schematic (if you make one, note that hall effect switches need the magnet to be the right way round.. if it does not trigger, flip the magnet over)


And the code (SourceBoost C... NOTE: you'll need programmer hardware like PICKit2 to burn the program to the PIC chip)
// HALL SENSOR TO MIDI NOTES

// J.Hotchkiss Mar2010

#include <system.h>

#include <memory.h>



// PIC CONFIG

#pragma DATA _CONFIG, _MCLRE_OFF&_WDT_OFF&_INTRC_OSC_NOCLKOUT

#pragma CLOCK_FREQ 8000000



#define P_SENSE1 porta.5

#define P_SENSE2 portc.2

#define P_SENSE3 portc.1

#define P_SENSE4 portc.0

#define P_SENSE5 porta.2



typedef unsigned char byte;



// INITIALISE SERIAL PORT FOR MIDI

void init_usart()

{

pir1.1 = 1; //TXIF transmit enable

pie1.1 = 0; //TXIE no interrupts



baudctl.4 = 0; // synchronous bit polarity

baudctl.3 = 1; // enable 16 bit brg

baudctl.1 = 0; // wake up enable off

baudctl.0 = 0; // disable auto baud detect



txsta.6 = 0; // 8 bit transmission

txsta.5 = 1; // transmit enable

txsta.4 = 0; // async mode

txsta.2 = 0; // high baudrate BRGH



rcsta.7 = 1; // serial port enable

rcsta.6 = 0; // 8 bit operation

rcsta.4 = 0; // enable receiver



spbrgh = 0; // brg high byte

spbrg = 15; // brg low byte (31250)

}



////////////////////////////////////////////////////////////

// SEND A MIDI BYTE

void send(unsigned char c)

{

txreg = c;

while(!txsta.1);

}



////////////////////////////////////////////////////////////

// CONTINUOUS CONTROLLER MESSAGE

void sendController(byte channel, byte controller, byte value)

{

send(0xb0 | channel);

send(controller&0x7f);

send(value&0x7f);

}



////////////////////////////////////////////////////////////

// NOTE MESSAGE

void startNote(byte channel, byte note, byte value)

{

send(0x90 | channel);

send(note&0x7f);

send(value&0x7f);

}



void main()

{

// osc control / 8MHz / internal

osccon = 0b01110001;



// timer0... configure source and prescaler

option_reg = 0b10000011;

cmcon0 = 7;



porta=0;

wpua=0;

portc=0;



// configure io

trisa = 0b00100100;

trisc = 0b00001111;

ansel = 0b00000000;



// initialise MIDI comms

init_usart();



// Set up the MIDI notes for each sensor

byte note[5] = {60,62,64,65,66};

// byte note[5] = {36,37,38,39,40}; // For Reason REDRUM

byte sense[5] = {0};

for(;;)

{

if(P_SENSE1 != sense[0])

{

startNote(0, note[0], P_SENSE1? 0:127);

sense[0] = P_SENSE1;

}

if(P_SENSE2 != sense[1])

{

startNote(0, note[1], P_SENSE2? 0:127);

sense[1] = P_SENSE2;

}

if(P_SENSE3 != sense[2])

{

startNote(0, note[2], P_SENSE3? 0:127);

sense[2] = P_SENSE3;

}

if(P_SENSE4 != sense[3])

{

startNote(0, note[3], P_SENSE4? 0:127);

sense[3] = P_SENSE4;

}

if(P_SENSE5 != sense[4])

{

startNote(0, note[4], P_SENSE5? 0:127);

sense[4] = P_SENSE5;

}

}

}

MIDI Guitar on Stripboard... Kind of

Somewhere between the Omnichord and the Stylophone lies this thing... simple but suprisingly effective... a PIC16F688 microcontroller, 2 shift registers IC's, 36 switches and a bunch of wire. The buttons select major/minor/maj7/min7/7/dim/aug chords based on any root note, and you "strum" across 3-4 octaves of notes from the chord by touching bits of exposed wire with a "stylus". The output is all MIDI (circuit makes no sound by itself) and Reason is being used here for sounds.



Note - If you are new to PIC stuff and want to make your own version of this project, remember you will need some way to program the PIC chip (its like a tiny computer and it comes without any software installed). The code is included below, but you'll need to compile it (using the free SourceBoost compiler) and "burn" it to the PIC... you can buy a programmer (e.g. PICkit2) or maybe borrow one. If there is enough demand I might be able to provide pre-programmed PIC16F688's for this, or my other PIC projects. Drop me a message if you'd be interested.



Schematic


The business end...


The mess on the back...


How it works (if you are interested)...
It's the tried and trusted principle of the keyboard matrix - the 74HC595 IC's are "shift registers" which are simply used to scan a single "on" bit across 16 lines, one at a time (all 16 are used for the stylus, the first 12 are used for the columns of the kepad). The program running on the PIC chip reads the voltage coming back from each row of the keypad and also from the stylus. Since the program knows which one of the 16 shift register outputs it has switched "on" at any moment in time it then knows which buttons are pressed / which "strings" the stylus is touching at any moment in time by which input lines (if any) it reads the voltage back on. The rest is down to the program code to convert this info into MIDI notes and send them to a synth. One other important things are the 10k "pull down" resistors on each of the 3 keyboard rows and the stylus line... they make sure that an unconnected line settles at 0V rather than reading spurious random values.

The source code
// STRUM CHORD CONTROLLER

// (c) 2010 J.Hotchkiss

// SOURCEBOOST C FOR PIC16F688

#include <system.h>

#include <memory.h>



// PIC CONFIG

#pragma DATA _CONFIG, _MCLRE_OFF&_WDT_OFF&_INTRC_OSC_NOCLKOUT

#pragma CLOCK_FREQ 8000000



// Define pins

#define P_CLK porta.2

#define P_DS portc.0

#define P_STYLUS portc.1

#define P_HEARTBEAT portc.2

#define P_KEYS1 portc.3

#define P_KEYS2 porta.4

#define P_KEYS3 porta.5



typedef unsigned char byte;



// Chord types

enum {

CHORD_NONE,

CHORD_MAJ,

CHORD_MIN,

CHORD_DOM7,

CHORD_MAJ7,

CHORD_MIN7,

CHORD_AUG,

CHORD_DIM

};



// special note value

#define NO_NOTE 0xff

//byte silent[1] = {NO_NOTE};



// Define the chord structures

byte maj[3] = {0,4,7};

byte min[3] = {0,3,7};

byte dom7[4] = {0,4,7,10};

byte maj7[4] = {0,4,7,11};

byte min7[4] = {0,3,7,10};

byte dim[3] = {0,3,6};

byte aug[3] = {0,3,8};



// Define the MIDI root notes mapped to each key

byte roots[16]={36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51};



// bit mapped register of which strings are currently connected

// to the stylus (notes triggered when stylus breaks contact

// with the strings)

unsigned long strings =0;



// Notes for each string

byte notes[16] = {0};



// current chord type

byte lastChordType = CHORD_NONE;



// current root note

byte lastRoot = NO_NOTE;





////////////////////////////////////////////////////////////

// INITIALISE SERIAL PORT FOR MIDI

void init_usart()

{

pir1.1 = 1; //TXIF transmit enable

pie1.1 = 0; //TXIE no interrupts



baudctl.4 = 0; // synchronous bit polarity

baudctl.3 = 1; // enable 16 bit brg

baudctl.1 = 0; // wake up enable off

baudctl.0 = 0; // disable auto baud detect



txsta.6 = 0; // 8 bit transmission

txsta.5 = 1; // transmit enable

txsta.4 = 0; // async mode

txsta.2 = 0; // high baudrate BRGH



rcsta.7 = 1; // serial port enable

rcsta.6 = 0; // 8 bit operation

rcsta.4 = 0; // enable receiver



spbrgh = 0; // brg high byte

spbrg = 15; // brg low byte (31250)

}



////////////////////////////////////////////////////////////

// SEND A MIDI BYTE

void send(unsigned char c)

{

txreg = c;

while(!txsta.1);

}



////////////////////////////////////////////////////////////

// CONTINUOUS CONTROLLER MESSAGE

void sendController(byte channel, byte controller, byte value)

{

P_HEARTBEAT = 1;

send(0xb0 | channel);

send(controller&0x7f);

send(value&0x7f);

P_HEARTBEAT = 0;

}



////////////////////////////////////////////////////////////

// NOTE MESSAGE

void startNote(byte channel, byte note, byte value)

{

P_HEARTBEAT = 1;

send(0x90 | channel);

send(note&0x7f);

send(value&0x7f);

P_HEARTBEAT = 0;

}



////////////////////////////////////////////////////////////

// CALCULATE NOTES FOR A CHORD SHAPE AND MAP THEM

// TO THE STRINGS

void changeToChord(int root, int which)

{

int i,j,len=0;

byte *struc = maj;

byte chord[16];



if(CHORD_NONE == which || NO_NOTE == root)

{

// stop playing

for(i=0;i<16;++i)

chord[i] = NO_NOTE;

}

else

{

// select the correct chord shape

switch(which)

{

case CHORD_MIN:

struc = min;

len = sizeof(min);

break;

case CHORD_DOM7:

struc = dom7;

len = sizeof(dom7);

break;

case CHORD_MAJ7:

struc = maj7;

len = sizeof(maj7);

break;

case CHORD_MIN7:

struc = min7;

len = sizeof(min7);

break;

case CHORD_AUG:

struc = aug;

len = sizeof(aug);

break;

case CHORD_DIM:

struc = dim;

len = sizeof(dim);

break;

case CHORD_MAJ:

default:

struc = maj;

len = sizeof(maj);

break;

break;

}



// fill the chord array with MIDI notes

int from = 0;

for(i=0;i<16;++i)

{

chord[i] = root+struc[from];

if(++from >= len)

{

root+=12;

from = 0;

}

}

}



// stop previous notes from playing if they are not a

// part of the new chord

for(i=0;i<16;++i)

{

if(notes[i] != NO_NOTE)

{

// check to see if it is part of the new chord

byte foundIt = 0;

for(j=0;j<16;++j)

{

if(chord[j] == notes[i])

{

foundIt = true;

break;

}

}



// if not, then make sure its not playing

if(!foundIt)

{

startNote(0, notes[i], 0);

}

}

}



// store the new chord

for(i=0;i<16;++i)

notes[i] = chord[i];



}



////////////////////////////////////////////////////////////

// POLL KEYBOARD MATRIX AND STRINGS

void pollIO()

{

// clock a single bit into the shift register

P_CLK = 0;

P_DS = 1;

P_CLK = 1;

P_DS = 0;



// get ready to scan

int root = NO_NOTE;

int chordType = CHORD_NONE;

unsigned long b = 1;



// scan for each string

for(int i=0;i<16;++i)

{

// clock pulse to shift the bit (note that

// the first bit does not appear until the

// second clock pulse, since we tied shift and store

// clock lines together)

P_CLK = 0;

P_CLK = 1;



// did we get a signal back on any of the

// keyboard scan rows?

if(P_KEYS1 || P_KEYS2 || P_KEYS3)

{

// have we decided on the root note yet?

if(NO_NOTE == root)

{

// look up the root note

root = roots[15-i];



// get the correct chord shape

switch(

(P_KEYS1? 0b100:0)|

(P_KEYS2? 0b010:0)|

(P_KEYS3? 0b001:0))

{

case 0b111:

chordType = CHORD_AUG;

break;

case 0b110:

chordType = CHORD_DIM;

break;

case 0b100:

chordType = CHORD_MAJ;

break;

case 0b101:

chordType = CHORD_MAJ7;

break;

case 0b010:

chordType = CHORD_MIN;

break;

case 0b011:

chordType = CHORD_MIN7;

break;

case 0b001:

chordType = CHORD_DOM7;

break;

default:

chordType = CHORD_NONE;

break;

}

}

}



// now check whether we got a signal

// back from the stylus (meaning that

// it's touching this string)

byte whichString = 15-i;

if(P_STYLUS)

{

// string is being touched... was

// it being touched before?

if(!(strings & b))

{

// stop the note playing (if

// it is currently playing). When

// stylus is touching a string it

// is "damped" and does not play

// till contact is broken

if(notes[whichString] != NO_NOTE)

{

startNote(0, notes[whichString], 0);

}



// remember this string is being touched

strings |= b;

}

}

// stylus not touching string now, but was it

// touching the string before?

else if(strings & b)

{

// start a note playing

if(notes[whichString] != NO_NOTE)

{

startNote(0, notes[whichString], 127);

}



// remember string is not being touched

strings &= ~b;

}



// shift the masking bit

b<<=1;



}



// has the chord changed?

if(chordType != lastChordType || root != lastRoot)

{

// change to the new chord

lastChordType = chordType;

lastRoot = root;

changeToChord(root, chordType);

}

}



void main()

{

// osc control / 8MHz / internal

osccon = 0b01110001;



// timer0... configure source and prescaler

option_reg = 0b10000011;

cmcon0 = 7;



// configure io

trisa = 0b00110000;

trisc = 0b00001010;

ansel = 0b00000000;



// initialise MIDI comms

init_usart();



// initialise the notes array

memset(notes,NO_NOTE,sizeof(notes));

for(;;)

{

// and now just repeatedly

// check for input

pollIO();

}

}

Stylophone MIDI controller

A few months ago I used an Arduino clone board to send MIDI messages out of a Stylophone. I always intended to take it to the next level and get another Stylophone (preferably a broken one) and rip out the guts to fit all the electronics inside, and also add a few buttons and pots for perfomance controllers.

Well, I finally got round to it. This time I am using a PIC16F688 microcontroller.. this little monkey only has 14 pins and costs a mere £1 yet it has a built in clock, serial port and ADC, which means its pretty much the *only* component needed in this project (with the exception of a couple of resistors and switches).

I added a pitchbend pot, a modwheel and a pot to control the note velocity. And pushbuttons to shift octaves and "hold" a MIDI note (basically force the code to forget to send note-off message so the last note rings on after lifting the stylus). This allows a kind of polyphonic drone out of the usually strictly monophonic stylophone.



I will include the code below. I wont bother with a schematic, but the wiring to the PIC16F688 is as follows

pin 1 - 5 volt supply
2 - octave UP momentary switch (other side of switch connected to ground)
3 - octave DOWN momentary switch (other side of switch connected to ground)
6 - to pin 5 of MIDI out socket via a 220R resistor. Pin 4 of the socket is pulled up to 5V via another 220R resitor
7 - wiper of PITCHBEND pot (100k). Pot terminal between from ground/+5V
8 - wiper of VELOCITY pot (100k). Pot terminal between from ground/+5V
9 - to the stylus. Also pulled up to +5v via 470k resistor
10 - activity LED via 1k resistor
11 - wiper of MOD WHEEL pot (100k). Pot terminal between from ground/+5V
13 - HOLD NOTE momentary switch (other side of switch connected to ground)
14 - to ground

If you want to run it from a PP3 you'll need a 5V voltage regulator. You also need to connect the stylophone keyboard/resistor ladder between 0V and 5V and you will need to set up the scale[] array based on the ADC values you get from each pad on *your* stylophone keyboard (which are almost certainly different to mine)

A few photos

// MIDI STYLOPHONE.. PIC16F688.. (c) 2010 hotchk155

// SourceBoost C



// Header files

#include <system.h>

#include <memory.h>



#pragma DATA _CONFIG, _MCLRE_OFF & _WDT_OFF & _INTRC_OSC_NOCLKOUT

#pragma CLOCK_FREQ 8000000

typedef unsigned char byte;



#define MIDI_A    45  // default root note

#define NO_NOTE   0x7f // means stylus "off keyboard"

#define NUM_PADS   20  // number of stylophone pads  



#define BUTTON_DEBOUNCE 10  // debounce octave buttons

#define ADC_AQUISITION_DELAY 10 // settling time for ADC

#define PBD_TOL   16  // tolerance applied to pitchbend ADC

#define MOD_TOL   5  // tolerance applied to modulation ADC



// Digital pins

#define P_HEARTBEAT  portc.0 // activity LED

#define P_UP   porta.5 // octave UP button

#define P_DN   porta.4 // octave DOWN button

#define P_HOLD   porta.0 // note hold button



// Analog pin mappings

#define ANA_MOD 0b00001000  // AN2 - MOD WHEEL

#define ANA_KBD 0b00010100 // AN5 - KEYBOARD STYLUS

#define ANA_VEL 0b00011100 // AN6 - VELOCITY

#define ANA_PBD 0b00011000 // AN7 - PITCHBEND



// define the four analog inputs

enum {

 ADC_KBD,

 ADC_VEL,

 ADC_MOD,

 ADC_PBD,

 ADC_MAX

};



// for the state machine which read analog inputs

enum {

 ADC_CONNECT,

 ADC_ACQUIRE,

 ADC_CONVERT    

};



// define the ADC readings for each stylophone key pad. This

// is likely to be different if you make your own circuit, so

// you will need to work out your own ADC values

int scale[NUM_PADS+1] = {

 0x000,

 0x043,

 0x081,

 0x0b9,

 0x0ed,

 0x110,

 0x149,

 0x172,

 0x199,

 0x1bd,

 0x1df,

 0x1ff,

 0x21c,

 0x238,

 0x252,

 0x26b,

 0x281,

 0x298,

 0x2ab,

 0x2c0,

 0x3ff

};



// midi note at bottom of scale (can be shifted

// up and down by an octave at a time)

char baseNote = MIDI_A;



// data used by doADC function

byte adcInput[ADC_MAX] = {ANA_KBD, ANA_VEL, ANA_MOD, ANA_PBD};

byte adcInitComplete = 0;

int adcResult[ADC_MAX] = {-1,-1,-1,-1};

int adcIndex = 0;

int adcState = ADC_CONNECT;



////////////////////////////////////////////////////////////////

// 

// init_usart

//

// Initialise the PIC16F688 USART (serial port) according to the

// requirements of sending MIDI traffic

//

void init_usart()

{

 pir1.1 = 1; //TXIF transmit enable

 pie1.1 = 0; //TXIE no interrupts

 

 baudctl.4 = 0;  // synchronous bit polarity 

 baudctl.3 = 1;  // enable 16 bit brg

 baudctl.1 = 0;  // wake up enable off

 baudctl.0 = 0;  // disable auto baud detect

  

 txsta.6 = 0; // 8 bit transmission

 txsta.5 = 1; // transmit enable

 txsta.4 = 0; // async mode

 txsta.2 = 0; // high baudrate BRGH



 rcsta.7 = 1; // serial port enable

 rcsta.6 = 0; // 8 bit operation

 rcsta.4 = 0; // enable receiver

 

 spbrgh = 0;  // brg high byte

 spbrg = 15;  // brg low byte (31250 baud) 

}

  

////////////////////////////////////////////////////////////////

// 

// send

//

// Send a single byte out on the serial port

//

void send(byte c)

{

 txreg = c;

 while(!txsta.1);

}



////////////////////////////////////////////////////////////////

// 

// sendController

//

// Send a MIDI continous controller message

//

void sendController(byte channel, byte controller, byte value)

{

 P_HEARTBEAT = 1;

 send(0xb0 | channel);

 send(controller&0x7f);

 send(value&0x7f);

 P_HEARTBEAT = 0; 

}



////////////////////////////////////////////////////////////////

// 

// startNote

//

// Send a MIDI note on message (or note off if 0 velocity)

//

void startNote(byte channel, byte note, byte velocity)

{

 P_HEARTBEAT = 1;

 send(0x90 | channel);

 send(note&0x7f);

 send(velocity&0x7f);

 P_HEARTBEAT = 0; 

}



////////////////////////////////////////////////////////////////

// 

// pitchBend

//

// Send a MIDI pitchbend message (14 data bits)

//

void pitchBend(byte channel, int value) {

  P_HEARTBEAT = 1;

  byte msb = (value>>7)&0x7f;

  byte lsb = value&0x7f;

  send(0xE0 | channel);

  send(lsb);

  send(msb);

  P_HEARTBEAT = 0;

}



////////////////////////////////////////////////////////////////

// 

// doADC

//

// State machine for running the ADC and updating the adcResult

// array with the result from each analog input. This function is 

// called periodically and keeps the adcResult[] array updated so

// other code can just check the array rather than making direct

// calls to the ADC

//

void doADC()

{

 switch(adcState)

 {

  // Connect ADC to the correct analog input

  case ADC_CONNECT:   

   adcon0=0b10000001 | adcInput[adcIndex];

   tmr0 = 0;

   adcState = ADC_ACQUIRE;

   // fall through

   

  // Waiting for a delay while the ADC input settles

  // - this is neededs or you can get garbage readings

  // as the ADC transitions between one input voltage

  // and another. The TMR0 (timer 0) register is used for

  // timings this

  case ADC_ACQUIRE:

   if(tmr0 > ADC_AQUISITION_DELAY)

   {

    // Start the conversion

    adcon0.1=1;

    adcState = ADC_CONVERT;    

   }

   break;

   

  // Waiting for the conversion to complete

  case ADC_CONVERT:

   if(!adcon0.1)

   {

    // store the result. Note that the PIC16F688 has

    // a 10 bit ADC so we need to form a 10 bit value

    // from ADRESH and ADRESL

    adcResult[adcIndex] = (((int)adresh)<<8)|adresl;    

    

    // and prepare for the next ADC

    if(++adcIndex>=ADC_MAX)

    {

     adcIndex = 0;

     

     // flag that each ADC has been read at least

     // one time, so adcResult now contains valid

     // information

     adcInitComplete = 1;

    }

    adcState = ADC_CONNECT;    

   }

   break;

 }   

}



////////////////////////////////////////////////////////////////

// 

// getNote

//

// Map ADC values from the stylus to MIDI note values by 

// looking for the scale[] entry which lies closest to the

// input value

//

char getNote(int input)

{

    for(int i = 0; i < NUM_PADS; ++i)

    {

      int lo = 0;

      int hi = 0x3ff;

      if(i>0)

      {

        lo = (scale[i-1] + scale[i]) / 2;

      }

      if(i<NUM_PADS)

      {

        hi = (scale[i] + scale[i+1]) / 2;

      }

      if(input >=lo && input <=hi)

      {

        if(i==NUM_PADS)

          return NO_NOTE;

        return baseNote+i;

      }

    }

    return NO_NOTE;

}



////////////////////////////////////////////////////////////////

// 

// main

//

// Where program starts running!

//

void main()

{ 

 // osc control / 8MHz / internal

 osccon = 0b01110001;

 

 // timer0... configure source and prescaler

 // port A weak pull ups enabled

 option_reg = 0b00000011;

 

 // enable pull ups on each button

 wpua = 0b00110001;



 // turn off the comparator to allow digital IO on CIO pins

 cmcon0 = 7;               

 

 // set data direction on each pin       

 trisa = 0b00110101;              

 trisc = 0b00001110;              

 

 // set up the analog input pins

 ansel = 0b11100100;

  

 // turn on the ADC

 adcon1=0b00100000; //fOSC/32

 adcon0=0b10000001; // Right justify / Vdd / AD on



 // start up the serial port

 init_usart();

 

 // ensure that the initial aquisition is completed

 // for all analog inputs that we're using

 adcInitComplete = 0;

 while(!adcInitComplete)

  doADC();

 

 

 //char buttons = 0;

 char debounce = 0; 

 char lastNote = NO_NOTE;

 int lastPitchBend = -1;

 int lastModWheel = -1;

 int value;

 int diff;

 for(;;)

 {

  // the debounce variable makes sure that user

  // has release buttons for a period of time before

  // a new press on the button can be registered.

  // handles possibility of "switch bounce"

  

  // Buttons are pulled up and touch ground when 

  // pressed, so the pin reads low when the button

  // is being pressed

  if(debounce > 0)

  {

   if(P_UP&&P_DN)

    --debounce;

   

  }

  else

  {   

   if(!P_UP)

   {

    // octave shift UP

    if(baseNote < 103)

     baseNote+=12;

    debounce = BUTTON_DEBOUNCE;

   }

   else if(!P_DN)

   {

    // octave shift DOWN

    if(baseNote > 12)

     baseNote-=12;

    debounce = BUTTON_DEBOUNCE;

   }

  }



  // poll the ADCs

  doADC();



  // check for a new note being played

  char note = getNote(adcResult[ADC_KBD]);

  if(note != lastNote)

  {

   // do we need to kill the previous note?

   if(lastNote != NO_NOTE && P_HOLD)

   {

    // make it so!

    startNote(0,lastNote,0);

   }

   // is a new note playing (rather than stylus

   // removed from keyboard?)

   if(note != NO_NOTE)

   {

    // play a note with appropriate velocity

    char velocity = (adcResult[ADC_VEL]>>3)&0x7f;

    startNote(0,note,velocity);

   }

   lastNote = note;    

  }



  // check for change in pitchbend which is 

  // outside the "noise" tolerance

  value = adcResult[ADC_PBD];

  diff = value - lastPitchBend;

  if(diff*diff > (PBD_TOL*PBD_TOL))

  {

   // Send MIDI pitchbend.. this has a 14-bit

   // data value

   pitchBend(0, value<<4); 

   lastPitchBend = value;

  }



  // check for change in modwheel which is 

  // outside the "noise" tolerance

  value = adcResult[ADC_MOD]>>3;

  diff = value - lastModWheel;

  if(diff*diff > (MOD_TOL*MOD_TOL))

  {

   // Send MIDI continuous controller message

   // for controller #1 (mod wheel) which has

   // 7 bit data value

   sendController(0, 1, value);

   lastModWheel = value;

  } 

 }

}

DIY Games Console

Another PIC project... this one using a 14-pin 16F688 and playing a version of "Breakout". I might see if I can get a convincing version of "Space Invaders" to run on that 8x8 matrix too....



Usual setup of 74HC595 shift registers (x3) and ULN2803 NPN transistor arrays (x2). Columns are driven directly thru 100R resistors from one of the 595's... rows alternate red LEDs/green LEDs and are driven via 2 x chained 595's (data out from one goes to data in on the other) which in turn drive the NPN arrays, so only 5 I/O's from the MCU are needed to drive the display..

- Data in for the 595 driving the columns
- Shift clock for the 595 driving the columns
- Data in for the first of chained 595's driving the rows
- Shift clock for the pair of 595's driving the columns
- Store clock line for all 3 x 595's

There are 4 buttons: 3 are connected to PIC I/O for controlling game (only 2 used for Breakout game) and other is MCU reset (grounds MCLR#). 12k pull up resistors on all 4 lines.

The piezo buzzer is connected to the remaining I/O via a 0.1uF capacitor.

The LED matrix was from Sure Electronics (on eBay).. I got 10 of them for about £10. It is red/green but by driving both you get orange.

Here is the PIC code


#include <system.h>
#include <memory.h>

// Config bits
#pragma DATA _CONFIG, _WDT_OFF & _INTRC_OSC_NOCLKOUT 

// Clock freq (for SourceBoost delayt functions)
#pragma CLOCK_FREQ 8000000

typedef unsigned char byte;

// define IO ports
#define P_STORE     porta.2
#define P_DT_ROW    porta.4
#define P_SH_ROW    porta.5
#define P_DT_COL    portc.0
#define P_SH_COL    portc.1
#define P_BUTTON3 portc.5
#define P_SPEAKER portc.3
#define P_BUTTON1 portc.4
#define P_BUTTON2 portc.2

// define IO port direction
#define P_TRISA 0b00000000
#define P_TRISC 0b00110100

// macro defs
#define SET_RED(x,y) disp[y]|=1<<(7-(x))
#define SET_GREEN(x,y) disp[8+(y)]|=1<<(7-(x))
#define SET_ORANGE(x,y) SET_RED(x,y); SET_GREEN(x,y)    
#define BUTTON_DEBOUNCE 2

// info used by the interrupt handler
byte soundPhase = 0;
byte soundPeriod =  100;
byte soundDur = 0;

// display buffer (rows 0-7 for red, 8-15 for green)
byte disp[16];

//////////////////////////////////////////////////////
//
// interrupt handler 
//
// timer0 interrupt is used to drive the piezo speaker
//
void interrupt( void )
{
// check if this is timer0 overflow event
if( intcon.2 )
{
// drive the piezo sounder
soundPhase=!soundPhase;
P_SPEAKER = soundPhase?1:0;

// still sounding?
if(!soundDur)
{
// stop the interrupt.. killing sound
intcon.5 = 0;
}
else
{
// still sounding
--soundDur;
}

// setup the next timer interrupt
tmr0=soundPeriod;

// clear interrupt flag
intcon.2 = 0;

}
}

//////////////////////////////////////////////////////
//
// beep
// 
// start a sound playing
//
void beep(byte pitch, byte dur)
{
soundPeriod = 255-pitch;
soundDur = dur;
intcon.5 = 1;
}

//////////////////////////////////////////////////////
//
// refresh
// 
// update the LED matrix based on content of the 
// disp[] array
//
void refresh()
{
  int i;
  
  // clear vertical shift register and load a logic 1 at 
  // bit position 0. This bit will be shifted along to 
  // drive each row of the LED matrix in turn
  for(i=0;i<16;++i)
  {
    P_SH_ROW = 0;
    P_DT_ROW = (i==15)?1:0;
    P_SH_ROW = 1;
  }
  P_DT_ROW = 0;

  // for each row of data (8 x red, 8 x green)
  for(i=0;i<16;++i)
  {
// this cross reference of vertical bit position to row of the 
// disp[] array is used since the matrix is connected for wiring
// convenience and the order of rows is different
byte ix[16] = { 15, 7, 14, 6, 13, 5, 12, 4, 0, 8, 1, 9, 2, 10, 3, 11 };

// look up the row data byte
    byte d=disp[ix[i]];
    
    // store clock low
    P_STORE = 0;

    // load the 8 bits of data    
    for(int j=0;j<8;++j)
    {
      // shift a column bit
      P_SH_COL = 0;
      P_DT_COL = d&1;
      P_SH_COL = 1;
      d>>=1;
    }
    
    // store clock high.. row data is clocked to 
    // the output of shift registers, simultaneously
    // with the clocking in of a new scan row in the
    // vertical shift registers
    P_STORE = 1;

    // set pins low again and add a "display delay"
    // while the row data is shown, before it is 
    // hidden again
    P_SH_ROW = 0;
    P_DT_COL = 0;
    delay_ms(1);  
    P_SH_ROW = 1;
    P_STORE = 0;
  }
  P_SH_COL = 0;  
  P_SH_ROW = 0;  
}    
   
void breakout()
{
int i;
byte bricks[8];
byte rowsOfBricks=3;
byte speed = 250;
byte lives=3;

// loop for each level
for(;;)
{
// setup the wall
memset(bricks,0,sizeof(bricks));
memset(bricks,255,rowsOfBricks);
    
// init variables
char x=3; // position of bat
char bx=4; // position of ball
char by=6;
char dx=0; // direction of ball
char dy=-1;

// ball movement counter. Set to a value to
// give a short delay at the start of a level
byte bc = 100;  

// counter used to debounce the movement buttons
byte buttonDebounce = 0;

// loop until level is complete
for(;;)
{
// do we need to move the ball?
if(++bc == 0)
{
// reset the counter
bc = speed;

// calc next ball position
char nx = bx + dx;
char ny = by + dy;
if(nx<0||nx>7) // off screen left or right
{
dx=-dx;
nx=bx;
}
if(ny<0||ny>7) // off screen top or bottom
{
dy=-dy;
ny=by;
}
if(ny==7) // on the bottom row?
{
if(bx==x) // flat hit left side
{
if(dx>0) dx=0; else dx=-1;
beep(200,50);
}
else if(bx==x+1) // hit right side
{
if(dx<0) dx=0; else dx=1;
beep(200,50);
}
else if(nx==x) // hit left end
{
dx=-1;
beep(100,50);
}
else if(nx==x+1) // hit right end
{
dx=1;
beep(100,50);
}
else
{
// ball has dropped off bottom of screen
for(i=0;i<3;++i)
{
// death routine
refresh();
beep(50,100);
delay_ms(100);
refresh();
beep(150,100);
delay_ms(100);
}

// lose a life
if(lives-- <= 0)
{
// all lives gone
for(;;)
{
for(i=0;i<50;++i)
refresh();
delay_ms(500);
}
}
else
{
// start of next round
x=3;
bx=4;
by=6;
dx=0;  
bc=100;
}
}

// common stuff
nx=bx;
ny=by;
dy=-1;
}

// move the ball
bx = nx;
by = ny;

// hit a brick?
if(bricks[by]&(1<<(7-bx)))
{
// remove the brick and bounce
bricks[by]&=~(1<<(7-bx));
dy=-dy;
beep(100,200);

// any bricks left?
byte allGone = 1;
for(i=0;i<sizeof(bricks);++i)
{
if(bricks[i])
{
allGone=0;
break;
}
}

// end of level
if(allGone)
{
// beep
for(i=0;i<10;++i)
{
beep(50,50);
delay_ms(100);
}

// add more bricks
if(rowsOfBricks<5)
{
rowsOfBricks++;
}
else
{
// or make it faster
if(speed < 254)
++speed;
}
break;
}
}
}

// prepare screen buffer
memcpy(&disp[0], bricks, sizeof(bricks));
memcpy(&disp[8], bricks, sizeof(bricks));

// show ball
SET_RED(bx,by);

// show bat
SET_GREEN(x,7);
SET_GREEN(x+1,7);

// still in debounce period?
if(buttonDebounce)
{
// wait for button release
if(P_BUTTON1 && P_BUTTON2 && P_BUTTON3)
buttonDebounce--;
}
else 
{
// left?
if(!P_BUTTON1)
{
if(x>0) x--;
buttonDebounce = BUTTON_DEBOUNCE;
}
// right?
else if(!P_BUTTON2)
{
if(x<6) x++;
buttonDebounce = BUTTON_DEBOUNCE;
}
}

// and refresh the display
refresh();
}
}
}

void main()
{ 

osccon = 0b01110001; // osc control / 8MHz / internal
cmcon0 = 7; // comparator off
ansel=0; // digital IO

trisa = P_TRISA; // port A I/O direction
trisc = P_TRISC; // port C I/O direction
  
porta = 0; // clear port A
portc = 0; // clear port C

option_reg = 0b10000011; // timer0... configure source and prescaler
intcon.7 = 1; // GIE - enable interrupts
intcon.6 = 1; // PEIE - enable interrupts
intcon.5 = 0; // T0IE - timer 0 interrupts diabled for now
intcon.2 = 0; // T0IF - clear timer 0 interrupt flag

breakout();
}

Make your own annoying musical greetings card!

I love the tiny 8 pin PICs from Microchip.. an entire computer in a package the size of a fingernail that costs pennies and can be programmed from your PC using just C and run on a watch battery. They're great.. but its taken me a while to find a use for one.

This was a quick and silly project to play a tune on a piezo sounder. Hopefully the comments in the source code included below are enough to work out whats going on.. this was actually a great project to work out how to use timers and interrupts on PICs, which I'd not done before. There were a few little hoops to jump through to fit the melody data into the tiny EEPROM space (128 bytes) of the 12F629.



I used SourceBoost C and PICkit 2 USB programmer.

#include <system.h>

// config word; internal oscillator, watchdog and master clear are off
#pragma DATA _CONFIG, _INTRC_OSC_NOCLKOUT & _WDT_OFF & _MCLRE_OFF

//Set clock frequency
#pragma CLOCK_FREQ 4000000

// This is the tune data... high nybble of each byte is the relative duration (1-16) and the
// low nybble is the note (1-16) or a break (0). Note numbers are mapped to frequencies in 
// code. A melody can use only 15 different notes in total and the total number of bytes that
// can be stored in EEPROM on a PIC12F629 is 128. There is a null terminator at the end of the
// melody data
#pragma DATA _EEPROM, 
0x44, 0x20, 0x44, 0x10, 0x18, 0x16, 0x10, 0x14, 0x16, 0x10, 0x18, 0x1b, 0x10, 0x18, 0x16, 0x10, 
0x14, 0x41, 0x20, 0x41, 0x10, 0x15, 0x13, 0x10, 0x11, 0x13, 0x10, 0x15, 0x17, 0x10, 0x15, 0x13, 
0x10, 0x11, 0x44, 0x20, 0x44, 0x10, 0x18, 0x16, 0x10, 0x14, 0x16, 0x10, 0x18, 0x1b, 0x10, 0x18, 
0x16, 0x10, 0x24, 0x10, 0x1b, 0x1a, 0x10, 0x19, 0x18, 0x10, 0x17, 0x16, 0x10, 0x15, 0x14, 0x20, 
0x16, 0x20, 0x14, 0x10, 0x14, 0x16, 0x10, 0x17, 0x48, 0x20, 0x48, 0x10, 0x18, 0x19, 0x10, 0x1a, 
0x1b, 0x10, 0x1a, 0x19, 0x10, 0x18, 0x17, 0x10, 0x16, 0x15, 0x10, 0x16, 0x17, 0x10, 0x16, 0x15, 
0x10, 0x11, 0x12, 0x10, 0x13, 0x44, 0x20, 0x44, 0x20, 0x44, 0x20, 0x44, 0x20, 0x24, 0x1b, 0x1a, 
0x10, 0x19, 0x18, 0x10, 0x17, 0x16, 0x10, 0x15, 0x34, 0x36, 0x44, 0x40, 0x00

typedef unsigned char byte;

// info used by the interrupt handler
byte next_tmr1h = 0;
byte next_tmr1l = 0;
byte wave = 0;

// interrupt handler called when the timer1 overflows
void interrupt( void )
{
 // check if this is timer1 overflow event
 if( pir1 & (1 << TMR1IF) )
 {
  // set up the timer 1 counters so they will overflow 
  // again after the appropriate time delay
  tmr1h = next_tmr1h;
  tmr1l = next_tmr1l;
 
  // toggle pin state GPIO5, which drives the piezo sounder
  wave=!wave;
  gpio = wave? 0b100000 : 0b000000;  
  
  //clear timer 1 interrupt bit
  clear_bit( pir1, TMR1IF ); 
 }
}

void main( void )
{
 // configure timer1 for interrupts / no prescaler
 t1con=0; 
 intcon.6=1;
 intcon.7=1;
 pie1.0=1;
 clear_bit( pir1, TMR1IF ); //clear timer 1 interrupt bit
 
 // set up IO pins
 trisio = 0;
 gpio=0;

 // loop forever
 for(;;)
 {
  byte addr = 0;
  byte data = 0;
  
  // loop through the tune
  for(;;)
  {
   // read byte from EEPROM
   eeadr = addr;
   eecon1.0 = 1;
   data = eedata;
   ++addr;

   // a zero byte indicates end of the tune
   if(!data || addr > 0x7f)
    break;
    
   // extract the note number from the low nybble
   byte note = data & 0x0f;
   
   // play a note?
   if(note)
   {
    // lookup corresponding frequency
    long freq = 0;
    switch(note)
    {
    case 1: freq=196; break; // G
    case 2: freq=220; break; // A
    case 3: freq=247; break; // B
    case 4: freq=262; break; // C
    case 5: freq=294; break; // D
    case 6: freq=330; break; // E
    case 7: freq=349; break; // F
    case 8: freq=392; break; // G
    case 9: freq=440; break; // A
    case 10: freq=494; break; // B
    case 11: freq=524; break; // C
    }
    
    // convert this into the correct timer count values
    // Internal clock is 4MHz and Timer1 counts at 1/4 
    // of this frequency (1MHz). We need to call the 
    // interrupt handler at double the pitch frequency so
    // that we can generate the 2 phases of the square wave
    // pulse. What we calculate here is the initial 16 bit 
    // Timer1 value that will overflow (at 0xffff) after the 
    // appropriate period of time.
    long l = (0xffff - (500000L/freq));
    next_tmr1h = l >> 8;
    next_tmr1l = l&0xff;
    tmr1h = next_tmr1h;
    tmr1l = next_tmr1l;
    wave = 0; 
    
    // enable the timer (start sound)  
    t1con.0=1; 
   }
   else
   {
    // disable the timer (stop sound)
    t1con.0=0; 
   }
     
   // duration is in top 4 bits. We'll just 
   // us an empty "for" loop to provide a delay
   int dur = 70*(data >> 4);
   for(int p=0;p<dur;++p)
   {
    // empty for loop for delay
    for(byte q=1;q;++q);
   }
  
  }
 }
}