scale selection problem

[Goatboy]

Hello, I've been working on adding a larger selection of scales for
the Auduino. However, it seems that I can only manage to add about 20
scales altogether (0-19) before things start to go wrong! After 20,
scales wont play correctly or won't function at all! Can anyone
explain to me why this might be? Or possibly how the code might be
modified to solve this? This is a modified version of code I'm
working on......

// Auduino, the Lo-Fi granular synthesiser
//
// by Peter Knight, Tinker.it http://tinker.it
//
// Help: http://code.google.com/p/tinkerit/wiki/Auduino
// More help: http://groups.google.com/group/auduino
//
// Analog in 0: Grain 1 pitch
// Analog in 1: Grain 2 decay
// Analog in 2: Grain 1 decay
// Analog in 3: Grain 2 pitch
// Analog in 4: Grain repetition frequency
//
// Digital 3: Audio out (Digital 11 on ATmega8)
//
// Changelog:
// 19 Nov 2008: Added support for ATmega8 boards
// 21 Mar 2009: Added support for ATmega328 boards
// 7 Apr 2009: Fixed interrupt vector for ATmega328 boards
// 8 Apr 2009: Added support for ATmega1280 boards (Arduino Mega)

#include <avr/io.h>
#include <avr/interrupt.h>
int C = 17;
int Cs = 18;
int D = 19;
int Ds = 20;
int E = 22;
int F = 23;
int Fs = 24;
int G = 26;
int Gs = 27;
int A = 29;
int As = 31;
int B = 32;
int C1 = 34;
int C1s = 36;
int D1 = 38;
int D1s = 41;
int E1 = 43;
int F1 = 46;
int F1s = 48;
int G1 = 51;
int G1s = 54;
int A1 = 58;
int A1s = 61;
int Bo1 = 65;
int C2 = 69;
int C2s = 73;
int D2 = 77;
int D2s = 82;
int E2 = 86;
int F2 = 92;
int F2s = 97;
int G2 = 103;
int G2s = 109;
int A2 = 115;
int A2s = 122;
int B2 = 129;
int C3 = 137;
int C3s = 145;
int D3 = 154;
int D3s= 163;
int E3 = 173;
int F3 = 183;
int F3s = 194;
int G3 = 206;
int G3s = 218;
int A3 = 231;
int A3s = 244;
int B3 = 259;
int C4 = 274;
int C4s = 291;
int D4 = 308;
int D4s = 326;
int E4 = 346;
int F4 = 366;
int F4s = 388;
int G4 = 411;
int G4s = 435;
int A4 = 461;
int A4s = 489;
int B4 = 518;
int C5 = 549;
int C5s = 581;
int D5 = 616;
int D5s = 652;
int E5 = 691;
int F5 = 732;
int F5s = 776;
int G5 = 822;
int G5s = 871;
int A5 = 923;
int A5s = 978;
int B5 = 1036;
int C6 = 1097;
int C6s = 1163;
int D6 = 1232;
int D6s = 1305;
int E6 = 1383;
int F6 = 1465;
int F6s = 1552;
int G6 = 1644;
int G6s = 1742;
int A6 = 1845;
int A6s = 1955;
int B6 = 2071;
int C7 = 2195;
int C7s = 2325;
int D7 = 2463;
int D7s = 2610;
int E7 = 2765;
int F7 = 2930;
int F7s = 3104;
int G7 = 3288;
int G7s = 3484;
int A7 = 3691;
int A7s = 3910;
int B7 = 4143;
int C8 = 4389;
int C8s = 4650;
int D8 = 4927;
int D8s = 5220;
int E8 = 5530;
int F8 = 5859;
int F8s = 6207;
int G8 = 6577;
int G8s = 6968;
int A8 = 7382;
int A8s = 7821;
int B8 = 8286;
int C9 = 8779;
int C9s = 9301;
int D9 = 9854;
int D9s = 10440;
int E9 = 11060;
int F9 = 11718;
int F9s = 12415;
int G9 = 13153;
int G9s = 13935;
int A9 = 14764;
int A9s = 15642;
int B9 = 16572;
int C10 = 17557;
int C10s = 18601;
int D10 = 19708;
int D10s = 20879;
int E10 = 22121;
int F10 = 23436;
int F10s = 24830;
int G10 = 26306;
int A10 = 29528;


