Custom Midi Controller

A midi controller designed specifically for TAL U No LX soft synth

Oct 14, 2024

•

3283 views

•

3 respects

•

Audio

Lights

Music

Components and supplies

10kOhm potentiometer

3-Position Slide Switch

Slide Switch, SPDT

Push Button Switch, Latching (Push on, Push off)

Rotary Switch, SMD

Arduino Leonardo without Headers

Slider

push buttons

Tools and machines

Table Saw

Soldering kit

Laser cutter (generic)

Apps and platforms

Arduino IDE

Project description

Code

Midi Controller

cpp

Code for midi controller with 2 multiplexers

1#include "MIDIUSB.h"
2
3
4
5// constants for selecting multiplexer1 pins
6const int selectPins[4] = {13, 12, 11, 10}; // S0~12, S1~11, S2~10 S3~9
7const int zInput = 9;
8
9
10// constants for selecting multiplexer2 pins
11const int select2Pins[4] = {4, 5, 6, 7}; // S0~2, S1~3, S2~4 S3~5
12const int z2Input = A3;
13
14
15//constants for midichannel
16const uint8_t midiChannel = 0;
17
18//constants for pots and switches that are connected straight to the Arduino input pins (not using multiplexers)
19const int potSPREAD = A2;
20const int potTONE = A5;
21const int potFBD = A4;
22const int potTIME = A1;
23const int potWET = A0;
24const int switchCHORUSII = 2;
25const int switchCHORUSI = 1;
26
27
28//variables to set the initial state of the peripherals
29int sliderLFOState = 0;
30int sliderPWState = 0;
31int sliderSUBOSCState = 0;
32int sliderNOISEState = 0;
33int sliderHPFState = 0;
34int sliderVCFState = 0;
35int sliderRESState = 0;
36int sliderENVState = 0;
37int sliderMODState = 0;
38int sliderKEYBState = 0;
39int sliderAState = 0;
40int sliderDState = 0;
41int sliderSState = 0;
42int sliderRState = 0;
43int sliderRATEState = 0;
44int sliderDELAYState = 0;
45int sliderTIMEState = 0;
46int sliderPWDCOState = 0;
47int sliderPWFILTERState = 0;
48int sliderVELENVState = 0;
49int sliderVELVOLUMEState = 0;
50int sliderPORTAMENTOTIMEState = 0;
51
52int potWETState = 0;
53int potTIMEState = 0;
54int potSPREADState = 0;
55int potTONEState = 0;
56int potFBDState = 0;
57
58int switchENVINVERTState = 0;
59int switchPWState = 0;
60int switchPULSEState = 0;
61int switchSAWState = 0;
62int switchSQUAREState = 0;
63int switchLFOWAVEState = 0;
64int switchLFOState = 0;
65int switchEFFECTState = 0;
66int switchPORTAMENTOState = 0;
67int SwitchCHORUSIIState = 0;
68int SwitchCHORUSIState = 0;
69
70
71
72//seting variables that define the smallest change in value of analog peripherals (pots and sliders) that will trigger a response from the Arduino
73int actionTresholdMax;
74int actionTresholdMin;
75
76uint8_t midiCCValue;
77
78//variables to set the initial state for debouncing the swithches and buttons
79int lastSwitchPULSEState = 0;
80int lastSwitchSAWState = 0;
81int lastSwitchSQUAREState = 0;
82int lastSwitchLFOWAVEState = 0;
83int lastSwitchPWState = 0;
84int lastSwitchLFOState = 0;
85int lastSwitchEFFECTState = 0;
86int lastSwitchPORTAMENTOState = 0;
87int lastSwitchCHORUSIIState = 0 ;
88int lastSwitchCHORUSIState = 0 ;
89
90// variables to set the initial state of debouncing timers. usingned long needed here as the numbers get bit very quickly
91unsigned long lastDebounceTimeENVINVERT = 0;  // the last time the output pin was toggled
92unsigned long lastDebounceTimeSwitchPULSE = 0;
93unsigned long lastDebounceTimeSwitchSaw = 0;
94unsigned long lastDebounceTimeSwitchSQUARE = 0;
95unsigned long lastDebounceTimeSwitchPW = 0;
96unsigned long lastDebounceTimeSwitchLFOWAVE = 0;
97unsigned long lastDebounceTimeSwitchLFO = 0;
98unsigned long lastDebounceTimeSwitchEFFECT = 0;
99unsigned long lastDebounceTimeSwitchPORTAMENTO = 0;
100unsigned long lastDebounceTimeSwitchCHORUSII = 0;
101unsigned long lastDebounceTimeSwitchCHORUSI = 0;
102
103unsigned long debounceDelay = 50;    // the debounce time; increase if the output flickers
104
105
106
107
108
109
110void setup()
111{
112
113  for (int i = 0; i < 4; i++)
114  {
115    pinMode(selectPins[i], OUTPUT);  // Set up the select pins as outputs:
116    digitalWrite(selectPins[i], HIGH);
117  }
118  pinMode(zInput, INPUT); // Set up Zinput as an input
119
120
121  for (int k = 0; k < 4; k++)
122  {
123    pinMode(select2Pins[k], OUTPUT);  // Set up the select pins as outputs:
124    digitalWrite(select2Pins[k], HIGH);
125  }
126  pinMode(z2Input, INPUT); // Set up z2input as an input
127
128
129}
130
131void loop() {
132
133
134
135
136
137
138  byte muxPin = 1;
139  selectMuxPin(muxPin); // Select the channel of the multiplexer you are reading
140  int readingSliderKEYB = analogRead(zInput); // and read Zinput
141  midiCCValue = (readingSliderKEYB / 8);  // changing the analog reading to 7-bit (0-127) value suitable for midi message
142  if (readingSliderKEYB > (sliderKEYBState + 4)  or readingSliderKEYB < (sliderKEYBState - 4))  // if the value is >4 bigger or smaller than the last saved value of the slider, then
143  {
144    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 11, midiCCValue};
145    MidiUSB.sendMIDI(event);
146    sliderKEYBState = readingSliderKEYB;
147  }                                                       // the value is prepared to be send as a 7-bit midi-message in the set midichannel and saved as a new value of the slider
148
149
150
151  muxPin = 2;
152  selectMuxPin(muxPin); 
153  int readingSliderMOD = analogRead(zInput); 
154  midiCCValue = (readingSliderMOD / 8);
155  if (readingSliderMOD > (sliderMODState + 4)  or readingSliderMOD < (sliderMODState - 4))
156  {
157    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 12, midiCCValue};
158    MidiUSB.sendMIDI(event);
159    sliderMODState = readingSliderMOD;
160  }
161
162
163  muxPin = 3;
164  selectMuxPin(muxPin); 
165  int readingSliderENV = analogRead(zInput); 
166  midiCCValue = (readingSliderENV / 8);
167  if (readingSliderENV > (sliderENVState + 4)  or readingSliderENV < (sliderENVState - 4))
168  {
169    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 13, midiCCValue};
170    MidiUSB.sendMIDI(event);
171    sliderENVState = readingSliderENV;
172  }
173
174
175
176  muxPin = 4;
177  selectMuxPin(muxPin); 
178  int readingSliderRES = analogRead(zInput); 
179  midiCCValue = (readingSliderRES / 8);
180  if (readingSliderRES > (sliderRESState + 4)  or readingSliderRES < (sliderRESState - 4))
181  {
182    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 14, midiCCValue};
183    MidiUSB.sendMIDI(event);
184    sliderRESState = readingSliderRES;
185  }
186
187
188  muxPin = 5;
189  selectMuxPin(muxPin); 
190  int readingSliderVCF = analogRead(zInput); 
191  midiCCValue = (readingSliderVCF / 8);
192  if (readingSliderVCF > (sliderVCFState + 4)  or readingSliderVCF < (sliderVCFState - 4))
193  {
194    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 15, midiCCValue};
195    MidiUSB.sendMIDI(event);
196    sliderVCFState = readingSliderVCF;
197  }
198
199
200
201  muxPin = 6;
202  selectMuxPin(muxPin); 
203  int readingSliderHPF = analogRead(zInput); 
204  midiCCValue = (readingSliderHPF / 8);
205  if (readingSliderHPF > (sliderHPFState + 4)  or readingSliderHPF < (sliderHPFState - 4))
206  {
207    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 16, midiCCValue};
208    MidiUSB.sendMIDI(event);
209    sliderHPFState = readingSliderHPF;
210  }
211
212
213  muxPin = 7;
214  selectMuxPin(muxPin); 
215  int readingSliderNOISE = analogRead(zInput); 
216  midiCCValue = (readingSliderNOISE / 8);
217  if (readingSliderNOISE > (sliderNOISEState + 4)  or readingSliderNOISE < (sliderNOISEState - 4))
218  {
219    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 17, midiCCValue};
220    MidiUSB.sendMIDI(event);
221    sliderNOISEState = readingSliderNOISE;
222  }
223
224
225
226
227
228  muxPin = 8;
229  selectMuxPin(muxPin); 
230  int readingSwitchPULSE = digitalRead(zInput); 
231  if (readingSwitchPULSE != lastSwitchPULSEState)
232  {
233    lastDebounceTimeSwitchPULSE = millis();  // debouncing the switch. reset the debouncing timer
234  }
235  if ((millis() - lastDebounceTimeSwitchPULSE) > debounceDelay) // If more that 50 ms has passed since the reading was different from last recorder state...
236  {
237    if (readingSwitchPULSE != switchPULSEState) // confirm the change of digital value is real
238    {
239      switchPULSEState = readingSwitchPULSE;
240      if (switchPULSEState == LOW)
241      {
242        midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 18, 127};
243        MidiUSB.sendMIDI(event);
244      }
245      else
246      {
247        midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 18, 0};
248        MidiUSB.sendMIDI(event);
249      }
250    }
251  }
252
253  lastSwitchPULSEState  = switchPULSEState;
254
255
256
257
258
259  muxPin = 9;
260  selectMuxPin(muxPin);
261  int readingSwitchSAW = digitalRead(zInput);
262  if (readingSwitchSAW != lastSwitchSAWState)
263  {
264    lastDebounceTimeSwitchSaw = millis();
265  }
266  if ((millis() - lastDebounceTimeSwitchSaw) > debounceDelay)
267  {
268    if (readingSwitchSAW != switchSAWState)
269    {
270      switchSAWState = readingSwitchSAW;
271      if (switchSAWState == LOW)
272      {
273        midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 19, 127};
274        MidiUSB.sendMIDI(event);
275      }
276      else
277      {
278        midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 19, 0};
279        MidiUSB.sendMIDI(event);
280      }
281    }
282  }
283
284  lastSwitchSAWState  = readingSwitchSAW;
285
286
287
288
289
290  muxPin = 10;
291  selectMuxPin(muxPin); 
292  int readingSwitchSQUARE = digitalRead(zInput); 
293
294  if (readingSwitchSQUARE != lastSwitchSQUAREState)
295  {
296    lastDebounceTimeSwitchSQUARE = millis();  
297  }
298  if ((millis() - lastDebounceTimeSwitchSQUARE) > debounceDelay)
299  {
300    if (readingSwitchSQUARE != switchSQUAREState)
301    {
302      switchSQUAREState = readingSwitchSQUARE;
303      if (switchSQUAREState == LOW)
304      {
305        midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 20, 127};
306        MidiUSB.sendMIDI(event);
307      }
308      else
309      {
310        midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 20, 0};
311        MidiUSB.sendMIDI(event);
312      }
313    }
314  }
315
316  lastSwitchSQUAREState  = readingSwitchSQUARE;
317
318
319  muxPin = 11;
320  selectMuxPin(muxPin); // Select one at a time
321  int readingSliderSUBOSC = analogRead(zInput); // and read Z
322  midiCCValue = (readingSliderSUBOSC / 8);
323  if (readingSliderSUBOSC > (sliderSUBOSCState + 4)  or readingSliderSUBOSC < (sliderSUBOSCState - 4))
324  {
325    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 21, midiCCValue};
326    MidiUSB.sendMIDI(event);
327    sliderSUBOSCState = readingSliderSUBOSC;
328  }
329
330
331  muxPin = 12;
332  selectMuxPin(muxPin); 
333  int readingSliderPW = analogRead(zInput); 
334  midiCCValue = (readingSliderPW / 8);
335  if (readingSliderPW > (sliderPWState + 4)  or readingSliderPW < (sliderPWState - 4))
336  {
337    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 22, midiCCValue};
338    MidiUSB.sendMIDI(event);
339    sliderPWState = readingSliderPW;
340  }
341
342
343  muxPin = 13;
344  selectMuxPin(muxPin); 
345  int readingSwitchPW = analogRead(zInput);
346
347  if (abs (readingSwitchPW - lastSwitchPWState) > 160)
348  {
349    lastDebounceTimeSwitchPW = millis();
350  }
351  if ((millis() - lastDebounceTimeSwitchPW) > debounceDelay) 
352  {
353    if (abs (readingSwitchPW - switchPWState) > 160)
354
355    { switchPWState = readingSwitchPW;
356
357      midiCCValue = (readingSwitchPW / 8);
358
359      midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 23, midiCCValue};
360      MidiUSB.sendMIDI(event);
361    }
362  }
363
364  lastSwitchPWState = readingSwitchPW;
365
366
367
368
369
370
371
372
373  muxPin = 14;
374  selectMuxPin(muxPin); 
375  int readingSliderLFO = analogRead(zInput); 
376  midiCCValue = (readingSliderLFO / 8);
377  if (readingSliderLFO > (sliderLFOState + 4)  or readingSliderLFO < (sliderLFOState - 4))
378  {
379    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 24, midiCCValue};
380    MidiUSB.sendMIDI(event);
381    sliderLFOState = readingSliderLFO;
382  }
383
384
385  muxPin = 15;
386  selectMuxPin(muxPin); 
387  int readingSwitchLFOWAVE = analogRead(zInput);
388  midiCCValue = (readingSwitchLFOWAVE / 8);
389  if (abs (readingSwitchLFOWAVE - lastSwitchLFOWAVEState) > 80)
390  {
391    lastDebounceTimeSwitchLFOWAVE = millis(); 
392  }
393  if ((millis() - lastDebounceTimeSwitchLFOWAVE) > debounceDelay) 
394  {
395    if (abs (readingSwitchLFOWAVE - switchLFOWAVEState) > 80)
396
397
398    {
399      midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 25, midiCCValue};
400      MidiUSB.sendMIDI(event);
401      switchLFOWAVEState = readingSwitchLFOWAVE;
402    }
403  }
404
405  lastSwitchLFOWAVEState = readingSwitchLFOWAVE ;
406
407
408
409
410
411
412
413  byte mux2Pin = 0;
414  selectMux2Pin(mux2Pin);
415  int readingSliderA = analogRead(z2Input); 
416  midiCCValue = (readingSliderA / 8);
417  if (readingSliderA > (sliderAState + 4)  or readingSliderA < (sliderAState - 4))
418  {
419    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 26, midiCCValue};
420    MidiUSB.sendMIDI(event);
421    sliderAState = readingSliderA;
422  }
423
424  mux2Pin = 1;
425  selectMux2Pin(mux2Pin); 
426  int readingSliderD = analogRead(z2Input); 
427  midiCCValue = (readingSliderD / 8);
428  if (readingSliderD > (sliderDState + 4)  or readingSliderD < (sliderDState - 4))
429  {
430    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 27, midiCCValue};
431    MidiUSB.sendMIDI(event);
432    sliderDState = readingSliderD;
433  }
434
435
436  mux2Pin = 2;
437  selectMux2Pin(mux2Pin); 
438  int readingSliderS = analogRead(z2Input); 
439  midiCCValue = (readingSliderS / 8);
440  if (readingSliderS > (sliderSState + 4)  or readingSliderS < (sliderSState - 4))
441  {
442    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 28, midiCCValue};
443    MidiUSB.sendMIDI(event);
444    sliderSState = readingSliderS;
445  }
446
447
448
449  mux2Pin = 3;
450  selectMux2Pin(mux2Pin); 
451  int readingSliderR = analogRead(z2Input); 
452  midiCCValue = (readingSliderR / 8);
453  if (readingSliderR > (sliderRState + 4)  or readingSliderR < (sliderRState - 4))
454  {
455    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 29, midiCCValue};
456    MidiUSB.sendMIDI(event);
457    sliderRState = readingSliderR;
458  }
459
460
461  mux2Pin = 4;
462  selectMux2Pin(mux2Pin); 
463  int readingSliderRATE = analogRead(z2Input); 
464  midiCCValue = (readingSliderRATE / 8);
465  if (readingSliderRATE > (sliderRATEState + 4)  or readingSliderRATE < (sliderRATEState - 4))
466  {
467    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 30, midiCCValue};
468    MidiUSB.sendMIDI(event);
469    sliderRATEState = readingSliderRATE;
470  }
471
472
473
474  mux2Pin = 5;
475  selectMux2Pin(mux2Pin); 
476  int readingSliderDELAY = analogRead(z2Input);
477  midiCCValue = (readingSliderDELAY / 8);
478  if (readingSliderDELAY > (sliderDELAYState + 4)  or readingSliderDELAY < (sliderDELAYState - 4))
479  {
480    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 31, midiCCValue};
481    MidiUSB.sendMIDI(event);
482    sliderDELAYState = readingSliderDELAY;
483  }
484
485
486
487
488  mux2Pin = 6;
489  selectMux2Pin(mux2Pin); 
490  int readingSwitchLFO = analogRead(zInput);
491  midiCCValue = (readingSwitchLFO / 8);
492  if (readingSwitchLFO > (lastSwitchLFOState + 160)  or readingSwitchLFO < (lastSwitchLFOState - 160))
493  {
494    lastDebounceTimeSwitchLFO = millis();
495  }
496  if ((millis() - lastDebounceTimeSwitchLFO) > debounceDelay) 
497  {
498    if (readingSwitchLFO > (switchLFOState + 160)  or readingSwitchLFO < (switchLFOState - 160))
499
500    { switchLFOState = readingSwitchLFO;
501
502
503      midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 32, midiCCValue};
504      MidiUSB.sendMIDI(event);
505
506    }
507  }
508
509  lastSwitchLFOState = readingSwitchLFO;
510
511
512
513
514
515
516
517
518  mux2Pin = 7;
519  selectMux2Pin(mux2Pin);
520  int readingSwitchEFFECT = analogRead(z2Input);
521  midiCCValue = (readingSwitchEFFECT / 8) ;
522  if (readingSwitchEFFECT > (lastSwitchEFFECTState + 160)  or readingSwitchEFFECT < (lastSwitchEFFECTState - 160))
523  {
524    lastDebounceTimeSwitchEFFECT = millis();
525  }
526  if ((millis() - lastDebounceTimeSwitchEFFECT) > debounceDelay) 
527  {
528
529    if (readingSwitchEFFECT > (switchEFFECTState + 160)  or readingSwitchEFFECT < (switchEFFECTState - 160))
530
531    { switchEFFECTState = readingSwitchEFFECT;
532
533      midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 33, midiCCValue};
534      MidiUSB.sendMIDI(event);
535    }
536  }
537
538  lastSwitchEFFECTState = readingSwitchEFFECT;
539
540
541
542  mux2Pin = 8;
543  selectMux2Pin(mux2Pin); 
544  int readingSliderVELVOLUME = analogRead(z2Input); 
545  midiCCValue = (readingSliderVELVOLUME / 8);
546  if (readingSliderVELVOLUME > (sliderVELVOLUMEState + 4)  or readingSliderVELVOLUME < (sliderVELVOLUMEState - 4))
547  {
548    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 34, midiCCValue};
549    MidiUSB.sendMIDI(event);
550    sliderVELVOLUMEState = readingSliderVELVOLUME;
551  }
552
553
554
555  mux2Pin = 11;
556  selectMux2Pin(mux2Pin); 
557  int readingSwitchPORTAMENTO = analogRead(zInput);
558  midiCCValue = (readingSwitchPORTAMENTO / 8);
559
560  if (abs (readingSwitchPORTAMENTO - lastSwitchPORTAMENTOState) > 160)
561  {
562    lastDebounceTimeSwitchPORTAMENTO = millis();
563  }
564  if ((millis() - lastDebounceTimeSwitchPORTAMENTO) > debounceDelay) 
565  {
566    if (abs (readingSwitchPORTAMENTO - switchPORTAMENTOState) > 160)
567
568    { switchPORTAMENTOState = readingSwitchPORTAMENTO;
569
570
571
572      midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 35, midiCCValue};
573      MidiUSB.sendMIDI(event);
574    }
575  }
576
577  lastSwitchPORTAMENTOState = readingSwitchPORTAMENTO;
578
579
580
581  mux2Pin = 12;
582  selectMux2Pin(mux2Pin); 
583  int readingSliderPORTAMENTOTIME = analogRead(z2Input); 
584  midiCCValue = (readingSliderPORTAMENTOTIME / 8);
585  if (readingSliderPORTAMENTOTIME > (sliderPORTAMENTOTIMEState + 4)  or readingSliderPORTAMENTOTIME < (sliderPORTAMENTOTIMEState - 4))
586  {
587    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 36, midiCCValue};
588    MidiUSB.sendMIDI(event);
589    sliderPORTAMENTOTIMEState = readingSliderPORTAMENTOTIME;
590  }
591
592
593  mux2Pin = 13;
594  selectMux2Pin(mux2Pin); 
595  int readingSliderPWDCO = analogRead(z2Input); 
596  midiCCValue = (readingSliderPWDCO / 8);
597  if (readingSliderPWDCO > (sliderPWDCOState + 4)  or readingSliderPWDCO < (sliderPWDCOState - 4))
598  {
599    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 37, midiCCValue};
600    MidiUSB.sendMIDI(event);
601    sliderPWDCOState = readingSliderPWDCO;
602  }
603
604
605  mux2Pin = 14;
606  selectMux2Pin(mux2Pin);
607  int readingSliderPWFILTER = analogRead(z2Input); 
608  midiCCValue = (readingSliderPWFILTER / 8);
609  if (readingSliderPWFILTER > (sliderPWFILTERState + 4)  or readingSliderPWFILTER < (sliderPWFILTERState - 4))
610  {
611    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 38, midiCCValue};
612    MidiUSB.sendMIDI(event);
613    sliderPWFILTERState = readingSliderPWFILTER;
614  }
615
616
617  mux2Pin = 15;
618  selectMux2Pin(mux2Pin); 
619  int readingSliderVELENV = analogRead(z2Input); 
620  midiCCValue = (readingSliderVELENV / 8);
621  if (readingSliderVELENV > (sliderVELENVState + 4)  or readingSliderVELENV < (sliderVELENVState - 4))
622  {
623    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 39, midiCCValue};
624    MidiUSB.sendMIDI(event);
625    sliderVELENVState = readingSliderVELENV;
626  }
627
628
629
630
631  int readingPotSPREAD = analogRead(potSPREAD);
632  midiCCValue = (readingPotSPREAD / 8);
633  if (readingPotSPREAD > (potSPREADState + 20)  or readingPotSPREAD < (potSPREADState - 20))
634  {
635    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 40, midiCCValue};
636    MidiUSB.sendMIDI(event);
637    potSPREADState = readingPotSPREAD;
638  }
639
640
641
642
643
644  int readingPotTIME = analogRead(potTIME);
645  midiCCValue = (readingPotTIME / 8);
646  if (readingPotTIME > (potTIMEState + 4)  or readingPotTIME < (potTIMEState - 4))
647  {
648    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 43, midiCCValue};
649    MidiUSB.sendMIDI(event);
650    potTIMEState = readingPotTIME;
651  }
652
653
654
655  int readingPotWET = analogRead(potWET);
656  midiCCValue = (readingPotWET / 8);
657  if (readingPotWET > (potWETState + 4)  or readingPotWET < (potWETState - 4))
658  {
659    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 44, midiCCValue};
660    MidiUSB.sendMIDI(event);
661    potWETState = readingPotWET;
662  }
663
664
665  int readingSwitchCHORUSII = digitalRead(switchCHORUSII);    // read the state of the switch into a local variable:
666  if (readingSwitchCHORUSII != lastSwitchCHORUSIIState) // if reading is different from last recorded state
667  {
668    lastDebounceTimeSwitchCHORUSII = millis();  // reset the debouncing timer
669  }
670  if ((millis() - lastDebounceTimeSwitchCHORUSII) > debounceDelay) // If more that 50 ms has passed since the reading was different from last recorder state...
671  {
672    if (readingSwitchCHORUSII != SwitchCHORUSIIState) //... and the reading still is different from the last recorded state...
673    {
674      SwitchCHORUSIIState = readingSwitchCHORUSII; // ...we believe it's genuine and update the buttonState...
675
676      if (SwitchCHORUSIIState == LOW)
677      {
678        midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 45, 127};
679        MidiUSB.sendMIDI(event);
680      }
681      else
682      {
683        midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 45, 0};
684        MidiUSB.sendMIDI(event);
685      }
686    }
687  }
688
689  lastSwitchCHORUSIIState = readingSwitchCHORUSII;   
690
691
692  int readingSwitchCHORUSI = digitalRead(switchCHORUSI);   
693  if (readingSwitchCHORUSI != lastSwitchCHORUSIState) 
694  {
695    lastDebounceTimeSwitchCHORUSI = millis();  
696  }
697  if ((millis() - lastDebounceTimeSwitchCHORUSI) > debounceDelay) 
698  {
699    if (readingSwitchCHORUSI != SwitchCHORUSIState) 
700    {
701      SwitchCHORUSIState = readingSwitchCHORUSI;
702
703      if (SwitchCHORUSIState == LOW)
704      {
705        midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 46, 127};
706        MidiUSB.sendMIDI(event);
707      }
708      else
709      {
710        midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 46, 0};
711        MidiUSB.sendMIDI(event);
712      }
713    }
714  }
715
716  lastSwitchCHORUSIState = readingSwitchCHORUSI;    // save the reading. Next time through the loop, it'll be the lastButtonState:
717
718
719
720  MidiUSB.flush();
721
722}
723
724
725
726// The selectMuxPin function sets the S0, S1, and S2 pins
727// accordingly, given a pin from 0-7.
728void selectMuxPin(byte muxPin)
729{
730  for (int i = 0; i < 4; i++)
731  {
732    if (muxPin & (1 << i))
733      digitalWrite(selectPins[i], HIGH);
734    else
735      digitalWrite(selectPins[i], LOW);
736  }
737}
738
739
740void selectMux2Pin(byte mux2Pin)
741{
742  for (int i = 0; i < 4; i++)
743  {
744    if (mux2Pin & (1 << i))
745      digitalWrite(select2Pins[i], HIGH);
746    else
747      digitalWrite(select2Pins[i], LOW);
748  }
749}

