Minimal MIDI Drum Kit with 3D Printer

This is minimal drum kit using Arduino UNO.

Jul 11, 2017

•

47168 views

•

41 respects

audio

music

Devices & Components

Arduino Uno Rev3

Zener Diode - 5.1V 1W

Resistor 1M ohm

USB-A to B Cable

Resistor 10k ohm

Standard LCD - 16x2 White on Blue

Force Sensitive Resistor (FSR)

Piezo

Lightning to USB Camera Adapter

Pushbutton switch 12mm

Slide Switch

TRS Socket

Hardware & Tools

Laser cutter (generic)

3D Printer (generic)

circle cutter

Soldering iron (generic)

Software & Tools

Arduino IDE

Project description

Code

Hello Drum v2

arduino

Modified: 05/12/2019 by George Brotherston

1/*
2	Drum MIDI Controller
3	Created:  28/06/2017 by Ryo Kosaka as   " HELLO DRUM " Ver.1.0
4	Modified: 05/12/2019 by George Brotherston
5*/
6
7//   Library Includes
8
9//	#include <Arduino.h>		// Arduino Library (automatically   included)
10		// LOW (Line 41)
11		// HIGH (Line 40)
12		// INPUT_PULLUP   (Line 47)
13		// digitalRead() (Line 177)
14		// analogRead() (Line 178)
15	#include   <MIDI.h>           // MIDI Library		- Version: 4.3.1
16		// includes <midi_Namespace.h>
17			//   class MIDI (Line 30)
18		// class method 'begin' (Line 55)
19	#include <LiquidCrystal.h>   // LiquidCrystal	- Version: 1.0.7
20		// lcd object instantiatied (in Variables   section below) from LiquidCrystal class (Line 45)
21
22//	Variables - Declare   and Initialize
23
24	// Variables - Program
25		boolean	bSnareFlag			=   false;
26		boolean	bHihatFlag			= false;
27		boolean	bKickFlag			=   false;
28		boolean	bPedalFlag			= false;
29		boolean	bButtonState		=   true;
30		boolean	bButtonState_set	= true;
31		int		iUPDOWN				= 0;
32		int		iNEXTBACK			=   0;
33
34	//	Arrays - Program
35		// InstrumentSensor[6] = {threshold, sensitivity,   note, flag, velocity, iPeakValue}
36		// 'iPeakValue' and 'velocity' must be   zero for all InstrumentSensor arrays
37		// All 'aHIHAT[]' and 'aHIHAT_CLOSE[]'   array elements should have the same value except for 'note' element.
38			int		aSNARE[6]		=   {150, 950, 38, 3, 0, 0};
39			int		aSNARE_RIM[6]	= {5, 500, 37, 3 , 0, 0};
40			int		aHIHAT[6]		=   {100, 800, 46, 1, 0, 0};     
41			int		aHIHAT_CLOSE[6]	= {100, 800, 42,   1, 0, 0};
42			int		aKICK[6]		= {200, 700, 36, 1, 0, 0};
43		// Instrument_ContinuousController[4]   = {scantime, snare/rim, pedalVelocity , masktime}
44			int		aHIHAT_PEDAL[4]	=   {600, 0, 44, 0};
45		// InstrumentSensor_ParameterValue[4] = {threshold, sensitivity,   note, flag}
46			int		aSETTING[4]		= {4, 500 ,100 ,1};
47
48	//	Libraries
49		//	LiquidCrystal.h
50			//	Constants   (already defined in Library, still in scope?  If not then define below)
51				//	const   int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
52			//	lcd object instantiatiated   from LiquidCrystal class (LiquidCrystal.h Line 45)
53				LiquidCrystal lcd(rs,   en, d4, d5, d6, d7);	//	Associate LCD interface pins to associated Arduino pin   number
54		// MIDI.h
55			//	Initialize the library
56				MIDI_CREATE_DEFAULT_INSTANCE();
57
58//   Program Code
59
60	// Program Execution - Initial (program setup)
61
62		void   setup() {
63			MIDI.begin(10);						// begin (MIDI.h Line 55)
64			lcd.begin(16,   2);					// begin (LiquidCrystal.h Line 62)
65			lcd.print("INITIALIZING...");		//   print (LiquidCrystal.h Line 45)
66			lcd.setCursor(0, 1);				// setCursor   (LiquidCrystal.h Line 82)
67			lcd.print("DRUM MIDI CONTROLLER");
68			pinMode(6,   INPUT_PULLUP);			// pinMode (Arduino.h Line 175); INPUT_PULLUP (Arduino.h Line   47)
69			pinMode(7, INPUT_PULLUP);
70			pinMode(8, INPUT_PULLUP);
71			pinMode(9,   INPUT_PULLUP);
72			pinMode(10, INPUT_PULLUP);
73		}
74
75	// Program   Execution - Steadystate (continuous loop until power is lost)
76
77		void loop()   {
78		// Drum MIDI Controller Circuit
79		// Declare and Initialize Variables
80
81			int		iButton_set		=   digitalRead(6);	// Set Button			// digitalRead() (Arduino.h Line 177)
82			int		iButton_up		=   digitalRead(7);	// Up Button
83			int		iButton_down	= digitalRead(8);	//   Down Button
84			int		iButton_next	= digitalRead(9);	// Next Button
85			int		iButton_back	=   digitalRead(10);	// Back Button
86			int		iPiezoValue_A0	= analogRead(A0);    // Piezo - Snare Head	// analogRead() (Arduino.h Line 178)
87			int		iPiezoValue_A1	=   analogRead(A1);   // Piezo - Snare Rim
88			int		iPiezoValue_A2	= analogRead(A2);    // Hi-hat
89			int		iPiezoValue_A3	= analogRead(A3);   // Kick Drum
90			int		iFSRValue_A4	=   analogRead(A4);   // Hi-hat Pedal
91	
92		// Edit Mode
93
94			int		aUP[4]			=   {5, 50, 1,1};		// {threshold, sensitivity, note, flag}
95			int		aUP_ADVANCE[4]	=   {1, 50, 1,1};		// {scantime, rim/head, pedal velocity, masktime}
96
97			//   Note: aINSTRUMENT[] array was not declared in 'Arrays' above
98			char* aINSTRUMENT[]   = {
99				"SNARE HEAD",  "SNARE RIM", "HIHAT OPEN", "HIHAT CLOSE",   "HIHAT PEDAL", "KICK", "ADVANCED SETTING"
100			};
101
102			// Note:   aSETTING[] array WAS declared in 'Arrays' above
103			char* aSETTING[] = {
104				"THRESHOLD",   "SENSITIVITY", "NOTE", "FLAG"
105			};
106
107			// Note: aSETTING_ADVANCE[]   was not declared in 'Arrays' above
108			char* aSETTING_ADVANCE[] = {
109				"SCAN   TIME", "HEAD / RIM ","PEDAL VELO", "MASK TIME"
110			};
111
112			if   (iUPDOWN < 0) {
113				iUPDOWN = 6;
114			}
115
116			if (iUPDOWN > 6)   {
117				iUPDOWN = 0;
118			}
119
120			if (iNEXTBACK < 0) {
121				iNEXTBACK   = 3;
122			}
123
124			if (iNEXTBACK > 3) {
125				iNEXTBACK = 0;
126			}
127
128		//   Pushbutton EDIT
129			// LOW (Arduino.h Line 41)
130			if (iButton_set ==   LOW && bButtonState == true && bButtonState_set == true) {
131				lcd.clear();
132				lcd.print("EDIT");
133				bButtonState		=   false;
134				bButtonState_set	= false;
135				delay(500);
136			}
137
138			if   (iButton_set == LOW && bButtonState == true && bButtonState_set == false) {
139				lcd.clear();
140             	lcd.print("EDIT DONE");
141            	bButtonState		= false;
142             	bButtonState_set	= true;
143            	delay(500);
144			}
145
146			if   (iButton_up == LOW && bButtonState == true && bButtonState_set == false) {
147				switch   (iUPDOWN) {
148					case 0:
149					aSNARE[iNEXTBACK] = aSNARE[iNEXTBACK]   + aUP[iNEXTBACK];
150					break;
151
152					case 1:
153					aSNARE_RIM[iNEXTBACK]   = aSNARE_RIM[iNEXTBACK] + aUP[iNEXTBACK];
154					break;
155
156					case   2:
157					switch (iNEXTBACK) {
158						case 2:
159						aHIHAT[iNEXTBACK]   = aHIHAT[iNEXTBACK] + aUP[iNEXTBACK];
160						break;
161
162						default:
163						aHIHAT_CLOSE[iNEXTBACK]   = aHIHAT_CLOSE[iNEXTBACK] + aUP[iNEXTBACK];
164						aHIHAT[iNEXTBACK] = aHIHAT[iNEXTBACK]   + aUP[iNEXTBACK];
165					}
166					break;
167
168					case 3:
169					switch   (iNEXTBACK) {
170						case 2:
171						aHIHAT_CLOSE[iNEXTBACK] = aHIHAT_CLOSE[iNEXTBACK]   + aUP[iNEXTBACK];
172						break;
173						
174						default:
175						aHIHAT_CLOSE[iNEXTBACK]   = aHIHAT_CLOSE[iNEXTBACK] + aUP[iNEXTBACK];
176						aHIHAT[iNEXTBACK] = aHIHAT[iNEXTBACK]   + aUP[iNEXTBACK];
177					}
178					break;
179
180					case 4:
181					switch   (iNEXTBACK) {
182						case 0:
183						aHIHAT_PEDAL[iNEXTBACK] = aHIHAT_PEDAL[iNEXTBACK]   + aUP[iNEXTBACK];
184						break;
185						
186						case 2:
187						aHIHAT_PEDAL[iNEXTBACK]   = aHIHAT_PEDAL[iNEXTBACK] + aUP[iNEXTBACK];
188						break;
189					}
190					break;
191
192					case   5:
193					aKICK[iNEXTBACK] = aKICK[iNEXTBACK] + aUP[iNEXTBACK];
194					break;
195
196					case   6:
197					aSETTING[iNEXTBACK] = aSETTING[iNEXTBACK] + aUP_ADVANCE[iNEXTBACK];
198					break;
199				}
200				bButtonState   = false;
201				delay(30);
202			}
203
204			if (iButton_down == LOW &&   bButtonState == true && bButtonState_set == false) {
205
206				switch (iUPDOWN)   {
207					case 0:
208					aSNARE[iNEXTBACK] = aSNARE[iNEXTBACK] - aUP[iNEXTBACK];
209					break;
210
211					case   1:
212					aSNARE_RIM[iNEXTBACK] = aSNARE_RIM[iNEXTBACK] - aUP[iNEXTBACK];
213					break;
214
215					case   2:
216					switch (iNEXTBACK) {
217						case 2:
218						aHIHAT[iNEXTBACK]   = aHIHAT[iNEXTBACK] - aUP[iNEXTBACK];
219						break;
220
221						default:
222						aHIHAT_CLOSE[iNEXTBACK]   = aHIHAT_CLOSE[iNEXTBACK] - aUP[iNEXTBACK];
223						aHIHAT[iNEXTBACK] = aHIHAT[iNEXTBACK]   - aUP[iNEXTBACK];
224					}
225					break;
226
227					case 3:
228					switch   (iNEXTBACK) {
229						case 2:
230						aHIHAT_CLOSE[iNEXTBACK] = aHIHAT_CLOSE[iNEXTBACK]   - aUP[iNEXTBACK];
231						break;
232
233						default:
234						aHIHAT_CLOSE[iNEXTBACK]   = aHIHAT_CLOSE[iNEXTBACK] - aUP[iNEXTBACK];
235						aHIHAT[iNEXTBACK] = aHIHAT[iNEXTBACK]   - aUP[iNEXTBACK];
236					}
237					break;
238
239					case 4:
240					switch   (iNEXTBACK) {
241						case 0:
242						aHIHAT_PEDAL[iNEXTBACK] = aHIHAT_PEDAL[iNEXTBACK]   - aUP[iNEXTBACK];
243						break;
244
245						case 2:
246						aHIHAT_PEDAL[iNEXTBACK]   = aHIHAT_PEDAL[iNEXTBACK] - aUP[iNEXTBACK];
247						break;
248					}
249					break;
250
251					case   5:
252					aKICK[iNEXTBACK] = aKICK[iNEXTBACK] - aUP[iNEXTBACK];
253					break;
254
255					case   6:
256					aSETTING[iNEXTBACK] = aSETTING[iNEXTBACK] - aUP_ADVANCE[iNEXTBACK];
257					break;
258				}
259				bButtonState   = false;
260				delay(30);
261			}
262
263		// Pushbuttons UP; DOWN; NEXT;   BACK
264			if (iButton_up == LOW && bButtonState == true && bButtonState_set   == true) {
265				iUPDOWN = ++iUPDOWN;
266				bButtonState = false;
267				delay(30);
268			}
269
270			if   (iButton_down == LOW && bButtonState == true && bButtonState_set == true) {
271				iUPDOWN   = --iUPDOWN;
272				bButtonState = false;
273				delay(30);
274			}
275
276			if   (iButton_next == LOW && bButtonState == true && bButtonState_set == true) {
277				iNEXTBACK   = ++iNEXTBACK;
278				bButtonState = false;
279				delay(30);
280			}
281
282			if   (iButton_back == LOW && bButtonState == true && bButtonState_set == true) {
283				iNEXTBACK   = --iNEXTBACK;
284				bButtonState = false;
285				delay(30);
286			}
287
288			if   (bButtonState == false && iButton_up == HIGH && iButton_down == HIGH && iButton_next   == HIGH && iButton_back == HIGH && iButton_set == HIGH) {
289				// HIGH is   defined in Arduino.h Line 40
290
291				switch (iUPDOWN) {
292
293					case   0:
294					lcd.clear();
295					lcd.print(aINSTRUMENT[iUPDOWN]);
296					lcd.setCursor(0,   1);
297					lcd.print(aSETTING[iNEXTBACK]);
298					lcd.setCursor(12,   1);
299					lcd.print(aSNARE[iNEXTBACK]);
300					break;
301
302					case   1:
303					lcd.clear();
304					lcd.print(aINSTRUMENT[iUPDOWN]);
305					lcd.setCursor(0,   1);
306					lcd.print(aSETTING[iNEXTBACK]);
307					lcd.setCursor(12,   1);
308					lcd.print(aSNARE_RIM[iNEXTBACK]);
309					break;
310
311					case   2:
312					lcd.clear();
313					lcd.print(aINSTRUMENT[iUPDOWN]);
314					lcd.setCursor(0,   1);
315					lcd.print(aSETTING[iNEXTBACK]);
316					lcd.setCursor(12,   1);
317					lcd.print(aHIHAT[iNEXTBACK]);
318					break;
319
320					case   3:
321					lcd.clear();lcd.print(aINSTRUMENT[iUPDOWN]);
322					lcd.setCursor(0,   1);
323					lcd.print(aSETTING[iNEXTBACK]);
324					lcd.setCursor(12,   1);
325					lcd.print(aHIHAT_CLOSE[iNEXTBACK]);
326					break;
327
328					case   4:
329					lcd.clear();
330					lcd.print(aINSTRUMENT[iUPDOWN]);
331					lcd.setCursor(0,   1);
332					lcd.print(aSETTING[iNEXTBACK]);
333					lcd.setCursor(12,   1);
334					lcd.print(aHIHAT_PEDAL[iNEXTBACK]);
335					break;
336
337					case   5:
338					lcd.clear();
339					lcd.print(aINSTRUMENT[iUPDOWN]);
340					lcd.setCursor(0,   1);
341					lcd.print(aSETTING[iNEXTBACK]);
342					lcd.setCursor(12,   1);
343					lcd.print(aKICK[iNEXTBACK]);
344					break;
345
346					case   6:
347					lcd.clear();
348					lcd.print(aINSTRUMENT[iUPDOWN]);
349					lcd.setCursor(0,   1);
350					lcd.print(aSETTING_ADVANCE[iNEXTBACK]);
351					lcd.setCursor(12,   1);
352					lcd.print(aSETTING[iNEXTBACK]);
353					break;
354				}
355
356				bButtonState   = true;
357			}
358
359		// Instrument Sensors
360
361			// Snare Drum
362			if   (iPiezoValue_A0 > aSNARE[0] && bSnareFlag == false) {
363
364				for (int i   = 0; i < aSETTING[0]; i++) {
365					int iPeak_A0 = analogRead(A0);
366					int   iPeak_A1 = analogRead(A1);
367					delay(1);
368					if (iPeak_A0 > aSNARE[4])   {
369						aSNARE[4] = iPeak_A0;
370					}
371					if (iPeak_A1   > aSNARE_RIM[4]) {
372						aSNARE_RIM[4] = iPeak_A1;
373					}
374				}
375				aSNARE[5]   = aSNARE[4];
376				aSNARE_RIM[5] = aSNARE_RIM[4];
377				aSNARE[4] = map(aSNARE[4],   aSNARE[0], aSNARE[1], 0, 127);
378				aSNARE_RIM[4] = map(aSNARE_RIM[4], aSNARE_RIM[0],   aSNARE_RIM[1], 0, 127);
379				aSNARE[4] = (aSNARE[4] *  aSNARE[4]) / 127; //   Curve setting
380
381			//aSNARE_RIM[4] = (aSNARE_RIM[4] * aSNARE_RIM[4]) / 127;
382				if   (aSNARE[4] <= 1) {
383					aSNARE[4] = 1;
384				}
385				if (aSNARE[4]   > 127) {
386					aSNARE[4] = 127;
387				}
388				if (aSNARE_RIM[4]   <= 0) {
389					aSNARE_RIM[4] = 0;
390				}
391				if (aSNARE_RIM[4]   > 127) {
392					aSNARE_RIM[4] = 127;
393				}
394				if (aSNARE_RIM[5]   > aSETTING[1]) {
395					MIDI.sendNoteOn(aSNARE_RIM[2], aSNARE_RIM[4], 1);    //(note, velocity, channel)
396					MIDI.sendNoteOn(aSNARE_RIM[2], 0, 1);
397					lcd.clear();
398					lcd.print("SNARE   RIM");
399					lcd.setCursor(0, 1);
400					lcd.print(aSNARE_RIM[4]);
401					bSnareFlag   = true;
402				}
403
404			//else if (aSNARE[5] > aSNARE_RIM[5])
405				else   {
406					MIDI.sendNoteOn(aSNARE[2], aSNARE[4], 1);   //(note, velocity, channel)
407					MIDI.sendNoteOn(aSNARE[2],   0, 1);
408					lcd.clear();
409					lcd.print("SNARE HEAD");
410					lcd.setCursor(0,   1);
411					lcd.print(aSNARE[4]);
412				//lcd.setCursor(10, 1);
413				//lcd.print(aSNARE_RIM[5]);
414					bSnareFlag   = true;
415				}
416			}
417
418		// Hi-Hat Cymbal
419			if (iPiezoValue_A2   > aHIHAT[0] && bHihatFlag == false) {
420				for (int i = 0; i < aSETTING[0];   i++) {
421					int iPeak_A2 = analogRead(A2);
422					delay(1);
423					if   (iPeak_A2 > aHIHAT[4]) {
424						aHIHAT[4] = iPeak_A2;
425					}
426				}
427				aHIHAT[5]   = aHIHAT[4];
428				aHIHAT[4] = map(aHIHAT[4], aHIHAT[0], aHIHAT[1], 0, 127);
429				aHIHAT[4]   = (aHIHAT[4] * aHIHAT[4]) / 127;
430				if (aHIHAT[4] <= 1) {
431					aHIHAT[4]   = 1;
432				}
433				if (aHIHAT[4] > 127) {
434					aHIHAT[4] = 127;
435				}
436				if   (iPiezoValue_A0 < aHIHAT_PEDAL[0]) {
437					MIDI.sendNoteOn(aHIHAT[2], aHIHAT[4],   1);
438					MIDI.sendNoteOn(aHIHAT[2], 0, 1);
439					lcd.clear();
440					lcd.print("HIHAT   OPEN");
441					lcd.setCursor(0, 1);
442					lcd.print(aHIHAT[4]);
443					bHihatFlag   = true;
444				}
445				else if (iPiezoValue_A0 >= aHIHAT_PEDAL[0]) {
446					MIDI.sendNoteOn(aHIHAT_CLOSE[2],   aHIHAT[4], 1);
447					MIDI.sendNoteOn(aHIHAT_CLOSE[2], 0, 1);
448					lcd.clear();
449					lcd.print("HIHAT   CLOSE");
450					lcd.setCursor(0, 1);
451					lcd.print(aHIHAT[4]);
452					bHihatFlag   = true;
453				}
454			}
455
456		// Hi-hat Pedal
457			if (iPiezoValue_A0   > aHIHAT_PEDAL[0] && bPedalFlag == false) {
458				MIDI.sendNoteOn(aHIHAT_PEDAL[2],   aSETTING[2], 1);  // (note, velocity, channel)
459				MIDI.sendNoteOn(aHIHAT_PEDAL[2],   0, 1);
460				lcd.clear();
461				lcd.print("HIHAT PEDAL");
462				lcd.setCursor(0,   1);
463				lcd.print(aSETTING[2]);
464				bPedalFlag = true;
465			}
466
467		//   Kick Drum
468			if (iPiezoValue_A3 > aKICK[0] && bKickFlag == false) {
469				for   (int i = 0; i < aSETTING[0]; i++) {
470					int iPeak_A3 = analogRead(A3);
471					delay(1);
472					if   (iPeak_A3 > aKICK[4]) {
473						aKICK[4] = iPeak_A3;
474					}
475				}
476
477				aKICK[5]   = aKICK[4];
478				aKICK[4] = map(aKICK[4], aKICK[0], aKICK[1], 0, 127);
479				aKICK[4]   = (aKICK[4] * aKICK[4]) / 127;
480				if (aKICK[4] <= 1) {
481					aKICK[4]   = 1;
482				}
483				if (aKICK[4] > 127) {
484					aKICK[4] = 127;
485				}
486				MIDI.sendNoteOn(aKICK[2],   aKICK[4], 1);
487				MIDI.sendNoteOn(aKICK[2], 0, 1);
488				lcd.clear();
489				lcd.print("KICK");
490				lcd.setCursor(0,   1);
491				lcd.print(aKICK[4]);
492				bKickFlag = true;
493			}
494
495//   --- BEGIN 'Code in Progress' --- //
496// --- I could be wrong, but this is what   it appears to be --- and out of curiousity what is purpose of this sequence? --   //
497
498			// I=(A0);  // Previous Code
499			// -- DOES iSensorValue_A0   need to be declared as an integer?  How does this relate to iPiezoValue_A0?  --   //
500			if (iSensorValue_A0 < (aSNARE[5] * (0.01 * aSNARE[3]))) {
501				bSnareFlag   = false;
502			}
503			if (iPiezoValue_A0 <= aHIHAT_PEDAL[0] && iPiezoValue_A2   < (aHIHAT[5] * (0.01 * aHIHAT[3])) && bHihatFlag == true) {
504				delay(aSETTING[3]);
505				//   iSensorValue_A1 is reading analogRead(A2), but this is aHIHAT_PEDAL (which is analogRead(A2)
506				int   iSensorValue_A1 = analogRead(A2);
507				if (iSensorValue_A1 < (aHIHAT[5] *   (0.01 * aHIHAT[3]))) {
508					bHihatFlag = false;
509				}
510			}
511			if   (iPiezoValue_A0 >= aHIHAT_PEDAL[0] && iPiezoValue_A2 < (aHIHAT[5] *(0.01 * aHIHAT[3]))   && bHihatFlag == true) {
512				delay(aSETTING[3]);
513				int iSensorValue_A2   = analogRead(A2);
514				if (iSensorValue_A2 < (aHIHAT[5] * (0.01 * aHIHAT[3])))   {
515					bHihatFlag = false;
516				}
517			}
518			if (iPiezoValue_A3   < (aKICK[5] * (0.01 * aKICK[3])) && bKickFlag == true) {
519				delay(aSETTING[3]);
520				//   -- Should declared iSensorValue_A3 be iPiezoValue_A3?  iSensorValue_A3 is declared   but not used anywhere??
521				int iSensorValue_A3 = analogRead(A3);
522				if   (iPiezoValue_A3 < (aKICK[5] * (0.01 * aKICK[3]))) {
523				bKickFlag = false;
524				}
525			}
526			if   (iPiezoValue_A0 <= aHIHAT_PEDAL[0] && bPedalFlag == true) {
527				bPedalFlag   = false;
528			}
529
530// --- END 'Code in Progress' --- //
531		}