uint16_t syncPhaseAcc;
uint16_t syncPhaseInc;
uint16_t grainPhaseAcc;
uint16_t grainPhaseInc;
uint16_t grainAmp;
uint8_t grainDecay;
uint16_t grain2PhaseAcc;
uint16_t grain2PhaseInc;
uint16_t grain2Amp;
uint8_t grain2Decay;

// Map Analogue channels
#define SYNC_CONTROL (5)
//#define GRAIN_FREQ_CONTROL (0)
//#define GRAIN_DECAY_CONTROL (2)
//#define GRAIN2_FREQ_CONTROL (3)
//#define GRAIN2_DECAY_CONTROL (1)




// For modern ATmega168 and ATmega328 boards
// Output is on pin 3
//
#define PWM_PIN 3
#define PWM_VALUE OCR2B
#define LED_PIN 13
#define LED_PORT PORTB
#define LED_BIT 5
#define PWM_INTERRUPT TIMER2_OVF_vect


// Smooth logarithmic mapping
//
uint16_t antilogTable[] = {

64830,64132,63441,62757,62081,61413,60751,60097,59449,58809,58176,57549,56929,56316,55709,55109,

54515,53928,53347,52773,52204,51642,51085,50535,49991,49452,48920,48393,47871,47356,46846,46341,

45842,45348,44859,44376,43898,43425,42958,42495,42037,41584,41136,40693,40255,39821,39392,38968,

38548,38133,37722,37316,36914,36516,36123,35734,35349,34968,34591,34219,33850,33486,33125,32768
};
uint16_t mapPhaseInc(uint16_t input) {
return (antilogTable[input & 0x3f]) >> (input >> 6);
}

// Stepped chromatic mapping
//
uint16_t midiTable[] = {

17,18,19,20,22,23,24,26,27,29,31,32,34,36,38,41,43,46,48,51,54,58,61,65,69,73,

77,82,86,92,97,103,109,115,122,129,137,145,154,163,173,183,194,206,218,231,

244,259,274,291,308,326,346,366,388,411,435,461,489,518,549,581,616,652,691,

732,776,822,871,923,978,1036,1097,1163,1232,1305,1383,1465,1552,1644,1742,

1845,1955,2071,2195,2325,2463,2610,2765,2930,3104,3288,3484,3691,3910,4143,

4389,4650,4927,5220,5530,5859,6207,6577,6968,7382,7821,8286,8779,9301,9854,

10440,11060,11718,12415,13153,13935,14764,15642,16572,17557,18601,19708,20879,
22121,23436,24830,26306
};
uint16_t mapMidi(uint16_t input) {
return (midiTable[(1023-input) >> 3]);
}


// Minor Pentatonic
// Key of C ........C D# F G A# C
uint16_t pentatonicTable0 [37] = {
0, C2, D2s, F2, G2, A2s, C3, D3s, F3, G3, A3s, C4, D4s, F4, G4, A4s,
C5, D5s, F5, G5, A5s,
C6, D6s, F6, G6, A6s, C7, D7s, F7, G7, A7s, C8, D8s, F8, G8, A8s,
C9
};

uint16_t mapPentatonic0(uint16_t input) {
uint8_t value = (1023-input) / (1024/37);
return (pentatonicTable0[value]);
}
//// Minor Pentatonic
// Key of D ........D F G A C D
uint16_t pentatonicTable1 [] = {
0, D2, F2, G2, A2, C3, D3, F3, G3, A3, C4, D4, F4, G4, A4, C5, D5,
F5, G5, A5, C6,
D6, F6, G6, A6, C7, D7, F7, G7, A7, C8, D8, F8, G8, A8, C9, D9
};

uint16_t mapPentatonic1(uint16_t input) {
uint8_t value = (1023-input) / (1024/37);
return (pentatonicTable1[value]);
}

// Minor Pentatonic
// Key of E.........E G A B D E
uint16_t pentatonicTable2 [] = {
0, E2, G2, A2, B2, D3, E3, G3, A3, B3, D4, E4, G4, A4, B4, D5, E5, G5,
A5, B5, D6,
E6, G6, A6, B6, D7, E7, G7, A7, B7, D8, E8, G8, A8, B8, D9, E9
};

