DIY 303 sequencer (MIDI)

[tbn]

Hoi,

Ik heb hier op het forum een hoop gelezen over het "bijzondere" van de 303 sequencer. OMdat ik geen zin heb om een 303 te kopen, ook niet zo nodig een cyclone 303 hoef en ik zelf toch wel eens het bijzondere van die 303-sequencer wil ervaren maar besloten om er zelf eentje te bouwen.

Daarnaast vind ik cv/gate prachtig, maar zoek ik iets dat mijn midi-synths kan sequencen, en waarbij de slide dan wordt doorgegeven door de noten overlappend te spelen, zodat een autoglide-functie op een monoynthje makelijk getrigerd kan worden.

Voor de liefheber zal ik hier een en ander over de voortang posten.

Achtergrond

Ik heb veel verschillende sequencers geprobeerd, waaronder electribe, x0xb0x, elektron, sequentix; allen werken met 16 steps voor zowel pitch als timing/slide/accent/.

Dit in tegenstelling tot de 303, waarbij je een reeks pitches opgeeft(1octaaf, c tot c), inclusief octaaf down,/octaaf up/slide/accent.

Los daarvan geef je bij een 303 de timing info op: rest, note of tie. "Rest" spreekt voor zichzelf. In geval van "note" wordt een noot gespeeld, en in geval van "tie" wordt de voorgaande noot verlengd.

De crux zit hem erin dat alleen bij elke niewe "note" een volgende pitch uit het lijstje wordt gepakt. Stel: ingevoerde piches zijn C, D, E, F, G, A, B, C2. Als in de timing info voor dat pattern maar 3 "note"-entrys staan dan worden alleen de eerste 3 noten uit het rijtje pitches gespeeld (C, D en E in dit geval.). OOk als deze 3 "note"-entrys op stap 14, 15 en 16 van je pattern zijn worden alleen deze 3 pitches gespeeld.
Zie ondestaand plaatje.


Projectplan

Die 303 heette nietvoor niets "computer controlled": hoewel de 303-synth analoog is, is de 303-sequencer een prachtig stukje digitale-jaren-tachtig-techniek, aangedreven door een ATMEGA? microcontroller. Ik ben niet zo'n geweldig onderlegd electronica-techneut, dus maar besloten om een arduino mega als brains te nemen.

Interface moet zonder schermpje zijn, gelijkend op de 303 met veel switches en leds.
Daarnaast wil ik dus een aparte "pitch-mode" en "Time-mode" voor het editen/afspelen van de paterns.

Status tot op heden

A) me verdiept in Arduino, en de gebruikte programmeertaal.

B) Arduino mega besteld, met een beetje zoeken nog geen 25,-

C) een stukje code gemaakt dat in ieder geval succesvol een pattern kan afspeen over midi

D) Zooitje switches, leds en een doosje besteld om een prototype behuizing/interface te maken

E) Prototype behuizing in elkaar -ge-zet/flanst) (zie foto)









Bekijk bijlage 303.txt

 

[tbn]

Voor de nerds onder ons wat meer info over de code:

requirements

MUSTHAVES

uitgangspunt is een pattern dat uit twee reeksen van 16 bestaat:
16 noten, en 16 timing-stappen.

Noten: C1 tot c2 (1 octaaf), daarnaast Down/Up/Slide/Accent
Timing stappen: rest, tie, note

Daarnaast heeft elke reeks nog een specifieke entry voor "end of patern" waarmee aangegeven kan worden dat een patern korter is dan 16 steps. of maar is opgebouwd uit minder dan 16 ingevoerde pitches.

midi notes uit, ingebouwde (BPM) timer, zo mogelijk ook midi-clock uit

Een interface met switches en Leds, geen display (voor dat echte jaren 80 gevoel)

een play-mode zodat er een pattern kan worden afgespeeld als test.

Opslag / opbouw van paterns moet efficient compact zijn, zodat er genoeg patterns op het 4K EEPROM-chippie passen.




SHOULDHAVES

Een pattern-edit mode met afzonderlijke pitch- en time-mode, van waaruit de EEPROM gevuld kan worden met patterns.


Sync via externe midiclock of dinsync,

switchen tussen play en edit-mode terwijl pattern blijft spelen


patern-chain/song-mode

 

[tbn]

Ontwerp

Gezien het uitgangspunt van een patern sequencer een pattern is ben ik maar begonnen met een pattern:

-16 pitches, waarvan elke Pitch bestaat uit 1 van 13 nootnummers en Up/Down/Slide/Accent / OF EndOfPattern code


Gezien DOWN / UP/ SLIDE / of ACCENT aan/uit switches zijn, lijkt een BOOLEAN logisch. 4 booleans als bitjes in een byte stoppen, en er zijn nog 4 bits, dus 16 combi's over; genoeg voor de 13 nootjes.....
16 pitches passen dus in 16 bytes.
per Byte: A-S-D-U-PPPP (Accent, Slide, DOWN, UP, 4 bits voor pitch) EOP gedefinieerd als B11111111

-16 steps, per step 4 mogelijkheden: Note, Tie, Rest, EOP-code
4 mogelijkheden is 2 bits; 4 stappen passen dus in een byte;met 4 bytes 16 steps.
per step:
B00 = rest
B01 = tie
B10 = note
B11 = end of patern

Daarmee past een patern met afzonderlijke pitch en timing info in 20 bytes oftewel "int patern[20]"

Zo, even genoeg getyp voor vanavond.
Voor de enthousiastelingen al een preview in de vorm van de huidige code in bijgevoegd .txt bestand. Voor syntax-highlghting een voudig te copy-pasten naar Arduino-IDE of willekeurige c++-editor

 

[Rvooh]

Ben je hiermee bekend?
http://antonsavov.net/cms/projects/n0nx0x2.html
Werk hier al enkele jaren aan mee en ik kan zeggen dat we nu voor 100% de 303 sequencer gekloond hebben.
een pattern past trouwens in 16 bytes hoewel de interface pitch en time info gescheiden houdt is de opslag ervan "flattened", lekker slim van Roland in de tijden van beperkt geheugen
sorry, geen open source..

 

[tbn]

Ja, heb inderdaad een en ander over n0nx0x gelezen: tof project! (heeft me ook op de hoogte gebracht van het verschil tussen x0x en 303 sequencing)

Ik vind het leuk om het wiel zelf uit te vinden, tevens een oefening in programeren
De code houd ik (voorlopig in elk geval) open source. (voor huidige status ie bijlage 303.txt in bovenste post)

keuze voor het afzonderlijk opslaan van pitch en timing-info is bewust: ik heb al een systeem voor switchen tussen x0x-style en 303-style sequencing bedacht en wil sowieso ook nog een 303-live-edit mode gaan maken, waarbij het fijn is als je pitches bewaard blijven.

