A midi controller designed specifically for the TAL U No LX software synthesizer
Devices and components
Arduino Leonardo without headers
10kOhm potentiometer
3-position slide switch
Slide switch, SPDT
Push button switch, locking (Push on, Push off)
Rotary switch, SMD
Slider
push buttons
Materials and tools
Table Saw
Soldering kit
Laser cutter (generic)
Software and tools
Arduino IDE
Project description
Midi Controller
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}
Note: Content and images are from: https://projecthub.arduino.cc/, with some modifications.
If you want it removed due to copyright reasons, please leave a comment. Thank you.
I want to share this article more widely so that everyone knows about Arduino and your project.