/*
	Drum MIDI Controller
	Created:  28/06/2017 by Ryo Kosaka as   " HELLO DRUM " Ver.1.0
	Modified: 05/12/2019 by George Brotherston
*/

//   Library Includes

//	#include <Arduino.h>		// Arduino Library (automatically   included)
		// LOW (Line 41)
		// HIGH (Line 40)
		// INPUT_PULLUP   (Line 47)
		// digitalRead() (Line 177)
		// analogRead() (Line 178)
	#include   <MIDI.h>           // MIDI Library		- Version: 4.3.1
		// includes <midi_Namespace.h>
			//   class MIDI (Line 30)
		// class method 'begin' (Line 55)
	#include <LiquidCrystal.h>   // LiquidCrystal	- Version: 1.0.7
		// lcd object instantiatied (in Variables   section below) from LiquidCrystal class (Line 45)

//	Variables - Declare   and Initialize

	// Variables - Program
		boolean	bSnareFlag			=   false;
		boolean	bHihatFlag			= false;
		boolean	bKickFlag			=   false;
		boolean	bPedalFlag			= false;
		boolean	bButtonState		=   true;
		boolean	bButtonState_set	= true;
		int		iUPDOWN				= 0;
		int		iNEXTBACK			=   0;

	//	Arrays - Program
		// InstrumentSensor[6] = {threshold, sensitivity,   note, flag, velocity, iPeakValue}
		// 'iPeakValue' and 'velocity' must be   zero for all InstrumentSensor arrays
		// All 'aHIHAT[]' and 'aHIHAT_CLOSE[]'   array elements should have the same value except for 'note' element.
			int		aSNARE[6]		=   {150, 950, 38, 3, 0, 0};
			int		aSNARE_RIM[6]	= {5, 500, 37, 3 , 0, 0};
			int		aHIHAT[6]		=   {100, 800, 46, 1, 0, 0};     
			int		aHIHAT_CLOSE[6]	= {100, 800, 42,   1, 0, 0};
			int		aKICK[6]		= {200, 700, 36, 1, 0, 0};
		// Instrument_ContinuousController[4]   = {scantime, snare/rim, pedalVelocity , masktime}
			int		aHIHAT_PEDAL[4]	=   {600, 0, 44, 0};
		// InstrumentSensor_ParameterValue[4] = {threshold, sensitivity,   note, flag}
			int		aSETTING[4]		= {4, 500 ,100 ,1};

	//	Libraries
		//	LiquidCrystal.h
			//	Constants   (already defined in Library, still in scope?  If not then define below)
				//	const   int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
			//	lcd object instantiatiated   from LiquidCrystal class (LiquidCrystal.h Line 45)
				LiquidCrystal lcd(rs,   en, d4, d5, d6, d7);	//	Associate LCD interface pins to associated Arduino pin   number
		// MIDI.h
			//	Initialize the library
				MIDI_CREATE_DEFAULT_INSTANCE();