Het idee is te beginnen met de basis-functionaliteit: patternplay / patternedit en van daaruit maar ns te kijken wat er verder voor een leke trucen uit te halen zijn.

 

[Rvooh]

We hadden eerst ook 20 byte patterns, en wilden ook de "extra" pitches bewaren.. maar hoe verder we kwamen, hoe meer problemen dat er door ontstonden (allerlei "details" in de 303 sequencer zijn een rechtstreeks gevolg van de implementatie.. dit alles gaan emuleren vanuit een andere implementatie zorgde constant voor onverwachte "bugs" ). Antto (de programmeur van n0nx0x) heeft lang in dezelfde richting gedacht als jij nu bezig bent, maar is uiteindelijk toch op 16 byte patterns overgeschakeld, formaat/implementatie is (zo goed als, het blijft giswerk) identiek aan de 303 en daardoor werken zelfs alle ongedocumenteerde truukjes om bvb de pitch buffer te kopieren naar een lege pattern, zonder speciale code om deze zaken na te bootsen
In "manipulate" mode in n0nx0x zitten veel overblijfsels uit de oorspronkelijke code, waardoor in feite het beste van beide werelden mogelijk is.
wat betreft realtime live edit: deze van ons is zo goed als af maar nog niet gereleased (reden is omdat we ook de computer applicatie voor pc/mac/linux enorm uitgebreid hebben en iedereen een beetje druk met andere zaken bezig is) release zal voor zeer binnenkort zijn
er staan enkele filmpjes van op youtube

in elk geval wens ik je veel programmeer plezier! Mocht je met technische/implementatie vragen zitten kan je altijd eens op irc checken, de #x0xb0x channel (freenode), daar hangen we rond

 

[tbn]

was niet blij met de eerder gemaakte behuizing (was een andere box dan besteld) nu alle onderdelen overgezet naar de juiste doos. Daarnaast ook de bedrading van het frontpaneel gemaakt en de verbindingen naar mijn arduino-bordje.

Snel geschreven testprogrammatje voor alle schakelaars en leds wijst uit dat het met solderen in een keer goed is gegaan

Nu maar weer verder met de code...

 

[tbn]

Joepie!

houston, we hebben een werkende pattern-play mode, en tempo pot.
ook 8 geheugenplaatsen waarvan geladen kan worden --> worden er 128.
een werkende pitch-write-mode, die in het geheugen weg kan schrijven, time mode in progress.
nu eerst maar eens slapen en werken, morgenavond verder

sleep work code repeat

 

[exel]

Mooie nijverheid!

Voor het netjes hoort er eigenlijk nog een 220Ω weerstand tussen je TX en de MIDI Out. Als die andere poort een MIDI In is (kan niet helemaal volgen waar die draden heengaan), dan moet je ook nog een opto-coupler in de mix goien

 

[tbn]

Midi in is nog niet aangesloten, maar de optocoupler ligt al klaar

Ik weet dat er 220 ohm tussen 5V en pin 4 moet voor midi-uit, maar ook tussen tx en pin 5??

Zie dat nergens in arduino-midi-out schema's terugkomen???

 

[exel]

Als ik google op "MIDI Out" schematic kom ik hem keer op keer tegen. Gaat om de output-impedantie, en voorkomen dat je je TX naar ground short als er iets misgaat in de kabel of connector.

Random voorbeeld:

 

[GentleG]

Ik weet dat er 220 ohm tussen 5V en pin 4 moet voor midi-uit, maar ook tussen tx en pin 5??

Ja.
Mocht midi niet werken dan heb je pin 4 en 5 omgedraaid,
dat doe ik al jaren

 

[exel]

Ja.
Mocht midi niet werken dan heb je pin 4 en 5 omgedraaid,
dat doe ik al jaren

Dat probleem is nog 2x zo vervelend als je met veel flat cables dealt. Altijd vier keer double checken .

 

[Designer]

Je moet die midi poort van de binnenkant bekijken bij die schematjes, zodoende draai je ze om.

 

[tbn]

Inderdaad die pinnetjes verkeerdom gesoldeerd.....

Inmiddels time-mode geïmplementeerd, evenals bankselect, waardoor er nu via de knoppen/led interface 64 patterns te programmeren en af te spelen zijn.

Nu rustig de code opschonen; de ruim 1100 regels tot nu toe zijn in een ruk geschreven en nog lang niet zo efficient als zou kunnen.

@rvooh: inderdaad komt ook bij mij langzaam een idee opzetten waarom je een pattern zou willen platslaan voor het op te slaan in maar 16 bits... (Playmode met rotate, random, etc)... Maar voorlopig eerst maar ff huidige code schonen.

 

[tbn]

Dit weekend hoop kunnen doen aan de code:

-Aantal bugs verholpen (oa pattern start vanaf stap 2 ipv 1....)
-efficientere keyscanning.
-Nauwkeurigere, interne 24ppq klok, en Midiclock out toegevoegd,
-Running-light mode toegevoegd voor patern play.
-Zelfde running-light methode voor het aangeven van welke pitchstep/timestep momenteel ge-edit wordt
-tempo-pot heeft nu logischer gedrag (gedroeg zich wat exponentieel), met bpm van 30-200, netjes verdeeld over het bereik.

Voor de enthousiastelingen hieronder de code (waaraan nog genoeg moet gebeuren, maar nu iig een stabiele implementatie)