uint16_t mapPentatonic2(uint16_t input) {
uint8_t value = (1023-input) / (1024/37);
return (pentatonicTable2[value]);
}

// Minor Pentatonic
// Key of F.......F G# A# C D# E
uint16_t pentatonicTable3[] = {
0, F2, G2s, A2s, C3, D3s, F3, G3s, A3s, C4, D4s, F4, G4s, A4s, C5,
D5s, F5, G5s, A5s, C6, D6s,
F6, G6s, A6s, C7, D7s, F7, G7s, A7s, C8, D8s, F8, G8s, A8s, C9,
D9s, F9
};

uint16_t mapPentatonic3(uint16_t input) {
uint8_t value = (1023-input) / (1024/37);
return (pentatonicTable3[value]);
}

// Minor Pentatonic
// Key of G.......G A# C D F G
uint16_t pentatonicTable4[] = {
0, G2, A2s, C3, D3, F3, G3, A3s, C4, D4, F4, G4, A4s, C5, D5, F5, G5,
A5s, C6, D6, F6,
G6, A6s, C7, D7, F7, G7, A7s, C8, D8, F8, G8, A8s, C9, D9, F9, G9
};

uint16_t mapPentatonic4(uint16_t input) {
uint8_t value = (1023-input) / (1024/37);
return (pentatonicTable4[value]);
}

// Minor Pentatonic
// Key of A.......A C D E G A
uint16_t pentatonicTable5[] = {
0, A2, C3, D3, E3, G3, A3, C4, D4, E4, G4, A4, C5, D5, E5, G5, A5,
C6, D6, E6, G6,
A6, C7, D7, E7, G7, A7, C8, D8, E8, G8, A8, C9, D9, E9, G9, A9
// Problem with D8!
};

uint16_t mapPentatonic5(uint16_t input) {
uint8_t value = (1023-input) / (1024/37);
return (pentatonicTable5[value]);
}

// Minor Pentatonic
// Key of B.......B D E F# A B
uint16_t pentatonicTable6[] = {
0, B2, D3, E3, F3s, A3, B3, D4, E4, F4s, A4, B4, D5, E5, F5s, A5, B5,
D6, E6, F6s, A6,
B6, D7, E7, F7s, A7, B7, D8, E8, F8s, A8, B8, D9, E9, F9s, A9, B9

};

uint16_t mapPentatonic6(uint16_t input) {
uint8_t value = (1023-input) / (1024/37);
return (pentatonicTable6[value]);
}

// Indian
// Key of B.......B Ds E Fs Gs As
uint16_t pentatonicTable7[] = {
0, B2, D3, E3, F3s, G3s, A3s, B3, D4, E4, F4s, G4s, A4s, B4, D5, E5,
F5s, G5s, A5s,
B5, D6, E6, F6s, G6s, A6s, B6, D7, E7, F7s, G7s, A7s, B7, D8, E8,
F8s, G8s, A8s,
B8, D9, E9, F9s, G9s, A9s, B9
};

uint16_t mapPentatonic7(uint16_t input) {
uint8_t value = (1023-input) / (1024/44);
return (pentatonicTable7[value]);
}

// Indian
// Key of C.......C E F G A# C
uint16_t pentatonicTable8[] = {
0, C2, E2, F2, G2, A2s, C3, E3, F3, G3, A3s, C4, E4, F4, G4, A4s, C5,
E5, F5, G5, A5s,
C6, E6, F6, G6, A6s, C7, E7, F7, G7, A7s, C8, E8, F8, G8, A8s, C9
};

uint16_t mapPentatonic8(uint16_t input) {
uint8_t value = (1023-input) / (1024/37);
return (pentatonicTable8[value]);
}

// Indian
// Key of D.......D F# G A C D
uint16_t pentatonicTable9[] = {
0, D2, F2s, G2, A2, C3, D3, F3s, G3, A3, C4, D4, F4s, G4, A4, C5, D5,
F5s, G5, A5, C6,
D6, F6s, G6, A6, C7, D7, F7s, G7, A7, C8, D8, F8s, G8, A8, C9, D9
};

