Components and supplies
Jumper wires (generic)
Breadboard (generic)
pulley
Rotary potentiometer (generic)
fishing line
Arduino Mega 2560
10-turn 10k pot
Tactile Switch, Top Actuated
LED (generic)
Tools and machines
Soldering iron (generic)
Hot glue gun (generic)
Multitool, Screwdriver
Apps and platforms
Arduino IDE
Hairless MIDI/Serial Bridge
loopMIDI
Soniccouture Ondes
Kontakt Player
Project description
Code
Controller.h
c_cpp
1#ifndef Controller_h 2#define Controller_h 3 4#include <Arduino.h> 5 6//*********************************************************************** 7class Mux 8{ 9 public: 10 Mux(byte outpin_, byte numPins_, bool analog_); 11 byte outpin; 12 byte numPins; 13 bool analog; 14}; 15//************************************************************************ 16//Button (Pin Number, Command, Note Number, Channel, Debounce Time) 17class Button 18{ 19 public: 20 Button(byte pin, byte command, byte value, byte channel, byte debounce); 21 Button(Mux mux, byte muxpin, byte command, byte value, byte channel, byte debounce); 22 byte getValue(); 23 void muxUpdate(); 24 void newValue(byte command, byte value, byte channel); 25 byte Bcommand; 26 byte Bvalue; 27 byte Bchannel; 28 byte Btoggle; 29 30 private: 31 byte _previous; 32 byte _current; 33 unsigned long _time; 34 int _debounce; 35 byte _pin; 36 byte _muxpin; 37 byte _numMuxPins; 38 byte _value; 39 byte _command; 40 bool _busy; 41 byte _status; 42 byte _last; 43 byte _enablepin; 44}; 45//************************************************************************* 46class Pot 47{ 48 public: 49 Pot(byte pin, byte command, byte control, byte channel); 50 Pot(Mux mux, byte muxpin ,byte command, byte control, byte channel); 51 void muxUpdate(); 52 void newValue(byte command, byte value, byte channel); 53 byte getValue(); 54 byte Pcommand; 55 byte Pcontrol; 56 byte Pchannel; 57 58 private: 59 byte _pin; 60 byte _muxpin; 61 byte _numMuxPins; 62 byte _control; 63 int _value; 64 int _oldValue; 65 bool _changed; 66 byte _enablepin; 67}; 68//************************************************************************* 69#endif 70
Controller.cpp
c_cpp
1 2#include "Controller.h" 3 4//**************************************************************************************** 5Mux::Mux(byte outpin_, byte numPins_, bool analog_) 6{ 7 outpin = outpin_; 8 //enablepin = enablepin_; 9 numPins = numPins_; 10 analog = analog_; 11 if (analog == false) pinMode(outpin, INPUT_PULLUP); 12 //pinMode(enablepin, OUTPUT); 13 pinMode(24, OUTPUT); 14 pinMode(25, OUTPUT); 15 pinMode(26, OUTPUT); 16 if (numPins > 8) pinMode(27, OUTPUT); 17} 18//**************************************************************************************** 19//Button (Pin Number, Command, Note Number, Channel, Debounce Time) 20Button::Button(byte pin, byte command, byte value, byte channel, byte debounce) 21{ 22 _pin = pin; 23 pinMode(_pin, INPUT_PULLUP); 24 _value = value; 25 _command = command; 26 _debounce = debounce; 27 _time = 0; 28 _busy = false; 29 _status = 0b00000010; 30 _last = 1; 31 Bcommand = command; 32 Bvalue = value; 33 Bchannel = channel; 34 Btoggle = 0; 35} 36 37Button::Button(Mux mux, byte muxpin, byte command, byte value, byte channel, byte debounce) 38{ 39 _pin = mux.outpin; 40 _numMuxPins = mux.numPins; 41 _muxpin = muxpin; 42 _value = value; 43 _command = command; 44 _debounce = debounce; 45 _time = 0; 46 _busy = false; 47 _status = 0b00000010; 48 _last = 1; 49 Bcommand = command; 50 Bvalue = value; 51 Bchannel = channel; 52 Btoggle = 0; 53} 54 55void Button::muxUpdate() 56{ 57 byte temp = _muxpin; 58 temp = temp << 2; 59 if (_numMuxPins > 8) PORTA = PORTA & B11000011; 60 else PORTA = PORTA & B11100011; 61 PORTA = PORTA | temp; 62} 63 64byte Button::getValue() 65{ 66 // If BUSY bit not set - read button 67 if (bitRead(_status, 0) == false) { // If busy false 68 if (digitalRead(_pin) == _last) return 2; // If same as last state - exit 69 } 70 71 // If NEW Bit set - Key just pressed, record time 72 if (bitRead(_status, 1) == true) { // If new is true 73 bitSet(_status, 0); // Set busy TRUE 74 bitClear(_status, 1); // Set New FALSE 75 _time = millis(); 76 return 255; 77 } 78 79 // Check if debounce time has passed - If no, exit 80 if (millis() - _time < _debounce) return 255; 81 82 // Debounce time has passed. Read pin to see if still set the same 83 // If it has changed back - assume false alarm 84 if (digitalRead(_pin) == _last) { 85 bitClear(_status, 0); // Set busy false 86 bitSet(_status, 1); // Set new true 87 return 255; 88 } 89 90 // If this point is reached, event is valid. return event type 91 else { 92 bitClear(_status, 0); // Set busy false 93 bitSet(_status, 1); // Set new true 94 _last = ((~_last) & 0b00000001); // invert _last 95 return _last; 96 } 97} 98 99void Button::newValue(byte command, byte value, byte channel) 100{ 101 Bvalue = value; 102 Bcommand = command; 103 Bchannel = channel; 104} 105 106//******************************************************************** 107Pot::Pot(byte pin, byte command, byte control, byte channel) 108{ 109 _pin = pin; 110 _control = control; 111 _value = analogRead(_pin); 112 _value = _value >> 3; 113 _oldValue = _value << 3; 114 _value = _value << 3; 115 Pcommand = command; 116 Pcontrol = control; 117 Pchannel = channel; 118} 119 120void Pot::muxUpdate() 121{ 122 byte temp = _muxpin; 123 temp = temp << 2; 124 if (_numMuxPins > 8) PORTA = PORTA & B11000011; 125 else PORTA = PORTA & B11100011; 126 //PORTA = PORTA & B11000011; 127 PORTA = PORTA | temp; 128} 129 130Pot::Pot(Mux mux, byte muxpin, byte command, byte control, byte channel) 131{ 132 _pin = mux.outpin; 133 _numMuxPins = mux.numPins; 134 _muxpin = muxpin; 135 _control = control; 136 muxUpdate(); 137 _value = analogRead(_pin); 138 _value = _value >> 3; 139 _oldValue = _value << 3; 140 _value = _value << 3; 141 Pcommand = command; 142 Pcontrol = control; 143 Pchannel = channel; 144} 145 146byte Pot::getValue() 147{ 148 _value = analogRead(_pin); 149 int tmp = (_oldValue - _value); 150 if (tmp >= 8 || tmp <= -8) { 151 _oldValue = _value >> 3; 152 _oldValue = _oldValue << 3; 153 return _value >> 3; 154 } 155 return 255; 156} 157 158void Pot::newValue(byte command, byte value, byte channel) { 159 Pcommand = command; 160 Pcontrol = value; 161 Pchannel = channel; 162} 163
MIDI_Controller_v1-2_CMB.ino
c_cpp
the 3 files must be in the same folder.
1#include <MIDI.h> 2#include "Controller.h" 3 4MIDI_CREATE_DEFAULT_INSTANCE(); 5 6 7//************************************************************************************************** 8 9 10//serial debug, to change manually: 11int DEBUG = false; 12 13//debounce time for buttons (channel and octave shift): 14int debouncetime = 100; 15 16//DEFINES: 17#define PITCHBEND_POT A1 18 19//midi channel buttons 20#define MIDICH_BUTTON_UP 29 21#define MIDICH_BUTTON_DOWN 30 22 23//FSR: 24#define FSR_PIN A0 25#define FSR_LED_PIN 44 26 27//trill buttons: 28#define QUARTERTONEUP_BUTTON 8 29#define QUARTERTONEDOWN_BUTTON 7 30#define SEMITONEUP_BUTTON 9 31#define TONEUP_BUTTON 10 32#define THIRDUP_BUTTON 11 33#define FIFTHUP_BUTTON 12 34 35//octave buttons: 36#define OCTAVEDOWN_BUTTON 3 37#define OCTAVEUP_BUTTON 2 38#define OCTAVE_LED_UP 46 39#define OCTAVE_LED_DOWN 45 40 41//VARIABLES: 42//trill buttons: 43int QUARTERTONEUPCOUNTER = 0; 44int QUARTERTONEDOWNCOUNTER = 0; 45int SEMITONEUPCOUNTER = 0; 46int TONEUPCOUNTER = 0; 47int THIRDUPCOUNTER = 0; 48int FIFTHUPCOUNTER = 0; 49 50int QUARTERTONEVALUE = 170; //a semi-tone = 16384/48 = 341. 51int SEMITONEVALUE = 341; 52int TONEVALUE = 682; 53int THIRDVALUE = 1023; 54int FIFTHVALUE = 2387; 55 56int trillvalue; 57 58//midi channel buttons: 59int MIDICH = 1; 60int midich_plus; 61int midich_moins; 62 63//pitchbend: 64int PB_INPUT_CURRENT = 0; 65int PB_INPUT_ADJUST; 66int PB_INPUT_LAST = 0; 67int PB_MAP; 68int PB_INVERT; 69int PB_ADJUST; 70int PB_TOTAL; 71int PB; 72int PB_INPUT_CURRENT_LED_MAP; 73 74//FSR LED: 75int FSR_INPUT; 76int FSR_INPUT_LED_MAP; 77 78//ajustements: 79float PBmultiplier = 1.25; 80int middleCadjust = 15; 81 82//octaves buttons: 83int OCTAVECOUNTER = 0; 84int OCTAVECOUNTERX; 85int OCTAVE_COUNTER_LAST = 0; 86int OCTAVE_COUNTER_CURRENT = 0; 87 88//FSR notetrigger: 89int currentNoteTriggerState = 0; 90int lastNoteTriggerState = 0; 91 92 93//NOTES AND VOLTS: 94//************************************************************ 95//***SET THE NUMBER OF CONTROLS USED************************** 96//************************************************************ 97//combien de TrillButtons: 98//byte NUMBER_TRILLBUTTONS = 6; 99//---How many buttons are connected directly to pins?--------- 100byte NUMBER_BUTTONS = 1; 101//---How many potentiometers are connected directly to pins?-- 102byte NUMBER_POTS = 13; 103//---How many buttons are connected to a multiplexer?--------- 104byte NUMBER_MUX_BUTTONS = 0; 105//---How many potentiometers are connected to a multiplexer?-- 106byte NUMBER_MUX_POTS = 0; 107 108//************************************************************ 109 110//***ANY MULTIPLEXERS? (74HC4067)************************************ 111//MUX address pins must be connected to Arduino UNO pins 2,3,4,5 112//A0 = PIN2, A1 = PIN3, A2 = PIN4, A3 = PIN5 113//******************************************************************* 114//Mux NAME (OUTPUT PIN, , How Many Mux Pins?(8 or 16) , Is It Analog?); 115 116//Mux M1(10, 16, false); //Digital multiplexer on Arduino pin 10 117//Mux M2(A5, 8, true); //Analog multiplexer on Arduino analog pin A5 118//******************************************************************* 119 120//***DEFINE DIRECTLY CONNECTED POTENTIOMETERS************************ 121//Pot (Pin Number, Command, CC Control, Channel Number) 122//**Command parameter is for future use** 123 124Pot PO1(A3, 0, 85, MIDICH); //BRIGHT 125Pot PO2(A5, 0, 20, MIDICH); //D3 126Pot PO3(A6, 0, 22, MIDICH); //D2 127Pot PO4(A7, 0, 23, MIDICH); //D1 128Pot PO5(A8, 0, 24, MIDICH); //LINE 129Pot PO6(A9, 0, 25, MIDICH); //8 130Pot PO7(A10, 0, 26, MIDICH); //N 131Pot PO8(A11, 0, 27, MIDICH); //C 132Pot PO9(A12, 0, 28, MIDICH); //O 133Pot PO10(A13, 0, 29, MIDICH); //G 134Pot PO11(A14, 0, 30, MIDICH); //g 135Pot PO12(A15, 0, 31, MIDICH); //S 136Pot PO13(A0, 0, 11, MIDICH); //FSR 137//Pot PO14(A5, 0, 31, 1); 138 139//******************************************************************* 140//Add pots used to array below like this-> Pot *POTS[] {&PO1, &PO2, &PO3, &PO4, &PO5, &PO6}; 141Pot *POTS[] {&PO1, &PO2, &PO3, &PO4, &PO5, &PO6, &PO7, &PO8, &PO9, &PO10, &PO11, &PO12, &PO13}; 142//******************************************************************* 143 144//***DEFINE DIRECTLY CONNECTED BUTTONS******************************* 145//Button (Pin Number, Command, Note Number, Channel, Debounce Time) 146//** Command parameter 0=NOTE 1=CC 2=Toggle CC ** 147 148Button BU1(6, 2, 86, MIDICH, 5 ); //TUTTI toggle 149//Button BU2(x, x, x, x, x); 150//Button BU3(4, 1, 64, 1, 5 ); 151//Button BU4(5, 2, 63, 1, 5 ); 152//Button BU5(6, 0, 64, 1, 5 ); 153//Button BU6(7, 0, 65, 1, 5 ); 154//Button BU7(8, 1, 64, 1, 5 ); 155//Button BU8(9, 2, 64, 1, 5 ); 156//******************************************************************* 157//Add buttons used to array below like this-> Button *BUTTONS[] {&BU1, &BU2, &BU3, &BU4, &BU5, &BU6, &BU7, &BU8}; 158Button *BUTTONS[] {&BU1}; 159//******************************************************************* 160 161//***DEFINE BUTTONS CONNECTED TO MULTIPLEXER************************* 162//Button::Button(Mux mux, byte muxpin, byte command, byte value, byte channel, byte debounce) 163//** Command parameter 0=NOTE 1=CC 2=Toggle CC ** 164 165//Button MBU1(M1, 0, 0, 70, 1, 5); 166//Button MBU2(M1, 1, 1, 71, 1, 5); 167//Button MBU3(M1, 2, 2, 72, 1, 5); 168//Button MBU4(M1, 3, 0, 73, 1, 5); 169//Button MBU5(M1, 4, 0, 74, 1, 5); 170//Button MBU6(M1, 5, 0, 75, 1, 5); 171//Button MBU7(M1, 6, 0, 76, 1, 5); 172//Button MBU8(M1, 7, 0, 77, 1, 5); 173//Button MBU9(M1, 8, 0, 78, 1, 5); 174//Button MBU10(M1, 9, 0, 79, 1, 5); 175//Button MBU11(M1, 10, 0, 80, 1, 5); 176//Button MBU12(M1, 11, 0, 81, 1, 5); 177//Button MBU13(M1, 12, 0, 82, 1, 5); 178//Button MBU14(M1, 13, 0, 83, 1, 5); 179//Button MBU15(M1, 14, 0, 84, 1, 5); 180//Button MBU16(M1, 15, 0, 85, 1, 5); 181//******************************************************************* 182////Add multiplexed buttons used to array below like this-> Button *MUXBUTTONS[] {&MBU1, &MBU2, &MBU3, &MBU4, &MBU5, &MBU6.....}; 183Button *MUXBUTTONS[] {}; 184 185//******************************************************************* 186 187//***DEFINE POTENTIOMETERS CONNECTED TO MULTIPLEXER******************* 188//Pot::Pot(Mux mux, byte muxpin, byte command, byte control, byte channel) 189//**Command parameter is for future use** 190//assigns au cc 20 27 inclusivement (midi cc qui sont de base unasigned...) 191//Pot MPO1(M2, 0, 0, 20, 1); 192//Pot MPO2(M2, 1, 0, 21, 1); 193//Pot MPO3(M2, 2, 0, 22, 1); 194//Pot MPO4(M2, 3, 0, 23, 1); 195//Pot MPO5(M2, 4, 0, 24, 1); 196//Pot MPO6(M2, 5, 0, 25, 1); 197//Pot MPO7(M2, 6, 0, 26, 1); 198//Pot MPO8(M2, 7, 0, 27, 1); 199//Pot MPO9(M2, 8, 0, 50, 1); 200//Pot MPO10(M2, 9, 0, 55, 2); 201//Pot MPO11(M2, 10, 0, 50, 1); 202//Pot MPO12(M2, 11, 0, 55, 2); 203//Pot MPO13(M2, 12, 0, 50, 1); 204//Pot MPO14(M2, 13, 0, 55, 2); 205//Pot MPO15(M2, 14, 0, 50, 1); 206//Pot MPO16(M2, 15, 0, 55, 2); 207//******************************************************************* 208//Add multiplexed pots used to array below like this-> Pot *MUXPOTS[] {&MPO1, &MPO2, &MPO3, &MPO4, &MPO5, &MPO6.....}; 209Pot *MUXPOTS[] {}; 210 211//******************************************************************* 212 213void setup() { 214 215 //pinModes pour octave buttons: 216 pinMode(OCTAVEDOWN_BUTTON, INPUT); 217 pinMode(OCTAVEUP_BUTTON, INPUT); 218 219 //pinModes pour trillbuttons: 220 pinMode(QUARTERTONEUP_BUTTON, INPUT); 221 pinMode(QUARTERTONEDOWN_BUTTON, INPUT); 222 pinMode(SEMITONEUP_BUTTON, INPUT); 223 pinMode(TONEUP_BUTTON, INPUT); 224 pinMode(THIRDUP_BUTTON, INPUT); 225 pinMode(FIFTHUP_BUTTON, INPUT); 226 227 //MIDICH buttons: 228 pinMode(MIDICH_BUTTON_DOWN, INPUT); 229 pinMode(MIDICH_BUTTON_UP, INPUT); 230 231 //leds: 232 pinMode(OCTAVE_LED_DOWN, OUTPUT); 233 pinMode(OCTAVE_LED_UP, OUTPUT); 234 235 pinMode(FSR_LED_PIN, OUTPUT); 236 237 238 //MIDI.begin(); 239 Serial.begin(115200); //115200 = default rate of Hairless MIDI/serial bridge software. 240 241} 242 243//************************************************************************************************************* 244 245void loop() { 246 247 //added: 248 MIDIChannel(); 249 PBVOID(); 250 NoteTrigger(); 251 LEDs(); 252 253 //original: 254 if (NUMBER_BUTTONS != 0) updateButtons(); 255 if (NUMBER_POTS != 0) updatePots(); 256 if (NUMBER_MUX_BUTTONS != 0) updateMuxButtons(); 257 if (NUMBER_MUX_POTS != 0) updateMuxPots(); 258 259 //added, serial debug: 260 if (DEBUG == true) { 261 Serial.print(PB_INPUT_CURRENT); 262 Serial.print(", "); Serial.print(PB_INPUT_ADJUST); 263 Serial.print(", "); Serial.print(PB_TOTAL); 264 Serial.print(", "); Serial.print(MIDICH); 265 Serial.print(", "); Serial.print(currentNoteTriggerState); 266 Serial.print(", "); Serial.print(OCTAVECOUNTER); 267 //Serial.print(", "); Serial.print(); 268 //Serial.print(", "); Serial.print(); 269 //Serial.print(", "); Serial.print(); 270 //Serial.print(", "); Serial.print(); 271 //Serial.print(", "); Serial.print(); 272 //Serial.print(", "); Serial.print(); 273 Serial.println(); 274 } 275} 276 277//************************************************************************************************************************************* 278 279void MIDIChannel() { 280 281 MIDICH = constrain(MIDICH, 1, 16); 282 283 midich_plus = digitalRead(MIDICH_BUTTON_UP); 284 midich_moins = digitalRead(MIDICH_BUTTON_DOWN); 285 286 //+: 287 if (midich_plus == HIGH) { 288 MIDICH++; 289 delay(debouncetime); 290 } 291 //-: 292 if (midich_moins == HIGH) { 293 MIDICH--; 294 delay(debouncetime); 295 } 296 297} 298 299//*********************************************************************** 300 301void NoteTrigger() { 302 303 OCTAVECOUNTER = constrain(OCTAVECOUNTER, -3, 3); //+- 3 octaves max shift 304 305 //octave buttons: 306 if (digitalRead(OCTAVEUP_BUTTON) == HIGH) { 307 OCTAVECOUNTER++; 308 delay(debouncetime); 309 } 310 if (digitalRead(OCTAVEDOWN_BUTTON) == HIGH) { 311 OCTAVECOUNTER--; 312 delay(debouncetime); 313 } 314 315 OCTAVECOUNTERX = OCTAVECOUNTER * 12; 316 317 318 currentNoteTriggerState = analogRead(FSR_PIN); 319 320 if (currentNoteTriggerState > 0 && lastNoteTriggerState == 0) { 321 MIDI.sendNoteOn(60 + OCTAVECOUNTERX, 127, MIDICH); 322 } 323 if (currentNoteTriggerState == 0 && lastNoteTriggerState > 0) { 324 MIDI.sendNoteOff(60 + OCTAVECOUNTERX, 127, MIDICH); 325 } 326 327 lastNoteTriggerState = currentNoteTriggerState; 328 329} 330 331//************************************************************************ 332 333void PBVOID() { 334 335 //quarter tone up: 336 if (digitalRead(QUARTERTONEUP_BUTTON) == HIGH) { 337 QUARTERTONEUPCOUNTER = QUARTERTONEVALUE; 338 } 339 if (digitalRead(QUARTERTONEUP_BUTTON) == LOW) { 340 QUARTERTONEUPCOUNTER = 0; 341 } 342 //quarter tone down: 343 if (digitalRead(QUARTERTONEDOWN_BUTTON) == HIGH) { 344 QUARTERTONEDOWNCOUNTER = -QUARTERTONEVALUE; 345 } 346 if (digitalRead(QUARTERTONEDOWN_BUTTON) == LOW) { 347 QUARTERTONEDOWNCOUNTER = 0; 348 } 349 //semi-tone up: 350 if (digitalRead(SEMITONEUP_BUTTON) == HIGH) { 351 SEMITONEUPCOUNTER = SEMITONEVALUE; 352 } 353 if (digitalRead(SEMITONEUP_BUTTON) == LOW) { 354 SEMITONEUPCOUNTER = 0; 355 } 356 //tone up: 357 if (digitalRead(TONEUP_BUTTON) == HIGH) { 358 TONEUPCOUNTER = TONEVALUE; 359 } 360 if (digitalRead(TONEUP_BUTTON) == LOW) { 361 TONEUPCOUNTER = 0; 362 } 363 //third up: 364 if (digitalRead(THIRDUP_BUTTON) == HIGH) { 365 THIRDUPCOUNTER = THIRDVALUE; 366 } 367 if (digitalRead(THIRDUP_BUTTON) == LOW) { 368 THIRDUPCOUNTER = 0; 369 } 370 //fifth up: 371 if (digitalRead(FIFTHUP_BUTTON) == HIGH) { 372 FIFTHUPCOUNTER = FIFTHVALUE; 373 } 374 if (digitalRead(FIFTHUP_BUTTON) == LOW) { 375 FIFTHUPCOUNTER = 0; 376 } 377 378 trillvalue = QUARTERTONEUPCOUNTER + QUARTERTONEDOWNCOUNTER + SEMITONEUPCOUNTER + TONEUPCOUNTER + THIRDUPCOUNTER + FIFTHUPCOUNTER; 379 380 //pitch bend pot: 381 PB_INPUT_CURRENT = analogRead(PITCHBEND_POT); 382 PB_INPUT_CURRENT_LED_MAP = map(PB_INPUT_CURRENT, -8192, 8191, 0, 255); 383 PB_INPUT_ADJUST = PB_INPUT_CURRENT + middleCadjust; 384 PB_INPUT_ADJUST = constrain(PB_INPUT_ADJUST, 0, 1023); 385 PB_MAP = map(PB_INPUT_ADJUST, 1023, 0, -8192, 8191); //signed integer value. 386 PB_ADJUST = PB_MAP * PBmultiplier; 387 PB_TOTAL = PB_ADJUST + trillvalue; 388 PB_TOTAL = constrain(PB_TOTAL, -8192, 8191); 389 390 //send pitchbend continuoulsy: 391 MIDI.sendPitchBend(PB_TOTAL, MIDICH); 392 delay(2); //for stability 393 394} 395 396//******************************************************************* 397 398void LEDs() { 399 400 OCTAVE_COUNTER_CURRENT = OCTAVECOUNTER; 401 402 if(OCTAVE_COUNTER_CURRENT != OCTAVE_COUNTER_LAST) { 403 if (OCTAVECOUNTER == -3) { 404 analogWrite(OCTAVE_LED_DOWN, 255); 405 digitalWrite(OCTAVE_LED_UP, LOW); 406 } 407 if (OCTAVECOUNTER == -2) { 408 analogWrite(OCTAVE_LED_DOWN, 170); 409 digitalWrite(OCTAVE_LED_UP, LOW); 410 } 411 if (OCTAVECOUNTER == -1) { 412 analogWrite(OCTAVE_LED_DOWN, 85); 413 digitalWrite(OCTAVE_LED_UP, LOW); 414 } 415 if (OCTAVECOUNTER == 0) { 416 digitalWrite(OCTAVE_LED_DOWN, LOW); 417 digitalWrite(OCTAVE_LED_UP, LOW); 418 } 419 if (OCTAVECOUNTER == 1) { 420 digitalWrite(OCTAVE_LED_DOWN, LOW); 421 analogWrite(OCTAVE_LED_UP, 85); 422 } 423 if (OCTAVECOUNTER == 2) { 424 digitalWrite(OCTAVE_LED_DOWN, LOW); 425 analogWrite(OCTAVE_LED_UP, 170); 426 } 427 if (OCTAVECOUNTER == 3) { 428 digitalWrite(OCTAVE_LED_DOWN, LOW); 429 analogWrite(OCTAVE_LED_UP, 255); 430 } 431 } 432 433 OCTAVE_COUNTER_LAST = OCTAVE_COUNTER_CURRENT; 434 435 FSR_INPUT = analogRead(FSR_PIN); 436 FSR_INPUT_LED_MAP = map(FSR_INPUT, 0, 1024, 0, 255); 437 438 //FSR LED: 439 if(analogRead(FSR_PIN) > 0) { 440 analogWrite(FSR_LED_PIN, FSR_INPUT_LED_MAP); 441 } 442 if(analogRead(FSR_PIN) == 0) { 443 digitalWrite(FSR_LED_PIN, LOW); 444 } 445 446} 447 448//********************************************************************************************** 449 450void updateButtons() { 451 452 // Cycle through Button array 453 for (int i = 0; i < NUMBER_BUTTONS; i = i + 1) { 454 byte message = BUTTONS[i]->getValue(); 455 456 // Button is pressed 457 if (message == 0) { 458 switch (BUTTONS[i]->Bcommand) { 459 case 0: //Note 460 MIDI.sendNoteOn(BUTTONS[i]->Bvalue + OCTAVECOUNTER * 12, 127, BUTTONS[i]->Bchannel); 461 break; 462 case 1: //CC 463 MIDI.sendControlChange(BUTTONS[i]->Bvalue, 127, BUTTONS[i]->Bchannel); 464 break; 465 case 2: //Toggle 466 if (BUTTONS[i]->Btoggle == 0) { 467 MIDI.sendControlChange(BUTTONS[i]->Bvalue, 127, MIDICH); //origine: BUTTONS[i]->Bchannel 468 BUTTONS[i]->Btoggle = 1; 469 } 470 else if (BUTTONS[i]->Btoggle == 1) { 471 MIDI.sendControlChange(BUTTONS[i]->Bvalue, 0, MIDICH); //origine: BUTTONS[i]->Bchannel 472 BUTTONS[i]->Btoggle = 0; 473 } 474 break; 475 } 476 } 477 478 // Button is not pressed 479 if (message == 1) { 480 switch (BUTTONS[i]->Bcommand) { 481 case 0: 482 MIDI.sendNoteOff(BUTTONS[i]->Bvalue + OCTAVECOUNTER * 12, 0, BUTTONS[i]->Bchannel); 483 break; 484 case 1: 485 MIDI.sendControlChange(BUTTONS[i]->Bvalue, 0, BUTTONS[i]->Bchannel); 486 break; 487 } 488 } 489 } 490} 491 492//******************************************************************* 493 494void updateMuxButtons() { 495 496 // Cycle through Mux Button array 497 for (int i = 0; i < NUMBER_MUX_BUTTONS; i = i + 1) { 498 499 MUXBUTTONS[i]->muxUpdate(); 500 byte message = MUXBUTTONS[i]->getValue(); 501 502 // Button is pressed 503 if (message == 0) { 504 switch (MUXBUTTONS[i]->Bcommand) { 505 case 0: //Note 506 MIDI.sendNoteOn(MUXBUTTONS[i]->Bvalue, 127, MUXBUTTONS[i]->Bchannel); 507 break; 508 case 1: //CC 509 MIDI.sendControlChange(MUXBUTTONS[i]->Bvalue, 127, MUXBUTTONS[i]->Bchannel); 510 break; 511 case 2: //Toggle 512 if (MUXBUTTONS[i]->Btoggle == 0) { 513 MIDI.sendControlChange(MUXBUTTONS[i]->Bvalue, 127, MUXBUTTONS[i]->Bchannel); 514 MUXBUTTONS[i]->Btoggle = 1; 515 } 516 else if (MUXBUTTONS[i]->Btoggle == 1) { 517 MIDI.sendControlChange(MUXBUTTONS[i]->Bvalue, 0, MUXBUTTONS[i]->Bchannel); 518 MUXBUTTONS[i]->Btoggle = 0; 519 } 520 break; 521 } 522 } 523 // Button is not pressed 524 if (message == 1) { 525 switch (MUXBUTTONS[i]->Bcommand) { 526 case 0: 527 MIDI.sendNoteOff(MUXBUTTONS[i]->Bvalue, 0, MUXBUTTONS[i]->Bchannel); 528 break; 529 case 1: 530 MIDI.sendControlChange(MUXBUTTONS[i]->Bvalue, 0, MUXBUTTONS[i]->Bchannel); 531 break; 532 } 533 } 534 } 535} 536 537//*********************************************************************** 538 539void updatePots() { 540 for (int i = 0; i < NUMBER_POTS; i = i + 1) { 541 byte potmessage = POTS[i]->getValue(); 542 if (potmessage != 255) MIDI.sendControlChange(POTS[i]->Pcontrol, potmessage, MIDICH); //origine: POTS[i]->Pchannel 543 } 544} 545 546//*********************************************************************** 547 548void updateMuxPots() { 549 for (int i = 0; i < NUMBER_MUX_POTS; i = i + 1) { 550 MUXPOTS[i]->muxUpdate(); 551 byte potmessage = MUXPOTS[i]->getValue(); 552 if (potmessage != 255) MIDI.sendControlChange(MUXPOTS[i]->Pcontrol, potmessage, MUXPOTS[i]->Pchannel); 553 } 554} 555 556// ******************** END ***************************** // 557
Controller.cpp
c_cpp
1 2#include "Controller.h" 3 4//**************************************************************************************** 5Mux::Mux(byte 6 outpin_, byte numPins_, bool analog_) 7{ 8 outpin = outpin_; 9 //enablepin 10 = enablepin_; 11 numPins = numPins_; 12 analog = analog_; 13 if (analog == 14 false) pinMode(outpin, INPUT_PULLUP); 15 //pinMode(enablepin, OUTPUT); 16 pinMode(24, 17 OUTPUT); 18 pinMode(25, OUTPUT); 19 pinMode(26, OUTPUT); 20 if (numPins > 21 8) pinMode(27, OUTPUT); 22} 23//**************************************************************************************** 24//Button 25 (Pin Number, Command, Note Number, Channel, Debounce Time) 26Button::Button(byte 27 pin, byte command, byte value, byte channel, byte debounce) 28{ 29 _pin = pin; 30 31 pinMode(_pin, INPUT_PULLUP); 32 _value = value; 33 _command = command; 34 35 _debounce = debounce; 36 _time = 0; 37 _busy = false; 38 _status = 0b00000010; 39 40 _last = 1; 41 Bcommand = command; 42 Bvalue = value; 43 Bchannel = channel; 44 45 Btoggle = 0; 46} 47 48Button::Button(Mux mux, byte muxpin, byte command, byte 49 value, byte channel, byte debounce) 50{ 51 _pin = mux.outpin; 52 _numMuxPins 53 = mux.numPins; 54 _muxpin = muxpin; 55 _value = value; 56 _command = command; 57 58 _debounce = debounce; 59 _time = 0; 60 _busy = false; 61 _status = 0b00000010; 62 63 _last = 1; 64 Bcommand = command; 65 Bvalue = value; 66 Bchannel = channel; 67 68 Btoggle = 0; 69} 70 71void Button::muxUpdate() 72{ 73 byte temp = _muxpin; 74 75 temp = temp << 2; 76 if (_numMuxPins > 8) PORTA = PORTA & B11000011; 77 else 78 PORTA = PORTA & B11100011; 79 PORTA = PORTA | temp; 80} 81 82byte Button::getValue() 83{ 84 85 // If BUSY bit not set - read button 86 if (bitRead(_status, 0) == false) { 87 // If busy false 88 if (digitalRead(_pin) == _last) return 2; // If same as 89 last state - exit 90 } 91 92 // If NEW Bit set - Key just pressed, record time 93 94 if (bitRead(_status, 1) == true) { // If new is true 95 bitSet(_status, 0); 96 // Set busy TRUE 97 bitClear(_status, 1); // Set New FALSE 98 _time = millis(); 99 100 return 255; 101 } 102 103 // Check if debounce time has passed - If no, exit 104 105 if (millis() - _time < _debounce) return 255; 106 107 // Debounce time has passed. 108 Read pin to see if still set the same 109 // If it has changed back - assume false 110 alarm 111 if (digitalRead(_pin) == _last) { 112 bitClear(_status, 0); // Set 113 busy false 114 bitSet(_status, 1); // Set new true 115 return 255; 116 } 117 118 119 // If this point is reached, event is valid. return event type 120 else { 121 122 bitClear(_status, 0); // Set busy false 123 bitSet(_status, 1); // Set new 124 true 125 _last = ((~_last) & 0b00000001); // invert _last 126 return _last; 127 128 } 129} 130 131void Button::newValue(byte command, byte value, byte channel) 132{ 133 134 Bvalue = value; 135 Bcommand = command; 136 Bchannel = channel; 137} 138 139//******************************************************************** 140Pot::Pot(byte 141 pin, byte command, byte control, byte channel) 142{ 143 _pin = pin; 144 _control 145 = control; 146 _value = analogRead(_pin); 147 _value = _value >> 3; 148 _oldValue 149 = _value << 3; 150 _value = _value << 3; 151 Pcommand = command; 152 Pcontrol 153 = control; 154 Pchannel = channel; 155} 156 157void Pot::muxUpdate() 158{ 159 byte 160 temp = _muxpin; 161 temp = temp << 2; 162 if (_numMuxPins > 8) PORTA = PORTA & 163 B11000011; 164 else PORTA = PORTA & B11100011; 165 //PORTA = PORTA & B11000011; 166 167 PORTA = PORTA | temp; 168} 169 170Pot::Pot(Mux mux, byte muxpin, byte command, 171 byte control, byte channel) 172{ 173 _pin = mux.outpin; 174 _numMuxPins = mux.numPins; 175 176 _muxpin = muxpin; 177 _control = control; 178 muxUpdate(); 179 _value = analogRead(_pin); 180 181 _value = _value >> 3; 182 _oldValue = _value << 3; 183 _value = _value << 3; 184 185 Pcommand = command; 186 Pcontrol = control; 187 Pchannel = channel; 188} 189 190byte 191 Pot::getValue() 192{ 193 _value = analogRead(_pin); 194 int tmp = (_oldValue - 195 _value); 196 if (tmp >= 8 || tmp <= -8) { 197 _oldValue = _value >> 3; 198 _oldValue 199 = _oldValue << 3; 200 return _value >> 3; 201 } 202 return 255; 203} 204 205void 206 Pot::newValue(byte command, byte value, byte channel) { 207 Pcommand = command; 208 209 Pcontrol = value; 210 Pchannel = channel; 211} 212
MIDI_Controller_v1-2_CMB.ino
c_cpp
the 3 files must be in the same folder.
1#include <MIDI.h> 2#include "Controller.h" 3 4MIDI_CREATE_DEFAULT_INSTANCE(); 5 6 7//************************************************************************************************** 8 9 10//serial 11 debug, to change manually: 12int DEBUG = false; 13 14//debounce time for buttons 15 (channel and octave shift): 16int debouncetime = 100; 17 18//DEFINES: 19#define 20 PITCHBEND_POT A1 21 22//midi channel buttons 23#define MIDICH_BUTTON_UP 29 24#define 25 MIDICH_BUTTON_DOWN 30 26 27//FSR: 28#define FSR_PIN A0 29#define FSR_LED_PIN 30 44 31 32//trill buttons: 33#define QUARTERTONEUP_BUTTON 8 34#define QUARTERTONEDOWN_BUTTON 35 7 36#define SEMITONEUP_BUTTON 9 37#define TONEUP_BUTTON 10 38#define THIRDUP_BUTTON 39 11 40#define FIFTHUP_BUTTON 12 41 42//octave buttons: 43#define OCTAVEDOWN_BUTTON 44 3 45#define OCTAVEUP_BUTTON 2 46#define OCTAVE_LED_UP 46 47#define 48 OCTAVE_LED_DOWN 45 49 50//VARIABLES: 51//trill buttons: 52int QUARTERTONEUPCOUNTER 53 = 0; 54int QUARTERTONEDOWNCOUNTER = 0; 55int SEMITONEUPCOUNTER = 0; 56int TONEUPCOUNTER 57 = 0; 58int THIRDUPCOUNTER = 0; 59int FIFTHUPCOUNTER = 0; 60 61int QUARTERTONEVALUE 62 = 170; //a semi-tone = 16384/48 = 341. 63int SEMITONEVALUE = 341; 64int 65 TONEVALUE = 682; 66int THIRDVALUE = 1023; 67int FIFTHVALUE = 2387; 68 69int 70 trillvalue; 71 72//midi channel buttons: 73int MIDICH = 1; 74int midich_plus; 75int 76 midich_moins; 77 78//pitchbend: 79int PB_INPUT_CURRENT = 0; 80int PB_INPUT_ADJUST; 81 82int PB_INPUT_LAST = 0; 83int PB_MAP; 84int PB_INVERT; 85int PB_ADJUST; 86int 87 PB_TOTAL; 88int PB; 89int PB_INPUT_CURRENT_LED_MAP; 90 91//FSR LED: 92int FSR_INPUT; 93int 94 FSR_INPUT_LED_MAP; 95 96//ajustements: 97float PBmultiplier = 1.25; 98int 99 middleCadjust = 15; 100 101//octaves buttons: 102int OCTAVECOUNTER = 103 0; 104int OCTAVECOUNTERX; 105int OCTAVE_COUNTER_LAST = 0; 106int OCTAVE_COUNTER_CURRENT 107 = 0; 108 109//FSR notetrigger: 110int currentNoteTriggerState = 0; 111int lastNoteTriggerState 112 = 0; 113 114 115//NOTES AND VOLTS: 116//************************************************************ 117//***SET 118 THE NUMBER OF CONTROLS USED************************** 119//************************************************************ 120//combien 121 de TrillButtons: 122//byte NUMBER_TRILLBUTTONS = 6; 123//---How many buttons are 124 connected directly to pins?--------- 125byte NUMBER_BUTTONS = 1; 126//---How many 127 potentiometers are connected directly to pins?-- 128byte NUMBER_POTS = 13; 129//---How 130 many buttons are connected to a multiplexer?--------- 131byte NUMBER_MUX_BUTTONS 132 = 0; 133//---How many potentiometers are connected to a multiplexer?-- 134byte NUMBER_MUX_POTS 135 = 0; 136 137//************************************************************ 138 139//***ANY 140 MULTIPLEXERS? (74HC4067)************************************ 141//MUX address pins 142 must be connected to Arduino UNO pins 2,3,4,5 143//A0 = PIN2, A1 = PIN3, A2 = PIN4, 144 A3 = PIN5 145//******************************************************************* 146//Mux 147 NAME (OUTPUT PIN, , How Many Mux Pins?(8 or 16) , Is It Analog?); 148 149//Mux M1(10, 150 16, false); //Digital multiplexer on Arduino pin 10 151//Mux M2(A5, 8, true); //Analog 152 multiplexer on Arduino analog pin A5 153//******************************************************************* 154 155//***DEFINE 156 DIRECTLY CONNECTED POTENTIOMETERS************************ 157//Pot (Pin Number, 158 Command, CC Control, Channel Number) 159//**Command parameter is for future use** 160 161Pot 162 PO1(A3, 0, 85, MIDICH); //BRIGHT 163Pot PO2(A5, 0, 20, MIDICH); //D3 164Pot 165 PO3(A6, 0, 22, MIDICH); //D2 166Pot PO4(A7, 0, 23, MIDICH); //D1 167Pot 168 PO5(A8, 0, 24, MIDICH); //LINE 169Pot PO6(A9, 0, 25, MIDICH); //8 170Pot 171 PO7(A10, 0, 26, MIDICH); //N 172Pot PO8(A11, 0, 27, MIDICH); //C 173Pot 174 PO9(A12, 0, 28, MIDICH); //O 175Pot PO10(A13, 0, 29, MIDICH); //G 176Pot 177 PO11(A14, 0, 30, MIDICH); //g 178Pot PO12(A15, 0, 31, MIDICH); //S 179Pot 180 PO13(A0, 0, 11, MIDICH); //FSR 181//Pot PO14(A5, 0, 31, 1); 182 183//******************************************************************* 184//Add 185 pots used to array below like this-> Pot *POTS[] {&PO1, &PO2, &PO3, &PO4, &PO5, 186 &PO6}; 187Pot *POTS[] {&PO1, &PO2, &PO3, &PO4, &PO5, &PO6, &PO7, &PO8, &PO9, &PO10, 188 &PO11, &PO12, &PO13}; 189//******************************************************************* 190 191//***DEFINE 192 DIRECTLY CONNECTED BUTTONS******************************* 193//Button (Pin Number, 194 Command, Note Number, Channel, Debounce Time) 195//** Command parameter 0=NOTE 1=CC 196 2=Toggle CC ** 197 198Button BU1(6, 2, 86, MIDICH, 5 ); //TUTTI toggle 199//Button 200 BU2(x, x, x, x, x); 201//Button BU3(4, 1, 64, 1, 5 ); 202//Button BU4(5, 203 2, 63, 1, 5 ); 204//Button BU5(6, 0, 64, 1, 5 ); 205//Button BU6(7, 0, 65, 1, 5 206 ); 207//Button BU7(8, 1, 64, 1, 5 ); 208//Button BU8(9, 2, 64, 1, 5 ); 209//******************************************************************* 210//Add 211 buttons used to array below like this-> Button *BUTTONS[] {&BU1, &BU2, &BU3, &BU4, 212 &BU5, &BU6, &BU7, &BU8}; 213Button *BUTTONS[] {&BU1}; 214//******************************************************************* 215 216//***DEFINE 217 BUTTONS CONNECTED TO MULTIPLEXER************************* 218//Button::Button(Mux 219 mux, byte muxpin, byte command, byte value, byte channel, byte debounce) 220//** 221 Command parameter 0=NOTE 1=CC 2=Toggle CC ** 222 223//Button MBU1(M1, 0, 0, 70, 224 1, 5); 225//Button MBU2(M1, 1, 1, 71, 1, 5); 226//Button MBU3(M1, 2, 2, 72, 1, 5); 227//Button 228 MBU4(M1, 3, 0, 73, 1, 5); 229//Button MBU5(M1, 4, 0, 74, 1, 5); 230//Button MBU6(M1, 231 5, 0, 75, 1, 5); 232//Button MBU7(M1, 6, 0, 76, 1, 5); 233//Button MBU8(M1, 7, 0, 234 77, 1, 5); 235//Button MBU9(M1, 8, 0, 78, 1, 5); 236//Button MBU10(M1, 9, 0, 79, 237 1, 5); 238//Button MBU11(M1, 10, 0, 80, 1, 5); 239//Button MBU12(M1, 11, 0, 81, 240 1, 5); 241//Button MBU13(M1, 12, 0, 82, 1, 5); 242//Button MBU14(M1, 13, 0, 83, 243 1, 5); 244//Button MBU15(M1, 14, 0, 84, 1, 5); 245//Button MBU16(M1, 15, 0, 85, 246 1, 5); 247//******************************************************************* 248////Add 249 multiplexed buttons used to array below like this-> Button *MUXBUTTONS[] {&MBU1, 250 &MBU2, &MBU3, &MBU4, &MBU5, &MBU6.....}; 251Button *MUXBUTTONS[] {}; 252 253//******************************************************************* 254 255//***DEFINE 256 POTENTIOMETERS CONNECTED TO MULTIPLEXER******************* 257//Pot::Pot(Mux mux, 258 byte muxpin, byte command, byte control, byte channel) 259//**Command parameter 260 is for future use** 261//assigns au cc 20 27 inclusivement (midi cc qui sont de 262 base unasigned...) 263//Pot MPO1(M2, 0, 0, 20, 1); 264//Pot MPO2(M2, 1, 0, 21, 1); 265//Pot 266 MPO3(M2, 2, 0, 22, 1); 267//Pot MPO4(M2, 3, 0, 23, 1); 268//Pot MPO5(M2, 4, 0, 24, 269 1); 270//Pot MPO6(M2, 5, 0, 25, 1); 271//Pot MPO7(M2, 6, 0, 26, 1); 272//Pot MPO8(M2, 273 7, 0, 27, 1); 274//Pot MPO9(M2, 8, 0, 50, 1); 275//Pot MPO10(M2, 9, 0, 55, 2); 276//Pot 277 MPO11(M2, 10, 0, 50, 1); 278//Pot MPO12(M2, 11, 0, 55, 2); 279//Pot MPO13(M2, 12, 280 0, 50, 1); 281//Pot MPO14(M2, 13, 0, 55, 2); 282//Pot MPO15(M2, 14, 0, 50, 1); 283//Pot 284 MPO16(M2, 15, 0, 55, 2); 285//******************************************************************* 286//Add 287 multiplexed pots used to array below like this-> Pot *MUXPOTS[] {&MPO1, &MPO2, 288 &MPO3, &MPO4, &MPO5, &MPO6.....}; 289Pot *MUXPOTS[] {}; 290 291//******************************************************************* 292 293void 294 setup() { 295 296 //pinModes pour octave buttons: 297 pinMode(OCTAVEDOWN_BUTTON, 298 INPUT); 299 pinMode(OCTAVEUP_BUTTON, INPUT); 300 301 //pinModes pour trillbuttons: 302 303 pinMode(QUARTERTONEUP_BUTTON, INPUT); 304 pinMode(QUARTERTONEDOWN_BUTTON, INPUT); 305 306 pinMode(SEMITONEUP_BUTTON, INPUT); 307 pinMode(TONEUP_BUTTON, INPUT); 308 pinMode(THIRDUP_BUTTON, 309 INPUT); 310 pinMode(FIFTHUP_BUTTON, INPUT); 311 312 //MIDICH buttons: 313 pinMode(MIDICH_BUTTON_DOWN, 314 INPUT); 315 pinMode(MIDICH_BUTTON_UP, INPUT); 316 317 //leds: 318 pinMode(OCTAVE_LED_DOWN, 319 OUTPUT); 320 pinMode(OCTAVE_LED_UP, OUTPUT); 321 322 pinMode(FSR_LED_PIN, OUTPUT); 323 324 325 326 //MIDI.begin(); 327 Serial.begin(115200); //115200 = default rate of 328 Hairless MIDI/serial bridge software. 329 330} 331 332//************************************************************************************************************* 333 334void 335 loop() { 336 337 //added: 338 MIDIChannel(); 339 PBVOID(); 340 NoteTrigger(); 341 342 LEDs(); 343 344 //original: 345 if (NUMBER_BUTTONS != 0) updateButtons(); 346 347 if (NUMBER_POTS != 0) updatePots(); 348 if (NUMBER_MUX_BUTTONS != 0) updateMuxButtons(); 349 350 if (NUMBER_MUX_POTS != 0) updateMuxPots(); 351 352 //added, 353 serial debug: 354 if (DEBUG == true) { 355 Serial.print(PB_INPUT_CURRENT); 356 357 Serial.print(", "); Serial.print(PB_INPUT_ADJUST); 358 Serial.print(", 359 "); Serial.print(PB_TOTAL); 360 Serial.print(", "); Serial.print(MIDICH); 361 362 Serial.print(", "); Serial.print(currentNoteTriggerState); 363 Serial.print(", 364 "); Serial.print(OCTAVECOUNTER); 365 //Serial.print(", "); Serial.print(); 366 367 //Serial.print(", "); Serial.print(); 368 //Serial.print(", "); Serial.print(); 369 370 //Serial.print(", "); Serial.print(); 371 //Serial.print(", "); Serial.print(); 372 373 //Serial.print(", "); Serial.print(); 374 Serial.println(); 375 } 376} 377 378//************************************************************************************************************************************* 379 380void 381 MIDIChannel() { 382 383 MIDICH = constrain(MIDICH, 1, 16); 384 385 midich_plus 386 = digitalRead(MIDICH_BUTTON_UP); 387 midich_moins = digitalRead(MIDICH_BUTTON_DOWN); 388 389 390 //+: 391 if (midich_plus == HIGH) { 392 MIDICH++; 393 delay(debouncetime); 394 395 } 396 //-: 397 if (midich_moins == HIGH) { 398 MIDICH--; 399 delay(debouncetime); 400 401 } 402 403} 404 405//*********************************************************************** 406 407void 408 NoteTrigger() { 409 410 OCTAVECOUNTER = constrain(OCTAVECOUNTER, -3, 3); //+- 411 3 octaves max shift 412 413 //octave buttons: 414 if (digitalRead(OCTAVEUP_BUTTON) 415 == HIGH) { 416 OCTAVECOUNTER++; 417 delay(debouncetime); 418 } 419 if 420 (digitalRead(OCTAVEDOWN_BUTTON) == HIGH) { 421 OCTAVECOUNTER--; 422 delay(debouncetime); 423 424 } 425 426 OCTAVECOUNTERX = OCTAVECOUNTER * 12; 427 428 429 currentNoteTriggerState 430 = analogRead(FSR_PIN); 431 432 if (currentNoteTriggerState > 0 && lastNoteTriggerState 433 == 0) { 434 MIDI.sendNoteOn(60 + OCTAVECOUNTERX, 127, MIDICH); 435 436 } 437 if (currentNoteTriggerState == 0 && lastNoteTriggerState 438 > 0) { 439 MIDI.sendNoteOff(60 + OCTAVECOUNTERX, 127, MIDICH); 440 } 441 442 443 lastNoteTriggerState = currentNoteTriggerState; 444 445} 446 447//************************************************************************ 448 449 450void PBVOID() { 451 452 //quarter tone up: 453 if (digitalRead(QUARTERTONEUP_BUTTON) 454 == HIGH) { 455 QUARTERTONEUPCOUNTER = QUARTERTONEVALUE; 456 } 457 if (digitalRead(QUARTERTONEUP_BUTTON) 458 == LOW) { 459 QUARTERTONEUPCOUNTER = 0; 460 } 461 //quarter tone down: 462 463 if (digitalRead(QUARTERTONEDOWN_BUTTON) == HIGH) { 464 QUARTERTONEDOWNCOUNTER 465 = -QUARTERTONEVALUE; 466 } 467 if (digitalRead(QUARTERTONEDOWN_BUTTON) == LOW) 468 { 469 QUARTERTONEDOWNCOUNTER = 0; 470 } 471 //semi-tone up: 472 if (digitalRead(SEMITONEUP_BUTTON) 473 == HIGH) { 474 SEMITONEUPCOUNTER = SEMITONEVALUE; 475 } 476 if (digitalRead(SEMITONEUP_BUTTON) 477 == LOW) { 478 SEMITONEUPCOUNTER = 0; 479 } 480 //tone up: 481 if (digitalRead(TONEUP_BUTTON) 482 == HIGH) { 483 TONEUPCOUNTER = TONEVALUE; 484 } 485 if (digitalRead(TONEUP_BUTTON) 486 == LOW) { 487 TONEUPCOUNTER = 0; 488 } 489 //third up: 490 if (digitalRead(THIRDUP_BUTTON) 491 == HIGH) { 492 THIRDUPCOUNTER = THIRDVALUE; 493 } 494 if (digitalRead(THIRDUP_BUTTON) 495 == LOW) { 496 THIRDUPCOUNTER = 0; 497 } 498 //fifth up: 499 if (digitalRead(FIFTHUP_BUTTON) 500 == HIGH) { 501 FIFTHUPCOUNTER = FIFTHVALUE; 502 } 503 if (digitalRead(FIFTHUP_BUTTON) 504 == LOW) { 505 FIFTHUPCOUNTER = 0; 506 } 507 508 trillvalue = QUARTERTONEUPCOUNTER 509 + QUARTERTONEDOWNCOUNTER + SEMITONEUPCOUNTER + TONEUPCOUNTER + THIRDUPCOUNTER + 510 FIFTHUPCOUNTER; 511 512 //pitch bend pot: 513 PB_INPUT_CURRENT = analogRead(PITCHBEND_POT); 514 515 PB_INPUT_CURRENT_LED_MAP = map(PB_INPUT_CURRENT, -8192, 8191, 0, 255); 516 PB_INPUT_ADJUST 517 = PB_INPUT_CURRENT + middleCadjust; 518 PB_INPUT_ADJUST = constrain(PB_INPUT_ADJUST, 519 0, 1023); 520 PB_MAP = map(PB_INPUT_ADJUST, 1023, 0, -8192, 8191); //signed 521 integer value. 522 PB_ADJUST = PB_MAP * PBmultiplier; 523 PB_TOTAL = PB_ADJUST 524 + trillvalue; 525 PB_TOTAL = constrain(PB_TOTAL, -8192, 8191); 526 527 //send 528 pitchbend continuoulsy: 529 MIDI.sendPitchBend(PB_TOTAL, MIDICH); 530 delay(2); 531 //for stability 532 533} 534 535//******************************************************************* 536 537void 538 LEDs() { 539 540 OCTAVE_COUNTER_CURRENT = OCTAVECOUNTER; 541 542 if(OCTAVE_COUNTER_CURRENT 543 != OCTAVE_COUNTER_LAST) { 544 if (OCTAVECOUNTER == -3) { 545 analogWrite(OCTAVE_LED_DOWN, 546 255); 547 digitalWrite(OCTAVE_LED_UP, LOW); 548 } 549 if (OCTAVECOUNTER 550 == -2) { 551 analogWrite(OCTAVE_LED_DOWN, 170); 552 digitalWrite(OCTAVE_LED_UP, 553 LOW); 554 } 555 if (OCTAVECOUNTER == -1) { 556 analogWrite(OCTAVE_LED_DOWN, 557 85); 558 digitalWrite(OCTAVE_LED_UP, LOW); 559 } 560 if (OCTAVECOUNTER 561 == 0) { 562 digitalWrite(OCTAVE_LED_DOWN, LOW); 563 digitalWrite(OCTAVE_LED_UP, 564 LOW); 565 } 566 if (OCTAVECOUNTER == 1) { 567 digitalWrite(OCTAVE_LED_DOWN, 568 LOW); 569 analogWrite(OCTAVE_LED_UP, 85); 570 } 571 if (OCTAVECOUNTER 572 == 2) { 573 digitalWrite(OCTAVE_LED_DOWN, LOW); 574 analogWrite(OCTAVE_LED_UP, 575 170); 576 } 577 if (OCTAVECOUNTER == 3) { 578 digitalWrite(OCTAVE_LED_DOWN, 579 LOW); 580 analogWrite(OCTAVE_LED_UP, 255); 581 } 582 } 583 584 585 OCTAVE_COUNTER_LAST = OCTAVE_COUNTER_CURRENT; 586 587 FSR_INPUT = analogRead(FSR_PIN); 588 589 FSR_INPUT_LED_MAP = map(FSR_INPUT, 0, 1024, 0, 255); 590 591 //FSR LED: 592 593 if(analogRead(FSR_PIN) > 0) { 594 analogWrite(FSR_LED_PIN, FSR_INPUT_LED_MAP); 595 596 } 597 if(analogRead(FSR_PIN) == 0) { 598 digitalWrite(FSR_LED_PIN, 599 LOW); 600 } 601 602} 603 604//********************************************************************************************** 605 606void 607 updateButtons() { 608 609 // Cycle through Button array 610 for (int 611 i = 0; i < NUMBER_BUTTONS; i = i + 1) { 612 byte message = BUTTONS[i]->getValue(); 613 614 615 // Button is pressed 616 if (message == 0) { 617 switch 618 (BUTTONS[i]->Bcommand) { 619 case 0: //Note 620 MIDI.sendNoteOn(BUTTONS[i]->Bvalue 621 + OCTAVECOUNTER * 12, 127, BUTTONS[i]->Bchannel); 622 break; 623 624 case 1: //CC 625 MIDI.sendControlChange(BUTTONS[i]->Bvalue, 626 127, BUTTONS[i]->Bchannel); 627 break; 628 case 2: //Toggle 629 630 if (BUTTONS[i]->Btoggle == 0) { 631 MIDI.sendControlChange(BUTTONS[i]->Bvalue, 632 127, MIDICH); //origine: BUTTONS[i]->Bchannel 633 BUTTONS[i]->Btoggle 634 = 1; 635 } 636 else if (BUTTONS[i]->Btoggle == 1) 637 { 638 MIDI.sendControlChange(BUTTONS[i]->Bvalue, 0, MIDICH); //origine: 639 BUTTONS[i]->Bchannel 640 BUTTONS[i]->Btoggle = 0; 641 } 642 643 break; 644 } 645 } 646 647 // Button 648 is not pressed 649 if (message == 1) { 650 switch (BUTTONS[i]->Bcommand) 651 { 652 case 0: 653 MIDI.sendNoteOff(BUTTONS[i]->Bvalue 654 + OCTAVECOUNTER * 12, 0, BUTTONS[i]->Bchannel); 655 break; 656 case 657 1: 658 MIDI.sendControlChange(BUTTONS[i]->Bvalue, 0, BUTTONS[i]->Bchannel); 659 660 break; 661 } 662 } 663 } 664} 665 666//******************************************************************* 667 668void 669 updateMuxButtons() { 670 671 // Cycle through Mux Button array 672 for 673 (int i = 0; i < NUMBER_MUX_BUTTONS; i = i + 1) { 674 675 MUXBUTTONS[i]->muxUpdate(); 676 677 byte message = MUXBUTTONS[i]->getValue(); 678 679 // Button 680 is pressed 681 if (message == 0) { 682 switch (MUXBUTTONS[i]->Bcommand) 683 { 684 case 0: //Note 685 MIDI.sendNoteOn(MUXBUTTONS[i]->Bvalue, 686 127, MUXBUTTONS[i]->Bchannel); 687 break; 688 case 1: 689 //CC 690 MIDI.sendControlChange(MUXBUTTONS[i]->Bvalue, 127, MUXBUTTONS[i]->Bchannel); 691 692 break; 693 case 2: //Toggle 694 if (MUXBUTTONS[i]->Btoggle 695 == 0) { 696 MIDI.sendControlChange(MUXBUTTONS[i]->Bvalue, 127, 697 MUXBUTTONS[i]->Bchannel); 698 MUXBUTTONS[i]->Btoggle = 1; 699 } 700 701 else if (MUXBUTTONS[i]->Btoggle == 1) { 702 MIDI.sendControlChange(MUXBUTTONS[i]->Bvalue, 703 0, MUXBUTTONS[i]->Bchannel); 704 MUXBUTTONS[i]->Btoggle = 0; 705 706 } 707 break; 708 } 709 } 710 711 // Button is not pressed 712 if (message == 1) { 713 switch 714 (MUXBUTTONS[i]->Bcommand) { 715 case 0: 716 MIDI.sendNoteOff(MUXBUTTONS[i]->Bvalue, 717 0, MUXBUTTONS[i]->Bchannel); 718 break; 719 case 1: 720 721 MIDI.sendControlChange(MUXBUTTONS[i]->Bvalue, 0, MUXBUTTONS[i]->Bchannel); 722 723 break; 724 } 725 } 726 } 727} 728 729//*********************************************************************** 730 731void 732 updatePots() { 733 for (int i = 0; i < NUMBER_POTS; i = i + 1) { 734 byte 735 potmessage = POTS[i]->getValue(); 736 if (potmessage != 255) MIDI.sendControlChange(POTS[i]->Pcontrol, 737 potmessage, MIDICH); //origine: POTS[i]->Pchannel 738 } 739} 740 741//*********************************************************************** 742 743void 744 updateMuxPots() { 745 for (int i = 0; i < NUMBER_MUX_POTS; i = i + 1) { 746 747 MUXPOTS[i]->muxUpdate(); 748 byte potmessage = MUXPOTS[i]->getValue(); 749 750 if (potmessage != 255) MIDI.sendControlChange(MUXPOTS[i]->Pcontrol, potmessage, 751 MUXPOTS[i]->Pchannel); 752 } 753} 754 755// ******************** END ***************************** 756 // 757
Comments
Only logged in users can leave comments
christophemagnanb
0 Followers
•0 Projects
Table of contents
Intro
4
0