#include*<EEPROM.h>
//leds
const int ledC1 =  2;
const int ledD2 =  3;
const int ledE3 =  4;
const int ledF4 =  5;
const int ledG5 =  6;
const int ledA6 =  7;
const int ledB7 =  8;
const int ledC8 =  9;
const int ledDWN =  10;
const int ledUP =  11;
const int ledACC =  12;
const int ledSLD =  13;
const int ledTME =  16;
const int ledX1 =  17;
const int ledX2 =  18;
const int ledX3 =  19;
const int ledRUN =  47;
const int ledCs =  46;
const int ledDs =  53;
const int ledFs =  52;
const int ledGs =  51;
const int ledAs =  50;
const int ledBCK =  49;
const int ledNXT =  48;
const int ledTEMPO =  36;
//keys
const int keyC1 =  20;
const int keyD2 =  21;
const int keyE3 =  23;
const int keyF4 =  22;
const int keyG5 =  25;
const int keyA6 =  24;
const int keyB7 =  27;
const int keyC8 =  26;
const int keyDWN =  29;
const int keyUP =  28;
const int keyACC =  31;
const int keySLD =  30;
const int keyTME =  33;
const int keyX1 =  32;
const int keyX2 =  35;
const int keyX3 =  34;
const int keyRUN =  45;
const int keyCs =  44;
const int keyDs =  43;
const int keyFs =  42;
const int keyGs =  41;
const int keyAs =  40;
const int keyBCK =  39;
const int keyNXT =  38;
const int switchMODE =  37;
//vars
long intervalMicro = 0; // = 30000000 / (bpm * 24);
int midiflag;
long currentMicro = 0;
long previousMillis = 0; //for getFlag
long previousMicro = 0;
int tempo = 60;  //for getFlag
int bpm = 120;
int runstop = LOW;
int noteOnFlag = LOW; //play note on on step
int noteOffFlag = LOW; // play noteoff on step
int slideOffFlag = LOW; // play slidenoteoff on step
int accentFlag = LOW;
int tiedelay = LOW;
byte pattern[20] ; //steps
byte currentpattern = 0; // pattern number
byte nextpattern = 0;    // next patern number, for change at end of current pattern
int currentbank = 0;
int mode = 0;
int lastButtonState[24] = { HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH};
int buttonState[24];
long lastDebounceTime = 0;
int pitchcounter = 0;
int stepcounter = 0;
int displaycounter = 0;
int nextstep = 0;
int vel = 63;
int accent = 127;
int pitch = 0;
int noteoffpitch = 0;
int slidepitch = 0;
int flag = HIGH;     //for getFlag\
int beatctr = 0;
int editmode = 0; // 0 = normal, 1= pitchmode , 2 = timemode
int editstep = 0;
byte editbuffer[20];
int timestep = 0;
int displayrefresh = 200;
int refreshcounter = 0;
int function = LOW;
int midicounter = 0;
void setup() {
**pinMode(ledC1, OUTPUT);
**pinMode(ledD2, OUTPUT);
**pinMode(ledE3, OUTPUT);
**pinMode(ledF4, OUTPUT);
**pinMode(ledG5, OUTPUT);
**pinMode(ledA6, OUTPUT);
**pinMode(ledB7, OUTPUT);
**pinMode(ledC8, OUTPUT);
**pinMode(ledDWN, OUTPUT);
**pinMode(ledUP, OUTPUT);
**pinMode(ledACC, OUTPUT);
**pinMode(ledSLD, OUTPUT);
**pinMode(ledTME, OUTPUT);
**pinMode(ledX1, OUTPUT);
**pinMode(ledX2, OUTPUT);
**pinMode(ledX3, OUTPUT);
**pinMode(ledRUN, OUTPUT);
**pinMode(ledCs, OUTPUT);
**pinMode(ledDs, OUTPUT);
**pinMode(ledFs, OUTPUT);
**pinMode(ledGs, OUTPUT);
**pinMode(ledAs, OUTPUT);
**pinMode(ledBCK, OUTPUT);
**pinMode(ledNXT, OUTPUT);
**pinMode(ledTEMPO, OUTPUT);
**lightup();
**delay(500);
**clearleds();
**pinMode(keyC1,  INPUT_PULLUP );
**pinMode(keyD2,  INPUT_PULLUP );
**pinMode(keyE3,  INPUT_PULLUP );
**pinMode(keyF4,  INPUT_PULLUP );
**pinMode(keyG5,  INPUT_PULLUP );
**pinMode(keyA6,  INPUT_PULLUP );
**pinMode(keyB7,  INPUT_PULLUP );
**pinMode(keyC8,  INPUT_PULLUP );
**pinMode(keyDWN,  INPUT_PULLUP );
**pinMode(keyUP,  INPUT_PULLUP );
**pinMode(keyACC,  INPUT_PULLUP );
**pinMode(keySLD,  INPUT_PULLUP );
**pinMode(keyTME,  INPUT_PULLUP );
**pinMode(keyX1,  INPUT_PULLUP );
**pinMode(keyX2,  INPUT_PULLUP );
**pinMode(keyX3,  INPUT_PULLUP );
**pinMode(keyRUN,  INPUT_PULLUP );
**pinMode(keyCs,  INPUT_PULLUP );
**pinMode(keyDs,  INPUT_PULLUP );
**pinMode(keyFs,  INPUT_PULLUP );
**pinMode(keyGs,  INPUT_PULLUP );
**pinMode(keyAs,  INPUT_PULLUP );
**pinMode(keyBCK,  INPUT_PULLUP );
**pinMode(keyNXT,  INPUT_PULLUP );
**pinMode(switchMODE, INPUT);
**lightup();
**delay(500);
**clearleds();
**Serial3.begin(31250);
**if (digitalRead(keyRUN)  == LOW) {
****testmode();
**}
**loadpattern(currentpattern);
**lightup();
**delay(100);
**clearleds();
}
void loop() {
**int newkey = 0;
**noteOnFlag*=*LOW; //play all notes off
**slideOffFlag*=*LOW; //all eventflags = false
**noteOffFlag*=*LOW;
**accentFlag*=*LOW;
**tiedelay*=*LOW; 
**stepcounter*=*0;// reset step
**pitchcounter*=*0;*// reset pitch
**if ((pattern[0] < 255) && ((pattern[16] & B11000000) != B11000000)) {
****getnextstep();*// get pattern step
****if (nextstep == 2) {
******noteOnFlag*=*HIGH;
****}
**}
**//get pattern first
**while (runstop == LOW) {   //playing
****if (currentpattern != nextpattern) {
******currentpattern*=*nextpattern;
******loadpattern(currentpattern);
******stepcounter*=*0;
******if ((pattern[0] < 255) && (pattern[16] & B11000000) != 192) {
********getnextstep();*// get pattern step
********if (nextstep == 2) {
**********noteOnFlag*=*HIGH;
********}
******}
******else {
********runstop*=*LOW;
********digitalWrite(ledRUN, LOW);
******}
****}
****newkey*=*readkeys();
****if (newkey != 0) {
******handlekeypress(newkey);
****}
****showdisplay();
**}
**while (runstop == HIGH) {//playing
****readtempo(0);
****newkey*=*readkeys();
****if (newkey != 0) {
******handlekeypress(newkey);
****}
****showdisplay();
**}
**readtempo(1);
}