//   Program Code

	// Program Execution - Initial (program setup)

		void   setup() {
			MIDI.begin(10);						// begin (MIDI.h Line 55)
			lcd.begin(16,   2);					// begin (LiquidCrystal.h Line 62)
			lcd.print("INITIALIZING...");		//   print (LiquidCrystal.h Line 45)
			lcd.setCursor(0, 1);				// setCursor   (LiquidCrystal.h Line 82)
			lcd.print("DRUM MIDI CONTROLLER");
			pinMode(6,   INPUT_PULLUP);			// pinMode (Arduino.h Line 175); INPUT_PULLUP (Arduino.h Line   47)
			pinMode(7, INPUT_PULLUP);
			pinMode(8, INPUT_PULLUP);
			pinMode(9,   INPUT_PULLUP);
			pinMode(10, INPUT_PULLUP);
		}

	// Program   Execution - Steadystate (continuous loop until power is lost)

		void loop()   {
		// Drum MIDI Controller Circuit
		// Declare and Initialize Variables

			int		iButton_set		=   digitalRead(6);	// Set Button			// digitalRead() (Arduino.h Line 177)
			int		iButton_up		=   digitalRead(7);	// Up Button
			int		iButton_down	= digitalRead(8);	//   Down Button
			int		iButton_next	= digitalRead(9);	// Next Button
			int		iButton_back	=   digitalRead(10);	// Back Button
			int		iPiezoValue_A0	= analogRead(A0);    // Piezo - Snare Head	// analogRead() (Arduino.h Line 178)
			int		iPiezoValue_A1	=   analogRead(A1);   // Piezo - Snare Rim
			int		iPiezoValue_A2	= analogRead(A2);    // Hi-hat
			int		iPiezoValue_A3	= analogRead(A3);   // Kick Drum
			int		iFSRValue_A4	=   analogRead(A4);   // Hi-hat Pedal
	
		// Edit Mode

			int		aUP[4]			=   {5, 50, 1,1};		// {threshold, sensitivity, note, flag}
			int		aUP_ADVANCE[4]	=   {1, 50, 1,1};		// {scantime, rim/head, pedal velocity, masktime}

			//   Note: aINSTRUMENT[] array was not declared in 'Arrays' above
			char* aINSTRUMENT[]   = {
				"SNARE HEAD",  "SNARE RIM", "HIHAT OPEN", "HIHAT CLOSE",   "HIHAT PEDAL", "KICK", "ADVANCED SETTING"
			};

			// Note:   aSETTING[] array WAS declared in 'Arrays' above
			char* aSETTING[] = {
				"THRESHOLD",   "SENSITIVITY", "NOTE", "FLAG"
			};

			// Note: aSETTING_ADVANCE[]   was not declared in 'Arrays' above
			char* aSETTING_ADVANCE[] = {
				"SCAN   TIME", "HEAD / RIM ","PEDAL VELO", "MASK TIME"
			};

			if   (iUPDOWN < 0) {
				iUPDOWN = 6;
			}

			if (iUPDOWN > 6)   {
				iUPDOWN = 0;
			}

			if (iNEXTBACK < 0) {
				iNEXTBACK   = 3;
			}

			if (iNEXTBACK > 3) {
				iNEXTBACK = 0;
			}

		//   Pushbutton EDIT
			// LOW (Arduino.h Line 41)
			if (iButton_set ==   LOW && bButtonState == true && bButtonState_set == true) {
				lcd.clear();
				lcd.print("EDIT");
				bButtonState		=   false;
				bButtonState_set	= false;
				delay(500);
			}

			if   (iButton_set == LOW && bButtonState == true && bButtonState_set == false) {
				lcd.clear();
             	lcd.print("EDIT DONE");
            	bButtonState		= false;
             	bButtonState_set	= true;
            	delay(500);
			}

			if   (iButton_up == LOW && bButtonState == true && bButtonState_set == false) {
				switch   (iUPDOWN) {
					case 0:
					aSNARE[iNEXTBACK] = aSNARE[iNEXTBACK]   + aUP[iNEXTBACK];
					break;

					case 1:
					aSNARE_RIM[iNEXTBACK]   = aSNARE_RIM[iNEXTBACK] + aUP[iNEXTBACK];
					break;

					case   2:
					switch (iNEXTBACK) {
						case 2:
						aHIHAT[iNEXTBACK]   = aHIHAT[iNEXTBACK] + aUP[iNEXTBACK];
						break;

						default:
						aHIHAT_CLOSE[iNEXTBACK]   = aHIHAT_CLOSE[iNEXTBACK] + aUP[iNEXTBACK];
						aHIHAT[iNEXTBACK] = aHIHAT[iNEXTBACK]   + aUP[iNEXTBACK];
					}
					break;

					case 3:
					switch   (iNEXTBACK) {
						case 2:
						aHIHAT_CLOSE[iNEXTBACK] = aHIHAT_CLOSE[iNEXTBACK]   + aUP[iNEXTBACK];
						break;
						
						default:
						aHIHAT_CLOSE[iNEXTBACK]   = aHIHAT_CLOSE[iNEXTBACK] + aUP[iNEXTBACK];
						aHIHAT[iNEXTBACK] = aHIHAT[iNEXTBACK]   + aUP[iNEXTBACK];
					}
					break;

					case 4:
					switch   (iNEXTBACK) {
						case 0:
						aHIHAT_PEDAL[iNEXTBACK] = aHIHAT_PEDAL[iNEXTBACK]   + aUP[iNEXTBACK];
						break;
						
						case 2:
						aHIHAT_PEDAL[iNEXTBACK]   = aHIHAT_PEDAL[iNEXTBACK] + aUP[iNEXTBACK];
						break;
					}
					break;

					case   5:
					aKICK[iNEXTBACK] = aKICK[iNEXTBACK] + aUP[iNEXTBACK];
					break;

					case   6:
					aSETTING[iNEXTBACK] = aSETTING[iNEXTBACK] + aUP_ADVANCE[iNEXTBACK];
					break;
				}
				bButtonState   = false;
				delay(30);
			}

			if (iButton_down == LOW &&   bButtonState == true && bButtonState_set == false) {

				switch (iUPDOWN)   {
					case 0:
					aSNARE[iNEXTBACK] = aSNARE[iNEXTBACK] - aUP[iNEXTBACK];
					break;

					case   1:
					aSNARE_RIM[iNEXTBACK] = aSNARE_RIM[iNEXTBACK] - aUP[iNEXTBACK];
					break;

					case   2:
					switch (iNEXTBACK) {
						case 2:
						aHIHAT[iNEXTBACK]   = aHIHAT[iNEXTBACK] - aUP[iNEXTBACK];
						break;

						default:
						aHIHAT_CLOSE[iNEXTBACK]   = aHIHAT_CLOSE[iNEXTBACK] - aUP[iNEXTBACK];
						aHIHAT[iNEXTBACK] = aHIHAT[iNEXTBACK]   - aUP[iNEXTBACK];
					}
					break;

					case 3:
					switch   (iNEXTBACK) {
						case 2:
						aHIHAT_CLOSE[iNEXTBACK] = aHIHAT_CLOSE[iNEXTBACK]   - aUP[iNEXTBACK];
						break;

						default:
						aHIHAT_CLOSE[iNEXTBACK]   = aHIHAT_CLOSE[iNEXTBACK] - aUP[iNEXTBACK];
						aHIHAT[iNEXTBACK] = aHIHAT[iNEXTBACK]   - aUP[iNEXTBACK];
					}
					break;

					case 4:
					switch   (iNEXTBACK) {
						case 0:
						aHIHAT_PEDAL[iNEXTBACK] = aHIHAT_PEDAL[iNEXTBACK]   - aUP[iNEXTBACK];
						break;

						case 2:
						aHIHAT_PEDAL[iNEXTBACK]   = aHIHAT_PEDAL[iNEXTBACK] - aUP[iNEXTBACK];
						break;
					}
					break;

					case   5:
					aKICK[iNEXTBACK] = aKICK[iNEXTBACK] - aUP[iNEXTBACK];
					break;

					case   6:
					aSETTING[iNEXTBACK] = aSETTING[iNEXTBACK] - aUP_ADVANCE[iNEXTBACK];
					break;
				}
				bButtonState   = false;
				delay(30);
			}

		// Pushbuttons UP; DOWN; NEXT;   BACK
			if (iButton_up == LOW && bButtonState == true && bButtonState_set   == true) {
				iUPDOWN = ++iUPDOWN;
				bButtonState = false;
				delay(30);
			}

			if   (iButton_down == LOW && bButtonState == true && bButtonState_set == true) {
				iUPDOWN   = --iUPDOWN;
				bButtonState = false;
				delay(30);
			}

			if   (iButton_next == LOW && bButtonState == true && bButtonState_set == true) {
				iNEXTBACK   = ++iNEXTBACK;
				bButtonState = false;
				delay(30);
			}

			if   (iButton_back == LOW && bButtonState == true && bButtonState_set == true) {
				iNEXTBACK   = --iNEXTBACK;
				bButtonState = false;
				delay(30);
			}

			if   (bButtonState == false && iButton_up == HIGH && iButton_down == HIGH && iButton_next   == HIGH && iButton_back == HIGH && iButton_set == HIGH) {
				// HIGH is   defined in Arduino.h Line 40

				switch (iUPDOWN) {

					case   0:
					lcd.clear();
					lcd.print(aINSTRUMENT[iUPDOWN]);
					lcd.setCursor(0,   1);
					lcd.print(aSETTING[iNEXTBACK]);
					lcd.setCursor(12,   1);
					lcd.print(aSNARE[iNEXTBACK]);
					break;

					case   1:
					lcd.clear();
					lcd.print(aINSTRUMENT[iUPDOWN]);
					lcd.setCursor(0,   1);
					lcd.print(aSETTING[iNEXTBACK]);
					lcd.setCursor(12,   1);
					lcd.print(aSNARE_RIM[iNEXTBACK]);
					break;

					case   2:
					lcd.clear();
					lcd.print(aINSTRUMENT[iUPDOWN]);
					lcd.setCursor(0,   1);
					lcd.print(aSETTING[iNEXTBACK]);
					lcd.setCursor(12,   1);
					lcd.print(aHIHAT[iNEXTBACK]);
					break;

					case   3:
					lcd.clear();lcd.print(aINSTRUMENT[iUPDOWN]);
					lcd.setCursor(0,   1);
					lcd.print(aSETTING[iNEXTBACK]);
					lcd.setCursor(12,   1);
					lcd.print(aHIHAT_CLOSE[iNEXTBACK]);
					break;

					case   4:
					lcd.clear();
					lcd.print(aINSTRUMENT[iUPDOWN]);
					lcd.setCursor(0,   1);
					lcd.print(aSETTING[iNEXTBACK]);
					lcd.setCursor(12,   1);
					lcd.print(aHIHAT_PEDAL[iNEXTBACK]);
					break;

					case   5:
					lcd.clear();
					lcd.print(aINSTRUMENT[iUPDOWN]);
					lcd.setCursor(0,   1);
					lcd.print(aSETTING[iNEXTBACK]);
					lcd.setCursor(12,   1);
					lcd.print(aKICK[iNEXTBACK]);
					break;

					case   6:
					lcd.clear();
					lcd.print(aINSTRUMENT[iUPDOWN]);
					lcd.setCursor(0,   1);
					lcd.print(aSETTING_ADVANCE[iNEXTBACK]);
					lcd.setCursor(12,   1);
					lcd.print(aSETTING[iNEXTBACK]);
					break;
				}

				bButtonState   = true;
			}

		// Instrument Sensors

			// Snare Drum
			if   (iPiezoValue_A0 > aSNARE[0] && bSnareFlag == false) {

				for (int i   = 0; i < aSETTING[0]; i++) {
					int iPeak_A0 = analogRead(A0);
					int   iPeak_A1 = analogRead(A1);
					delay(1);
					if (iPeak_A0 > aSNARE[4])   {
						aSNARE[4] = iPeak_A0;
					}
					if (iPeak_A1   > aSNARE_RIM[4]) {
						aSNARE_RIM[4] = iPeak_A1;
					}
				}
				aSNARE[5]   = aSNARE[4];
				aSNARE_RIM[5] = aSNARE_RIM[4];
				aSNARE[4] = map(aSNARE[4],   aSNARE[0], aSNARE[1], 0, 127);
				aSNARE_RIM[4] = map(aSNARE_RIM[4], aSNARE_RIM[0],   aSNARE_RIM[1], 0, 127);
				aSNARE[4] = (aSNARE[4] *  aSNARE[4]) / 127; //   Curve setting

			//aSNARE_RIM[4] = (aSNARE_RIM[4] * aSNARE_RIM[4]) / 127;
				if   (aSNARE[4] <= 1) {
					aSNARE[4] = 1;
				}
				if (aSNARE[4]   > 127) {
					aSNARE[4] = 127;
				}
				if (aSNARE_RIM[4]   <= 0) {
					aSNARE_RIM[4] = 0;
				}
				if (aSNARE_RIM[4]   > 127) {
					aSNARE_RIM[4] = 127;
				}
				if (aSNARE_RIM[5]   > aSETTING[1]) {
					MIDI.sendNoteOn(aSNARE_RIM[2], aSNARE_RIM[4], 1);    //(note, velocity, channel)
					MIDI.sendNoteOn(aSNARE_RIM[2], 0, 1);
					lcd.clear();
					lcd.print("SNARE   RIM");
					lcd.setCursor(0, 1);
					lcd.print(aSNARE_RIM[4]);
					bSnareFlag   = true;
				}

			//else if (aSNARE[5] > aSNARE_RIM[5])
				else   {
					MIDI.sendNoteOn(aSNARE[2], aSNARE[4], 1);   //(note, velocity, channel)
					MIDI.sendNoteOn(aSNARE[2],   0, 1);
					lcd.clear();
					lcd.print("SNARE HEAD");
					lcd.setCursor(0,   1);
					lcd.print(aSNARE[4]);
				//lcd.setCursor(10, 1);
				//lcd.print(aSNARE_RIM[5]);
					bSnareFlag   = true;
				}
			}

		// Hi-Hat Cymbal
			if (iPiezoValue_A2   > aHIHAT[0] && bHihatFlag == false) {
				for (int i = 0; i < aSETTING[0];   i++) {
					int iPeak_A2 = analogRead(A2);
					delay(1);
					if   (iPeak_A2 > aHIHAT[4]) {
						aHIHAT[4] = iPeak_A2;
					}
				}
				aHIHAT[5]   = aHIHAT[4];
				aHIHAT[4] = map(aHIHAT[4], aHIHAT[0], aHIHAT[1], 0, 127);
				aHIHAT[4]   = (aHIHAT[4] * aHIHAT[4]) / 127;
				if (aHIHAT[4] <= 1) {
					aHIHAT[4]   = 1;
				}
				if (aHIHAT[4] > 127) {
					aHIHAT[4] = 127;
				}
				if   (iPiezoValue_A0 < aHIHAT_PEDAL[0]) {
					MIDI.sendNoteOn(aHIHAT[2], aHIHAT[4],   1);
					MIDI.sendNoteOn(aHIHAT[2], 0, 1);
					lcd.clear();
					lcd.print("HIHAT   OPEN");
					lcd.setCursor(0, 1);
					lcd.print(aHIHAT[4]);
					bHihatFlag   = true;
				}
				else if (iPiezoValue_A0 >= aHIHAT_PEDAL[0]) {
					MIDI.sendNoteOn(aHIHAT_CLOSE[2],   aHIHAT[4], 1);
					MIDI.sendNoteOn(aHIHAT_CLOSE[2], 0, 1);
					lcd.clear();
					lcd.print("HIHAT   CLOSE");
					lcd.setCursor(0, 1);
					lcd.print(aHIHAT[4]);
					bHihatFlag   = true;
				}
			}

		// Hi-hat Pedal
			if (iPiezoValue_A0   > aHIHAT_PEDAL[0] && bPedalFlag == false) {
				MIDI.sendNoteOn(aHIHAT_PEDAL[2],   aSETTING[2], 1);  // (note, velocity, channel)
				MIDI.sendNoteOn(aHIHAT_PEDAL[2],   0, 1);
				lcd.clear();
				lcd.print("HIHAT PEDAL");
				lcd.setCursor(0,   1);
				lcd.print(aSETTING[2]);
				bPedalFlag = true;
			}

		//   Kick Drum
			if (iPiezoValue_A3 > aKICK[0] && bKickFlag == false) {
				for   (int i = 0; i < aSETTING[0]; i++) {
					int iPeak_A3 = analogRead(A3);
					delay(1);
					if   (iPeak_A3 > aKICK[4]) {
						aKICK[4] = iPeak_A3;
					}
				}

				aKICK[5]   = aKICK[4];
				aKICK[4] = map(aKICK[4], aKICK[0], aKICK[1], 0, 127);
				aKICK[4]   = (aKICK[4] * aKICK[4]) / 127;
				if (aKICK[4] <= 1) {
					aKICK[4]   = 1;
				}
				if (aKICK[4] > 127) {
					aKICK[4] = 127;
				}
				MIDI.sendNoteOn(aKICK[2],   aKICK[4], 1);
				MIDI.sendNoteOn(aKICK[2], 0, 1);
				lcd.clear();
				lcd.print("KICK");
				lcd.setCursor(0,   1);
				lcd.print(aKICK[4]);
				bKickFlag = true;
			}

//   --- BEGIN 'Code in Progress' --- //
// --- I could be wrong, but this is what   it appears to be --- and out of curiousity what is purpose of this sequence? --   //

			// I=(A0);  // Previous Code
			// -- DOES iSensorValue_A0   need to be declared as an integer?  How does this relate to iPiezoValue_A0?  --   //
			if (iSensorValue_A0 < (aSNARE[5] * (0.01 * aSNARE[3]))) {
				bSnareFlag   = false;
			}
			if (iPiezoValue_A0 <= aHIHAT_PEDAL[0] && iPiezoValue_A2   < (aHIHAT[5] * (0.01 * aHIHAT[3])) && bHihatFlag == true) {
				delay(aSETTING[3]);
				//   iSensorValue_A1 is reading analogRead(A2), but this is aHIHAT_PEDAL (which is analogRead(A2)
				int   iSensorValue_A1 = analogRead(A2);
				if (iSensorValue_A1 < (aHIHAT[5] *   (0.01 * aHIHAT[3]))) {
					bHihatFlag = false;
				}
			}
			if   (iPiezoValue_A0 >= aHIHAT_PEDAL[0] && iPiezoValue_A2 < (aHIHAT[5] *(0.01 * aHIHAT[3]))   && bHihatFlag == true) {
				delay(aSETTING[3]);
				int iSensorValue_A2   = analogRead(A2);
				if (iSensorValue_A2 < (aHIHAT[5] * (0.01 * aHIHAT[3])))   {
					bHihatFlag = false;
				}
			}
			if (iPiezoValue_A3   < (aKICK[5] * (0.01 * aKICK[3])) && bKickFlag == true) {
				delay(aSETTING[3]);
				//   -- Should declared iSensorValue_A3 be iPiezoValue_A3?  iSensorValue_A3 is declared   but not used anywhere??
				int iSensorValue_A3 = analogRead(A3);
				if   (iPiezoValue_A3 < (aKICK[5] * (0.01 * aKICK[3]))) {
				bKickFlag = false;
				}
			}
			if   (iPiezoValue_A0 <= aHIHAT_PEDAL[0] && bPedalFlag == true) {
				bPedalFlag   = false;
			}

// --- END 'Code in Progress' --- //
		}

