2019-06-28 01:03:40 +02:00
|
|
|
#include <MIDI.h>
|
|
|
|
#include <HID.h>
|
2019-07-06 03:39:35 +02:00
|
|
|
#include <Wire.h>
|
|
|
|
#include <Adafruit_MPR121.h>
|
2019-06-28 01:03:40 +02:00
|
|
|
|
2019-06-29 02:42:38 +02:00
|
|
|
#define BPQN 24 // Ableton sends 24, VCV rack only one, by standard should be 24?
|
|
|
|
|
2019-06-27 18:58:37 +02:00
|
|
|
#define NOTEOffset 36
|
2019-06-30 00:39:01 +02:00
|
|
|
#define DRUMSHIFT 6
|
2019-06-27 18:58:37 +02:00
|
|
|
#define drumOffset 60
|
2019-03-08 21:10:15 +01:00
|
|
|
#define MINUTE 60000
|
2019-03-09 15:23:18 +01:00
|
|
|
#define MIDICLOCK 0xf8
|
2019-06-27 18:58:37 +02:00
|
|
|
#define MAXKEYS 48
|
|
|
|
#define MAXDPAD 3
|
2019-07-08 02:45:50 +02:00
|
|
|
#define MAXSTEP 64
|
2019-07-04 16:11:44 +02:00
|
|
|
#define NBITS 6
|
2019-07-08 02:45:50 +02:00
|
|
|
#define DEBOUNCE 100
|
2018-10-31 17:18:50 +01:00
|
|
|
|
2019-03-08 21:10:15 +01:00
|
|
|
MIDI_CREATE_DEFAULT_INSTANCE();
|
2019-06-28 01:03:40 +02:00
|
|
|
|
2019-03-10 02:33:59 +01:00
|
|
|
typedef struct SequencerStep* link;
|
|
|
|
|
2019-06-27 18:58:37 +02:00
|
|
|
typedef struct OCTAVEStatus { // This struct is for an OCTAVE status. Each bool is for 1 NOTE
|
2019-03-04 18:54:22 +01:00
|
|
|
bool stat[12];
|
|
|
|
int nOct;
|
|
|
|
} octst;
|
2018-10-31 17:18:50 +01:00
|
|
|
|
2019-03-10 02:33:59 +01:00
|
|
|
typedef struct SequencerStep {
|
2019-06-30 00:39:01 +02:00
|
|
|
bool clean = LOW;
|
2019-06-28 01:03:40 +02:00
|
|
|
bool kboard_s[MAXKEYS];
|
|
|
|
bool dpad_s[MAXDPAD];
|
2019-06-29 02:42:38 +02:00
|
|
|
unsigned short stepnumber;
|
2019-03-10 02:33:59 +01:00
|
|
|
link next;
|
|
|
|
} step;
|
2019-03-09 15:23:18 +01:00
|
|
|
|
2019-03-09 19:14:18 +01:00
|
|
|
// PIN DECLARATIONS
|
2019-06-27 18:58:37 +02:00
|
|
|
int NOTE[12] = { // Pins used to read each note (C is 0, B is 11)
|
2019-03-09 15:23:18 +01:00
|
|
|
22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44 };
|
2019-06-27 18:58:37 +02:00
|
|
|
int OCTAVE[4] = { // Pins associated to each OCTAVE's contact bar
|
2019-03-09 15:23:18 +01:00
|
|
|
12, 9, 8, 10 };
|
2019-07-04 16:11:44 +02:00
|
|
|
int LEDS[NBITS] = { // Pins used for leds
|
2019-07-08 02:45:50 +02:00
|
|
|
5, 4, 3, 14, 16, 18 };
|
2019-06-27 18:58:37 +02:00
|
|
|
int OW = 2; // Pin used for overwrite switch
|
2019-07-08 02:45:50 +02:00
|
|
|
int NEXT = 51; // Pin used for next step switch
|
2019-07-06 03:39:35 +02:00
|
|
|
int DEL = 11; // Capacitive button used for DELETE button
|
|
|
|
int PLUS = 10; // Capacitive button used for PLUS button
|
|
|
|
int MINUS = 9; // Capacitive button used for MINUS button
|
2019-03-09 19:14:18 +01:00
|
|
|
|
2019-03-10 02:33:59 +01:00
|
|
|
// GLOBAL SETTINGS
|
2019-07-06 03:39:35 +02:00
|
|
|
int pentathonic[10] = { // Used to quantize drum notes
|
|
|
|
0, 2, 5, 7, 9, 12, 14, 17, 19, 21 };
|
2019-03-09 19:14:18 +01:00
|
|
|
|
2019-03-10 02:33:59 +01:00
|
|
|
// PLACEHOLDERS
|
2019-03-09 19:14:18 +01:00
|
|
|
byte velocity = 100; //
|
2019-07-08 02:45:50 +02:00
|
|
|
int bpm = 360; //
|
2019-03-09 19:14:18 +01:00
|
|
|
|
2019-06-30 00:39:01 +02:00
|
|
|
// SEQUENCER POINTERS AND RELATED ARRAYS
|
|
|
|
link head[6];
|
|
|
|
link current[6];
|
|
|
|
link previous;
|
|
|
|
unsigned short nstep[6]; // Keeps track of the sequencer steps
|
|
|
|
bool mute[6];
|
|
|
|
byte channel; // Current selected channel. Drums are shifted of DRUMSHIFT channels (so channels can only be 6)
|
2019-03-10 02:33:59 +01:00
|
|
|
|
|
|
|
// SYSTEM VARIABLES
|
2019-06-27 18:58:37 +02:00
|
|
|
int arp = 0; // Keeps track of last played NOTE if arpeggiating
|
2019-03-09 19:14:18 +01:00
|
|
|
int midiclock = 0; // Used to sync with MIDI clock
|
2019-07-06 04:09:00 +02:00
|
|
|
bool plus_step = LOW; // This is used to remember the addition of a step
|
|
|
|
bool minus_step = LOW; // This is used to remember the deletion of a step
|
|
|
|
bool clear_step = LOW; // This is used to remember the clearing of a step
|
2019-06-30 00:39:01 +02:00
|
|
|
bool chan_up = LOW; // Only for now because I have few buttons :C
|
2019-07-08 02:45:50 +02:00
|
|
|
bool next_step = LOW; // Used to wait for a full switch cycle
|
2019-06-27 18:58:37 +02:00
|
|
|
int sem_beat = 0; // Basic semaphore used to sync with MIDI beat
|
|
|
|
int sem_gate = 0; // Basic semaphore used for gate timing
|
|
|
|
unsigned long last_gate = 0; // Gate start time for last sequencer step
|
2019-07-04 16:11:44 +02:00
|
|
|
unsigned long gate_length = 1000; // ms of keypress if arpeggiator
|
2019-07-08 02:45:50 +02:00
|
|
|
unsigned long last_next = 0;
|
2019-06-27 18:58:37 +02:00
|
|
|
bool dpadhit = LOW; // If any drum pad has been hit in this cycle, this is true
|
2019-03-09 19:14:18 +01:00
|
|
|
int npressed; // Number of keys pressed, used to avoid doing anything when no keys are pressed
|
2019-06-27 18:58:37 +02:00
|
|
|
bool kboard[MAXKEYS]; // Last status of keyboard
|
|
|
|
bool dpad[MAXDPAD]; // Last status of Capacitive Buttons
|
2019-07-06 03:39:35 +02:00
|
|
|
int cap_read = 0;
|
2019-03-09 15:23:18 +01:00
|
|
|
|
2019-07-06 03:39:35 +02:00
|
|
|
Adafruit_MPR121 cap = Adafruit_MPR121();
|
2018-11-11 01:11:49 +01:00
|
|
|
|
2019-03-04 18:54:22 +01:00
|
|
|
void setup() {
|
2019-06-28 01:48:24 +02:00
|
|
|
for (int cOCTAVE = 0; cOCTAVE < 4; cOCTAVE++) pinMode(OCTAVE[cOCTAVE], OUTPUT);
|
|
|
|
for (int cNOTE = 0; cNOTE < 12; cNOTE++) pinMode(NOTE[cNOTE], INPUT);
|
2019-07-04 16:11:44 +02:00
|
|
|
for (int cLED = 0; cLED < NBITS; cLED++) pinMode(LEDS[cLED], OUTPUT);
|
2019-07-06 03:39:35 +02:00
|
|
|
while (!cap.begin(0x5A)) delay(10); // If MPR121 is not ready, wait for it
|
2019-06-27 18:58:37 +02:00
|
|
|
for (int cStat = 0; cStat < MAXKEYS; cStat++) kboard[cStat] = LOW; // All keyboard keys start LOW
|
2019-03-08 21:10:15 +01:00
|
|
|
MIDI.begin(MIDI_CHANNEL_OFF);
|
2019-07-04 16:11:44 +02:00
|
|
|
Serial.begin(115200); // Uncomment this if you use Hairless and set baud rate
|
2019-06-28 01:03:40 +02:00
|
|
|
pinMode(OW, INPUT_PULLUP); // Used for overwrite switch
|
2019-07-08 02:45:50 +02:00
|
|
|
pinMode(NEXT, INPUT_PULLUP); // Used for overwrite switch
|
2019-06-30 02:55:50 +02:00
|
|
|
for (int i = 0; i < 6; i++){
|
2019-06-30 00:39:01 +02:00
|
|
|
current[i] = NULL;
|
|
|
|
head[i] = NULL;
|
|
|
|
nstep[i] = 0;
|
|
|
|
mute[i] = LOW;
|
|
|
|
}
|
2019-06-30 02:55:50 +02:00
|
|
|
channel = (byte) 1;
|
2019-07-08 02:45:50 +02:00
|
|
|
for (int i=0; i<NBITS; i++) {
|
|
|
|
digitalWrite(LEDS[i], HIGH);
|
|
|
|
delay(10);
|
|
|
|
}
|
|
|
|
last_gate = millis();
|
|
|
|
last_next = millis();
|
|
|
|
display(0);
|
2018-11-11 02:00:08 +01:00
|
|
|
}
|
|
|
|
|
2019-03-04 18:54:22 +01:00
|
|
|
void loop() {
|
2019-03-09 19:14:18 +01:00
|
|
|
sync();
|
2019-07-08 02:45:50 +02:00
|
|
|
cap_read = cap.touched();
|
2019-07-06 03:39:35 +02:00
|
|
|
|
2019-07-08 02:45:50 +02:00
|
|
|
if ((cap_read >> 8) & 1) { // Only for now!
|
|
|
|
for (int i=0; i<NBITS; i++) digitalWrite(LEDS[i], LOW);
|
|
|
|
digitalWrite(LEDS[channel-1], HIGH);
|
|
|
|
}
|
|
|
|
else if (current[channel-1] == NULL) display(analogRead(channel));
|
2019-07-06 03:39:35 +02:00
|
|
|
else display(current[channel-1]->stepnumber);
|
2019-07-06 04:09:00 +02:00
|
|
|
|
|
|
|
plus_step = plus_step || ((cap_read >> PLUS) & 1);
|
|
|
|
minus_step = minus_step || ((cap_read >> MINUS) & 1);
|
|
|
|
clear_step = clear_step || ((cap_read >> DEL) & 1);
|
|
|
|
|
|
|
|
if (chan_up != (bool) ((cap_read >> 8) & 1)) { // Used to increase channel with a button because I don't have a rotary switch (yet!)
|
2019-07-08 02:45:50 +02:00
|
|
|
chan_up = (bool) ((cap_read >> 8) & 1);
|
|
|
|
if (chan_up == HIGH) {
|
|
|
|
channel++;
|
|
|
|
if (channel > 6) channel = (byte) 1;
|
2019-07-06 04:09:00 +02:00
|
|
|
}
|
2019-07-08 02:45:50 +02:00
|
|
|
}
|
2019-06-28 01:48:24 +02:00
|
|
|
|
2019-06-27 18:58:37 +02:00
|
|
|
if (sem_beat > 0) {
|
|
|
|
sem_beat--;
|
2019-06-29 02:42:38 +02:00
|
|
|
|
2019-07-04 16:11:44 +02:00
|
|
|
if (sem_gate > 0) { // If step was shorter than GATE, close all open notes before next step
|
2019-06-27 18:58:37 +02:00
|
|
|
sem_gate--;
|
2019-06-30 02:55:50 +02:00
|
|
|
for (int chan = 0; chan < 6; chan++) {
|
2019-06-30 00:39:01 +02:00
|
|
|
if (mute[chan]) continue;
|
2019-07-04 16:11:44 +02:00
|
|
|
for (int i = 0; i < MAXKEYS; i++)
|
|
|
|
if (current[chan]->kboard_s[i] && !kboard[i] && !current[chan]->next->kboard_s[i])
|
|
|
|
playNote(i, !current[chan]->kboard_s[i], (byte) chan+1);
|
|
|
|
for (int i = 0; i < MAXDPAD; i++)
|
|
|
|
if (current[chan]->dpad_s[i] && !dpad[i])
|
|
|
|
playDrum(i, !current[chan]->dpad_s[i], (byte) chan+1);
|
2019-06-30 00:39:01 +02:00
|
|
|
}
|
2019-06-27 18:58:37 +02:00
|
|
|
}
|
2019-06-30 00:39:01 +02:00
|
|
|
|
2019-07-06 04:09:00 +02:00
|
|
|
if (plus_step && minus_step) {
|
|
|
|
plus_step = LOW;
|
|
|
|
minus_step = LOW;
|
2019-06-30 00:39:01 +02:00
|
|
|
}
|
2019-07-06 04:09:00 +02:00
|
|
|
if (plus_step) {
|
|
|
|
plus_step = LOW;
|
|
|
|
if (nstep[channel-1] < MAXSTEP) insertStep(channel-1);
|
2019-06-30 00:39:01 +02:00
|
|
|
}
|
2019-07-06 04:09:00 +02:00
|
|
|
if (minus_step) {
|
|
|
|
minus_step = LOW;
|
|
|
|
if (nstep[channel-1] > 0) deleteStep(channel-1);
|
2019-06-30 00:39:01 +02:00
|
|
|
}
|
2019-07-06 04:09:00 +02:00
|
|
|
if (clear_step) {
|
|
|
|
clear_step = LOW;
|
|
|
|
if (current[channel-1] != NULL) {
|
|
|
|
for (int i = 0; i < MAXKEYS; i++) current[channel-1]->kboard_s[i] = LOW;
|
|
|
|
for (int i = 0; i < MAXDPAD; i++) current[channel-1]->dpad_s[i] = LOW;
|
|
|
|
}
|
|
|
|
}
|
2019-06-30 00:39:01 +02:00
|
|
|
|
2019-07-06 04:09:00 +02:00
|
|
|
nextStep(); // ALL STEPS INCREMENTED
|
2019-06-30 00:39:01 +02:00
|
|
|
display(current[channel-1]->stepnumber);
|
2019-07-06 04:09:00 +02:00
|
|
|
|
2019-06-30 02:55:50 +02:00
|
|
|
for (int chan = 0; chan < 6; chan++) {
|
2019-06-30 00:39:01 +02:00
|
|
|
if (mute[chan]) continue;
|
2019-07-04 16:11:44 +02:00
|
|
|
if (current[chan] != NULL) { // PLAY all step notes in all unmuted channels
|
2019-07-08 02:45:50 +02:00
|
|
|
if (!(npressed > 0 && chan == (int) channel-1))
|
|
|
|
for (int i = 0; i < MAXKEYS; i++)
|
|
|
|
if (current[chan]->kboard_s[i] && !kboard[i])
|
|
|
|
playNote(i, current[chan]->kboard_s[i], (byte) chan+1);
|
2019-07-04 16:11:44 +02:00
|
|
|
for (int i = 0; i < MAXDPAD; i++) // Drums are played nonetheless because drums already layered won't overrule
|
|
|
|
if (current[chan]->dpad_s[i] && !dpad[i])
|
|
|
|
playDrum(i, current[chan]->dpad_s[i], (byte) chan+1);
|
2019-06-30 00:39:01 +02:00
|
|
|
}
|
2019-06-27 18:58:37 +02:00
|
|
|
}
|
2019-06-30 00:39:01 +02:00
|
|
|
last_gate = millis();
|
|
|
|
sem_gate++;
|
2019-03-09 15:23:18 +01:00
|
|
|
}
|
2019-06-29 02:42:38 +02:00
|
|
|
|
2019-06-27 18:58:37 +02:00
|
|
|
if (sem_gate > 0 && (millis() - last_gate) > gate_length) {
|
|
|
|
sem_gate--;
|
2019-06-30 02:55:50 +02:00
|
|
|
for (int chan = 0; chan < 6; chan++) {
|
2019-06-30 00:39:01 +02:00
|
|
|
if (mute[chan]) continue;
|
2019-07-04 16:11:44 +02:00
|
|
|
for (int i = 0; i < MAXKEYS; i++)
|
|
|
|
if (current[chan]->kboard_s[i] && !kboard[i])
|
|
|
|
playNote(i, !current[chan]->kboard_s[i], (byte) chan+1);
|
|
|
|
for (int i = 0; i < MAXDPAD; i++)
|
|
|
|
if (current[chan]->dpad_s[i] && !dpad[i])
|
|
|
|
playDrum(i, !current[chan]->dpad_s[i], (byte) chan+1);
|
2019-06-30 00:39:01 +02:00
|
|
|
}
|
2019-06-27 18:58:37 +02:00
|
|
|
}
|
2019-06-29 02:42:38 +02:00
|
|
|
|
2019-06-27 18:58:37 +02:00
|
|
|
dpadhit = LOW;
|
|
|
|
for (int cButton = 0; cButton < MAXDPAD; cButton++) {
|
2019-07-06 03:39:35 +02:00
|
|
|
if (( 1 & (cap_read >> cButton)) ^ dpad[cButton]) {
|
|
|
|
dpad[cButton] = (bool) 1 & (cap_read >> cButton);
|
|
|
|
playDrum(cButton, dpad[cButton], channel);
|
|
|
|
}
|
2019-06-28 01:03:40 +02:00
|
|
|
dpadhit = (dpad[cButton] || dpadhit);
|
2019-03-08 21:10:15 +01:00
|
|
|
}
|
2019-03-10 02:33:59 +01:00
|
|
|
|
2019-06-27 18:58:37 +02:00
|
|
|
npressed = 0;
|
|
|
|
for (int cOCTAVE = 0; cOCTAVE < 4; cOCTAVE++) {
|
|
|
|
digitalWrite(OCTAVE[cOCTAVE], HIGH);
|
|
|
|
npressed += eval(scan(cOCTAVE));
|
|
|
|
digitalWrite(OCTAVE[cOCTAVE], LOW);
|
2019-03-09 19:14:18 +01:00
|
|
|
}
|
2019-06-28 00:14:44 +02:00
|
|
|
|
2019-07-08 02:45:50 +02:00
|
|
|
if (current[channel-1] != NULL && digitalRead(OW)) {
|
2019-07-04 16:11:44 +02:00
|
|
|
if (npressed > 0) for (int i = 0; i < MAXKEYS; i++)
|
|
|
|
current[channel-1]->kboard_s[i] = kboard[i];
|
|
|
|
if (dpadhit) for (int i = 0; i < MAXDPAD; i++)
|
|
|
|
current[channel-1]->dpad_s[i] = dpad[i] || current[channel-1]->dpad_s[i]; // Drum hits aren't exclusive!
|
2019-06-30 00:39:01 +02:00
|
|
|
current[channel-1]->clean = LOW;
|
2018-11-11 02:00:08 +01:00
|
|
|
}
|
2018-10-31 17:21:02 +01:00
|
|
|
}
|
|
|
|
|
2019-06-27 18:58:37 +02:00
|
|
|
// Hardware specific functions
|
2019-03-04 18:56:20 +01:00
|
|
|
|
2019-06-27 18:58:37 +02:00
|
|
|
octst scan(int nOct) { // This function reads the 12 NOTE pins and returns a struct
|
|
|
|
int c; // with 1 bool for each NOTE
|
2019-03-04 18:54:22 +01:00
|
|
|
octst output;
|
2018-10-31 17:18:50 +01:00
|
|
|
|
2019-03-04 18:54:22 +01:00
|
|
|
output.nOct = nOct;
|
2018-11-11 01:11:49 +01:00
|
|
|
|
2019-03-04 18:54:22 +01:00
|
|
|
for (c = 0; c < 12; c++) {
|
2019-06-27 18:58:37 +02:00
|
|
|
output.stat[c] = digitalRead(NOTE[c]);
|
2018-11-11 01:11:49 +01:00
|
|
|
}
|
2019-03-04 18:54:22 +01:00
|
|
|
return output;
|
2018-11-11 01:11:49 +01:00
|
|
|
}
|
|
|
|
|
2019-06-28 01:48:24 +02:00
|
|
|
void display(int number){
|
2019-07-04 16:11:44 +02:00
|
|
|
for(int i = 0; i < NBITS; i++) {
|
2019-06-29 02:42:38 +02:00
|
|
|
digitalWrite(LEDS[i], number & (unsigned short) 1);
|
|
|
|
number = number >> 1;
|
|
|
|
}
|
2019-06-28 01:48:24 +02:00
|
|
|
}
|
|
|
|
|
2019-06-27 18:58:37 +02:00
|
|
|
// NOTE Functions
|
|
|
|
|
2019-03-08 21:10:15 +01:00
|
|
|
int eval(octst input) {
|
|
|
|
int pressed = 0;
|
2019-06-27 18:58:37 +02:00
|
|
|
int sNOTE = input.nOct * 12;
|
2019-03-08 21:10:15 +01:00
|
|
|
|
|
|
|
for (int c = 0; c < 12; c++) {
|
2019-06-27 18:58:37 +02:00
|
|
|
if (input.stat[c] ^ kboard[c + sNOTE]) {
|
2019-06-30 00:39:01 +02:00
|
|
|
playNote(c + sNOTE, input.stat[c], channel);
|
2019-06-27 18:58:37 +02:00
|
|
|
kboard[c + sNOTE] = input.stat[c];
|
2019-03-08 21:10:15 +01:00
|
|
|
}
|
2019-06-27 18:58:37 +02:00
|
|
|
if (kboard[c + sNOTE] == HIGH) pressed++;
|
2018-10-31 17:18:50 +01:00
|
|
|
}
|
2019-03-08 21:10:15 +01:00
|
|
|
return pressed;
|
2018-11-11 01:11:49 +01:00
|
|
|
}
|
|
|
|
|
2019-06-30 00:39:01 +02:00
|
|
|
void playNote(int c, bool status, byte chan) {
|
2019-06-27 18:58:37 +02:00
|
|
|
byte n = c + NOTEOffset;
|
2019-03-08 21:10:15 +01:00
|
|
|
if (status == HIGH) {
|
2019-06-30 00:39:01 +02:00
|
|
|
MIDI.sendNoteOn(n, velocity, chan);
|
2019-03-08 21:10:15 +01:00
|
|
|
}
|
|
|
|
else if (status == LOW) {
|
2019-06-30 00:39:01 +02:00
|
|
|
MIDI.sendNoteOff(n, velocity, chan);
|
2019-03-08 21:10:15 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-30 00:39:01 +02:00
|
|
|
void playDrum(int c, bool status, byte chan) {
|
2019-07-06 03:39:35 +02:00
|
|
|
// The note is first quantized to a pentathonic and then scaled up to start at C4.
|
|
|
|
byte n = (byte) (pentathonic[c] + drumOffset);
|
2019-06-27 18:58:37 +02:00
|
|
|
if (status == HIGH) {
|
2019-06-30 02:55:50 +02:00
|
|
|
MIDI.sendNoteOn(n, velocity, chan + (byte) DRUMSHIFT);
|
2019-03-08 21:10:15 +01:00
|
|
|
}
|
2019-06-27 18:58:37 +02:00
|
|
|
else if (status == LOW) {
|
2019-06-30 02:55:50 +02:00
|
|
|
MIDI.sendNoteOff(n, velocity, chan + (byte) DRUMSHIFT);
|
2019-03-08 21:10:15 +01:00
|
|
|
}
|
2019-03-09 19:14:18 +01:00
|
|
|
}
|
|
|
|
|
2019-06-27 18:58:37 +02:00
|
|
|
// Sync functions
|
|
|
|
|
2019-03-09 19:14:18 +01:00
|
|
|
void sync() {
|
2019-07-08 02:45:50 +02:00
|
|
|
if (next_step != (bool) !digitalRead(NEXT)) { // Used to increase channel with a button because I don't have a rotary switch (yet!)
|
|
|
|
next_step = (bool) !digitalRead(NEXT);
|
|
|
|
if (millis() > last_next+DEBOUNCE && next_step == HIGH) {
|
|
|
|
last_next = millis();
|
|
|
|
sem_beat++;
|
|
|
|
}
|
|
|
|
}
|
2019-06-29 02:42:38 +02:00
|
|
|
if (Serial.available()) {
|
|
|
|
if (Serial.read() == MIDICLOCK) {
|
|
|
|
//sem_beat++;
|
|
|
|
midiclock++;
|
|
|
|
if (midiclock == BPQN){
|
|
|
|
midiclock = 0;
|
|
|
|
sem_beat++;
|
|
|
|
}
|
2019-06-28 01:48:24 +02:00
|
|
|
}
|
2019-03-09 19:14:18 +01:00
|
|
|
}
|
2019-03-10 02:33:59 +01:00
|
|
|
}
|
|
|
|
|
2019-06-27 18:58:37 +02:00
|
|
|
// List management functions
|
|
|
|
|
2019-03-10 02:33:59 +01:00
|
|
|
link newStep() {
|
|
|
|
return (link)malloc(sizeof(struct SequencerStep));
|
|
|
|
}
|
|
|
|
|
2019-06-30 00:39:01 +02:00
|
|
|
bool insertStep(byte chan) {
|
2019-07-06 03:39:35 +02:00
|
|
|
// Creates a new enpty step and places it as next step in the channel passed as argument
|
2019-03-10 02:33:59 +01:00
|
|
|
link newS = newStep();
|
2019-06-29 02:42:38 +02:00
|
|
|
link buffer;
|
2019-06-30 02:55:50 +02:00
|
|
|
|
|
|
|
if (newS == NULL) return LOW;
|
2019-03-10 02:33:59 +01:00
|
|
|
|
2019-06-29 02:42:38 +02:00
|
|
|
for (int i = 0; i < MAXKEYS; i++) newS->kboard_s[i] = LOW;
|
|
|
|
for (int i = 0; i < MAXDPAD; i++) newS->dpad_s[i] = LOW;
|
2019-06-27 18:58:37 +02:00
|
|
|
|
2019-06-30 02:55:50 +02:00
|
|
|
if (head[chan] == NULL) {
|
2019-03-10 02:33:59 +01:00
|
|
|
newS->next = newS;
|
2019-06-29 02:42:38 +02:00
|
|
|
newS->stepnumber = (unsigned short) 0;
|
2019-06-30 00:39:01 +02:00
|
|
|
current[chan] = newS;
|
|
|
|
head[chan] = newS;
|
|
|
|
nstep[chan] = 1;
|
2019-07-08 02:45:50 +02:00
|
|
|
return HIGH;
|
2019-03-10 02:33:59 +01:00
|
|
|
}
|
2019-07-08 02:45:50 +02:00
|
|
|
|
|
|
|
newS->stepnumber = current[chan]->stepnumber +1;
|
|
|
|
buffer = current[chan]->next;
|
|
|
|
current[chan]->next = newS;
|
|
|
|
newS->next = buffer;
|
|
|
|
nstep[chan]++;
|
|
|
|
while (buffer != head[chan]) {
|
|
|
|
buffer->stepnumber++;
|
|
|
|
buffer = buffer->next;
|
2019-03-10 02:33:59 +01:00
|
|
|
}
|
2019-07-08 02:45:50 +02:00
|
|
|
|
2019-03-10 02:33:59 +01:00
|
|
|
return HIGH;
|
|
|
|
}
|
|
|
|
|
|
|
|
void nextStep() {
|
2019-06-30 02:55:50 +02:00
|
|
|
for (int chan=0; chan < 6; chan++) {
|
|
|
|
if (head[chan] == NULL) continue;
|
2019-06-30 00:39:01 +02:00
|
|
|
current[chan] = current[chan]->next;
|
|
|
|
}
|
2019-03-10 02:33:59 +01:00
|
|
|
}
|
|
|
|
|
2019-06-30 00:39:01 +02:00
|
|
|
bool deleteStep(byte chan) {
|
|
|
|
if (nstep[chan] < 1) return LOW;
|
|
|
|
|
|
|
|
if (nstep[chan] == 1) {
|
2019-06-30 02:55:50 +02:00
|
|
|
free(current[chan]);
|
2019-06-30 00:39:01 +02:00
|
|
|
head[chan] = NULL;
|
|
|
|
current[chan] = NULL;
|
2019-07-06 04:09:00 +02:00
|
|
|
return HIGH;
|
|
|
|
}
|
|
|
|
|
|
|
|
link buffer = current[chan];
|
2019-07-08 02:45:50 +02:00
|
|
|
while (buffer->next != current[chan]) buffer = buffer->next; // Search for previous step
|
|
|
|
buffer->next = current[chan]->next; // Skip step which is being deleted
|
|
|
|
if (current[chan] == head[chan]) head[chan] = head[chan]->next; // If deleting head, head moves forward
|
|
|
|
free(current[chan]); // Step is actually deleted
|
|
|
|
nstep[chan]--; // Decreased the counter
|
|
|
|
current[chan] = buffer; // Current step becomes previous step
|
|
|
|
buffer = buffer->next; // Skip the current step which was just before deleted step
|
|
|
|
while(buffer != head[chan]) { // If this is not the head,
|
|
|
|
buffer->stepnumber--; // decrease counter
|
|
|
|
buffer = buffer->next; // and move on
|
2019-03-10 02:33:59 +01:00
|
|
|
}
|
|
|
|
return HIGH;
|
2019-03-08 21:10:15 +01:00
|
|
|
}
|