void readtempo (int reset) { // converts an encoder setting to a bpm to an interval. TODO swingtiming

**currentMicro*=*micros();
**intervalMicro*=*60000000*/*(bpm***24);
**if (reset == 0) {
****if (currentMicro - previousMicro > intervalMicro) {
******previousMicro*=*previousMicro*+*intervalMicro;
******sendmidiclock();
******midicounter++;
******if ( midicounter == 1) {
********midiflag*=*HIGH ;
********patternplay(midiflag);
********displaycounter*=*stepcounter*-*1;
********beatctr++;
******}
******if ( midicounter == 4) {
********midiflag*=*LOW;
********patternplay(midiflag);
******}
******if ( midicounter == 6) {
********midicounter*=*0;
******}
******if (beatctr == 1) {
********digitalWrite(ledTEMPO, HIGH);
******}
******if (beatctr == 2) {
********digitalWrite(ledTEMPO, LOW);
******}
******if (beatctr > 3) {
********beatctr*=*0;
******}
****}
**}
**if (reset == 1) {
****midicounter*=*0;
****beatctr*=*0;
****displaycounter*=*-1;
****allnotesoff();
**}
}
void patternplay (int stage) {
**if (stage == HIGH) {
****if (noteOnFlag == HIGH) {
******noteOn()*;*//note on
******noteOnFlag*=*LOW;
******noteOffFlag*=*HIGH; // set note off
******noteoffpitch*=*pitch;
****}
****if (slideOffFlag == HIGH && tiedelay == LOW) {
******slideOff()*;*//slide note off
******slideOffFlag*=*LOW;
****}
****if (bitRead(pattern[pitchcounter], 6) == 1)  {
******slidepitch*=*pitch*;
******noteOffFlag*=*LOW;
******slideOffFlag*=*HIGH;
****}
****getnextstep();
****if (nextstep == 1) {
******tiedelay*=*HIGH;
****}
****else {
******tiedelay*=*LOW;
****}
****if (nextstep == 2) {
******noteOnFlag*=*HIGH;
****}
****if (slideOffFlag == HIGH & noteOnFlag == HIGH & pitch == slidepitch ) {
******noteOnFlag*=*LOW;
******slideOffFlag*=*LOW;
****}
**}
**if (stage == LOW) {
****if (noteOffFlag == HIGH && tiedelay == LOW) {
******noteOff();**//noteoff
******noteOffFlag*=*LOW;
****}
**}
}
void getnextstep() {
**int bit1 = 0;
**int bit2 = 0;
**int bitIndex[] {7, 5, 3, 1, 7, 5, 3, 1, 7, 5, 3, 1, 7, 5, 3, 1 } ; //bitpointer
**int byteIndex[] {16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19}  ;  //bytepointer
**int bitpointer = 0;
**int bytepointer = 0;
readagain:
**bytepointer*=*byteIndex[stepcounter];
**bitpointer*=*bitIndex[stepcounter];
**bit1*=*bitRead(pattern[bytepointer], bitpointer);
**bit2*=*bitRead(pattern[bytepointer], ( bitpointer - 1) );
**if ((bit1 == 1 && bit2 == 1) || stepcounter == 16 ) {
****stepcounter*=*0;
****pitchcounter*=*0;
****displaycounter*=*0;
****if (currentpattern != nextpattern) {
******currentpattern*=*nextpattern;
******loadpattern(currentpattern);
******if ((pattern[0] & B00001111 != B00001111) && (pattern[16] & B11000000) != B11000000) {
********getnextstep();*// get pattern step
********if (nextstep == 2) {
**********noteOnFlag*=*HIGH;
********}
******}
******else {
********runstop*=*LOW;
********digitalWrite(ledRUN, LOW);
******}
****}//get new pattern at end of current
****goto*readagain*;
**}
**if (bit1 == 1 && bit2 == 0) {
****pitch*=*(48*+*(pattern[pitchcounter]*&*B00001111)*+*(bitRead(pattern[pitchcounter], 4) * 12) - bitRead(pattern[pitchcounter], 5) * 12) ;
****if (bitRead(pattern[pitchcounter], 7) == 1) {
******accentFlag*=*HIGH;
****}
****//note
****if (pitchcounter == 15 || pattern[pitchcounter + 1] == 255) {
******pitchcounter*=*0;
****}
****else if (pitchcounter < 15) {
******pitchcounter++*;
****}
****pitch*=*(48*+*(pattern[pitchcounter]*&*B00001111)*+*(bitRead(pattern[pitchcounter], 4) * 12) - bitRead(pattern[pitchcounter], 5) * 12) ;
****if (bitRead(pattern[pitchcounter], 7) == 1) {
******accentFlag*=*HIGH;
****}
****nextstep*=*2*;
**}
**if (bit1 == 0 && bit2 == 1) {
****nextstep*=*1;***// tie
**}
**if (bit1 == 0 && bit2 == 0) {
****nextstep*=*0;**//rest
**}
**if (stepcounter < 16 ) {
****stepcounter++*;
**}
}
void sendmidiclock() {
**Serial3.write(0xF8);
}
void sendstopstart() {
**if (runstop == HIGH) {
****Serial3.write(0xFA);
**}
**if (runstop == LOW) {
****Serial3.write(0xFC);
**}
}

void noteOn() {
**byte cmd = 0x90;
**byte note = pitch;
**byte velocity = vel;
**if (accentFlag == HIGH) {
****velocity*=*accent;
****accentFlag*=*LOW;
**}
**else {
****velocity*=*vel;
**}
**Serial3.write(cmd);
**Serial3.write(note);
**Serial3.write(velocity);
}
void noteOff() {
**byte cmd = 0x90;
**byte note = noteoffpitch;
**byte velocity = 0;
**Serial3.write(cmd);
**Serial3.write(note);
**Serial3.write(velocity);
}
void slideOff() {
**byte cmd = 0x90;
**byte note = slidepitch;
**byte velocity = 0;
**Serial3.write(cmd);
**Serial3.write(note);
**Serial3.write(velocity);
}
void allnotesoff() {
**byte cmd = 0xB0;
**byte note = 0x7B;
**byte velocity = 0;
**Serial3.write(cmd);
**Serial3.write(note);
**Serial3.write(velocity);
}
void previewpitch() {
**byte cmd = 0x90;
**byte note = (48 + ( editbuffer[editstep] & B00001111) + (bitRead( editbuffer[editstep], 4) * 12) - bitRead( editbuffer[editstep], 5) * 12);
**byte velocity = 0;
**if (bitRead( editbuffer[editstep], 7) == 1) {
****velocity*=*accent;
**}
**else {
****velocity*=*vel;
**}
**Serial3.write(cmd);
**Serial3.write(note);
**Serial3.write(velocity);
**delay(250);
**Serial3.write(cmd);
**Serial3.write(note);
**Serial3.write(0);
}
void loadpattern(int patternnumber) { //loads a pattern from eeprom to pattern[] (20 bytes}
**int address = patternnumber * 20;
**for (int i = 0 ; i < 20 ; i++) {
****pattern[i]*=*EEPROM.read(address + i);
**}
}
void writepattern(int patternnumber) { //writes a pattern to a specified location from pattern[] (20 bytes}
**int address = patternnumber * 20;
**for (int i = 0 ; i < 20 ; i++) {
****EEPROM.update(address + i, pattern[i] );
**}
}