Hello Drum v2

arduino

Modified: 05/12/2019 by George Brotherston

1/*
2	Drum MIDI Controller
3	Created:  28/06/2017 by Ryo Kosaka as  " HELLO DRUM " Ver.1.0
4	Modified: 05/12/2019 by George Brotherston
5*/
6
7//  Library Includes
8
9//	#include <Arduino.h>		// Arduino Library (automatically  included)
10		// LOW (Line 41)
11		// HIGH (Line 40)
12		// INPUT_PULLUP  (Line 47)
13		// digitalRead() (Line 177)
14		// analogRead() (Line 178)
15	#include  <MIDI.h>           // MIDI Library		- Version: 4.3.1
16		// includes <midi_Namespace.h>
17			//  class MIDI (Line 30)
18		// class method 'begin' (Line 55)
19	#include <LiquidCrystal.h>  // LiquidCrystal	- Version: 1.0.7
20		// lcd object instantiatied (in Variables  section below) from LiquidCrystal class (Line 45)
21
22//	Variables - Declare  and Initialize
23
24	// Variables - Program
25		boolean	bSnareFlag			=  false;
26		boolean	bHihatFlag			= false;
27		boolean	bKickFlag			=  false;
28		boolean	bPedalFlag			= false;
29		boolean	bButtonState		=  true;
30		boolean	bButtonState_set	= true;
31		int		iUPDOWN				= 0;
32		int		iNEXTBACK			=  0;
33
34	//	Arrays - Program
35		// InstrumentSensor[6] = {threshold, sensitivity,  note, flag, velocity, iPeakValue}
36		// 'iPeakValue' and 'velocity' must be  zero for all InstrumentSensor arrays
37		// All 'aHIHAT[]' and 'aHIHAT_CLOSE[]'  array elements should have the same value except for 'note' element.
38			int		aSNARE[6]		=  {150, 950, 38, 3, 0, 0};
39			int		aSNARE_RIM[6]	= {5, 500, 37, 3 , 0, 0};
40			int		aHIHAT[6]		=  {100, 800, 46, 1, 0, 0};     
41			int		aHIHAT_CLOSE[6]	= {100, 800, 42,  1, 0, 0};
42			int		aKICK[6]		= {200, 700, 36, 1, 0, 0};
43		// Instrument_ContinuousController[4]  = {scantime, snare/rim, pedalVelocity , masktime}
44			int		aHIHAT_PEDAL[4]	=  {600, 0, 44, 0};
45		// InstrumentSensor_ParameterValue[4] = {threshold, sensitivity,  note, flag}
46			int		aSETTING[4]		= {4, 500 ,100 ,1};
47
48	//	Libraries
49		//	LiquidCrystal.h
50			//	Constants  (already defined in Library, still in scope?  If not then define below)
51				//	const  int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
52			//	lcd object instantiatiated  from LiquidCrystal class (LiquidCrystal.h Line 45)
53				LiquidCrystal lcd(rs,  en, d4, d5, d6, d7);	//	Associate LCD interface pins to associated Arduino pin  number
54		// MIDI.h
55			//	Initialize the library
56				MIDI_CREATE_DEFAULT_INSTANCE();
57
58//  Program Code
59
60	// Program Execution - Initial (program setup)
61
62		void  setup() {
63			MIDI.begin(10);						// begin (MIDI.h Line 55)
64			lcd.begin(16,  2);					// begin (LiquidCrystal.h Line 62)
65			lcd.print("INITIALIZING...");		//  print (LiquidCrystal.h Line 45)
66			lcd.setCursor(0, 1);				// setCursor  (LiquidCrystal.h Line 82)
67			lcd.print("DRUM MIDI CONTROLLER");
68			pinMode(6,  INPUT_PULLUP);			// pinMode (Arduino.h Line 175); INPUT_PULLUP (Arduino.h Line  47)
69			pinMode(7, INPUT_PULLUP);
70			pinMode(8, INPUT_PULLUP);
71			pinMode(9,  INPUT_PULLUP);
72			pinMode(10, INPUT_PULLUP);
73		}
74
75	// Program  Execution - Steadystate (continuous loop until power is lost)
76
77		void loop()  {
78		// Drum MIDI Controller Circuit
79		// Declare and Initialize Variables
80
81			int		iButton_set		=  digitalRead(6);	// Set Button			// digitalRead() (Arduino.h Line 177)
82			int		iButton_up		=  digitalRead(7);	// Up Button
83			int		iButton_down	= digitalRead(8);	//  Down Button
84			int		iButton_next	= digitalRead(9);	// Next Button
85			int		iButton_back	=  digitalRead(10);	// Back Button
86			int		iPiezoValue_A0	= analogRead(A0);   // Piezo - Snare Head	// analogRead() (Arduino.h Line 178)
87			int		iPiezoValue_A1	=  analogRead(A1);   // Piezo - Snare Rim
88			int		iPiezoValue_A2	= analogRead(A2);   // Hi-hat
89			int		iPiezoValue_A3	= analogRead(A3);   // Kick Drum
90			int		iFSRValue_A4	=  analogRead(A4);   // Hi-hat Pedal
91	
92		// Edit Mode
93
94			int		aUP[4]			=  {5, 50, 1,1};		// {threshold, sensitivity, note, flag}
95			int		aUP_ADVANCE[4]	=  {1, 50, 1,1};		// {scantime, rim/head, pedal velocity, masktime}
96
97			//  Note: aINSTRUMENT[] array was not declared in 'Arrays' above
98			char* aINSTRUMENT[]  = {
99				"SNARE HEAD",  "SNARE RIM", "HIHAT OPEN", "HIHAT CLOSE",  "HIHAT PEDAL", "KICK", "ADVANCED SETTING"
100			};
101
102			// Note:  aSETTING[] array WAS declared in 'Arrays' above
103			char* aSETTING[] = {
104				"THRESHOLD",  "SENSITIVITY", "NOTE", "FLAG"
105			};
106
107			// Note: aSETTING_ADVANCE[]  was not declared in 'Arrays' above
108			char* aSETTING_ADVANCE[] = {
109				"SCAN  TIME", "HEAD / RIM ","PEDAL VELO", "MASK TIME"
110			};
111
112			if  (iUPDOWN < 0) {
113				iUPDOWN = 6;
114			}
115
116			if (iUPDOWN > 6)  {
117				iUPDOWN = 0;
118			}
119
120			if (iNEXTBACK < 0) {
121				iNEXTBACK  = 3;
122			}
123
124			if (iNEXTBACK > 3) {
125				iNEXTBACK = 0;
126			}
127
128		//  Pushbutton EDIT
129			// LOW (Arduino.h Line 41)
130			if (iButton_set ==  LOW && bButtonState == true && bButtonState_set == true) {
131				lcd.clear();
132				lcd.print("EDIT");
133				bButtonState		=  false;
134				bButtonState_set	= false;
135				delay(500);
136			}
137
138			if  (iButton_set == LOW && bButtonState == true && bButtonState_set == false) {
139				lcd.clear();
140            	lcd.print("EDIT DONE");
141            	bButtonState		= false;
142            	bButtonState_set	= true;
143            	delay(500);
144			}
145
146			if  (iButton_up == LOW && bButtonState == true && bButtonState_set == false) {
147				switch  (iUPDOWN) {
148					case 0:
149					aSNARE[iNEXTBACK] = aSNARE[iNEXTBACK]  + aUP[iNEXTBACK];
150					break;
151
152					case 1:
153					aSNARE_RIM[iNEXTBACK]  = aSNARE_RIM[iNEXTBACK] + aUP[iNEXTBACK];
154					break;
155
156					case  2:
157					switch (iNEXTBACK) {
158						case 2:
159						aHIHAT[iNEXTBACK]  = aHIHAT[iNEXTBACK] + aUP[iNEXTBACK];
160						break;
161
162						default:
163						aHIHAT_CLOSE[iNEXTBACK]  = aHIHAT_CLOSE[iNEXTBACK] + aUP[iNEXTBACK];
164						aHIHAT[iNEXTBACK] = aHIHAT[iNEXTBACK]  + aUP[iNEXTBACK];
165					}
166					break;
167
168					case 3:
169					switch  (iNEXTBACK) {
170						case 2:
171						aHIHAT_CLOSE[iNEXTBACK] = aHIHAT_CLOSE[iNEXTBACK]  + aUP[iNEXTBACK];
172						break;
173						
174						default:
175						aHIHAT_CLOSE[iNEXTBACK]  = aHIHAT_CLOSE[iNEXTBACK] + aUP[iNEXTBACK];
176						aHIHAT[iNEXTBACK] = aHIHAT[iNEXTBACK]  + aUP[iNEXTBACK];
177					}
178					break;
179
180					case 4:
181					switch  (iNEXTBACK) {
182						case 0:
183						aHIHAT_PEDAL[iNEXTBACK] = aHIHAT_PEDAL[iNEXTBACK]  + aUP[iNEXTBACK];
184						break;
185						
186						case 2:
187						aHIHAT_PEDAL[iNEXTBACK]  = aHIHAT_PEDAL[iNEXTBACK] + aUP[iNEXTBACK];
188						break;
189					}
190					break;
191
192					case  5:
193					aKICK[iNEXTBACK] = aKICK[iNEXTBACK] + aUP[iNEXTBACK];
194					break;
195
196					case  6:
197					aSETTING[iNEXTBACK] = aSETTING[iNEXTBACK] + aUP_ADVANCE[iNEXTBACK];
198					break;
199				}
200				bButtonState  = false;
201				delay(30);
202			}
203
204			if (iButton_down == LOW &&  bButtonState == true && bButtonState_set == false) {
205
206				switch (iUPDOWN)  {
207					case 0:
208					aSNARE[iNEXTBACK] = aSNARE[iNEXTBACK] - aUP[iNEXTBACK];
209					break;
210
211					case  1:
212					aSNARE_RIM[iNEXTBACK] = aSNARE_RIM[iNEXTBACK] - aUP[iNEXTBACK];
213					break;
214
215					case  2:
216					switch (iNEXTBACK) {
217						case 2:
218						aHIHAT[iNEXTBACK]  = aHIHAT[iNEXTBACK] - aUP[iNEXTBACK];
219						break;
220
221						default:
222						aHIHAT_CLOSE[iNEXTBACK]  = aHIHAT_CLOSE[iNEXTBACK] - aUP[iNEXTBACK];
223						aHIHAT[iNEXTBACK] = aHIHAT[iNEXTBACK]  - aUP[iNEXTBACK];
224					}
225					break;
226
227					case 3:
228					switch  (iNEXTBACK) {
229						case 2:
230						aHIHAT_CLOSE[iNEXTBACK] = aHIHAT_CLOSE[iNEXTBACK]  - aUP[iNEXTBACK];
231						break;
232
233						default:
234						aHIHAT_CLOSE[iNEXTBACK]  = aHIHAT_CLOSE[iNEXTBACK] - aUP[iNEXTBACK];
235						aHIHAT[iNEXTBACK] = aHIHAT[iNEXTBACK]  - aUP[iNEXTBACK];
236					}
237					break;
238
239					case 4:
240					switch  (iNEXTBACK) {
241						case 0:
242						aHIHAT_PEDAL[iNEXTBACK] = aHIHAT_PEDAL[iNEXTBACK]  - aUP[iNEXTBACK];
243						break;
244
245						case 2:
246						aHIHAT_PEDAL[iNEXTBACK]  = aHIHAT_PEDAL[iNEXTBACK] - aUP[iNEXTBACK];
247						break;
248					}
249					break;
250
251					case  5:
252					aKICK[iNEXTBACK] = aKICK[iNEXTBACK] - aUP[iNEXTBACK];
253					break;
254
255					case  6:
256					aSETTING[iNEXTBACK] = aSETTING[iNEXTBACK] - aUP_ADVANCE[iNEXTBACK];
257					break;
258				}
259				bButtonState  = false;
260				delay(30);
261			}
262
263		// Pushbuttons UP; DOWN; NEXT;  BACK
264			if (iButton_up == LOW && bButtonState == true && bButtonState_set  == true) {
265				iUPDOWN = ++iUPDOWN;
266				bButtonState = false;
267				delay(30);
268			}
269
270			if  (iButton_down == LOW && bButtonState == true && bButtonState_set == true) {
271				iUPDOWN  = --iUPDOWN;
272				bButtonState = false;
273				delay(30);
274			}
275
276			if  (iButton_next == LOW && bButtonState == true && bButtonState_set == true) {
277				iNEXTBACK  = ++iNEXTBACK;
278				bButtonState = false;
279				delay(30);
280			}
281
282			if  (iButton_back == LOW && bButtonState == true && bButtonState_set == true) {
283				iNEXTBACK  = --iNEXTBACK;
284				bButtonState = false;
285				delay(30);
286			}
287
288			if  (bButtonState == false && iButton_up == HIGH && iButton_down == HIGH && iButton_next  == HIGH && iButton_back == HIGH && iButton_set == HIGH) {
289				// HIGH is  defined in Arduino.h Line 40
290
291				switch (iUPDOWN) {
292
293					case  0:
294					lcd.clear();
295					lcd.print(aINSTRUMENT[iUPDOWN]);
296					lcd.setCursor(0,  1);
297					lcd.print(aSETTING[iNEXTBACK]);
298					lcd.setCursor(12,  1);
299					lcd.print(aSNARE[iNEXTBACK]);
300					break;
301
302					case  1:
303					lcd.clear();
304					lcd.print(aINSTRUMENT[iUPDOWN]);
305					lcd.setCursor(0,  1);
306					lcd.print(aSETTING[iNEXTBACK]);
307					lcd.setCursor(12,  1);
308					lcd.print(aSNARE_RIM[iNEXTBACK]);
309					break;
310
311					case  2:
312					lcd.clear();
313					lcd.print(aINSTRUMENT[iUPDOWN]);
314					lcd.setCursor(0,  1);
315					lcd.print(aSETTING[iNEXTBACK]);
316					lcd.setCursor(12,  1);
317					lcd.print(aHIHAT[iNEXTBACK]);
318					break;
319
320					case  3:
321					lcd.clear();lcd.print(aINSTRUMENT[iUPDOWN]);
322					lcd.setCursor(0,  1);
323					lcd.print(aSETTING[iNEXTBACK]);
324					lcd.setCursor(12,  1);
325					lcd.print(aHIHAT_CLOSE[iNEXTBACK]);
326					break;
327
328					case  4:
329					lcd.clear();
330					lcd.print(aINSTRUMENT[iUPDOWN]);
331					lcd.setCursor(0,  1);
332					lcd.print(aSETTING[iNEXTBACK]);
333					lcd.setCursor(12,  1);
334					lcd.print(aHIHAT_PEDAL[iNEXTBACK]);
335					break;
336
337					case  5:
338					lcd.clear();
339					lcd.print(aINSTRUMENT[iUPDOWN]);
340					lcd.setCursor(0,  1);
341					lcd.print(aSETTING[iNEXTBACK]);
342					lcd.setCursor(12,  1);
343					lcd.print(aKICK[iNEXTBACK]);
344					break;
345
346					case  6:
347					lcd.clear();
348					lcd.print(aINSTRUMENT[iUPDOWN]);
349					lcd.setCursor(0,  1);
350					lcd.print(aSETTING_ADVANCE[iNEXTBACK]);
351					lcd.setCursor(12,  1);
352					lcd.print(aSETTING[iNEXTBACK]);
353					break;
354				}
355
356				bButtonState  = true;
357			}
358
359		// Instrument Sensors
360
361			// Snare Drum
362			if  (iPiezoValue_A0 > aSNARE[0] && bSnareFlag == false) {
363
364				for (int i  = 0; i < aSETTING[0]; i++) {
365					int iPeak_A0 = analogRead(A0);
366					int  iPeak_A1 = analogRead(A1);
367					delay(1);
368					if (iPeak_A0 > aSNARE[4])  {
369						aSNARE[4] = iPeak_A0;
370					}
371					if (iPeak_A1  > aSNARE_RIM[4]) {
372						aSNARE_RIM[4] = iPeak_A1;
373					}
374				}
375				aSNARE[5]  = aSNARE[4];
376				aSNARE_RIM[5] = aSNARE_RIM[4];
377				aSNARE[4] = map(aSNARE[4],  aSNARE[0], aSNARE[1], 0, 127);
378				aSNARE_RIM[4] = map(aSNARE_RIM[4], aSNARE_RIM[0],  aSNARE_RIM[1], 0, 127);
379				aSNARE[4] = (aSNARE[4] *  aSNARE[4]) / 127; //  Curve setting
380
381			//aSNARE_RIM[4] = (aSNARE_RIM[4] * aSNARE_RIM[4]) / 127;
382				if  (aSNARE[4] <= 1) {
383					aSNARE[4] = 1;
384				}
385				if (aSNARE[4]  > 127) {
386					aSNARE[4] = 127;
387				}
388				if (aSNARE_RIM[4]  <= 0) {
389					aSNARE_RIM[4] = 0;
390				}
391				if (aSNARE_RIM[4]  > 127) {
392					aSNARE_RIM[4] = 127;
393				}
394				if (aSNARE_RIM[5]  > aSETTING[1]) {
395					MIDI.sendNoteOn(aSNARE_RIM[2], aSNARE_RIM[4], 1);   //(note, velocity, channel)
396					MIDI.sendNoteOn(aSNARE_RIM[2], 0, 1);
397					lcd.clear();
398					lcd.print("SNARE  RIM");
399					lcd.setCursor(0, 1);
400					lcd.print(aSNARE_RIM[4]);
401					bSnareFlag  = true;
402				}
403
404			//else if (aSNARE[5] > aSNARE_RIM[5])
405				else  {
406					MIDI.sendNoteOn(aSNARE[2], aSNARE[4], 1);   //(note, velocity, channel)
407					MIDI.sendNoteOn(aSNARE[2],  0, 1);
408					lcd.clear();
409					lcd.print("SNARE HEAD");
410					lcd.setCursor(0,  1);
411					lcd.print(aSNARE[4]);
412				//lcd.setCursor(10, 1);
413				//lcd.print(aSNARE_RIM[5]);
414					bSnareFlag  = true;
415				}
416			}
417
418		// Hi-Hat Cymbal
419			if (iPiezoValue_A2  > aHIHAT[0] && bHihatFlag == false) {
420				for (int i = 0; i < aSETTING[0];  i++) {
421					int iPeak_A2 = analogRead(A2);
422					delay(1);
423					if  (iPeak_A2 > aHIHAT[4]) {
424						aHIHAT[4] = iPeak_A2;
425					}
426				}
427				aHIHAT[5]  = aHIHAT[4];
428				aHIHAT[4] = map(aHIHAT[4], aHIHAT[0], aHIHAT[1], 0, 127);
429				aHIHAT[4]  = (aHIHAT[4] * aHIHAT[4]) / 127;
430				if (aHIHAT[4] <= 1) {
431					aHIHAT[4]  = 1;
432				}
433				if (aHIHAT[4] > 127) {
434					aHIHAT[4] = 127;
435				}
436				if  (iPiezoValue_A0 < aHIHAT_PEDAL[0]) {
437					MIDI.sendNoteOn(aHIHAT[2], aHIHAT[4],  1);
438					MIDI.sendNoteOn(aHIHAT[2], 0, 1);
439					lcd.clear();
440					lcd.print("HIHAT  OPEN");
441					lcd.setCursor(0, 1);
442					lcd.print(aHIHAT[4]);
443					bHihatFlag  = true;
444				}
445				else if (iPiezoValue_A0 >= aHIHAT_PEDAL[0]) {
446					MIDI.sendNoteOn(aHIHAT_CLOSE[2],  aHIHAT[4], 1);
447					MIDI.sendNoteOn(aHIHAT_CLOSE[2], 0, 1);
448					lcd.clear();
449					lcd.print("HIHAT  CLOSE");
450					lcd.setCursor(0, 1);
451					lcd.print(aHIHAT[4]);
452					bHihatFlag  = true;
453				}
454			}
455
456		// Hi-hat Pedal
457			if (iPiezoValue_A0  > aHIHAT_PEDAL[0] && bPedalFlag == false) {
458				MIDI.sendNoteOn(aHIHAT_PEDAL[2],  aSETTING[2], 1);  // (note, velocity, channel)
459				MIDI.sendNoteOn(aHIHAT_PEDAL[2],  0, 1);
460				lcd.clear();
461				lcd.print("HIHAT PEDAL");
462				lcd.setCursor(0,  1);
463				lcd.print(aSETTING[2]);
464				bPedalFlag = true;
465			}
466
467		//  Kick Drum
468			if (iPiezoValue_A3 > aKICK[0] && bKickFlag == false) {
469				for  (int i = 0; i < aSETTING[0]; i++) {
470					int iPeak_A3 = analogRead(A3);
471					delay(1);
472					if  (iPeak_A3 > aKICK[4]) {
473						aKICK[4] = iPeak_A3;
474					}
475				}
476
477				aKICK[5]  = aKICK[4];
478				aKICK[4] = map(aKICK[4], aKICK[0], aKICK[1], 0, 127);
479				aKICK[4]  = (aKICK[4] * aKICK[4]) / 127;
480				if (aKICK[4] <= 1) {
481					aKICK[4]  = 1;
482				}
483				if (aKICK[4] > 127) {
484					aKICK[4] = 127;
485				}
486				MIDI.sendNoteOn(aKICK[2],  aKICK[4], 1);
487				MIDI.sendNoteOn(aKICK[2], 0, 1);
488				lcd.clear();
489				lcd.print("KICK");
490				lcd.setCursor(0,  1);
491				lcd.print(aKICK[4]);
492				bKickFlag = true;
493			}
494
495//  --- BEGIN 'Code in Progress' --- //
496// --- I could be wrong, but this is what  it appears to be --- and out of curiousity what is purpose of this sequence? --  //
497
498			// I=(A0);  // Previous Code
499			// -- DOES iSensorValue_A0  need to be declared as an integer?  How does this relate to iPiezoValue_A0?  --  //
500			if (iSensorValue_A0 < (aSNARE[5] * (0.01 * aSNARE[3]))) {
501				bSnareFlag  = false;
502			}
503			if (iPiezoValue_A0 <= aHIHAT_PEDAL[0] && iPiezoValue_A2  < (aHIHAT[5] * (0.01 * aHIHAT[3])) && bHihatFlag == true) {
504				delay(aSETTING[3]);
505				//  iSensorValue_A1 is reading analogRead(A2), but this is aHIHAT_PEDAL (which is analogRead(A2)
506				int  iSensorValue_A1 = analogRead(A2);
507				if (iSensorValue_A1 < (aHIHAT[5] *  (0.01 * aHIHAT[3]))) {
508					bHihatFlag = false;
509				}
510			}
511			if  (iPiezoValue_A0 >= aHIHAT_PEDAL[0] && iPiezoValue_A2 < (aHIHAT[5] *(0.01 * aHIHAT[3]))  && bHihatFlag == true) {
512				delay(aSETTING[3]);
513				int iSensorValue_A2  = analogRead(A2);
514				if (iSensorValue_A2 < (aHIHAT[5] * (0.01 * aHIHAT[3])))  {
515					bHihatFlag = false;
516				}
517			}
518			if (iPiezoValue_A3  < (aKICK[5] * (0.01 * aKICK[3])) && bKickFlag == true) {
519				delay(aSETTING[3]);
520				//  -- Should declared iSensorValue_A3 be iPiezoValue_A3?  iSensorValue_A3 is declared  but not used anywhere??
521				int iSensorValue_A3 = analogRead(A3);
522				if  (iPiezoValue_A3 < (aKICK[5] * (0.01 * aKICK[3]))) {
523				bKickFlag = false;
524				}
525			}
526			if  (iPiezoValue_A0 <= aHIHAT_PEDAL[0] && bPedalFlag == true) {
527				bPedalFlag  = false;
528			}
529
530// --- END 'Code in Progress' --- //
531		}