#include "MIDIUSB.h"



// constants for selecting multiplexer1 pins
const int selectPins[4] = {13, 12, 11, 10}; // S0~12, S1~11, S2~10 S3~9
const int zInput = 9;


// constants for selecting multiplexer2 pins
const int select2Pins[4] = {4, 5, 6, 7}; // S0~2, S1~3, S2~4 S3~5
const int z2Input = A3;


//constants for midichannel
const uint8_t midiChannel = 0;

//constants for pots and switches that are connected straight to the Arduino input pins (not using multiplexers)
const int potSPREAD = A2;
const int potTONE = A5;
const int potFBD = A4;
const int potTIME = A1;
const int potWET = A0;
const int switchCHORUSII = 2;
const int switchCHORUSI = 1;


//variables to set the initial state of the peripherals
int sliderLFOState = 0;
int sliderPWState = 0;
int sliderSUBOSCState = 0;
int sliderNOISEState = 0;
int sliderHPFState = 0;
int sliderVCFState = 0;
int sliderRESState = 0;
int sliderENVState = 0;
int sliderMODState = 0;
int sliderKEYBState = 0;
int sliderAState = 0;
int sliderDState = 0;
int sliderSState = 0;
int sliderRState = 0;
int sliderRATEState = 0;
int sliderDELAYState = 0;
int sliderTIMEState = 0;
int sliderPWDCOState = 0;
int sliderPWFILTERState = 0;
int sliderVELENVState = 0;
int sliderVELVOLUMEState = 0;
int sliderPORTAMENTOTIMEState = 0;