uint16_t mapPentatonic9(uint16_t input) {
uint8_t value = (1023-input) / (1024/37);
return (pentatonicTable9[value]);
}

// Indian
// Key of E.......E G3 A B D E
uint16_t pentatonicTable10[] = {
0, E2, G2s, A2, B2, D3, E3, G3s, A3, B3, D4, E4, G4s, A4, B4, D5, E5,
G5s, A5, B5, D6,
E6, G6s, A6, B6, D7, E7, G7s, A7, B7, D8, E8, G8s, A8, B8, D9, E9
};

uint16_t mapPentatonic10(uint16_t input) {
uint8_t value = (1023-input) / (1024/37);
return (pentatonicTable10[value]);
}

// Pentatonic Blues
// Key of C.......C D# F F# G A# C
uint16_t pentatonicTable11[] = {
0, C2, D2s, F2, F2s, G2, A2s, C3, D3s, F3, F3s, G3, A3s, C4, D4s, F4,
F4s, G4, A4s,
C5, D5s, F5, F5s, G5, A5s, C6, D6s, F6, F6s, G6, A6s, C7, D7s, F7,
F7s, G7, A7s,
C8, D8s, F8, F8s, G8, A8s, C9
};

uint16_t mapPentatonic11(uint16_t input) {
uint8_t value = (1023-input) / (1024/44);
return (pentatonicTable11[value]);
}

// Pentatonic Blues
// Key of D.......D F G G# A C D
uint16_t pentatonicTable12[] = {
0, D2, F2, G2, G2s, A2, C3, D3, F3, G3, G3s, A3, C4, D4, F4, G4, G4s,
A4, C5,
D5, F5, G5, G5s, A5, C6, D6, F6, G6, G6s, A6, C7, D7, F7, G7, G7s,
A7, C8,
D8, F8, G8, G8s, A8, C9, D9
};

uint16_t mapPentatonic12(uint16_t input) {
uint8_t value = (1023-input) / (1024/44);
return (pentatonicTable12[value]);
}

// Pentatonic Blues
// Key of E.......E G A As B D E
uint16_t pentatonicTable13[] = {
0, E2, G2, A2, A2s, B2, D3, E3, G3, A3, A3s, B3, D4, E4, G4, A4, A4s,
B4, D5,
E5, G5, A5, A5s, B5, D6, E6, G6, A6, A6s, B6, D7, E7, G7, A7, A7s,
B7, D8,
E8, G8, A8, A8s, B8, D9, E9
};

uint16_t mapPentatonic13(uint16_t input) {
uint8_t value = (1023-input) / (1024/44);
return (pentatonicTable13[value]);
}
//////////////////////////////////////////////////////////////////////////////////////
// Pelog
// Key of C ........C E F G B C
uint16_t pentatonicTable14 [] = {
0, C2, E2, F2, G2, B2, C3, E3, F3, G3, B3, C4, E4, F4, G4, B4, C5, E5,
F5, G5, B5,
C6, E6, F6, G6, B6, C7, E7, F7, G7, B7, C8, E8, F8, G8, B8, C9
};

uint16_t mapPentatonic14(uint16_t input) {
uint8_t value = (1023-input) / (1024/37);
return (pentatonicTable14[value]);
}

//// Pelog
// Key of D ........D Fs G A Cs D
uint16_t pentatonicTable15 [] = {
// Stepped Pentatonic mapping 34
0, D2, F2s, G2, A2, C3s, D3, F3s, G3, A3, C4s, D4, F4s, G4, A4,
C5s, D5, F5s, G5, A5, C6s,
D6, F6s, G6, A6, C7s, D7, F7s, G7, A7, C8s, D8, F8s, G8, A8,
C9s, D9
};

uint16_t mapPentatonic15(uint16_t input) {
uint8_t value = (1023-input) / (1024/37);
return (pentatonicTable15[value]);
}

// Pelog
// Key of E.........E Gs A B Ds E
uint16_t pentatonicTable16 [] = {
0, E2, G2s, A2, B2, D3s, E3, G3s, A3, B3, D4s, E4, G4s, A4, B4, D5s,
E5, G5s, A5, B5, D6s,
E6, G6s, A6, B6, D7s, E7, G7s, A7, B7, D8s, E8, G8s, A8, B8, D9s,
E9
};

