/*

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);

  }

}