AllenKeysPedExp
Scan
/*
Allen Keyboards plus Pedal plus Expression Scan
==============================================
This sketch is designed to scan a pair of keyboards as well as the pedal salvaged from a MDC 20 Allen organ.
The original wiring is retained but since the Allen is active HIGH and the Arduino is active LOW, the scanning
procedure is reversed. There is also provision for scanning an expression pedal.
Referring to the pin numbers on Allen's schematic for this organ, the Swell is scanned by sequentially bringing
pins 52, 63,69,54,64 and 62 LOW (Arduino pins 22 - 27).
Pins 16, 20, 18, 22, 24, 26, 28, 30, 32,34 and 36 (Arduino pins 36 - 46)
are then scanned to determine which keys are closed. LOW = switch closed. Output on Ch. 3
Referring to the pin numbers on Allen's schematic for this organ, the Great is scanned by sequentially bringing
pins 48, 53,57, 55, 59 and 61 LOW (Arduino pins 28 - 33).
Pins 16, 20, 18, 22, 24, 26, 28, 30, 32,34 and 36 (Arduino pins 36 - 46)
are then scanned to determine which keys are closed. LOW = switch closed. Output on Ch. 2
Referring to the pin numbers on Allen's schematic for this organ, the Pedal is scanned by sequentially bringing
pins 67, 65, 58, 60, 68 and 66 LOW (Arduino pins 14 - 19).
Pins 16, 20, 18, 22, 24, 26, and 28 (Arduino pins 62 - 68)
are then scanned to determine which keys are closed. LOW = switch closed. Output on Ch. 1
Note! the wires running to pins 16, 20, 18, 22, 24, 26, and 28 on the pedal are to be detached from the
corresponding pins on the Great and Swell.
Piston inputs for 1,2,3,4,5 and GC are Arduino pins 48 - 53. Output on Ch. 4
Pin 69: Reserved for analog input. The controllerArray values will have to be edited to
reflect the voltage range put out by device device. Connect 15k (+/-) pot across Arduino's
5V and Ground. Centre tap goes to pin 69.Input must never exceed 5V.
Note: ***** Unused analog inputs must be grounded to avoid spurious control messages *****
Equipment: Arduino Mega with one MIDI shield
The connections for the pedal are partially covered by the MIDI shield. Either the MIDI shield can be mounted off
the Arduino or right angle connectors can be used to bring out the connections.
created 2021 June 1
modified 2023 July 27
by John Coenraads
*/
// Declarations==========================================
//Counters (old Fortran habit)
int i, j, k;
byte noteStatus;
byte noteNumber; // low C = 36
byte noteVelocity;
const byte debounceCount = 4; //Note ON if count > 0, OFF if count = 0
byte swellDebounceArray [100]; //holds debounce count for each Swell switch
byte greatDebounceArray [100]; //holds debounce count for each Great switch
byte pistonDebounceArray [100]; //holds debounce count for each Piston switch
byte pedalDebounceArray [100]; //holds debounce count for each Piston switch
int oldOldExpression = 0, oldExpression = 0, newExpression = 0; // Expression controller values
// The following array represents the controller values output for analog device voltages
// in 0.31V increments ranging from 0 to 5V. Input must never exceed 5V.
// Array can be edited as desired, but must contain exactly 17 entries with values between 0 and 127 only.
byte controllerArray [17] = {0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 127};
//Initialize =========================================================
void setup()
{
// Set MIDI baud rate:
Serial.begin(31250);
//Initialize output (normally high)
for (i = 22; i < 34; i++)
{
pinMode (i, OUTPUT);
digitalWrite (i, HIGH);
}
for (i = 14; i < 20; i++)
{
pinMode (i, OUTPUT);
digitalWrite (i, HIGH);
}
//Initialize input. Normally high (via internal pullups)
for (i = 36; i < 54; i++)
{ pinMode (i, INPUT_PULLUP);}
for (i = 62; i < 69; i++)
{ pinMode (i, INPUT_PULLUP);}
//Initialize debounce count arrays to zero
for (i= 0; i < 100; i++){
swellDebounceArray[i] = 0;
greatDebounceArray[i] = 0;
pistonDebounceArray[i] = 0;
pedalDebounceArray[i] = 0;
}
}
//Main Loop ===========================================================
void loop()
{
scanSwell();
scanGreat();
scanPistons();
scanPedal();
scanExpressionPedal();
}
//Scan Swell keyboard, convert to MIDI and output via port 0, channel 3.
void scanSwell ()
{
digitalWrite (22, LOW);
if (digitalRead(37) == LOW) {turnONswell (37);} else {turnOFFswell (37);}
if (digitalRead(38) == LOW) {turnONswell (43);} else {turnOFFswell (43);}
if (digitalRead(39) == LOW) {turnONswell (49);} else {turnOFFswell (49);}
if (digitalRead(40) == LOW) {turnONswell (55);} else {turnOFFswell (55);}
if (digitalRead(41) == LOW) {turnONswell (61);} else {turnOFFswell (61);}
if (digitalRead(42) == LOW) {turnONswell (67);} else {turnOFFswell (67);}
if (digitalRead(43) == LOW) {turnONswell (73);} else {turnOFFswell (73);}
if (digitalRead(44) == LOW) {turnONswell (79);} else {turnOFFswell (79);}
if (digitalRead(45) == LOW) {turnONswell (85);} else {turnOFFswell (85);}
if (digitalRead(46) == LOW) {turnONswell (91);} else {turnOFFswell (91);}
digitalWrite (22, HIGH);
digitalWrite (23, LOW);
if (digitalRead(37) == LOW) {turnONswell (38);} else {turnOFFswell (38);}
if (digitalRead(38) == LOW) {turnONswell (44);} else {turnOFFswell (44);}
if (digitalRead(39) == LOW) {turnONswell (50);} else {turnOFFswell (50);}
if (digitalRead(40) == LOW) {turnONswell (56);} else {turnOFFswell (56);}
if (digitalRead(41) == LOW) {turnONswell (62);} else {turnOFFswell (62);}
if (digitalRead(42) == LOW) {turnONswell (68);} else {turnOFFswell (68);}
if (digitalRead(43) == LOW) {turnONswell (74);} else {turnOFFswell (74);}
if (digitalRead(44) == LOW) {turnONswell (80);} else {turnOFFswell (80);}
if (digitalRead(45) == LOW) {turnONswell (86);} else {turnOFFswell (86);}
if (digitalRead(46) == LOW) {turnONswell (92);} else {turnOFFswell (92);}
digitalWrite (23, HIGH);
digitalWrite (24, LOW);
if (digitalRead(37) == LOW) {turnONswell (39);} else {turnOFFswell (39);}
if (digitalRead(38) == LOW) {turnONswell (45);} else {turnOFFswell (45);}
if (digitalRead(39) == LOW) {turnONswell (51);} else {turnOFFswell (51);}
if (digitalRead(40) == LOW) {turnONswell (57);} else {turnOFFswell (57);}
if (digitalRead(41) == LOW) {turnONswell (63);} else {turnOFFswell (63);}
if (digitalRead(42) == LOW) {turnONswell (69);} else {turnOFFswell (69);}
if (digitalRead(43) == LOW) {turnONswell (75);} else {turnOFFswell (75);}
if (digitalRead(44) == LOW) {turnONswell (81);} else {turnOFFswell (81);}
if (digitalRead(45) == LOW) {turnONswell (87);} else {turnOFFswell (87);}
if (digitalRead(46) == LOW) {turnONswell (93);} else {turnOFFswell (93);}
digitalWrite (24, HIGH);
digitalWrite (25, LOW);
if (digitalRead(37) == LOW) {turnONswell (40);} else {turnOFFswell (40);}
if (digitalRead(38) == LOW) {turnONswell (46);} else {turnOFFswell (46);}
if (digitalRead(39) == LOW) {turnONswell (52);} else {turnOFFswell (52);}
if (digitalRead(40) == LOW) {turnONswell (58);} else {turnOFFswell (58);}
if (digitalRead(41) == LOW) {turnONswell (64);} else {turnOFFswell (64);}
if (digitalRead(42) == LOW) {turnONswell (70);} else {turnOFFswell (70);}
if (digitalRead(43) == LOW) {turnONswell (76);} else {turnOFFswell (76);}
if (digitalRead(44) == LOW) {turnONswell (82);} else {turnOFFswell (82);}
if (digitalRead(45) == LOW) {turnONswell (88);} else {turnOFFswell (88);}
if (digitalRead(46) == LOW) {turnONswell (94);} else {turnOFFswell (94);}
digitalWrite (25, HIGH);
digitalWrite (26, LOW);
if (digitalRead(37) == LOW) {turnONswell (41);} else {turnOFFswell (41);}
if (digitalRead(38) == LOW) {turnONswell (47);} else {turnOFFswell (47);}
if (digitalRead(39) == LOW) {turnONswell (53);} else {turnOFFswell (53);}
if (digitalRead(40) == LOW) {turnONswell (59);} else {turnOFFswell (59);}
if (digitalRead(41) == LOW) {turnONswell (65);} else {turnOFFswell (65);}
if (digitalRead(42) == LOW) {turnONswell (71);} else {turnOFFswell (71);}
if (digitalRead(43) == LOW) {turnONswell (77);} else {turnOFFswell (77);}
if (digitalRead(44) == LOW) {turnONswell (83);} else {turnOFFswell (83);}
if (digitalRead(45) == LOW) {turnONswell (89);} else {turnOFFswell (89);}
if (digitalRead(46) == LOW) {turnONswell (95);} else {turnOFFswell (95);}
digitalWrite (26, HIGH);
digitalWrite (27, LOW);
if (digitalRead(36) == LOW) {turnONswell (36);} else {turnOFFswell (36);} //bottom C
if (digitalRead(37) == LOW) {turnONswell (42);} else {turnOFFswell (42);}
if (digitalRead(38) == LOW) {turnONswell (48);} else {turnOFFswell (48);}
if (digitalRead(39) == LOW) {turnONswell (54);} else {turnOFFswell (54);}
if (digitalRead(40) == LOW) {turnONswell (60);} else {turnOFFswell (60);}
if (digitalRead(41) == LOW) {turnONswell (66);} else {turnOFFswell (66);}
if (digitalRead(42) == LOW) {turnONswell (72);} else {turnOFFswell (72);}
if (digitalRead(43) == LOW) {turnONswell (78);} else {turnOFFswell (78);}
if (digitalRead(44) == LOW) {turnONswell (84);} else {turnOFFswell (84);}
if (digitalRead(45) == LOW) {turnONswell (90);} else {turnOFFswell (90);}
if (digitalRead(46) == LOW) {turnONswell (96);} else {turnOFFswell (96);}
digitalWrite (27, HIGH);
}
//MIDI ON message is sent only if note is not already ON.
void turnONswell (byte noteNumber)
{
if (swellDebounceArray[noteNumber] == 0)
{
Serial.write (0x92); //note ON, channel 3
Serial.write (noteNumber);
Serial.write (0x7f); //medium velocity
swellDebounceArray[noteNumber] = debounceCount;
}
}
//MIDI OFF message is sent only if note is not already OFF.
void turnOFFswell (byte noteNumber)
{
if (swellDebounceArray[noteNumber] == 1)
{
Serial.write (0x92); //note ON, channel 3
Serial.write (noteNumber);
Serial.write (0); //zero velocity = OFF
}
if (swellDebounceArray[noteNumber] > 0) {swellDebounceArray[noteNumber] -- ;}
}
//*******************************************************************************************
//Scan Great keyboard, convert to MIDI and output via port 0, channel 2.
void scanGreat ()
{
digitalWrite (28, LOW);
if (digitalRead(37) == LOW) {turnONgreat (37);} else {turnOFFgreat (37);}
if (digitalRead(38) == LOW) {turnONgreat (43);} else {turnOFFgreat (43);}
if (digitalRead(39) == LOW) {turnONgreat (49);} else {turnOFFgreat (49);}
if (digitalRead(40) == LOW) {turnONgreat (55);} else {turnOFFgreat (55);}
if (digitalRead(41) == LOW) {turnONgreat (61);} else {turnOFFgreat (61);}
if (digitalRead(42) == LOW) {turnONgreat (67);} else {turnOFFgreat (67);}
if (digitalRead(43) == LOW) {turnONgreat (73);} else {turnOFFgreat (73);}
if (digitalRead(44) == LOW) {turnONgreat (79);} else {turnOFFgreat (79);}
if (digitalRead(45) == LOW) {turnONgreat (85);} else {turnOFFgreat (85);}
if (digitalRead(46) == LOW) {turnONgreat (91);} else {turnOFFgreat (91);}
digitalWrite (28, HIGH);
digitalWrite (29, LOW);
if (digitalRead(37) == LOW) {turnONgreat (38);} else {turnOFFgreat (38);}
if (digitalRead(38) == LOW) {turnONgreat (44);} else {turnOFFgreat (44);}
if (digitalRead(39) == LOW) {turnONgreat (50);} else {turnOFFgreat (50);}
if (digitalRead(40) == LOW) {turnONgreat (56);} else {turnOFFgreat (56);}
if (digitalRead(41) == LOW) {turnONgreat (62);} else {turnOFFgreat (62);}
if (digitalRead(42) == LOW) {turnONgreat (68);} else {turnOFFgreat (68);}
if (digitalRead(43) == LOW) {turnONgreat (74);} else {turnOFFgreat (74);}
if (digitalRead(44) == LOW) {turnONgreat (80);} else {turnOFFgreat (80);}
if (digitalRead(45) == LOW) {turnONgreat (86);} else {turnOFFgreat (86);}
if (digitalRead(46) == LOW) {turnONgreat (92);} else {turnOFFgreat (92);}
digitalWrite (29, HIGH);
digitalWrite (30, LOW);
if (digitalRead(37) == LOW) {turnONgreat (39);} else {turnOFFgreat (39);}
if (digitalRead(38) == LOW) {turnONgreat (45);} else {turnOFFgreat (45);}
if (digitalRead(39) == LOW) {turnONgreat (51);} else {turnOFFgreat (51);}
if (digitalRead(40) == LOW) {turnONgreat (57);} else {turnOFFgreat (57);}
if (digitalRead(41) == LOW) {turnONgreat (63);} else {turnOFFgreat (63);}
if (digitalRead(42) == LOW) {turnONgreat (69);} else {turnOFFgreat (69);}
if (digitalRead(43) == LOW) {turnONgreat (75);} else {turnOFFgreat (75);}
if (digitalRead(44) == LOW) {turnONgreat (81);} else {turnOFFgreat (81);}
if (digitalRead(45) == LOW) {turnONgreat (87);} else {turnOFFgreat (87);}
if (digitalRead(46) == LOW) {turnONgreat (93);} else {turnOFFgreat (93);}
digitalWrite (30, HIGH);
digitalWrite (31, LOW);
if (digitalRead(37) == LOW) {turnONgreat (40);} else {turnOFFgreat (40);}
if (digitalRead(38) == LOW) {turnONgreat (46);} else {turnOFFgreat (46);}
if (digitalRead(39) == LOW) {turnONgreat (52);} else {turnOFFgreat (52);}
if (digitalRead(40) == LOW) {turnONgreat (58);} else {turnOFFgreat (58);}
if (digitalRead(41) == LOW) {turnONgreat (64);} else {turnOFFgreat (64);}
if (digitalRead(42) == LOW) {turnONgreat (70);} else {turnOFFgreat (70);}
if (digitalRead(43) == LOW) {turnONgreat (76);} else {turnOFFgreat (76);}
if (digitalRead(44) == LOW) {turnONgreat (82);} else {turnOFFgreat (82);}
if (digitalRead(45) == LOW) {turnONgreat (88);} else {turnOFFgreat (88);}
if (digitalRead(46) == LOW) {turnONgreat (94);} else {turnOFFgreat (94);}
digitalWrite (31, HIGH);
digitalWrite (32, LOW);
if (digitalRead(37) == LOW) {turnONgreat (41);} else {turnOFFgreat (41);}
if (digitalRead(38) == LOW) {turnONgreat (47);} else {turnOFFgreat (47);}
if (digitalRead(39) == LOW) {turnONgreat (53);} else {turnOFFgreat (53);}
if (digitalRead(40) == LOW) {turnONgreat (59);} else {turnOFFgreat (59);}
if (digitalRead(41) == LOW) {turnONgreat (65);} else {turnOFFgreat (65);}
if (digitalRead(42) == LOW) {turnONgreat (71);} else {turnOFFgreat (71);}
if (digitalRead(43) == LOW) {turnONgreat (77);} else {turnOFFgreat (77);}
if (digitalRead(44) == LOW) {turnONgreat (83);} else {turnOFFgreat (83);}
if (digitalRead(45) == LOW) {turnONgreat (89);} else {turnOFFgreat (89);}
if (digitalRead(46) == LOW) {turnONgreat (95);} else {turnOFFgreat (95);}
digitalWrite (32, HIGH);
digitalWrite (33, LOW);
if (digitalRead(36) == LOW) {turnONgreat (36);} else {turnOFFgreat (36);} //bottom C
if (digitalRead(37) == LOW) {turnONgreat (42);} else {turnOFFgreat (42);}
if (digitalRead(38) == LOW) {turnONgreat (48);} else {turnOFFgreat (48);}
if (digitalRead(39) == LOW) {turnONgreat (54);} else {turnOFFgreat (54);}
if (digitalRead(40) == LOW) {turnONgreat (60);} else {turnOFFgreat (60);}
if (digitalRead(41) == LOW) {turnONgreat (66);} else {turnOFFgreat (66);}
if (digitalRead(42) == LOW) {turnONgreat (72);} else {turnOFFgreat (72);}
if (digitalRead(43) == LOW) {turnONgreat (78);} else {turnOFFgreat (78);}
if (digitalRead(44) == LOW) {turnONgreat (84);} else {turnOFFgreat (84);}
if (digitalRead(45) == LOW) {turnONgreat (90);} else {turnOFFgreat (90);}
if (digitalRead(46) == LOW) {turnONgreat (96);} else {turnOFFgreat (96);}
digitalWrite (33, HIGH);
}
//MIDI ON message is sent only if note is not already ON.
void turnONgreat (byte noteNumber)
{
if (greatDebounceArray[noteNumber] == 0)
{
Serial.write (0x91); //note ON, channel 2
Serial.write (noteNumber);
Serial.write (0x7f); //medium velocity
greatDebounceArray[noteNumber] = debounceCount;
}
}
//MIDI OFF message is sent only if note is not already OFF.
void turnOFFgreat (byte noteNumber)
{
if (greatDebounceArray[noteNumber] == 1)
{
Serial.write (0x91); //note ON, channel 2
Serial.write (noteNumber);
Serial.write (0); //zero velocity = OFF
}
if (greatDebounceArray[noteNumber] > 0) {greatDebounceArray[noteNumber] -- ;}
}
//*******************************************************************************************
//Scan Pedal, convert to MIDI and output via port 0, channel 1.
void scanPedal ()
{
digitalWrite (14, LOW);
if (digitalRead(63) == LOW) {turnONpedal (37);} else {turnOFFpedal (37);}
if (digitalRead(64) == LOW) {turnONpedal (43);} else {turnOFFpedal (43);}
if (digitalRead(65) == LOW) {turnONpedal (49);} else {turnOFFpedal (49);}
if (digitalRead(66) == LOW) {turnONpedal (55);} else {turnOFFpedal (55);}
if (digitalRead(67) == LOW) {turnONpedal (61);} else {turnOFFpedal (61);}
if (digitalRead(68) == LOW) {turnONpedal (67);} else {turnOFFpedal (67);}
digitalWrite (14, HIGH);
digitalWrite (15, LOW);
if (digitalRead(63) == LOW) {turnONpedal (38);} else {turnOFFpedal (38);}
if (digitalRead(64) == LOW) {turnONpedal (44);} else {turnOFFpedal (44);}
if (digitalRead(65) == LOW) {turnONpedal (50);} else {turnOFFpedal (50);}
if (digitalRead(66) == LOW) {turnONpedal (56);} else {turnOFFpedal (56);}
if (digitalRead(67) == LOW) {turnONpedal (62);} else {turnOFFpedal (62);}
digitalWrite (15, HIGH);
digitalWrite (16, LOW);
if (digitalRead(63) == LOW) {turnONpedal (39);} else {turnOFFpedal (39);}
if (digitalRead(64) == LOW) {turnONpedal (45);} else {turnOFFpedal (45);}
if (digitalRead(65) == LOW) {turnONpedal (51);} else {turnOFFpedal (51);}
if (digitalRead(66) == LOW) {turnONpedal (57);} else {turnOFFpedal (57);}
if (digitalRead(67) == LOW) {turnONpedal (63);} else {turnOFFpedal (63);}
digitalWrite (16, HIGH);
digitalWrite (17, LOW);
if (digitalRead(63) == LOW) {turnONpedal (40);} else {turnOFFpedal (40);}
if (digitalRead(64) == LOW) {turnONpedal (46);} else {turnOFFpedal (46);}
if (digitalRead(65) == LOW) {turnONpedal (52);} else {turnOFFpedal (52);}
if (digitalRead(66) == LOW) {turnONpedal (58);} else {turnOFFpedal (58);}
if (digitalRead(67) == LOW) {turnONpedal (64);} else {turnOFFpedal (64);}
digitalWrite (17, HIGH);
digitalWrite (18, LOW);
if (digitalRead(63) == LOW) {turnONpedal (41);} else {turnOFFpedal (41);}
if (digitalRead(64) == LOW) {turnONpedal (47);} else {turnOFFpedal (47);}
if (digitalRead(65) == LOW) {turnONpedal (53);} else {turnOFFpedal (53);}
if (digitalRead(66) == LOW) {turnONpedal (59);} else {turnOFFpedal (59);}
if (digitalRead(67) == LOW) {turnONpedal (65);} else {turnOFFpedal (65);}
digitalWrite (18, HIGH);
digitalWrite (19, LOW);
if (digitalRead(62) == LOW) {turnONpedal (36);} else {turnOFFpedal (36);} //bottom C
if (digitalRead(63) == LOW) {turnONpedal (42);} else {turnOFFpedal (42);}
if (digitalRead(64) == LOW) {turnONpedal (48);} else {turnOFFpedal (48);}
if (digitalRead(65) == LOW) {turnONpedal (54);} else {turnOFFpedal (54);}
if (digitalRead(66) == LOW) {turnONpedal (60);} else {turnOFFpedal (60);}
if (digitalRead(67) == LOW) {turnONpedal (66);} else {turnOFFpedal (66);}
digitalWrite (19, HIGH);
}
//MIDI ON message is sent only if note is not already ON.
void turnONpedal (byte noteNumber)
{
if (pedalDebounceArray[noteNumber] == 0)
{
Serial.write (0x90); //note ON, channel 1
Serial.write (noteNumber);
Serial.write (0x7f); //medium velocity
pedalDebounceArray[noteNumber] = debounceCount;
}
}
//MIDI OFF message is sent only if note is not already OFF.
void turnOFFpedal (byte noteNumber)
{
if (pedalDebounceArray[noteNumber] == 1)
{
Serial.write (0x90); //note ON, channel 1
Serial.write (noteNumber);
Serial.write (0); //zero velocity = OFF
}
if (pedalDebounceArray[noteNumber] > 0) {pedalDebounceArray[noteNumber] -- ;}
}
//**********************************************************************************************
//Scan Pistons, convert to MIDI and output via port 0, channel 4.
//Piston feed is permanently wired to ground
void scanPistons ()
{
for (j = 48; j < 54; j++)
{
if (digitalRead(j) == LOW) {turnONpiston (j);} else {turnOFFpiston (j);}
}
}
//MIDI ON message is sent only if note is not already ON.
void turnONpiston (byte noteNumber)
{
if (pistonDebounceArray[noteNumber] == 0)
{
Serial.write (0x93); //note ON, channel 4
Serial.write (noteNumber);
Serial.write (0x7f); //medium velocity
pistonDebounceArray[noteNumber] = debounceCount;
}
}
//MIDI OFF message is sent only if note is not already OFF.
void turnOFFpiston (byte noteNumber)
{
if (pistonDebounceArray[noteNumber] == 1)
{
Serial.write (0x93); //note ON, channel 4
Serial.write (noteNumber);
Serial.write (0); //zero velocity = OFF
}
if (pistonDebounceArray[noteNumber] > 0) {pistonDebounceArray[noteNumber] -- ;}
}
//Expression pedal input:
//Voltage inputs from 0 to 5V are converted to a 10 bit integer from 0 to 1023 by analog to digital converter.
//Adding 1 and dividing by 64, yields an integer from 0 to 16. This is used as an index into the controllerArray
//to select the controller value to be output.
void scanExpressionPedal()
{
newExpression = analogRead (69); //0 to 1023
newExpression = (newExpression + 1) / 64; //0 to 16
if ((newExpression != oldExpression) && (newExpression != oldOldExpression)) // double check avoids jitter
{
oldOldExpression = oldExpression;
oldExpression = newExpression;
newExpression = controllerArray [newExpression]; //extract controller value from array
if (newExpression > 127)
{
newExpression = 127; //correct out of range controller value
}
Serial.write (0xB0); //controller (channel 1)
Serial.write (0); //number zero
Serial.write (newExpression);
}
}