int potWETState = 0;
int potTIMEState = 0;
int potSPREADState = 0;
int potTONEState = 0;
int potFBDState = 0;

int switchENVINVERTState = 0;
int switchPWState = 0;
int switchPULSEState = 0;
int switchSAWState = 0;
int switchSQUAREState = 0;
int switchLFOWAVEState = 0;
int switchLFOState = 0;
int switchEFFECTState = 0;
int switchPORTAMENTOState = 0;
int SwitchCHORUSIIState = 0;
int SwitchCHORUSIState = 0;



//seting variables that define the smallest change in value of analog peripherals (pots and sliders) that will trigger a response from the Arduino
int actionTresholdMax;
int actionTresholdMin;

uint8_t midiCCValue;

//variables to set the initial state for debouncing the swithches and buttons
int lastSwitchPULSEState = 0;
int lastSwitchSAWState = 0;
int lastSwitchSQUAREState = 0;
int lastSwitchLFOWAVEState = 0;
int lastSwitchPWState = 0;
int lastSwitchLFOState = 0;
int lastSwitchEFFECTState = 0;
int lastSwitchPORTAMENTOState = 0;
int lastSwitchCHORUSIIState = 0 ;
int lastSwitchCHORUSIState = 0 ;

// variables to set the initial state of debouncing timers. usingned long needed here as the numbers get bit very quickly
unsigned long lastDebounceTimeENVINVERT = 0;  // the last time the output pin was toggled
unsigned long lastDebounceTimeSwitchPULSE = 0;
unsigned long lastDebounceTimeSwitchSaw = 0;
unsigned long lastDebounceTimeSwitchSQUARE = 0;
unsigned long lastDebounceTimeSwitchPW = 0;
unsigned long lastDebounceTimeSwitchLFOWAVE = 0;
unsigned long lastDebounceTimeSwitchLFO = 0;
unsigned long lastDebounceTimeSwitchEFFECT = 0;
unsigned long lastDebounceTimeSwitchPORTAMENTO = 0;
unsigned long lastDebounceTimeSwitchCHORUSII = 0;
unsigned long lastDebounceTimeSwitchCHORUSI = 0;