int readkeys() {
**int keyarray[24] = {keyC1, keyD2, keyE3, keyF4, keyG5, keyA6, keyB7, keyC8, keyDWN, keyUP, keyACC, keySLD,  keyTME, keyX1, keyX2, keyX3, keyRUN, keyCs, keyDs, keyFs, keyGs, keyAs, keyBCK, keyNXT }   ;
**int reading[24];
**int buttonState[24];
**long lastDebounceTime[24];
**long debounceDelay = 15;
**vel*=*64*-*(analogRead(A14) / 16);
**accent*=*127*-*vel;
**bpm*=*30*+*(analogRead(A15) / 6);
**if (digitalRead(switchMODE) == HIGH) {
****mode*=*1;
**}
**else {
****mode*=*0;
**}
**for (int i = 0 ; i < 24 ; i++) {
****reading[i]*=*digitalRead(keyarray[i]);
****if (reading[i] != lastButtonState[i] && buttonState[i] != reading[i]) {
******buttonState[i]*=*reading[i];
******lastDebounceTime[i]*=*millis();
****}
****if ((millis() - lastDebounceTime[i]) > debounceDelay) {
******if (reading[i] != lastButtonState[i]  && buttonState[i] == reading[i]) {
********lastButtonState[i]*=*reading[i];
********if (buttonState[i] == LOW) {
**********return keyarray[i];
********}
********else {
**********return (0 - keyarray[i]);
********}
******}
****}
**}
**return 0;
}
void handlekeypress (int key) {
**if (key == 0) {
****return;
**}
**if  (key == keyRUN) {
****if (runstop == LOW) {
******runstop*=*HIGH;
****}
****else if (runstop == HIGH) {
******runstop*=*LOW;
****}
****digitalWrite(ledRUN, runstop);
****sendstopstart();
****previousMicro*=*micros() - intervalMicro;
**}
**if (key == keyX1) {
****function*=*HIGH;
**}
**if (key == (0 - keyX1)) {
****function*=*LOW;
**}
**if (mode == 0) {
****playmode(key);
**}
**if (mode == 1) {
****if  (key == keyTME) {
******for (int i = 0 ; i < 20 ; i++) {
********editbuffer[i]*=*pattern[i];
******}
******editmode*=*2;
******timestep*=*0;
****}
****if  (key == keyX2) {
******for (int i = 0 ; i < 20 ; i++) {
********editbuffer[i]*=*pattern[i];
******}
******editmode*=*1;
******editstep*=*0;
****}
****if  (key == keyX1) {
******editmode*=**0;
****}
****if (editmode == 0) {
******if (function == HIGH) {
********if  (key == keyC1) {
**********nextpattern*=*(currentbank***8)*+*0;
**********for (int i = 0; i < 20; i++) {
************EEPROM.update(nextpattern * 20 + i, 255);
**********}
********}
********if  (key == keyD2) {
**********nextpattern*=*(currentbank***8)*+*1;
**********for (int i = 0; i < 20; i++) {
************EEPROM.update(nextpattern * 20 + i, 255);
**********}
********}
********if  (key == keyE3) {
**********nextpattern*=*(currentbank***8)*+*2;
**********for (int i = 0; i < 20; i++) {
************EEPROM.update(nextpattern * 20 + i, 255);
**********}
********}
********if  (key == keyF4) {
**********nextpattern*=*(currentbank***8)*+*3;
**********for (int i = 0; i < 20; i++) {
************EEPROM.update(nextpattern * 20 + i, 255);
**********}
********}
********if  (key == keyG5) {
**********nextpattern*=*(currentbank***8)*+*4;
**********for (int i = 0; i < 20; i++) {
************EEPROM.update(nextpattern * 20 + i, 255);
**********}
********}
********if  (key == keyA6) {
**********nextpattern*=*(currentbank***8)*+*5;
**********for (int i = 0; i < 20; i++) {
************EEPROM.update(nextpattern * 20 + i, 255);
**********}
********}
********if  (key == keyB7) {
**********nextpattern*=*(currentbank***8)*+*6;
**********for (int i = 0; i < 20; i++) {
************EEPROM.update(nextpattern * 20 + i, 255);
**********}
********}
********if  (key == keyC8) {
**********nextpattern*=*(currentbank***8)*+*7;
**********for (int i = 0; i < 20; i++) {
************EEPROM.update(nextpattern * 20 + i, 255);
**********}
********}
******}
******if (function == LOW) {
********if  (key == keyC1) {
**********nextpattern*=*(currentbank***8)*+*0;
********}
********if  (key == keyD2) {
**********nextpattern*=*(currentbank***8)*+*1;
********}
********if  (key == keyE3) {
**********nextpattern*=*(currentbank***8)*+*2;
********}
********if  (key == keyF4) {
**********nextpattern*=*(currentbank***8)*+*3;
********}
********if  (key == keyG5) {
**********nextpattern*=*(currentbank***8)*+*4;
********}
********if  (key == keyA6) {
**********nextpattern*=*(currentbank***8)*+*5;
********}
********if  (key == keyB7) {
**********nextpattern*=*(currentbank***8)*+*6;
********}
********if  (key == keyC8) {
**********nextpattern*=*(currentbank***8)*+*7;
********}
******}
****}//end of normal mode
****if (editmode == 1) {
******pitchmode(key);
****}
****if (editmode == 2) {
******timemode(key);
****}
**}
}
void playmode(int key) {  //playmode
**if (function == LOW) {
****if  (key == keyC1 ) {
******nextpattern*=*(currentbank***8)*+*0;
****}
****if  (key == keyD2 ) {
******nextpattern*=*(currentbank***8)*+*1;
****}
****if  (key == keyE3 ) {
******nextpattern*=*(currentbank***8)*+*2;
****}
****if  (key == keyF4 ) {
******nextpattern*=*(currentbank***8)*+*3;
****}
****if  (key == keyG5 ) {
******nextpattern*=*(currentbank***8)*+*4;
****}
****if  (key == keyA6 ) {
******nextpattern*=*(currentbank***8)*+*5;
****}
****if  (key == keyB7 ) {
******nextpattern*=*(currentbank***8)*+*6;
****}
****if  (key == keyC8 ) {
******nextpattern*=*(currentbank***8)*+*7;
****}
**}
**if (function == HIGH) {
****if  (key == keyC1 ) {
******currentbank*=*0;
****}
****if  (key == keyD2 ) {
******currentbank*=*1;
****}
****if  (key == keyE3 ) {
******currentbank*=*2;
****}
****if  (key == keyF4 ) {
******currentbank*=*3;
****}
****if  (key == keyG5 ) {
******currentbank*=*4;
****}
****if  (key == keyA6 ) {
******currentbank*=*5;
****}
****if  (key == keyB7 ) {
******currentbank*=*6;
****}
****if  (key == keyC8 ) {
******currentbank*=*7;
****}
**}
}
//pitchmode
void pitchmode(int key) {
**if  (key == keyC1) {
****if (editbuffer[editstep] == B11111111) {
******editbuffer[editstep]*=*0;
****}
****else {
******editbuffer[editstep]*=*(editbuffer[editstep]*&*B11110000)*+*0;
****}
****if (runstop == LOW) {
******previewpitch();
****}
**}
**if  (key == keyCs) {
****if (editbuffer[editstep] == B11111111) {
******editbuffer[editstep]*=*1;
****}
****else {
******editbuffer[editstep]*=*(editbuffer[editstep]*&*B11110000)*+*1;
****}
****if (runstop == LOW) {
******previewpitch();
****}
**}
**if  (key == keyD2) {
****if (editbuffer[editstep] == B11111111) {
******editbuffer[editstep]*=*2;
****}
****else {
******editbuffer[editstep]*=*(editbuffer[editstep]*&*B11110000)*+*2;
****}
****if (runstop == LOW) {
******previewpitch();
****}
**}
**if  (key == keyDs) {
****if (editbuffer[editstep] == B11111111) {
******editbuffer[editstep]*=*3;
****}
****else {
******editbuffer[editstep]*=*(editbuffer[editstep]*&*B11110000)*+*3;
****}
****if (runstop == LOW) {
******previewpitch();
****}
**}
**if  (key == keyE3) {
****if (editbuffer[editstep] == B11111111) {
******editbuffer[editstep]*=*4;
****}
****else {
******editbuffer[editstep]*=*(editbuffer[editstep]*&*B11110000)*+*4;
****}
****if (runstop == LOW) {
******previewpitch();
****}
**}
**if  (key == keyF4) {
****if (editbuffer[editstep] == B11111111) {
******editbuffer[editstep]*=*5;
****}
****else {
******editbuffer[editstep]*=*(editbuffer[editstep]*&*B11110000)*+*5;
****}
****if (runstop == LOW) {
******previewpitch();
****}
**}
**if  (key == keyFs) {
****if (editbuffer[editstep] == B11111111) {
******editbuffer[editstep]*=*6;
****}
****else {
******editbuffer[editstep]*=*(editbuffer[editstep]*&*B11110000)*+*6;
****}
****if (runstop == LOW) {
******previewpitch();
****}
**}
**if  (key == keyG5) {
****if (editbuffer[editstep] == B11111111) {
******editbuffer[editstep]*=*7;
****}
****else {
******editbuffer[editstep]*=*(editbuffer[editstep]*&*B11110000)*+*7;
****}
****if (runstop == LOW) {
******previewpitch();
****}
**}
**if  (key == keyGs) {
****if (editbuffer[editstep] == B11111111) {
******editbuffer[editstep]*=*8;
****}
****else {
******editbuffer[editstep]*=*(editbuffer[editstep]*&*B11110000)*+*8;
****}
****if (runstop == LOW) {
******previewpitch();
****}
**}
**if  (key == keyA6) {
****if (editbuffer[editstep] == B11111111) {
******editbuffer[editstep]*=*9;
****}
****else {
******editbuffer[editstep]*=*(editbuffer[editstep]*&*B11110000)*+*9;
****}
****if (runstop == LOW) {
******previewpitch();
****}
**}
**if  (key == keyAs) {
****if (editbuffer[editstep] == B11111111) {
******editbuffer[editstep]*=*10;
****}
****else {
******editbuffer[editstep]*=*(editbuffer[editstep]*&*B11110000)*+*10;
****}
****if (runstop == LOW) {
******previewpitch();
****}
**}
**if  (key == keyB7) {
****if (editbuffer[editstep] == B11111111) {
******editbuffer[editstep]*=*11;
****}
****else {
******editbuffer[editstep]*=*(editbuffer[editstep]*&*B11110000)*+*11;
****}
****if (runstop == LOW) {
******previewpitch();
****}
**}
**if  (key == keyC8) {
****if (editbuffer[editstep] == B11111111) {
******editbuffer[editstep]*=*12;
****}
****else {
******editbuffer[editstep]*=*(editbuffer[editstep]*&*B11110000)*+*12;
****}
****if (runstop == LOW) {
******previewpitch();
****}
**}
**if  (key == keyDWN) {
****if (editbuffer[editstep] != B11111111) {
******bitWrite(editbuffer[editstep], 5 , 1 - (bitRead(editbuffer[editstep],  5)));
******if ((bitRead(editbuffer[editstep], 5) == 1) && (bitRead(editbuffer[editstep], 4) == 1)) {
********bitWrite(editbuffer[editstep], 4, 0);
********bitWrite(editbuffer[editstep], 5, 0);
******}
****}
****if (runstop == LOW) {
******previewpitch();
****}
**}
**if  (key == keyUP) {
****if (editbuffer[editstep] != B11111111) {
******bitWrite(editbuffer[editstep], 4 , 1 - (bitRead(editbuffer[editstep],  4)));
******if ((bitRead(editbuffer[editstep], 5) == 1) && (bitRead(editbuffer[editstep], 4) == 1)) {
********bitWrite(editbuffer[editstep], 4, 0);
********bitWrite(editbuffer[editstep], 5, 0);
******}
****}
****if (runstop == LOW) {
******previewpitch();
****}
**}
**if  (key == keyACC) {
****if (editbuffer[editstep] != B11111111) {
******editbuffer[editstep]*=*(editbuffer[editstep]*^*B10000000);
****}
****if (runstop == LOW) {
******previewpitch();
****}
**}
**if  (key == keySLD) {
****if (editbuffer[editstep] != B11111111) {
******editbuffer[editstep]*=*(editbuffer[editstep]*^*B01000000);
****}
****if (runstop == LOW) {
******previewpitch();
****}
**}
**if  (key == keyNXT) {
****EEPROM.update((currentpattern * 20 + editstep), editbuffer[editstep]);
****editstep++;
****if (editstep == 16) {
******editstep*=*0;
******editmode*=*0;
****}
****if (runstop == LOW && editbuffer[editstep] != B11111111) {
******previewpitch();
****}
**}
**if  (key == keyBCK) {
****editstep--;
****if (editstep < 0) {
******editstep*=*0;
******editmode*=*0;
****}
****if (runstop == LOW) {
******previewpitch();
****}
**}
**for (int i = 0 ; i < 16; i++ ) {
****pattern[i]*=*editbuffer[i];
**}
}
//timemode
void timemode(int key) {
**int bit1 = 0;
**int bit2 = 0;
**if  (key == keyX3) {
****bit1*=*14;
****bit2*=*14;
****writestep(bit1,*bit2);
**}
**if  (key == keyNXT) {
****bit1*=*14;
****bit2*=*14;
****writestep(bit1,*bit2);
**}

**if  (key == keyDWN) {
****bit1*=*1;
****bit2*=*0;
****writestep(bit1,*bit2);
**}
**if  (key == keyUP) {
****bit1*=*0;
****bit2*=*1;
****writestep(bit1,*bit2);
**}
**if  (key == keyACC) {
****bit1*=*0;
****bit2*=*0;
****writestep(bit1,*bit2);
**}
**if  (key == keySLD) {
****bit1*=*1;
****bit2*=*1;
****writestep(bit1,*bit2);
**}
**if  (key == keyBCK) {
****lightup();
****delay(1000);
****clearleds();
****timestep--*;
****lightup();
****;
****clearleds();
****if (timestep < 0) {
******timestep*=*0;
******editmode*=*0;
****}
**}
**for (int i = 0 ; i < 16; i++ ) {
****pattern[i]*=*editbuffer[i];
**}
}
void writestep( int bit1 , int bit2) {
**int bitIndex[] {7, 5, 3, 1, 7, 5, 3, 1, 7, 5, 3, 1, 7, 5, 3, 1 } ; //bitpointer
**int byteIndex[] {16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19}  ;  //bytepointer
**int bitpointer = 0;
**int bytepointer = 0;
**if (bit1 < 2 && bit2 < 2) {
****bitpointer*=*bitIndex[timestep];
****bytepointer*=*byteIndex[timestep];
****bitWrite(editbuffer[bytepointer], bitpointer, bit1);
****bitWrite(editbuffer[bytepointer], ( bitpointer - 1),  bit2);
****EEPROM.update(((currentpattern * 20) + byteIndex[timestep]) ,  editbuffer[bytepointer]);
****lightup();
****clearleds();
**}
**timestep++*;
**if (timestep == 16 ) {
****timestep*=*0;
****editmode*=*0;
**}
**pattern[bytepointer]*=*editbuffer[bytepointer];
}
void showdisplay() {
**int  ledarray[] = {ledC1, ledD2, ledE3, ledF4, ledG5, ledA6, ledB7, ledC8};
**refreshcounter++;
**if (refreshcounter > displayrefresh) {
****clearleds();
****refreshcounter*=*0;
**}
**if ( mode == 0) {
****if (function == LOW) {
******displaybank();
******if (runstop == HIGH) {
********displaystep(displaycounter);
******}
****}
****if (function == HIGH) {
******digitalWrite(ledX1, HIGH);
******displaybankselect();
****}
**}
**if (mode == 1) {
****if (editmode == 0) {
******if (function == HIGH) {
********digitalWrite(ledX1, LOW);
******}
******else {
********digitalWrite(ledX1, HIGH);
******}
******displaybank();
****}
****if (editmode == 1) {
******displaypitch(editbuffer[editstep]);
****}
****if (editmode == 2) {
******digitalWrite(ledTME, HIGH);
******displaytime();
****}
**}
}
void displaystep(int wich) {
**int  ledarray[] = {ledC1, ledD2, ledE3, ledF4, ledG5, ledA6, ledB7, ledC8};
**if (wich / 8 == 1) {
****analogWrite(ledCs, 25);
**}
**if (wich <= 7) {
****analogWrite(ledarray[wich], 25);
**}
**else {
****analogWrite(ledarray[(wich - 8)], 25);
**}
}
void displaybank() {
**int  ledarray[] = {ledC1, ledD2, ledE3, ledF4, ledG5, ledA6, ledB7, ledC8};
**for (int i = 0 ; i < 7 ; i++) {
****if (EEPROM.read((currentbank * 8) + i * 20) != B11111111) {
******analogWrite(ledarray[i], 25);
****}
****else {
******digitalWrite(ledarray[i], LOW);
****}
**}
**digitalWrite(ledarray[currentpattern % 8], HIGH);
}
void displaybankselect() {
**if (currentbank == 0) {
****digitalWrite(ledC1, HIGH);
**}
**if (currentbank == 1) {
****digitalWrite(ledD2, HIGH);
**}
**if (currentbank == 2) {
****digitalWrite(ledE3, HIGH);
**}
**if (currentbank == 3) {
****digitalWrite(ledF4, HIGH);
**}
**if (currentbank == 4) {
****digitalWrite(ledG5, HIGH);
**}
**if (currentbank == 5) {
****digitalWrite(ledA6, HIGH);
**}
**if (currentbank == 6) {
****digitalWrite(ledB7, HIGH);
**}
**if (currentbank == 7) {
****digitalWrite(ledC8, HIGH);
**}
}
void displaypitch(byte pitchdisplay) {
**int pitchindex[] = {ledC1, ledCs, ledD2, ledDs, ledE3, ledF4, ledFs, ledG5, ledGs, ledA6, ledAs, ledB7, ledC8, ledDWN, ledUP, ledACC, ledSLD };
**for (int i = 0; i < 17;  i++) {
****digitalWrite(pitchindex[i], LOW);
**}
**digitalWrite(ledX2, HIGH);
**if (bitRead(pitchdisplay, 7)) {
****digitalWrite(ledACC, HIGH);
**}
**if (bitRead(pitchdisplay, 6)) {
****digitalWrite(ledSLD, HIGH);
**}
**if (bitRead(pitchdisplay, 5)) {
****digitalWrite(ledDWN, HIGH);
**}
**if (bitRead(pitchdisplay, 4)) {
****digitalWrite(ledUP, HIGH);
**}
**if ((pitchdisplay & B00001111) < 13) {
****digitalWrite(pitchindex[(pitchdisplay & B00001111)], HIGH);
**}
**if ((pitchdisplay & B00001111) > 12) {
****for (int i = 0; i < 13;  i++) {
******digitalWrite(pitchindex[i], HIGH);
****}
**}
**displaystep(editstep);
}
void displaytime() {
**int bit1 = 0;
**int bit2 = 0;
**int bitIndex[] {7, 5, 3, 1, 7, 5, 3, 1, 7, 5, 3, 1, 7, 5, 3, 1 } ; //bitpointer
**int byteIndex[] {16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19}  ;  //bytepointer
**int bitpointer = 0;
**int bytepointer = 0;

**bytepointer*=*byteIndex[timestep];
**bitpointer*=*bitIndex[timestep];
**bit1*=*bitRead(editbuffer[bytepointer], bitpointer);
**bit2*=*bitRead(editbuffer[bytepointer], ( bitpointer - 1) );
**if (bit1 == 1 && bit2 == 1) {
****digitalWrite(ledDWN, HIGH);
****digitalWrite(ledUP, HIGH);
****digitalWrite(ledACC, HIGH);
****digitalWrite(ledSLD, HIGH);
**}
**if (bit1 == 1 && bit2 == 0) {
****digitalWrite(ledDWN, HIGH);
**}
**if (bit1 == 0 && bit2 == 1) {
****digitalWrite(ledUP, HIGH);
**}
**if (bit1 == 0 && bit2 == 0) {
****digitalWrite(ledACC, HIGH);
**}
**digitalWrite(ledTME, HIGH);
**displaystep(timestep);
}
void clearleds() {
**digitalWrite( ledC1, LOW);
**digitalWrite( ledD2, LOW);
**digitalWrite( ledE3, LOW);
**digitalWrite( ledF4, LOW);
**digitalWrite( ledG5, LOW);
**digitalWrite( ledA6, LOW);
**digitalWrite( ledB7, LOW);
**digitalWrite( ledC8, LOW);
**digitalWrite( ledDWN, LOW);
**digitalWrite( ledUP, LOW);
**digitalWrite( ledACC, LOW);
**digitalWrite( ledSLD, LOW);
**digitalWrite( ledTME, LOW);
**digitalWrite( ledX1, LOW);
**digitalWrite( ledX2, LOW);
**digitalWrite( ledX3, LOW);
**digitalWrite( ledCs, LOW);
**digitalWrite( ledDs, LOW);
**digitalWrite( ledFs, LOW);
**digitalWrite( ledGs, LOW);
**digitalWrite( ledAs, LOW);
**digitalWrite( ledBCK, LOW);
**digitalWrite( ledNXT, LOW);
}
void lightup() {
**digitalWrite( ledC1, HIGH);
**digitalWrite( ledD2, HIGH);
**digitalWrite( ledE3, HIGH);
**digitalWrite( ledF4, HIGH);
**digitalWrite( ledG5, HIGH);
**digitalWrite( ledA6, HIGH);
**digitalWrite( ledB7, HIGH);
**digitalWrite( ledC8, HIGH);
**digitalWrite( ledDWN, HIGH);
**digitalWrite( ledUP, HIGH);
**digitalWrite( ledACC, HIGH);
**digitalWrite( ledSLD, HIGH);
**digitalWrite( ledTME, HIGH);
**digitalWrite( ledX1, HIGH);
**digitalWrite( ledX2, HIGH);
**digitalWrite( ledX3, HIGH);
**digitalWrite( ledCs, HIGH);
**digitalWrite( ledDs, HIGH);
**digitalWrite( ledFs, HIGH);
**digitalWrite( ledGs, HIGH);
**digitalWrite( ledAs, HIGH);
**digitalWrite( ledBCK, HIGH);
**digitalWrite( ledNXT, HIGH);
}
void testmode() {
**// put your main code here, to run repeatedly:
**for (int exit = 0;  exit < 1;  ) {
****if (digitalRead(keyC1)  == HIGH ) {
******digitalWrite(ledC1, HIGH);
****}
****else {
******digitalWrite(ledC1, LOW);
****}
****if (digitalRead(keyD2)  == HIGH ) {
******digitalWrite(ledD2, HIGH);
****}
****else {
******digitalWrite(ledD2, LOW);
****}
****if (digitalRead(keyE3)  == HIGH ) {
******digitalWrite(ledE3, HIGH);
****}
****else {
******digitalWrite(ledE3, LOW);
****}
****if (digitalRead(keyF4)  == HIGH ) {
******digitalWrite(ledF4, HIGH);
****}
****else {
******digitalWrite(ledF4, LOW);
****}
****if (digitalRead(keyG5)  == HIGH ) {
******digitalWrite(ledG5, HIGH);
****}
****else {
******digitalWrite(ledG5, LOW);
****}
****if (digitalRead(keyA6)  == HIGH ) {
******digitalWrite(ledA6, HIGH);
****}
****else {
******digitalWrite(ledA6, LOW);
****}
****if (digitalRead(keyB7)  == HIGH ) {
******digitalWrite(ledB7, HIGH);
****}
****else {
******digitalWrite(ledB7, LOW);
****}
****if (digitalRead(keyC8)  == HIGH ) {
******digitalWrite(ledC8, HIGH);
****}
****else {
******digitalWrite(ledC8, LOW);
****}
****if (digitalRead(keyDWN)  == HIGH ) {
******digitalWrite(ledDWN, HIGH);
****}
****else {
******digitalWrite(ledDWN, LOW);
****}
****if (digitalRead(keyUP)  == HIGH ) {
******digitalWrite(ledUP, HIGH);
****}
****else {
******digitalWrite(ledUP, LOW);
****}
****if (digitalRead(keyACC)  == HIGH ) {
******digitalWrite(ledACC, HIGH);
****}
****else {
******digitalWrite(ledACC, LOW);
****}
****if (digitalRead(keySLD)  == HIGH ) {
******digitalWrite(ledSLD, HIGH);
****}
****else {
******digitalWrite(ledSLD, LOW);
****}
****if (digitalRead(keyTME)  == HIGH ) {
******digitalWrite(ledTME, HIGH);
****}
****else {
******digitalWrite(ledTME, LOW);
****}
****if (digitalRead(keyX1)  == HIGH ) {
******digitalWrite(ledX1, HIGH);
****}
****else {
******digitalWrite(ledX1, LOW);
****}
****if (digitalRead(keyX2)  == HIGH ) {
******digitalWrite(ledX2, HIGH);
****}
****else {
******digitalWrite(ledX2, LOW);
****}
****if (digitalRead(keyX3)  == HIGH ) {
******digitalWrite(ledX3, HIGH);
****}
****else {
******digitalWrite(ledX3, LOW);
****}
****if (digitalRead(keyRUN)  == HIGH ) {
******digitalWrite(ledRUN, HIGH);
****}
****else {
******digitalWrite(ledRUN, LOW);
****}
****if (digitalRead(keyCs)  == HIGH ) {
******digitalWrite(ledCs, HIGH);
****}
****else {
******digitalWrite(ledCs, LOW);
****}
****if (digitalRead(keyDs)  == HIGH ) {
******digitalWrite(ledDs, HIGH);
****}
****else {
******digitalWrite(ledDs, LOW);
****}
****if (digitalRead(keyFs)  == HIGH ) {
******digitalWrite(ledFs, HIGH);
****}
****else {
******digitalWrite(ledFs, LOW);
****}
****if (digitalRead(keyGs)  == HIGH ) {
******digitalWrite(ledGs, HIGH);
****}
****else {
******digitalWrite(ledGs, LOW);
****}
****if (digitalRead(keyAs)  == HIGH ) {
******digitalWrite(ledAs, HIGH);
****}
****else {
******digitalWrite(ledAs, LOW);
****}
****if (digitalRead(keyBCK)  == HIGH ) {
******digitalWrite(ledBCK, HIGH);
****}
****else {
******digitalWrite(ledBCK, LOW);
****}
****if (digitalRead(keyNXT)  == HIGH ) {
******digitalWrite(ledNXT, HIGH);
****}
****else {
******digitalWrite(ledNXT, LOW);
****}
****if (digitalRead(switchMODE) == HIGH) {
******digitalWrite(ledTEMPO, HIGH);
****}
****else {
******digitalWrite(ledTEMPO, LOW);
****}
****if (digitalRead(keyNXT)  == LOW && digitalRead(keyX1)  == LOW  ) {
******exit*=*1;
******clearleds();
****}
**}
}