/*
	Drum MIDI Controller
	Created:  28/06/2017 by Ryo Kosaka as  " HELLO DRUM " Ver.1.0
	Modified: 05/12/2019 by George Brotherston
*/

//  Library Includes

//	#include <Arduino.h>		// Arduino Library (automatically  included)
		// LOW (Line 41)
		// HIGH (Line 40)
		// INPUT_PULLUP  (Line 47)
		// digitalRead() (Line 177)
		// analogRead() (Line 178)
	#include  <MIDI.h>           // MIDI Library		- Version: 4.3.1
		// includes <midi_Namespace.h>
			//  class MIDI (Line 30)
		// class method 'begin' (Line 55)
	#include <LiquidCrystal.h>  // LiquidCrystal	- Version: 1.0.7
		// lcd object instantiatied (in Variables  section below) from LiquidCrystal class (Line 45)

//	Variables - Declare  and Initialize

	// Variables - Program
		boolean	bSnareFlag			=  false;
		boolean	bHihatFlag			= false;
		boolean	bKickFlag			=  false;
		boolean	bPedalFlag			= false;
		boolean	bButtonState		=  true;
		boolean	bButtonState_set	= true;
		int		iUPDOWN				= 0;
		int		iNEXTBACK			=  0;

	//	Arrays - Program
		// InstrumentSensor[6] = {threshold, sensitivity,  note, flag, velocity, iPeakValue}
		// 'iPeakValue' and 'velocity' must be  zero for all InstrumentSensor arrays
		// All 'aHIHAT[]' and 'aHIHAT_CLOSE[]'  array elements should have the same value except for 'note' element.
			int		aSNARE[6]		=  {150, 950, 38, 3, 0, 0};
			int		aSNARE_RIM[6]	= {5, 500, 37, 3 , 0, 0};
			int		aHIHAT[6]		=  {100, 800, 46, 1, 0, 0};     
			int		aHIHAT_CLOSE[6]	= {100, 800, 42,  1, 0, 0};
			int		aKICK[6]		= {200, 700, 36, 1, 0, 0};
		// Instrument_ContinuousController[4]  = {scantime, snare/rim, pedalVelocity , masktime}
			int		aHIHAT_PEDAL[4]	=  {600, 0, 44, 0};
		// InstrumentSensor_ParameterValue[4] = {threshold, sensitivity,  note, flag}
			int		aSETTING[4]		= {4, 500 ,100 ,1};

	//	Libraries
		//	LiquidCrystal.h
			//	Constants  (already defined in Library, still in scope?  If not then define below)
				//	const  int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
			//	lcd object instantiatiated  from LiquidCrystal class (LiquidCrystal.h Line 45)
				LiquidCrystal lcd(rs,  en, d4, d5, d6, d7);	//	Associate LCD interface pins to associated Arduino pin  number
		// MIDI.h
			//	Initialize the library
				MIDI_CREATE_DEFAULT_INSTANCE();