unsigned long debounceDelay = 50;    // the debounce time; increase if the output flickers






void setup()
{

  for (int i = 0; i < 4; i++)
  {
    pinMode(selectPins[i], OUTPUT);  // Set up the select pins as outputs:
    digitalWrite(selectPins[i], HIGH);
  }
  pinMode(zInput, INPUT); // Set up Zinput as an input


  for (int k = 0; k < 4; k++)
  {
    pinMode(select2Pins[k], OUTPUT);  // Set up the select pins as outputs:
    digitalWrite(select2Pins[k], HIGH);
  }
  pinMode(z2Input, INPUT); // Set up z2input as an input


}

void loop() {






  byte muxPin = 1;
  selectMuxPin(muxPin); // Select the channel of the multiplexer you are reading
  int readingSliderKEYB = analogRead(zInput); // and read Zinput
  midiCCValue = (readingSliderKEYB / 8);  // changing the analog reading to 7-bit (0-127) value suitable for midi message
  if (readingSliderKEYB > (sliderKEYBState + 4)  or readingSliderKEYB < (sliderKEYBState - 4))  // if the value is >4 bigger or smaller than the last saved value of the slider, then
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 11, midiCCValue};
    MidiUSB.sendMIDI(event);
    sliderKEYBState = readingSliderKEYB;
  }                                                       // the value is prepared to be send as a 7-bit midi-message in the set midichannel and saved as a new value of the slider



  muxPin = 2;
  selectMuxPin(muxPin); 
  int readingSliderMOD = analogRead(zInput); 
  midiCCValue = (readingSliderMOD / 8);
  if (readingSliderMOD > (sliderMODState + 4)  or readingSliderMOD < (sliderMODState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 12, midiCCValue};
    MidiUSB.sendMIDI(event);
    sliderMODState = readingSliderMOD;
  }


  muxPin = 3;
  selectMuxPin(muxPin); 
  int readingSliderENV = analogRead(zInput); 
  midiCCValue = (readingSliderENV / 8);
  if (readingSliderENV > (sliderENVState + 4)  or readingSliderENV < (sliderENVState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 13, midiCCValue};
    MidiUSB.sendMIDI(event);
    sliderENVState = readingSliderENV;
  }



  muxPin = 4;
  selectMuxPin(muxPin); 
  int readingSliderRES = analogRead(zInput); 
  midiCCValue = (readingSliderRES / 8);
  if (readingSliderRES > (sliderRESState + 4)  or readingSliderRES < (sliderRESState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 14, midiCCValue};
    MidiUSB.sendMIDI(event);
    sliderRESState = readingSliderRES;
  }


  muxPin = 5;
  selectMuxPin(muxPin); 
  int readingSliderVCF = analogRead(zInput); 
  midiCCValue = (readingSliderVCF / 8);
  if (readingSliderVCF > (sliderVCFState + 4)  or readingSliderVCF < (sliderVCFState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 15, midiCCValue};
    MidiUSB.sendMIDI(event);
    sliderVCFState = readingSliderVCF;
  }



  muxPin = 6;
  selectMuxPin(muxPin); 
  int readingSliderHPF = analogRead(zInput); 
  midiCCValue = (readingSliderHPF / 8);
  if (readingSliderHPF > (sliderHPFState + 4)  or readingSliderHPF < (sliderHPFState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 16, midiCCValue};
    MidiUSB.sendMIDI(event);
    sliderHPFState = readingSliderHPF;
  }


  muxPin = 7;
  selectMuxPin(muxPin); 
  int readingSliderNOISE = analogRead(zInput); 
  midiCCValue = (readingSliderNOISE / 8);
  if (readingSliderNOISE > (sliderNOISEState + 4)  or readingSliderNOISE < (sliderNOISEState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 17, midiCCValue};
    MidiUSB.sendMIDI(event);
    sliderNOISEState = readingSliderNOISE;
  }





  muxPin = 8;
  selectMuxPin(muxPin); 
  int readingSwitchPULSE = digitalRead(zInput); 
  if (readingSwitchPULSE != lastSwitchPULSEState)
  {
    lastDebounceTimeSwitchPULSE = millis();  // debouncing the switch. reset the debouncing timer
  }
  if ((millis() - lastDebounceTimeSwitchPULSE) > debounceDelay) // If more that 50 ms has passed since the reading was different from last recorder state...
  {
    if (readingSwitchPULSE != switchPULSEState) // confirm the change of digital value is real
    {
      switchPULSEState = readingSwitchPULSE;
      if (switchPULSEState == LOW)
      {
        midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 18, 127};
        MidiUSB.sendMIDI(event);
      }
      else
      {
        midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 18, 0};
        MidiUSB.sendMIDI(event);
      }
    }
  }

  lastSwitchPULSEState  = switchPULSEState;





  muxPin = 9;
  selectMuxPin(muxPin);
  int readingSwitchSAW = digitalRead(zInput);
  if (readingSwitchSAW != lastSwitchSAWState)
  {
    lastDebounceTimeSwitchSaw = millis();
  }
  if ((millis() - lastDebounceTimeSwitchSaw) > debounceDelay)
  {
    if (readingSwitchSAW != switchSAWState)
    {
      switchSAWState = readingSwitchSAW;
      if (switchSAWState == LOW)
      {
        midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 19, 127};
        MidiUSB.sendMIDI(event);
      }
      else
      {
        midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 19, 0};
        MidiUSB.sendMIDI(event);
      }
    }
  }

  lastSwitchSAWState  = readingSwitchSAW;





  muxPin = 10;
  selectMuxPin(muxPin); 
  int readingSwitchSQUARE = digitalRead(zInput); 

  if (readingSwitchSQUARE != lastSwitchSQUAREState)
  {
    lastDebounceTimeSwitchSQUARE = millis();  
  }
  if ((millis() - lastDebounceTimeSwitchSQUARE) > debounceDelay)
  {
    if (readingSwitchSQUARE != switchSQUAREState)
    {
      switchSQUAREState = readingSwitchSQUARE;
      if (switchSQUAREState == LOW)
      {
        midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 20, 127};
        MidiUSB.sendMIDI(event);
      }
      else
      {
        midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 20, 0};
        MidiUSB.sendMIDI(event);
      }
    }
  }

  lastSwitchSQUAREState  = readingSwitchSQUARE;


  muxPin = 11;
  selectMuxPin(muxPin); // Select one at a time
  int readingSliderSUBOSC = analogRead(zInput); // and read Z
  midiCCValue = (readingSliderSUBOSC / 8);
  if (readingSliderSUBOSC > (sliderSUBOSCState + 4)  or readingSliderSUBOSC < (sliderSUBOSCState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 21, midiCCValue};
    MidiUSB.sendMIDI(event);
    sliderSUBOSCState = readingSliderSUBOSC;
  }


  muxPin = 12;
  selectMuxPin(muxPin); 
  int readingSliderPW = analogRead(zInput); 
  midiCCValue = (readingSliderPW / 8);
  if (readingSliderPW > (sliderPWState + 4)  or readingSliderPW < (sliderPWState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 22, midiCCValue};
    MidiUSB.sendMIDI(event);
    sliderPWState = readingSliderPW;
  }


  muxPin = 13;
  selectMuxPin(muxPin); 
  int readingSwitchPW = analogRead(zInput);

  if (abs (readingSwitchPW - lastSwitchPWState) > 160)
  {
    lastDebounceTimeSwitchPW = millis();
  }
  if ((millis() - lastDebounceTimeSwitchPW) > debounceDelay) 
  {
    if (abs (readingSwitchPW - switchPWState) > 160)

    { switchPWState = readingSwitchPW;

      midiCCValue = (readingSwitchPW / 8);

      midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 23, midiCCValue};
      MidiUSB.sendMIDI(event);
    }
  }

  lastSwitchPWState = readingSwitchPW;








  muxPin = 14;
  selectMuxPin(muxPin); 
  int readingSliderLFO = analogRead(zInput); 
  midiCCValue = (readingSliderLFO / 8);
  if (readingSliderLFO > (sliderLFOState + 4)  or readingSliderLFO < (sliderLFOState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 24, midiCCValue};
    MidiUSB.sendMIDI(event);
    sliderLFOState = readingSliderLFO;
  }


  muxPin = 15;
  selectMuxPin(muxPin); 
  int readingSwitchLFOWAVE = analogRead(zInput);
  midiCCValue = (readingSwitchLFOWAVE / 8);
  if (abs (readingSwitchLFOWAVE - lastSwitchLFOWAVEState) > 80)
  {
    lastDebounceTimeSwitchLFOWAVE = millis(); 
  }
  if ((millis() - lastDebounceTimeSwitchLFOWAVE) > debounceDelay) 
  {
    if (abs (readingSwitchLFOWAVE - switchLFOWAVEState) > 80)


    {
      midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 25, midiCCValue};
      MidiUSB.sendMIDI(event);
      switchLFOWAVEState = readingSwitchLFOWAVE;
    }
  }

  lastSwitchLFOWAVEState = readingSwitchLFOWAVE ;







  byte mux2Pin = 0;
  selectMux2Pin(mux2Pin);
  int readingSliderA = analogRead(z2Input); 
  midiCCValue = (readingSliderA / 8);
  if (readingSliderA > (sliderAState + 4)  or readingSliderA < (sliderAState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 26, midiCCValue};
    MidiUSB.sendMIDI(event);
    sliderAState = readingSliderA;
  }

  mux2Pin = 1;
  selectMux2Pin(mux2Pin); 
  int readingSliderD = analogRead(z2Input); 
  midiCCValue = (readingSliderD / 8);
  if (readingSliderD > (sliderDState + 4)  or readingSliderD < (sliderDState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 27, midiCCValue};
    MidiUSB.sendMIDI(event);
    sliderDState = readingSliderD;
  }


  mux2Pin = 2;
  selectMux2Pin(mux2Pin); 
  int readingSliderS = analogRead(z2Input); 
  midiCCValue = (readingSliderS / 8);
  if (readingSliderS > (sliderSState + 4)  or readingSliderS < (sliderSState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 28, midiCCValue};
    MidiUSB.sendMIDI(event);
    sliderSState = readingSliderS;
  }



  mux2Pin = 3;
  selectMux2Pin(mux2Pin); 
  int readingSliderR = analogRead(z2Input); 
  midiCCValue = (readingSliderR / 8);
  if (readingSliderR > (sliderRState + 4)  or readingSliderR < (sliderRState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 29, midiCCValue};
    MidiUSB.sendMIDI(event);
    sliderRState = readingSliderR;
  }


  mux2Pin = 4;
  selectMux2Pin(mux2Pin); 
  int readingSliderRATE = analogRead(z2Input); 
  midiCCValue = (readingSliderRATE / 8);
  if (readingSliderRATE > (sliderRATEState + 4)  or readingSliderRATE < (sliderRATEState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 30, midiCCValue};
    MidiUSB.sendMIDI(event);
    sliderRATEState = readingSliderRATE;
  }



  mux2Pin = 5;
  selectMux2Pin(mux2Pin); 
  int readingSliderDELAY = analogRead(z2Input);
  midiCCValue = (readingSliderDELAY / 8);
  if (readingSliderDELAY > (sliderDELAYState + 4)  or readingSliderDELAY < (sliderDELAYState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 31, midiCCValue};
    MidiUSB.sendMIDI(event);
    sliderDELAYState = readingSliderDELAY;
  }




  mux2Pin = 6;
  selectMux2Pin(mux2Pin); 
  int readingSwitchLFO = analogRead(zInput);
  midiCCValue = (readingSwitchLFO / 8);
  if (readingSwitchLFO > (lastSwitchLFOState + 160)  or readingSwitchLFO < (lastSwitchLFOState - 160))
  {
    lastDebounceTimeSwitchLFO = millis();
  }
  if ((millis() - lastDebounceTimeSwitchLFO) > debounceDelay) 
  {
    if (readingSwitchLFO > (switchLFOState + 160)  or readingSwitchLFO < (switchLFOState - 160))

    { switchLFOState = readingSwitchLFO;


      midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 32, midiCCValue};
      MidiUSB.sendMIDI(event);

    }
  }

  lastSwitchLFOState = readingSwitchLFO;








  mux2Pin = 7;
  selectMux2Pin(mux2Pin);
  int readingSwitchEFFECT = analogRead(z2Input);
  midiCCValue = (readingSwitchEFFECT / 8) ;
  if (readingSwitchEFFECT > (lastSwitchEFFECTState + 160)  or readingSwitchEFFECT < (lastSwitchEFFECTState - 160))
  {
    lastDebounceTimeSwitchEFFECT = millis();
  }
  if ((millis() - lastDebounceTimeSwitchEFFECT) > debounceDelay) 
  {

    if (readingSwitchEFFECT > (switchEFFECTState + 160)  or readingSwitchEFFECT < (switchEFFECTState - 160))

    { switchEFFECTState = readingSwitchEFFECT;

      midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 33, midiCCValue};
      MidiUSB.sendMIDI(event);
    }
  }

  lastSwitchEFFECTState = readingSwitchEFFECT;



  mux2Pin = 8;
  selectMux2Pin(mux2Pin); 
  int readingSliderVELVOLUME = analogRead(z2Input); 
  midiCCValue = (readingSliderVELVOLUME / 8);
  if (readingSliderVELVOLUME > (sliderVELVOLUMEState + 4)  or readingSliderVELVOLUME < (sliderVELVOLUMEState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 34, midiCCValue};
    MidiUSB.sendMIDI(event);
    sliderVELVOLUMEState = readingSliderVELVOLUME;
  }



  mux2Pin = 11;
  selectMux2Pin(mux2Pin); 
  int readingSwitchPORTAMENTO = analogRead(zInput);
  midiCCValue = (readingSwitchPORTAMENTO / 8);

  if (abs (readingSwitchPORTAMENTO - lastSwitchPORTAMENTOState) > 160)
  {
    lastDebounceTimeSwitchPORTAMENTO = millis();
  }
  if ((millis() - lastDebounceTimeSwitchPORTAMENTO) > debounceDelay) 
  {
    if (abs (readingSwitchPORTAMENTO - switchPORTAMENTOState) > 160)

    { switchPORTAMENTOState = readingSwitchPORTAMENTO;



      midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 35, midiCCValue};
      MidiUSB.sendMIDI(event);
    }
  }

  lastSwitchPORTAMENTOState = readingSwitchPORTAMENTO;



  mux2Pin = 12;
  selectMux2Pin(mux2Pin); 
  int readingSliderPORTAMENTOTIME = analogRead(z2Input); 
  midiCCValue = (readingSliderPORTAMENTOTIME / 8);
  if (readingSliderPORTAMENTOTIME > (sliderPORTAMENTOTIMEState + 4)  or readingSliderPORTAMENTOTIME < (sliderPORTAMENTOTIMEState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 36, midiCCValue};
    MidiUSB.sendMIDI(event);
    sliderPORTAMENTOTIMEState = readingSliderPORTAMENTOTIME;
  }


  mux2Pin = 13;
  selectMux2Pin(mux2Pin); 
  int readingSliderPWDCO = analogRead(z2Input); 
  midiCCValue = (readingSliderPWDCO / 8);
  if (readingSliderPWDCO > (sliderPWDCOState + 4)  or readingSliderPWDCO < (sliderPWDCOState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 37, midiCCValue};
    MidiUSB.sendMIDI(event);
    sliderPWDCOState = readingSliderPWDCO;
  }


  mux2Pin = 14;
  selectMux2Pin(mux2Pin);
  int readingSliderPWFILTER = analogRead(z2Input); 
  midiCCValue = (readingSliderPWFILTER / 8);
  if (readingSliderPWFILTER > (sliderPWFILTERState + 4)  or readingSliderPWFILTER < (sliderPWFILTERState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 38, midiCCValue};
    MidiUSB.sendMIDI(event);
    sliderPWFILTERState = readingSliderPWFILTER;
  }


  mux2Pin = 15;
  selectMux2Pin(mux2Pin); 
  int readingSliderVELENV = analogRead(z2Input); 
  midiCCValue = (readingSliderVELENV / 8);
  if (readingSliderVELENV > (sliderVELENVState + 4)  or readingSliderVELENV < (sliderVELENVState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 39, midiCCValue};
    MidiUSB.sendMIDI(event);
    sliderVELENVState = readingSliderVELENV;
  }




  int readingPotSPREAD = analogRead(potSPREAD);
  midiCCValue = (readingPotSPREAD / 8);
  if (readingPotSPREAD > (potSPREADState + 20)  or readingPotSPREAD < (potSPREADState - 20))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 40, midiCCValue};
    MidiUSB.sendMIDI(event);
    potSPREADState = readingPotSPREAD;
  }





  int readingPotTIME = analogRead(potTIME);
  midiCCValue = (readingPotTIME / 8);
  if (readingPotTIME > (potTIMEState + 4)  or readingPotTIME < (potTIMEState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 43, midiCCValue};
    MidiUSB.sendMIDI(event);
    potTIMEState = readingPotTIME;
  }



  int readingPotWET = analogRead(potWET);
  midiCCValue = (readingPotWET / 8);
  if (readingPotWET > (potWETState + 4)  or readingPotWET < (potWETState - 4))
  {
    midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 44, midiCCValue};
    MidiUSB.sendMIDI(event);
    potWETState = readingPotWET;
  }


  int readingSwitchCHORUSII = digitalRead(switchCHORUSII);    // read the state of the switch into a local variable:
  if (readingSwitchCHORUSII != lastSwitchCHORUSIIState) // if reading is different from last recorded state
  {
    lastDebounceTimeSwitchCHORUSII = millis();  // reset the debouncing timer
  }
  if ((millis() - lastDebounceTimeSwitchCHORUSII) > debounceDelay) // If more that 50 ms has passed since the reading was different from last recorder state...
  {
    if (readingSwitchCHORUSII != SwitchCHORUSIIState) //... and the reading still is different from the last recorded state...
    {
      SwitchCHORUSIIState = readingSwitchCHORUSII; // ...we believe it's genuine and update the buttonState...

      if (SwitchCHORUSIIState == LOW)
      {
        midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 45, 127};
        MidiUSB.sendMIDI(event);
      }
      else
      {
        midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 45, 0};
        MidiUSB.sendMIDI(event);
      }
    }
  }

  lastSwitchCHORUSIIState = readingSwitchCHORUSII;   


  int readingSwitchCHORUSI = digitalRead(switchCHORUSI);   
  if (readingSwitchCHORUSI != lastSwitchCHORUSIState) 
  {
    lastDebounceTimeSwitchCHORUSI = millis();  
  }
  if ((millis() - lastDebounceTimeSwitchCHORUSI) > debounceDelay) 
  {
    if (readingSwitchCHORUSI != SwitchCHORUSIState) 
    {
      SwitchCHORUSIState = readingSwitchCHORUSI;

      if (SwitchCHORUSIState == LOW)
      {
        midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 46, 127};
        MidiUSB.sendMIDI(event);
      }
      else
      {
        midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 46, 0};
        MidiUSB.sendMIDI(event);
      }
    }
  }

  lastSwitchCHORUSIState = readingSwitchCHORUSI;    // save the reading. Next time through the loop, it'll be the lastButtonState:



  MidiUSB.flush();

}



// The selectMuxPin function sets the S0, S1, and S2 pins
// accordingly, given a pin from 0-7.
void selectMuxPin(byte muxPin)
{
  for (int i = 0; i < 4; i++)
  {
    if (muxPin & (1 << i))
      digitalWrite(selectPins[i], HIGH);
    else
      digitalWrite(selectPins[i], LOW);
  }
}


void selectMux2Pin(byte mux2Pin)
{
  for (int i = 0; i < 4; i++)
  {
    if (mux2Pin & (1 << i))
      digitalWrite(select2Pins[i], HIGH);
    else
      digitalWrite(select2Pins[i], LOW);
  }
}

Comments

Only logged in users can leave comments

Waltter1

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content