uint16_t mapPentatonic16(uint16_t input) {
uint8_t value = (1023-input) / (1024/37);
return (pentatonicTable16[value]);
}

// Hirajoshi
// Key of C.........C E Fs G B C
uint16_t pentatonicTable17 [] = {
0, C2, E2, F2s, G2, B2, C3, E3, F3s, G3, B3, C4, E4, F4s, G4, B4, C5,
E5, F5s, G5, B5,
C6, E6, F6s, G6, B6, C7, E7, F7s, G7, B7, C8, E8, F8s, G8, B8, C9
};

uint16_t mapPentatonic17(uint16_t input) {
uint8_t value = (1023-input) / (1024/37);
return (pentatonicTable17[value]);
}

// Hirajoshi
// Key of D.........D Fs Gs A Cs D
uint16_t pentatonicTable18 [] = {
0, D2, F2s, G2s, A2, C3s, D3, F3s, G3s, A3, C4s, D4, F4s, G4s, A4,
C5s, D5, F5s, G5s, A5, C6s,
D6, F6s, G6s, A6, C7s, D7, F7s, G7s, A7, C8s, D8
};

uint16_t mapPentatonic18(uint16_t input) {
uint8_t value = (1023-input) / (1024/32);
return (pentatonicTable18[value]);
}

// Hirajoshi
// Key of D.........D Fs Gs A Cs D
uint16_t pentatonicTable19 [] = {
0, D2, F2s, G2s, A2, C3s, D3,F3s, G3s, A3, C4s, D4, F4s, G4s, A4, C5s,
D5, F5s, G5s, A5, C6s,
D6, F6s, G6s, A6, C7s, D7, F7s, G7s, A7, C8s, D8
};

uint16_t mapPentatonic19(uint16_t input) {
uint8_t value = (1023-input) / (1024/32);
return (pentatonicTable19[value]);
}




void audioOn() {

// Set up PWM to 31.25kHz, phase accurate
TCCR2A = _BV(COM2B1) | _BV(WGM20);
TCCR2B = _BV(CS20);
TIMSK2 = _BV(TOIE2);

}


void setup() {
pinMode(PWM_PIN,OUTPUT);
audioOn();
pinMode(LED_PIN,OUTPUT);



Serial.begin(9600);

}

void loop() {

syncPhaseInc = mapPentatonic19(analogRead(SYNC_CONTROL));

int Value1 = 300;
int Value2 = 100;
int Value3 = 150;
int Value4 = 200;

grainPhaseInc = mapPhaseInc(Value1);
grainDecay = Value2;
grain2PhaseInc = mapPhaseInc(Value1);
grain2Decay = Value1;


}


SIGNAL(PWM_INTERRUPT)
{
uint8_t value;
uint16_t output;

syncPhaseAcc += syncPhaseInc;
if (syncPhaseAcc < syncPhaseInc) {
// Time to start the next grain
grainPhaseAcc = 0;
grainAmp = 0x7fff;
grain2PhaseAcc = 0;
grain2Amp = 0x7fff;
LED_PORT ^= 1 << LED_BIT; // Faster than using digitalWrite
}

// Increment the phase of the grain oscillators
grainPhaseAcc += grainPhaseInc;
grain2PhaseAcc += grain2PhaseInc;

// Convert phase into a triangle wave
value = (grainPhaseAcc >> 7) & 0xff;
if (grainPhaseAcc & 0x8000) value = ~value;
// Multiply by current grain amplitude to get sample
output = value * (grainAmp >> 8);

// Repeat for second grain
value = (grain2PhaseAcc >> 7) & 0xff;
if (grain2PhaseAcc & 0x8000) value = ~value;
output += value * (grain2Amp >> 8);

// Make the grain amplitudes decay by a factor every sample
(exponential decay)
grainAmp -= (grainAmp >> 8) * grainDecay;
grain2Amp -= (grain2Amp >> 8) * grain2Decay;



// Scale output to the available range, clipping if necessary
output >>= 9;
if (output > 255) output = 255;

// Output to PWM (this is faster than using analogWrite)
PWM_VALUE = output;

}