//  Program Code

	// Program Execution - Initial (program setup)

		void  setup() {
			MIDI.begin(10);						// begin (MIDI.h Line 55)
			lcd.begin(16,  2);					// begin (LiquidCrystal.h Line 62)
			lcd.print("INITIALIZING...");		//  print (LiquidCrystal.h Line 45)
			lcd.setCursor(0, 1);				// setCursor  (LiquidCrystal.h Line 82)
			lcd.print("DRUM MIDI CONTROLLER");
			pinMode(6,  INPUT_PULLUP);			// pinMode (Arduino.h Line 175); INPUT_PULLUP (Arduino.h Line  47)
			pinMode(7, INPUT_PULLUP);
			pinMode(8, INPUT_PULLUP);
			pinMode(9,  INPUT_PULLUP);
			pinMode(10, INPUT_PULLUP);
		}

	// Program  Execution - Steadystate (continuous loop until power is lost)

		void loop()  {
		// Drum MIDI Controller Circuit
		// Declare and Initialize Variables

			int		iButton_set		=  digitalRead(6);	// Set Button			// digitalRead() (Arduino.h Line 177)
			int		iButton_up		=  digitalRead(7);	// Up Button
			int		iButton_down	= digitalRead(8);	//  Down Button
			int		iButton_next	= digitalRead(9);	// Next Button
			int		iButton_back	=  digitalRead(10);	// Back Button
			int		iPiezoValue_A0	= analogRead(A0);   // Piezo - Snare Head	// analogRead() (Arduino.h Line 178)
			int		iPiezoValue_A1	=  analogRead(A1);   // Piezo - Snare Rim
			int		iPiezoValue_A2	= analogRead(A2);   // Hi-hat
			int		iPiezoValue_A3	= analogRead(A3);   // Kick Drum
			int		iFSRValue_A4	=  analogRead(A4);   // Hi-hat Pedal
	
		// Edit Mode

			int		aUP[4]			=  {5, 50, 1,1};		// {threshold, sensitivity, note, flag}
			int		aUP_ADVANCE[4]	=  {1, 50, 1,1};		// {scantime, rim/head, pedal velocity, masktime}

			//  Note: aINSTRUMENT[] array was not declared in 'Arrays' above
			char* aINSTRUMENT[]  = {
				"SNARE HEAD",  "SNARE RIM", "HIHAT OPEN", "HIHAT CLOSE",  "HIHAT PEDAL", "KICK", "ADVANCED SETTING"
			};

			// Note:  aSETTING[] array WAS declared in 'Arrays' above
			char* aSETTING[] = {
				"THRESHOLD",  "SENSITIVITY", "NOTE", "FLAG"
			};

			// Note: aSETTING_ADVANCE[]  was not declared in 'Arrays' above
			char* aSETTING_ADVANCE[] = {
				"SCAN  TIME", "HEAD / RIM ","PEDAL VELO", "MASK TIME"
			};

			if  (iUPDOWN < 0) {
				iUPDOWN = 6;
			}

			if (iUPDOWN > 6)  {
				iUPDOWN = 0;
			}

			if (iNEXTBACK < 0) {
				iNEXTBACK  = 3;
			}

			if (iNEXTBACK > 3) {
				iNEXTBACK = 0;
			}

		//  Pushbutton EDIT
			// LOW (Arduino.h Line 41)
			if (iButton_set ==  LOW && bButtonState == true && bButtonState_set == true) {
				lcd.clear();
				lcd.print("EDIT");
				bButtonState		=  false;
				bButtonState_set	= false;
				delay(500);
			}

			if  (iButton_set == LOW && bButtonState == true && bButtonState_set == false) {
				lcd.clear();
            	lcd.print("EDIT DONE");
            	bButtonState		= false;
            	bButtonState_set	= true;
            	delay(500);
			}

			if  (iButton_up == LOW && bButtonState == true && bButtonState_set == false) {
				switch  (iUPDOWN) {
					case 0:
					aSNARE[iNEXTBACK] = aSNARE[iNEXTBACK]  + aUP[iNEXTBACK];
					break;

					case 1:
					aSNARE_RIM[iNEXTBACK]  = aSNARE_RIM[iNEXTBACK] + aUP[iNEXTBACK];
					break;

					case  2:
					switch (iNEXTBACK) {
						case 2:
						aHIHAT[iNEXTBACK]  = aHIHAT[iNEXTBACK] + aUP[iNEXTBACK];
						break;

						default:
						aHIHAT_CLOSE[iNEXTBACK]  = aHIHAT_CLOSE[iNEXTBACK] + aUP[iNEXTBACK];
						aHIHAT[iNEXTBACK] = aHIHAT[iNEXTBACK]  + aUP[iNEXTBACK];
					}
					break;

					case 3:
					switch  (iNEXTBACK) {
						case 2:
						aHIHAT_CLOSE[iNEXTBACK] = aHIHAT_CLOSE[iNEXTBACK]  + aUP[iNEXTBACK];
						break;
						
						default:
						aHIHAT_CLOSE[iNEXTBACK]  = aHIHAT_CLOSE[iNEXTBACK] + aUP[iNEXTBACK];
						aHIHAT[iNEXTBACK] = aHIHAT[iNEXTBACK]  + aUP[iNEXTBACK];
					}
					break;

					case 4:
					switch  (iNEXTBACK) {
						case 0:
						aHIHAT_PEDAL[iNEXTBACK] = aHIHAT_PEDAL[iNEXTBACK]  + aUP[iNEXTBACK];
						break;
						
						case 2:
						aHIHAT_PEDAL[iNEXTBACK]  = aHIHAT_PEDAL[iNEXTBACK] + aUP[iNEXTBACK];
						break;
					}
					break;

					case  5:
					aKICK[iNEXTBACK] = aKICK[iNEXTBACK] + aUP[iNEXTBACK];
					break;

					case  6:
					aSETTING[iNEXTBACK] = aSETTING[iNEXTBACK] + aUP_ADVANCE[iNEXTBACK];
					break;
				}
				bButtonState  = false;
				delay(30);
			}

			if (iButton_down == LOW &&  bButtonState == true && bButtonState_set == false) {

				switch (iUPDOWN)  {
					case 0:
					aSNARE[iNEXTBACK] = aSNARE[iNEXTBACK] - aUP[iNEXTBACK];
					break;

					case  1:
					aSNARE_RIM[iNEXTBACK] = aSNARE_RIM[iNEXTBACK] - aUP[iNEXTBACK];
					break;

					case  2:
					switch (iNEXTBACK) {
						case 2:
						aHIHAT[iNEXTBACK]  = aHIHAT[iNEXTBACK] - aUP[iNEXTBACK];
						break;

						default:
						aHIHAT_CLOSE[iNEXTBACK]  = aHIHAT_CLOSE[iNEXTBACK] - aUP[iNEXTBACK];
						aHIHAT[iNEXTBACK] = aHIHAT[iNEXTBACK]  - aUP[iNEXTBACK];
					}
					break;

					case 3:
					switch  (iNEXTBACK) {
						case 2:
						aHIHAT_CLOSE[iNEXTBACK] = aHIHAT_CLOSE[iNEXTBACK]  - aUP[iNEXTBACK];
						break;

						default:
						aHIHAT_CLOSE[iNEXTBACK]  = aHIHAT_CLOSE[iNEXTBACK] - aUP[iNEXTBACK];
						aHIHAT[iNEXTBACK] = aHIHAT[iNEXTBACK]  - aUP[iNEXTBACK];
					}
					break;

					case 4:
					switch  (iNEXTBACK) {
						case 0:
						aHIHAT_PEDAL[iNEXTBACK] = aHIHAT_PEDAL[iNEXTBACK]  - aUP[iNEXTBACK];
						break;

						case 2:
						aHIHAT_PEDAL[iNEXTBACK]  = aHIHAT_PEDAL[iNEXTBACK] - aUP[iNEXTBACK];
						break;
					}
					break;

					case  5:
					aKICK[iNEXTBACK] = aKICK[iNEXTBACK] - aUP[iNEXTBACK];
					break;

					case  6:
					aSETTING[iNEXTBACK] = aSETTING[iNEXTBACK] - aUP_ADVANCE[iNEXTBACK];
					break;
				}
				bButtonState  = false;
				delay(30);
			}

		// Pushbuttons UP; DOWN; NEXT;  BACK
			if (iButton_up == LOW && bButtonState == true && bButtonState_set  == true) {
				iUPDOWN = ++iUPDOWN;
				bButtonState = false;
				delay(30);
			}

			if  (iButton_down == LOW && bButtonState == true && bButtonState_set == true) {
				iUPDOWN  = --iUPDOWN;
				bButtonState = false;
				delay(30);
			}

			if  (iButton_next == LOW && bButtonState == true && bButtonState_set == true) {
				iNEXTBACK  = ++iNEXTBACK;
				bButtonState = false;
				delay(30);
			}

			if  (iButton_back == LOW && bButtonState == true && bButtonState_set == true) {
				iNEXTBACK  = --iNEXTBACK;
				bButtonState = false;
				delay(30);
			}

			if  (bButtonState == false && iButton_up == HIGH && iButton_down == HIGH && iButton_next  == HIGH && iButton_back == HIGH && iButton_set == HIGH) {
				// HIGH is  defined in Arduino.h Line 40

				switch (iUPDOWN) {

					case  0:
					lcd.clear();
					lcd.print(aINSTRUMENT[iUPDOWN]);
					lcd.setCursor(0,  1);
					lcd.print(aSETTING[iNEXTBACK]);
					lcd.setCursor(12,  1);
					lcd.print(aSNARE[iNEXTBACK]);
					break;

					case  1:
					lcd.clear();
					lcd.print(aINSTRUMENT[iUPDOWN]);
					lcd.setCursor(0,  1);
					lcd.print(aSETTING[iNEXTBACK]);
					lcd.setCursor(12,  1);
					lcd.print(aSNARE_RIM[iNEXTBACK]);
					break;

					case  2:
					lcd.clear();
					lcd.print(aINSTRUMENT[iUPDOWN]);
					lcd.setCursor(0,  1);
					lcd.print(aSETTING[iNEXTBACK]);
					lcd.setCursor(12,  1);
					lcd.print(aHIHAT[iNEXTBACK]);
					break;

					case  3:
					lcd.clear();lcd.print(aINSTRUMENT[iUPDOWN]);
					lcd.setCursor(0,  1);
					lcd.print(aSETTING[iNEXTBACK]);
					lcd.setCursor(12,  1);
					lcd.print(aHIHAT_CLOSE[iNEXTBACK]);
					break;

					case  4:
					lcd.clear();
					lcd.print(aINSTRUMENT[iUPDOWN]);
					lcd.setCursor(0,  1);
					lcd.print(aSETTING[iNEXTBACK]);
					lcd.setCursor(12,  1);
					lcd.print(aHIHAT_PEDAL[iNEXTBACK]);
					break;

					case  5:
					lcd.clear();
					lcd.print(aINSTRUMENT[iUPDOWN]);
					lcd.setCursor(0,  1);
					lcd.print(aSETTING[iNEXTBACK]);
					lcd.setCursor(12,  1);
					lcd.print(aKICK[iNEXTBACK]);
					break;

					case  6:
					lcd.clear();
					lcd.print(aINSTRUMENT[iUPDOWN]);
					lcd.setCursor(0,  1);
					lcd.print(aSETTING_ADVANCE[iNEXTBACK]);
					lcd.setCursor(12,  1);
					lcd.print(aSETTING[iNEXTBACK]);
					break;
				}

				bButtonState  = true;
			}

		// Instrument Sensors

			// Snare Drum
			if  (iPiezoValue_A0 > aSNARE[0] && bSnareFlag == false) {

				for (int i  = 0; i < aSETTING[0]; i++) {
					int iPeak_A0 = analogRead(A0);
					int  iPeak_A1 = analogRead(A1);
					delay(1);
					if (iPeak_A0 > aSNARE[4])  {
						aSNARE[4] = iPeak_A0;
					}
					if (iPeak_A1  > aSNARE_RIM[4]) {
						aSNARE_RIM[4] = iPeak_A1;
					}
				}
				aSNARE[5]  = aSNARE[4];
				aSNARE_RIM[5] = aSNARE_RIM[4];
				aSNARE[4] = map(aSNARE[4],  aSNARE[0], aSNARE[1], 0, 127);
				aSNARE_RIM[4] = map(aSNARE_RIM[4], aSNARE_RIM[0],  aSNARE_RIM[1], 0, 127);
				aSNARE[4] = (aSNARE[4] *  aSNARE[4]) / 127; //  Curve setting

			//aSNARE_RIM[4] = (aSNARE_RIM[4] * aSNARE_RIM[4]) / 127;
				if  (aSNARE[4] <= 1) {
					aSNARE[4] = 1;
				}
				if (aSNARE[4]  > 127) {
					aSNARE[4] = 127;
				}
				if (aSNARE_RIM[4]  <= 0) {
					aSNARE_RIM[4] = 0;
				}
				if (aSNARE_RIM[4]  > 127) {
					aSNARE_RIM[4] = 127;
				}
				if (aSNARE_RIM[5]  > aSETTING[1]) {
					MIDI.sendNoteOn(aSNARE_RIM[2], aSNARE_RIM[4], 1);   //(note, velocity, channel)
					MIDI.sendNoteOn(aSNARE_RIM[2], 0, 1);
					lcd.clear();
					lcd.print("SNARE  RIM");
					lcd.setCursor(0, 1);
					lcd.print(aSNARE_RIM[4]);
					bSnareFlag  = true;
				}

			//else if (aSNARE[5] > aSNARE_RIM[5])
				else  {
					MIDI.sendNoteOn(aSNARE[2], aSNARE[4], 1);   //(note, velocity, channel)
					MIDI.sendNoteOn(aSNARE[2],  0, 1);
					lcd.clear();
					lcd.print("SNARE HEAD");
					lcd.setCursor(0,  1);
					lcd.print(aSNARE[4]);
				//lcd.setCursor(10, 1);
				//lcd.print(aSNARE_RIM[5]);
					bSnareFlag  = true;
				}
			}

		// Hi-Hat Cymbal
			if (iPiezoValue_A2  > aHIHAT[0] && bHihatFlag == false) {
				for (int i = 0; i < aSETTING[0];  i++) {
					int iPeak_A2 = analogRead(A2);
					delay(1);
					if  (iPeak_A2 > aHIHAT[4]) {
						aHIHAT[4] = iPeak_A2;
					}
				}
				aHIHAT[5]  = aHIHAT[4];
				aHIHAT[4] = map(aHIHAT[4], aHIHAT[0], aHIHAT[1], 0, 127);
				aHIHAT[4]  = (aHIHAT[4] * aHIHAT[4]) / 127;
				if (aHIHAT[4] <= 1) {
					aHIHAT[4]  = 1;
				}
				if (aHIHAT[4] > 127) {
					aHIHAT[4] = 127;
				}
				if  (iPiezoValue_A0 < aHIHAT_PEDAL[0]) {
					MIDI.sendNoteOn(aHIHAT[2], aHIHAT[4],  1);
					MIDI.sendNoteOn(aHIHAT[2], 0, 1);
					lcd.clear();
					lcd.print("HIHAT  OPEN");
					lcd.setCursor(0, 1);
					lcd.print(aHIHAT[4]);
					bHihatFlag  = true;
				}
				else if (iPiezoValue_A0 >= aHIHAT_PEDAL[0]) {
					MIDI.sendNoteOn(aHIHAT_CLOSE[2],  aHIHAT[4], 1);
					MIDI.sendNoteOn(aHIHAT_CLOSE[2], 0, 1);
					lcd.clear();
					lcd.print("HIHAT  CLOSE");
					lcd.setCursor(0, 1);
					lcd.print(aHIHAT[4]);
					bHihatFlag  = true;
				}
			}

		// Hi-hat Pedal
			if (iPiezoValue_A0  > aHIHAT_PEDAL[0] && bPedalFlag == false) {
				MIDI.sendNoteOn(aHIHAT_PEDAL[2],  aSETTING[2], 1);  // (note, velocity, channel)
				MIDI.sendNoteOn(aHIHAT_PEDAL[2],  0, 1);
				lcd.clear();
				lcd.print("HIHAT PEDAL");
				lcd.setCursor(0,  1);
				lcd.print(aSETTING[2]);
				bPedalFlag = true;
			}

		//  Kick Drum
			if (iPiezoValue_A3 > aKICK[0] && bKickFlag == false) {
				for  (int i = 0; i < aSETTING[0]; i++) {
					int iPeak_A3 = analogRead(A3);
					delay(1);
					if  (iPeak_A3 > aKICK[4]) {
						aKICK[4] = iPeak_A3;
					}
				}

				aKICK[5]  = aKICK[4];
				aKICK[4] = map(aKICK[4], aKICK[0], aKICK[1], 0, 127);
				aKICK[4]  = (aKICK[4] * aKICK[4]) / 127;
				if (aKICK[4] <= 1) {
					aKICK[4]  = 1;
				}
				if (aKICK[4] > 127) {
					aKICK[4] = 127;
				}
				MIDI.sendNoteOn(aKICK[2],  aKICK[4], 1);
				MIDI.sendNoteOn(aKICK[2], 0, 1);
				lcd.clear();
				lcd.print("KICK");
				lcd.setCursor(0,  1);
				lcd.print(aKICK[4]);
				bKickFlag = true;
			}

//  --- BEGIN 'Code in Progress' --- //
// --- I could be wrong, but this is what  it appears to be --- and out of curiousity what is purpose of this sequence? --  //

			// I=(A0);  // Previous Code
			// -- DOES iSensorValue_A0  need to be declared as an integer?  How does this relate to iPiezoValue_A0?  --  //
			if (iSensorValue_A0 < (aSNARE[5] * (0.01 * aSNARE[3]))) {
				bSnareFlag  = false;
			}
			if (iPiezoValue_A0 <= aHIHAT_PEDAL[0] && iPiezoValue_A2  < (aHIHAT[5] * (0.01 * aHIHAT[3])) && bHihatFlag == true) {
				delay(aSETTING[3]);
				//  iSensorValue_A1 is reading analogRead(A2), but this is aHIHAT_PEDAL (which is analogRead(A2)
				int  iSensorValue_A1 = analogRead(A2);
				if (iSensorValue_A1 < (aHIHAT[5] *  (0.01 * aHIHAT[3]))) {
					bHihatFlag = false;
				}
			}
			if  (iPiezoValue_A0 >= aHIHAT_PEDAL[0] && iPiezoValue_A2 < (aHIHAT[5] *(0.01 * aHIHAT[3]))  && bHihatFlag == true) {
				delay(aSETTING[3]);
				int iSensorValue_A2  = analogRead(A2);
				if (iSensorValue_A2 < (aHIHAT[5] * (0.01 * aHIHAT[3])))  {
					bHihatFlag = false;
				}
			}
			if (iPiezoValue_A3  < (aKICK[5] * (0.01 * aKICK[3])) && bKickFlag == true) {
				delay(aSETTING[3]);
				//  -- Should declared iSensorValue_A3 be iPiezoValue_A3?  iSensorValue_A3 is declared  but not used anywhere??
				int iSensorValue_A3 = analogRead(A3);
				if  (iPiezoValue_A3 < (aKICK[5] * (0.01 * aKICK[3]))) {
				bKickFlag = false;
				}
			}
			if  (iPiezoValue_A0 <= aHIHAT_PEDAL[0] && bPedalFlag == true) {
				bPedalFlag  = false;
			}

// --- END 'Code in Progress' --- //
		}

Downloadable files

circuit_x5tIBQ5SLw.png

circuit_nZotR7rJMM.fzz

circuit_x5tIBQ5SLw.png

Comments

Only logged in users can leave comments

ryokosaka

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content