#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();
****}
**}
}