Five-matrix-8x8-keyboards-with-the-74HC138-chip

1//---------------------------------------------------------------------------
2//----------------------------for  signalisations work:----------------------
3// Variables will chang 
4int ledState  = LOW;             // ledState used to set the LED
5
6// Generally, you should  use "unsigned long" for variables that hold time
7// The value will quickly  become too large for an int to store
8unsigned long previousMillis = 0;        //  will store last time LED was updated
9
10// constants won't change:
11const  long interval = 1000;  
12//-------------------------------------------------------
13
14//  define adress pins for adressed 74HC138 
15#define pin_adress0 A0
16#define pin_adress1  A1
17#define pin_adress2 A2
18#define pin_E1_man1 A3
19#define pin_E1_man2 A4
20#define  pin_E1_man3 A5
21#define pin_E1_man4 10
22#define pin_E1_man5 11
23
24
25#define  LiczbaKlawiszy (61)
26boolean Key[LiczbaKlawiszy];
27boolean Key2[LiczbaKlawiszy];
28boolean  Key3[LiczbaKlawiszy];
29boolean Key4[LiczbaKlawiszy];
30boolean Key5[LiczbaKlawiszy];
31
32boolean  Key_last[LiczbaKlawiszy];
33boolean Key2_last[LiczbaKlawiszy];
34boolean Key3_last[LiczbaKlawiszy];
35boolean  Key4_last[LiczbaKlawiszy];
36boolean Key5_last[LiczbaKlawiszy];
37int pin_data[]  = {2,3,4,5,6,7,8,9}; // define data pins 
38
39  
40
41
42int vol = 90; //  walue velocity
43int channel_on = 0x90; // kanal 1 - initial variables for midi  channel
44int channel_off = 0x80; // kanal 1 - initial variables for midi channel
45
46//  int channel_on = 0x91; // kanal 2
47// int channel_off = 0x81; // kanal 2
48
49//  int channel_on = 0x92; // kanal 3
50// int channel_off = 0x81; // kanal 3
51
52//int  channel_on = 0x93; // kanal 4
53//int channel_off = 0x83; // kanal 4
54
55//  int channel_on = 0x94; // kanal 5
56// int channel_off = 0x84; // kanal 5
57
58//  int channel_on = 0x95; // kanal 6
59// int channel_off = 0x85; // kanal 6
60
61//  int channel_on = 0x96; // kanal 7
62// int channel_off = 0x86; // kanal 7
63
64//  int channel_on = 0x97; // kanal 8
65// int channel_off = 0x87; // kanal 8
66
67void  setup()  {
68  
69  Serial.begin (115200); //(31250); // setup serial for MIDI
70  for (int i = 0; i <= LiczbaKlawiszy -1; i++) {
71   Key[i] = 1;
72   Key2[i]  = 1;
73   Key3[i] = 1;
74   Key4[i] = 1;
75   Key5[i] = 1;
76   Key_last[i]  = 1;
77   Key2_last[i] = 1;
78   Key3_last[i] = 1;
79   Key4_last[i] = 1;
80   Key5_last[i] = 1;
81   }
82   
83  // define input pin_data
84  for (int  i = 0; i <= 7; i++) {
85  pinMode(pin_data[i], INPUT_PULLUP);
86  }
87  
88  //define output pin_adress 74HC138)
89    pinMode(pin_adress0, OUTPUT);
90 digitalWrite(pin_adress0,  HIGH);
91    pinMode(pin_adress1, OUTPUT);
92 digitalWrite(pin_adress1, HIGH);
93    pinMode(pin_adress2, OUTPUT);
94 digitalWrite(pin_adress2, HIGH);
95 
96
97  //define output pin_E1 ( selest 74HC138) select manual
98    pinMode( pin_E1_man1,  OUTPUT);
99 digitalWrite( pin_E1_man1, HIGH);
100    pinMode( pin_E1_man2, OUTPUT);
101  digitalWrite( pin_E1_man2, HIGH);
102    pinMode( pin_E1_man3, OUTPUT);
103 digitalWrite(  pin_E1_man3, HIGH);
104     pinMode( pin_E1_man4, OUTPUT);
105 digitalWrite( pin_E1_man4,  HIGH);
106      pinMode( pin_E1_man5, OUTPUT);
107 digitalWrite( pin_E1_man5, HIGH);
108//  define output LED
109pinMode(LED_BUILTIN, OUTPUT);
110
111
112}
113
114void loop()  {
115
116  
117  // vol = analogRead(A5);
118  // vol = map(vol, 0, 1023, 0, 127);
119
120   //*****************************************
121 //Obsługa man I
122  digitalWrite(  pin_E1_man1, LOW); 
123  digitalWrite( pin_E1_man2, HIGH);
124  digitalWrite( pin_E1_man3,  HIGH);
125  digitalWrite( pin_E1_man4, HIGH);
126  digitalWrite( pin_E1_man5, HIGH);//  właczenie I man do odczytu
127  
128  channel_on = 0x90; // setup variable chcnell  for man. I kanal 1
129  channel_off = 0x80; // ustawienie zmiennych kanału midi  dla I man. kanal 1
130  digitalWrite(pin_adress0, LOW);
131  digitalWrite(pin_adress1,  LOW);
132  digitalWrite(pin_adress2, LOW); // read 1-st (first) octet
133   
134      for (int i = 0; i <= 7; i++) {
135      Key[i+0*8] = digitalRead(pin_data[i]);
136     }
137
138  digitalWrite(pin_adress0, HIGH);
139  digitalWrite(pin_adress1,  LOW);
140  digitalWrite(pin_adress2, LOW); // read 2-st (second) octet
141      for  (int i = 0; i <= 7; i++) {
142      Key[i+1*8] = digitalRead(pin_data[i]);
143     }
144  
145  digitalWrite(pin_adress0, LOW);
146  digitalWrite(pin_adress1, HIGH);
147  digitalWrite(pin_adress2, LOW); // read 3-st (thrid) octet
148  
149      for  (int i = 0; i <= 7; i++) {
150      Key[i+2*8] = digitalRead(pin_data[i]);
151     }
152
153  digitalWrite(pin_adress0, HIGH);
154  digitalWrite(pin_adress1, HIGH);
155  digitalWrite(pin_adress2,  LOW); // read 4-st (quad) octet
156  
157   for (int i = 0; i <= 7; i++) {
158      Key[i+3*8]  = digitalRead(pin_data[i]);
159     }
160  digitalWrite(pin_adress0, LOW);
161  digitalWrite(pin_adress1,  LOW);
162  digitalWrite(pin_adress2, HIGH); // read 5-st (quad) octet
163   for  (int i = 0; i <= 7; i++) {
164      Key[i+4*8] = digitalRead(pin_data[i]);
165     }
166
167  digitalWrite(pin_adress0, HIGH);
168  digitalWrite(pin_adress1, LOW);
169  digitalWrite(pin_adress2,  HIGH); // read 6-st (qwint) octet
170   for (int i = 0; i <= 7; i++) {
171      Key[i+5*8]  = digitalRead(pin_data[i]);
172     }
173
174  digitalWrite(pin_adress0, LOW);
175  digitalWrite(pin_adress1, HIGH);
176  digitalWrite(pin_adress2, HIGH); // read  7-st (sext) octet
177   for (int i = 0; i <= 7; i++) {
178      Key[i+6*8] = digitalRead(pin_data[i]);
179     }
180  digitalWrite(pin_adress0, HIGH);
181  digitalWrite(pin_adress1, HIGH);
182  digitalWrite(pin_adress2, HIGH); // read 8-st (sept) octet
183   for (int i =  0; i <= 7; i++) {
184      Key[i+7*8] = digitalRead(pin_data[i]);
185     }
186  
187  
188
189//****************************************************
190// porównywanie  odczytów i wysyłanie komunikatów midi
191
192    for (int i = 0; i <= LiczbaKlawiszy  -1; i++) {
193    if(Key[i] != Key_last[i] ) {
194    if(Key[i] == 0)  {
195      noteOn(channel_on,  36+i, vol);
196    }
197    else  {
198      noteOn(channel_off, 36+i, 0x00);
199      noteOn(channel_off, 36+i, 0x00);
200    }
201  }
202  }
203  
204 
205 
206  //*****************************************
207 //Obsługa man II
208digitalWrite(  pin_E1_man1, HIGH); 
209digitalWrite( pin_E1_man2, LOW);
210digitalWrite( pin_E1_man3,  HIGH);
211digitalWrite( pin_E1_man4, HIGH); 
212digitalWrite( pin_E1_man5, HIGH);//  właczenie II man do odczytu
213channel_on = 0x91; // ustawienie kanałów dla II man  - kanal 2
214channel_off = 0x81; // kanal 2
215
216  digitalWrite(pin_adress0, LOW);
217  digitalWrite(pin_adress1, LOW);
218  digitalWrite(pin_adress2, LOW); // read 1-st  (first) octet
219      for (int i = 0; i <= 7; i++) {
220      Key2[i+0*8] = digitalRead(pin_data[i]);
221     }
222
223  digitalWrite(pin_adress0, HIGH);
224  digitalWrite(pin_adress1,  LOW);
225  digitalWrite(pin_adress2, LOW); // read 2-st (second) octet
226      for  (int i = 0; i <= 7; i++) {
227      Key2[i+1*8] = digitalRead(pin_data[i]);
228     }
229  
230  digitalWrite(pin_adress0, LOW);
231  digitalWrite(pin_adress1,  HIGH);
232  digitalWrite(pin_adress2, LOW); // read 3-st (thrid) octet
233  
234      for (int i = 0; i <= 7; i++) {
235      Key2[i+2*8] = digitalRead(pin_data[i]);
236     }
237
238  digitalWrite(pin_adress0, HIGH);
239  digitalWrite(pin_adress1,  HIGH);
240  digitalWrite(pin_adress2, LOW); // read 4-st (quad) octet
241  
242   for (int i = 0; i <= 7; i++) {
243      Key2[i+3*8] = digitalRead(pin_data[i]);
244     }
245  digitalWrite(pin_adress0, LOW);
246  digitalWrite(pin_adress1, LOW);
247  digitalWrite(pin_adress2, HIGH); // read 5-st (quad) octet
248   for (int i =  0; i <= 7; i++) {
249      Key2[i+4*8] = digitalRead(pin_data[i]);
250     }
251
252  digitalWrite(pin_adress0, HIGH);
253  digitalWrite(pin_adress1, LOW);
254  digitalWrite(pin_adress2,  HIGH); // read 6-st (qwint) octet
255   for (int i = 0; i <= 7; i++) {
256      Key2[i+5*8]  = digitalRead(pin_data[i]);
257     }
258
259  digitalWrite(pin_adress0, LOW);
260  digitalWrite(pin_adress1, HIGH);
261  digitalWrite(pin_adress2, HIGH); // read  7-st (sext) octet
262   for (int i = 0; i <= 7; i++) {
263      Key2[i+6*8] = digitalRead(pin_data[i]);
264     }
265  digitalWrite(pin_adress0, HIGH);
266  digitalWrite(pin_adress1, HIGH);
267  digitalWrite(pin_adress2, HIGH); // read 8-st (sept) octet
268   for (int i =  0; i <= 7; i++) {
269      Key2[i+7*8] = digitalRead(pin_data[i]);
270     }
271  
272  
273
274//****************************************************
275// porównywanie  odczytów i wysyłanie komunikatów midi dla man II
276// 
277   for (int i = 0; i  <= LiczbaKlawiszy -1; i++) {
278    if(Key2[i] != Key2_last[i] ) {
279    if(Key2[i]  == 0)  {
280      noteOn(channel_on, 36+i, vol);
281    }
282    else  {
283      noteOn(channel_off,  36+i, 0x00);
284      noteOn(channel_off, 36+i, 0x00);
285    }
286  }
287  }
288//*****************************************
289  //Obsługa man III
290digitalWrite( pin_E1_man1, HIGH); 
291digitalWrite( pin_E1_man2,  HIGH);
292digitalWrite( pin_E1_man3, LOW); 
293digitalWrite( pin_E1_man4, HIGH);
294digitalWrite(  pin_E1_man5, HIGH);// właczenie III man do odczytu
295channel_on = 0x92; // ustawienie  kanałów dla III man - kanal 3
296channel_off = 0x82; // kanal 3
297
298  digitalWrite(pin_adress0,  LOW);
299  digitalWrite(pin_adress1, LOW);
300  digitalWrite(pin_adress2, LOW);  // read 1-st (first) octet
301      for (int i = 0; i <= 7; i++) {
302      Key3[i+0*8]  = digitalRead(pin_data[i]);
303     }
304
305  digitalWrite(pin_adress0, HIGH);
306  digitalWrite(pin_adress1, LOW);
307  digitalWrite(pin_adress2, LOW); // read 2-st  (second) octet
308      for (int i = 0; i <= 7; i++) {
309      Key3[i+1*8] = digitalRead(pin_data[i]);
310     }
311  
312  digitalWrite(pin_adress0, LOW);
313  digitalWrite(pin_adress1,  HIGH);
314  digitalWrite(pin_adress2, LOW); // read 3-st (thrid) octet
315  
316      for (int i = 0; i <= 7; i++) {
317      Key3[i+2*8] = digitalRead(pin_data[i]);
318     }
319
320  digitalWrite(pin_adress0, HIGH);
321  digitalWrite(pin_adress1,  HIGH);
322  digitalWrite(pin_adress2, LOW); // read 4-st (quad) octet
323  
324   for (int i = 0; i <= 7; i++) {
325      Key3[i+3*8] = digitalRead(pin_data[i]);
326     }
327  digitalWrite(pin_adress0, LOW);
328  digitalWrite(pin_adress1, LOW);
329  digitalWrite(pin_adress2, HIGH); // read 5-st (quad) octet
330   for (int i =  0; i <= 7; i++) {
331      Key3[i+4*8] = digitalRead(pin_data[i]);
332     }
333
334  digitalWrite(pin_adress0, HIGH);
335  digitalWrite(pin_adress1, LOW);
336  digitalWrite(pin_adress2,  HIGH); // read 6-st (qwint) octet
337   for (int i = 0; i <= 7; i++) {
338      Key3[i+5*8]  = digitalRead(pin_data[i]);
339     }
340
341  digitalWrite(pin_adress0, LOW);
342  digitalWrite(pin_adress1, HIGH);
343  digitalWrite(pin_adress2, HIGH); // read  7-st (sext) octet
344   for (int i = 0; i <= 7; i++) {
345      Key3[i+6*8] = digitalRead(pin_data[i]);
346     }
347  digitalWrite(pin_adress0, HIGH);
348  digitalWrite(pin_adress1, HIGH);
349  digitalWrite(pin_adress2, HIGH); // read 8-st (sept) octet
350   for (int i =  0; i <= 7; i++) {
351      Key3[i+7*8] = digitalRead(pin_data[i]);
352     }
353  
354  
355
356//****************************************************
357// porównywanie  odczytów i wysyłanie komunikatów midi dla man III
358// 
359   for (int i = 0; i  <= LiczbaKlawiszy -1; i++) {
360    if(Key3[i] != Key3_last[i] ) {
361    if(Key3[i]  == 0)  {
362      noteOn(channel_on, 36+i, vol);
363    }
364    else  {
365      noteOn(channel_off,  36+i, 0x00);
366      noteOn(channel_off, 36+i, 0x00);
367    }
368  }
369  }
370
371  //*****************************************
372 //Obsługa man IV
373digitalWrite(  pin_E1_man1, HIGH); 
374digitalWrite( pin_E1_man2, HIGH);
375digitalWrite( pin_E1_man3,  HIGH); 
376digitalWrite( pin_E1_man4, LOW);
377digitalWrite( pin_E1_man5, HIGH);//  właczenie III man do odczytu
378channel_on = 0x93; // ustawienie kanałów dla IV  man - kanal 4
379channel_off = 0x83; // kanal 4
380
381  digitalWrite(pin_adress0,  LOW);
382  digitalWrite(pin_adress1, LOW);
383  digitalWrite(pin_adress2, LOW);  // read 1-st (first) octet
384      for (int i = 0; i <= 7; i++) {
385      Key4[i+0*8]  = digitalRead(pin_data[i]);
386     }
387
388  digitalWrite(pin_adress0, HIGH);
389  digitalWrite(pin_adress1, LOW);
390  digitalWrite(pin_adress2, LOW); // read 2-st  (second) octet
391      for (int i = 0; i <= 7; i++) {
392      Key4[i+1*8] = digitalRead(pin_data[i]);
393     }
394  
395  digitalWrite(pin_adress0, LOW);
396  digitalWrite(pin_adress1,  HIGH);
397  digitalWrite(pin_adress2, LOW); // read 3-st (thrid) octet
398  
399      for (int i = 0; i <= 7; i++) {
400      Key4[i+2*8] = digitalRead(pin_data[i]);
401     }
402
403  digitalWrite(pin_adress0, HIGH);
404  digitalWrite(pin_adress1,  HIGH);
405  digitalWrite(pin_adress2, LOW); // read 4-st (quad) octet
406  
407   for (int i = 0; i <= 7; i++) {
408      Key4[i+3*8] = digitalRead(pin_data[i]);
409     }
410  digitalWrite(pin_adress0, LOW);
411  digitalWrite(pin_adress1, LOW);
412  digitalWrite(pin_adress2, HIGH); // read 5-st (quad) octet
413   for (int i =  0; i <= 7; i++) {
414      Key4[i+4*8] = digitalRead(pin_data[i]);
415     }
416
417  digitalWrite(pin_adress0, HIGH);
418  digitalWrite(pin_adress1, LOW);
419  digitalWrite(pin_adress2,  HIGH); // read 6-st (qwint) octet
420   for (int i = 0; i <= 7; i++) {
421      Key4[i+5*8]  = digitalRead(pin_data[i]);
422     }
423
424  digitalWrite(pin_adress0, LOW);
425  digitalWrite(pin_adress1, HIGH);
426  digitalWrite(pin_adress2, HIGH); // read  7-st (sext) octet
427   for (int i = 0; i <= 7; i++) {
428      Key4[i+6*8] = digitalRead(pin_data[i]);
429     }
430  digitalWrite(pin_adress0, HIGH);
431  digitalWrite(pin_adress1, HIGH);
432  digitalWrite(pin_adress2, HIGH); // read 8-st (sept) octet
433   for (int i =  0; i <= 7; i++) {
434      Key4[i+7*8] = digitalRead(pin_data[i]);
435     }
436  
437  
438
439//****************************************************
440// porównywanie  odczytów i wysyłanie komunikatów midi dla man IV
441// 
442   for (int i = 0; i  <= LiczbaKlawiszy -1; i++) {
443    if(Key4[i] != Key4_last[i] ) {
444    if(Key4[i]  == 0)  {
445      noteOn(channel_on, 36+i, vol);
446    }
447    else  {
448      noteOn(channel_off,  36+i, 0x00);
449      noteOn(channel_off, 36+i, 0x00);
450    }
451  }
452  }
453    //*****************************************
454 //Obsługa man V
455digitalWrite(  pin_E1_man1, HIGH); 
456digitalWrite( pin_E1_man2, HIGH);
457digitalWrite( pin_E1_man3,  HIGH); 
458digitalWrite( pin_E1_man4, HIGH);
459digitalWrite( pin_E1_man5, LOW);//  właczenie III man do odczytu
460channel_on = 0x94; // ustawienie kanałów dla IV  man - kanal 4
461channel_off = 0x84; // kanal 5
462
463  digitalWrite(pin_adress0,  LOW);
464  digitalWrite(pin_adress1, LOW);
465  digitalWrite(pin_adress2, LOW);  // read 1-st (first) octet
466      for (int i = 0; i <= 7; i++) {
467      Key5[i+0*8]  = digitalRead(pin_data[i]);
468     }
469
470  digitalWrite(pin_adress0, HIGH);
471  digitalWrite(pin_adress1, LOW);
472  digitalWrite(pin_adress2, LOW); // read 2-st  (second) octet
473      for (int i = 0; i <= 7; i++) {
474      Key5[i+1*8] = digitalRead(pin_data[i]);
475     }
476  
477  digitalWrite(pin_adress0, LOW);
478  digitalWrite(pin_adress1,  HIGH);
479  digitalWrite(pin_adress2, LOW); // read 3-st (thrid) octet
480  
481      for (int i = 0; i <= 7; i++) {
482      Key5[i+2*8] = digitalRead(pin_data[i]);
483     }
484
485  digitalWrite(pin_adress0, HIGH);
486  digitalWrite(pin_adress1,  HIGH);
487  digitalWrite(pin_adress2, LOW); // read 4-st (quad) octet
488  
489   for (int i = 0; i <= 7; i++) {
490      Key5[i+3*8] = digitalRead(pin_data[i]);
491     }
492  digitalWrite(pin_adress0, LOW);
493  digitalWrite(pin_adress1, LOW);
494  digitalWrite(pin_adress2, HIGH); // read 5-st (quad) octet
495   for (int i =  0; i <= 7; i++) {
496      Key5[i+4*8] = digitalRead(pin_data[i]);
497     }
498
499  digitalWrite(pin_adress0, HIGH);
500  digitalWrite(pin_adress1, LOW);
501  digitalWrite(pin_adress2,  HIGH); // read 6-st (qwint) octet
502   for (int i = 0; i <= 7; i++) {
503      Key5[i+5*8]  = digitalRead(pin_data[i]);
504     }
505
506  digitalWrite(pin_adress0, LOW);
507  digitalWrite(pin_adress1, HIGH);
508  digitalWrite(pin_adress2, HIGH); // read  7-st (sext) octet
509   for (int i = 0; i <= 7; i++) {
510      Key5[i+6*8] = digitalRead(pin_data[i]);
511     }
512  digitalWrite(pin_adress0, HIGH);
513  digitalWrite(pin_adress1, HIGH);
514  digitalWrite(pin_adress2, HIGH); // read 8-st (sept) octet
515   for (int i =  0; i <= 7; i++) {
516      Key5[i+7*8] = digitalRead(pin_data[i]);
517     }
518  
519  
520
521//****************************************************
522// porównywanie  odczytów i wysyłanie komunikatów midi dla man V
523// 
524   for (int i = 0; i <=  LiczbaKlawiszy -1; i++) {
525    if(Key5[i] != Key5_last[i] ) {
526    if(Key5[i]  == 0)  {
527      noteOn(channel_on, 36+i, vol);
528    }
529    else  {
530      noteOn(channel_off,  36+i, 0x00);
531      noteOn(channel_off, 36+i, 0x00);
532    }
533  }
534  }
535  //*****************************************************
536  
537  for (int i =  0; i <= LiczbaKlawiszy -1; i++) {
538  Key_last[i] = Key[i];
539 }
540 for (int  i = 0; i <= LiczbaKlawiszy -1 ; i++) {
541  Key2_last[i] = Key2[i];
542 }
543 for  (int i = 0; i <= LiczbaKlawiszy -1 ; i++) {
544  Key3_last[i] = Key3[i];
545 }  
546  for (int i = 0; i <= LiczbaKlawiszy -1 ; i++) {
547  Key4_last[i] = Key4[i];
548  }  
549  for (int i = 0; i <= LiczbaKlawiszy -1 ; i++) {
550  Key5_last[i] = Key5[i];
551  }  
552 //**************************************
553
554 // moduł sygnalizacji działania  
555 //----------------------------------------------------------
556 unsigned long  currentMillis = millis();
557 // szybkość działania programu
558 // Serial.println(currentMillis);
559
560  if (currentMillis - previousMillis >= interval) {
561    // save the last time  you blinked the LED
562    previousMillis = currentMillis;
563
564    // if the  LED is off turn it on and vice-versa:
565    if (ledState == LOW) {
566      ledState  = HIGH;
567    } else {
568      ledState = LOW;
569    }
570
571    // set the  LED with the ledState of the variable:
572    digitalWrite(LED_BUILTIN, ledState);
573  }
574//---------------------------------------------------------------  
575}
576
577  void noteOn(byte cmd, byte data1, byte data2) {
578   Serial.write(cmd);
579   Serial.write(data1);
580   Serial.write(data2);
581   
582   digitalWrite(LED_BUILTIN, HIGH);
583   delay(5);
584   digitalWrite(LED_BUILTIN, LOW);
585 }

1//---------------------------------------------------------------------------
2//----------------------------for
3  signalisations work:----------------------
4// Variables will chang 
5int ledState
6  = LOW;             // ledState used to set the LED
7
8// Generally, you should
9  use "unsigned long" for variables that hold time
10// The value will quickly
11  become too large for an int to store
12unsigned long previousMillis = 0;        //
13  will store last time LED was updated
14
15// constants won't change:
16const
17  long interval = 1000;  
18//-------------------------------------------------------
19
20//
21  define adress pins for adressed 74HC138 
22#define pin_adress0 A0
23#define pin_adress1
24  A1
25#define pin_adress2 A2
26#define pin_E1_man1 A3
27#define pin_E1_man2 A4
28#define
29  pin_E1_man3 A5
30#define pin_E1_man4 10
31#define pin_E1_man5 11
32
33
34#define
35  LiczbaKlawiszy (61)
36boolean Key[LiczbaKlawiszy];
37boolean Key2[LiczbaKlawiszy];
38boolean
39  Key3[LiczbaKlawiszy];
40boolean Key4[LiczbaKlawiszy];
41boolean Key5[LiczbaKlawiszy];
42
43boolean
44  Key_last[LiczbaKlawiszy];
45boolean Key2_last[LiczbaKlawiszy];
46boolean Key3_last[LiczbaKlawiszy];
47boolean
48  Key4_last[LiczbaKlawiszy];
49boolean Key5_last[LiczbaKlawiszy];
50int pin_data[]
51  = {2,3,4,5,6,7,8,9}; // define data pins 
52
53  
54
55
56int vol = 90; //
57  walue velocity
58int channel_on = 0x90; // kanal 1 - initial variables for midi
59  channel
60int channel_off = 0x80; // kanal 1 - initial variables for midi channel
61
62//
63  int channel_on = 0x91; // kanal 2
64// int channel_off = 0x81; // kanal 2
65
66//
67  int channel_on = 0x92; // kanal 3
68// int channel_off = 0x81; // kanal 3
69
70//int
71  channel_on = 0x93; // kanal 4
72//int channel_off = 0x83; // kanal 4
73
74//
75  int channel_on = 0x94; // kanal 5
76// int channel_off = 0x84; // kanal 5
77
78//
79  int channel_on = 0x95; // kanal 6
80// int channel_off = 0x85; // kanal 6
81
82//
83  int channel_on = 0x96; // kanal 7
84// int channel_off = 0x86; // kanal 7
85
86//
87  int channel_on = 0x97; // kanal 8
88// int channel_off = 0x87; // kanal 8
89
90void
91  setup()  {
92  
93  Serial.begin (115200); //(31250); // setup serial for MIDI
94
95  for (int i = 0; i <= LiczbaKlawiszy -1; i++) {
96   Key[i] = 1;
97   Key2[i]
98  = 1;
99   Key3[i] = 1;
100   Key4[i] = 1;
101   Key5[i] = 1;
102   Key_last[i]
103  = 1;
104   Key2_last[i] = 1;
105   Key3_last[i] = 1;
106   Key4_last[i] = 1;
107
108   Key5_last[i] = 1;
109   }
110   
111  // define input pin_data
112  for (int
113  i = 0; i <= 7; i++) {
114  pinMode(pin_data[i], INPUT_PULLUP);
115  }
116  
117
118  //define output pin_adress 74HC138)
119    pinMode(pin_adress0, OUTPUT);
120 digitalWrite(pin_adress0,
121  HIGH);
122    pinMode(pin_adress1, OUTPUT);
123 digitalWrite(pin_adress1, HIGH);
124
125    pinMode(pin_adress2, OUTPUT);
126 digitalWrite(pin_adress2, HIGH);
127 
128
129
130  //define output pin_E1 ( selest 74HC138) select manual
131    pinMode( pin_E1_man1,
132  OUTPUT);
133 digitalWrite( pin_E1_man1, HIGH);
134    pinMode( pin_E1_man2, OUTPUT);
135
136  digitalWrite( pin_E1_man2, HIGH);
137    pinMode( pin_E1_man3, OUTPUT);
138 digitalWrite(
139  pin_E1_man3, HIGH);
140     pinMode( pin_E1_man4, OUTPUT);
141 digitalWrite( pin_E1_man4,
142  HIGH);
143      pinMode( pin_E1_man5, OUTPUT);
144 digitalWrite( pin_E1_man5, HIGH);
145//
146  define output LED
147pinMode(LED_BUILTIN, OUTPUT);
148
149
150}
151
152void loop()
153  {
154
155  
156  // vol = analogRead(A5);
157  // vol = map(vol, 0, 1023, 0, 127);
158
159
160   //*****************************************
161 //Obsługa man I
162  digitalWrite(
163  pin_E1_man1, LOW); 
164  digitalWrite( pin_E1_man2, HIGH);
165  digitalWrite( pin_E1_man3,
166  HIGH);
167  digitalWrite( pin_E1_man4, HIGH);
168  digitalWrite( pin_E1_man5, HIGH);//
169  właczenie I man do odczytu
170  
171  channel_on = 0x90; // setup variable chcnell
172  for man. I kanal 1
173  channel_off = 0x80; // ustawienie zmiennych kanału midi
174  dla I man. kanal 1
175  digitalWrite(pin_adress0, LOW);
176  digitalWrite(pin_adress1,
177  LOW);
178  digitalWrite(pin_adress2, LOW); // read 1-st (first) octet
179   
180
181      for (int i = 0; i <= 7; i++) {
182      Key[i+0*8] = digitalRead(pin_data[i]);
183
184     }
185
186  digitalWrite(pin_adress0, HIGH);
187  digitalWrite(pin_adress1,
188  LOW);
189  digitalWrite(pin_adress2, LOW); // read 2-st (second) octet
190      for
191  (int i = 0; i <= 7; i++) {
192      Key[i+1*8] = digitalRead(pin_data[i]);
193     }
194
195  
196  digitalWrite(pin_adress0, LOW);
197  digitalWrite(pin_adress1, HIGH);
198
199  digitalWrite(pin_adress2, LOW); // read 3-st (thrid) octet
200  
201      for
202  (int i = 0; i <= 7; i++) {
203      Key[i+2*8] = digitalRead(pin_data[i]);
204     }
205
206
207  digitalWrite(pin_adress0, HIGH);
208  digitalWrite(pin_adress1, HIGH);
209  digitalWrite(pin_adress2,
210  LOW); // read 4-st (quad) octet
211  
212   for (int i = 0; i <= 7; i++) {
213      Key[i+3*8]
214  = digitalRead(pin_data[i]);
215     }
216  digitalWrite(pin_adress0, LOW);
217  digitalWrite(pin_adress1,
218  LOW);
219  digitalWrite(pin_adress2, HIGH); // read 5-st (quad) octet
220   for
221  (int i = 0; i <= 7; i++) {
222      Key[i+4*8] = digitalRead(pin_data[i]);
223     }
224
225
226  digitalWrite(pin_adress0, HIGH);
227  digitalWrite(pin_adress1, LOW);
228  digitalWrite(pin_adress2,
229  HIGH); // read 6-st (qwint) octet
230   for (int i = 0; i <= 7; i++) {
231      Key[i+5*8]
232  = digitalRead(pin_data[i]);
233     }
234
235  digitalWrite(pin_adress0, LOW);
236
237  digitalWrite(pin_adress1, HIGH);
238  digitalWrite(pin_adress2, HIGH); // read
239  7-st (sext) octet
240   for (int i = 0; i <= 7; i++) {
241      Key[i+6*8] = digitalRead(pin_data[i]);
242
243     }
244  digitalWrite(pin_adress0, HIGH);
245  digitalWrite(pin_adress1, HIGH);
246
247  digitalWrite(pin_adress2, HIGH); // read 8-st (sept) octet
248   for (int i =
249  0; i <= 7; i++) {
250      Key[i+7*8] = digitalRead(pin_data[i]);
251     }
252
253  
254  
255
256//****************************************************
257// porównywanie
258  odczytów i wysyłanie komunikatów midi
259
260    for (int i = 0; i <= LiczbaKlawiszy
261  -1; i++) {
262    if(Key[i] != Key_last[i] ) {
263    if(Key[i] == 0)  {
264      noteOn(channel_on,
265  36+i, vol);
266    }
267    else  {
268      noteOn(channel_off, 36+i, 0x00);
269
270      noteOn(channel_off, 36+i, 0x00);
271    }
272  }
273  }
274  
275 
276 
277
278  //*****************************************
279 //Obsługa man II
280digitalWrite(
281  pin_E1_man1, HIGH); 
282digitalWrite( pin_E1_man2, LOW);
283digitalWrite( pin_E1_man3,
284  HIGH);
285digitalWrite( pin_E1_man4, HIGH); 
286digitalWrite( pin_E1_man5, HIGH);//
287  właczenie II man do odczytu
288channel_on = 0x91; // ustawienie kanałów dla II man
289  - kanal 2
290channel_off = 0x81; // kanal 2
291
292  digitalWrite(pin_adress0, LOW);
293
294  digitalWrite(pin_adress1, LOW);
295  digitalWrite(pin_adress2, LOW); // read 1-st
296  (first) octet
297      for (int i = 0; i <= 7; i++) {
298      Key2[i+0*8] = digitalRead(pin_data[i]);
299
300     }
301
302  digitalWrite(pin_adress0, HIGH);
303  digitalWrite(pin_adress1,
304  LOW);
305  digitalWrite(pin_adress2, LOW); // read 2-st (second) octet
306      for
307  (int i = 0; i <= 7; i++) {
308      Key2[i+1*8] = digitalRead(pin_data[i]);
309
310     }
311  
312  digitalWrite(pin_adress0, LOW);
313  digitalWrite(pin_adress1,
314  HIGH);
315  digitalWrite(pin_adress2, LOW); // read 3-st (thrid) octet
316  
317
318      for (int i = 0; i <= 7; i++) {
319      Key2[i+2*8] = digitalRead(pin_data[i]);
320
321     }
322
323  digitalWrite(pin_adress0, HIGH);
324  digitalWrite(pin_adress1,
325  HIGH);
326  digitalWrite(pin_adress2, LOW); // read 4-st (quad) octet
327  
328
329   for (int i = 0; i <= 7; i++) {
330      Key2[i+3*8] = digitalRead(pin_data[i]);
331
332     }
333  digitalWrite(pin_adress0, LOW);
334  digitalWrite(pin_adress1, LOW);
335
336  digitalWrite(pin_adress2, HIGH); // read 5-st (quad) octet
337   for (int i =
338  0; i <= 7; i++) {
339      Key2[i+4*8] = digitalRead(pin_data[i]);
340     }
341
342
343  digitalWrite(pin_adress0, HIGH);
344  digitalWrite(pin_adress1, LOW);
345  digitalWrite(pin_adress2,
346  HIGH); // read 6-st (qwint) octet
347   for (int i = 0; i <= 7; i++) {
348      Key2[i+5*8]
349  = digitalRead(pin_data[i]);
350     }
351
352  digitalWrite(pin_adress0, LOW);
353
354  digitalWrite(pin_adress1, HIGH);
355  digitalWrite(pin_adress2, HIGH); // read
356  7-st (sext) octet
357   for (int i = 0; i <= 7; i++) {
358      Key2[i+6*8] = digitalRead(pin_data[i]);
359
360     }
361  digitalWrite(pin_adress0, HIGH);
362  digitalWrite(pin_adress1, HIGH);
363
364  digitalWrite(pin_adress2, HIGH); // read 8-st (sept) octet
365   for (int i =
366  0; i <= 7; i++) {
367      Key2[i+7*8] = digitalRead(pin_data[i]);
368     }
369
370  
371  
372
373//****************************************************
374// porównywanie
375  odczytów i wysyłanie komunikatów midi dla man II
376// 
377   for (int i = 0; i
378  <= LiczbaKlawiszy -1; i++) {
379    if(Key2[i] != Key2_last[i] ) {
380    if(Key2[i]
381  == 0)  {
382      noteOn(channel_on, 36+i, vol);
383    }
384    else  {
385      noteOn(channel_off,
386  36+i, 0x00);
387      noteOn(channel_off, 36+i, 0x00);
388    }
389  }
390  }
391//*****************************************
392
393  //Obsługa man III
394digitalWrite( pin_E1_man1, HIGH); 
395digitalWrite( pin_E1_man2,
396  HIGH);
397digitalWrite( pin_E1_man3, LOW); 
398digitalWrite( pin_E1_man4, HIGH);
399digitalWrite(
400  pin_E1_man5, HIGH);// właczenie III man do odczytu
401channel_on = 0x92; // ustawienie
402  kanałów dla III man - kanal 3
403channel_off = 0x82; // kanal 3
404
405  digitalWrite(pin_adress0,
406  LOW);
407  digitalWrite(pin_adress1, LOW);
408  digitalWrite(pin_adress2, LOW);
409  // read 1-st (first) octet
410      for (int i = 0; i <= 7; i++) {
411      Key3[i+0*8]
412  = digitalRead(pin_data[i]);
413     }
414
415  digitalWrite(pin_adress0, HIGH);
416
417  digitalWrite(pin_adress1, LOW);
418  digitalWrite(pin_adress2, LOW); // read 2-st
419  (second) octet
420      for (int i = 0; i <= 7; i++) {
421      Key3[i+1*8] = digitalRead(pin_data[i]);
422
423     }
424  
425  digitalWrite(pin_adress0, LOW);
426  digitalWrite(pin_adress1,
427  HIGH);
428  digitalWrite(pin_adress2, LOW); // read 3-st (thrid) octet
429  
430
431      for (int i = 0; i <= 7; i++) {
432      Key3[i+2*8] = digitalRead(pin_data[i]);
433
434     }
435
436  digitalWrite(pin_adress0, HIGH);
437  digitalWrite(pin_adress1,
438  HIGH);
439  digitalWrite(pin_adress2, LOW); // read 4-st (quad) octet
440  
441
442   for (int i = 0; i <= 7; i++) {
443      Key3[i+3*8] = digitalRead(pin_data[i]);
444
445     }
446  digitalWrite(pin_adress0, LOW);
447  digitalWrite(pin_adress1, LOW);
448
449  digitalWrite(pin_adress2, HIGH); // read 5-st (quad) octet
450   for (int i =
451  0; i <= 7; i++) {
452      Key3[i+4*8] = digitalRead(pin_data[i]);
453     }
454
455
456  digitalWrite(pin_adress0, HIGH);
457  digitalWrite(pin_adress1, LOW);
458  digitalWrite(pin_adress2,
459  HIGH); // read 6-st (qwint) octet
460   for (int i = 0; i <= 7; i++) {
461      Key3[i+5*8]
462  = digitalRead(pin_data[i]);
463     }
464
465  digitalWrite(pin_adress0, LOW);
466
467  digitalWrite(pin_adress1, HIGH);
468  digitalWrite(pin_adress2, HIGH); // read
469  7-st (sext) octet
470   for (int i = 0; i <= 7; i++) {
471      Key3[i+6*8] = digitalRead(pin_data[i]);
472
473     }
474  digitalWrite(pin_adress0, HIGH);
475  digitalWrite(pin_adress1, HIGH);
476
477  digitalWrite(pin_adress2, HIGH); // read 8-st (sept) octet
478   for (int i =
479  0; i <= 7; i++) {
480      Key3[i+7*8] = digitalRead(pin_data[i]);
481     }
482
483  
484  
485
486//****************************************************
487// porównywanie
488  odczytów i wysyłanie komunikatów midi dla man III
489// 
490   for (int i = 0; i
491  <= LiczbaKlawiszy -1; i++) {
492    if(Key3[i] != Key3_last[i] ) {
493    if(Key3[i]
494  == 0)  {
495      noteOn(channel_on, 36+i, vol);
496    }
497    else  {
498      noteOn(channel_off,
499  36+i, 0x00);
500      noteOn(channel_off, 36+i, 0x00);
501    }
502  }
503  }
504
505
506  //*****************************************
507 //Obsługa man IV
508digitalWrite(
509  pin_E1_man1, HIGH); 
510digitalWrite( pin_E1_man2, HIGH);
511digitalWrite( pin_E1_man3,
512  HIGH); 
513digitalWrite( pin_E1_man4, LOW);
514digitalWrite( pin_E1_man5, HIGH);//
515  właczenie III man do odczytu
516channel_on = 0x93; // ustawienie kanałów dla IV
517  man - kanal 4
518channel_off = 0x83; // kanal 4
519
520  digitalWrite(pin_adress0,
521  LOW);
522  digitalWrite(pin_adress1, LOW);
523  digitalWrite(pin_adress2, LOW);
524  // read 1-st (first) octet
525      for (int i = 0; i <= 7; i++) {
526      Key4[i+0*8]
527  = digitalRead(pin_data[i]);
528     }
529
530  digitalWrite(pin_adress0, HIGH);
531
532  digitalWrite(pin_adress1, LOW);
533  digitalWrite(pin_adress2, LOW); // read 2-st
534  (second) octet
535      for (int i = 0; i <= 7; i++) {
536      Key4[i+1*8] = digitalRead(pin_data[i]);
537
538     }
539  
540  digitalWrite(pin_adress0, LOW);
541  digitalWrite(pin_adress1,
542  HIGH);
543  digitalWrite(pin_adress2, LOW); // read 3-st (thrid) octet
544  
545
546      for (int i = 0; i <= 7; i++) {
547      Key4[i+2*8] = digitalRead(pin_data[i]);
548
549     }
550
551  digitalWrite(pin_adress0, HIGH);
552  digitalWrite(pin_adress1,
553  HIGH);
554  digitalWrite(pin_adress2, LOW); // read 4-st (quad) octet
555  
556
557   for (int i = 0; i <= 7; i++) {
558      Key4[i+3*8] = digitalRead(pin_data[i]);
559
560     }
561  digitalWrite(pin_adress0, LOW);
562  digitalWrite(pin_adress1, LOW);
563
564  digitalWrite(pin_adress2, HIGH); // read 5-st (quad) octet
565   for (int i =
566  0; i <= 7; i++) {
567      Key4[i+4*8] = digitalRead(pin_data[i]);
568     }
569
570
571  digitalWrite(pin_adress0, HIGH);
572  digitalWrite(pin_adress1, LOW);
573  digitalWrite(pin_adress2,
574  HIGH); // read 6-st (qwint) octet
575   for (int i = 0; i <= 7; i++) {
576      Key4[i+5*8]
577  = digitalRead(pin_data[i]);
578     }
579
580  digitalWrite(pin_adress0, LOW);
581
582  digitalWrite(pin_adress1, HIGH);
583  digitalWrite(pin_adress2, HIGH); // read
584  7-st (sext) octet
585   for (int i = 0; i <= 7; i++) {
586      Key4[i+6*8] = digitalRead(pin_data[i]);
587
588     }
589  digitalWrite(pin_adress0, HIGH);
590  digitalWrite(pin_adress1, HIGH);
591
592  digitalWrite(pin_adress2, HIGH); // read 8-st (sept) octet
593   for (int i =
594  0; i <= 7; i++) {
595      Key4[i+7*8] = digitalRead(pin_data[i]);
596     }
597
598  
599  
600
601//****************************************************
602// porównywanie
603  odczytów i wysyłanie komunikatów midi dla man IV
604// 
605   for (int i = 0; i
606  <= LiczbaKlawiszy -1; i++) {
607    if(Key4[i] != Key4_last[i] ) {
608    if(Key4[i]
609  == 0)  {
610      noteOn(channel_on, 36+i, vol);
611    }
612    else  {
613      noteOn(channel_off,
614  36+i, 0x00);
615      noteOn(channel_off, 36+i, 0x00);
616    }
617  }
618  }
619
620    //*****************************************
621 //Obsługa man V
622digitalWrite(
623  pin_E1_man1, HIGH); 
624digitalWrite( pin_E1_man2, HIGH);
625digitalWrite( pin_E1_man3,
626  HIGH); 
627digitalWrite( pin_E1_man4, HIGH);
628digitalWrite( pin_E1_man5, LOW);//
629  właczenie III man do odczytu
630channel_on = 0x94; // ustawienie kanałów dla IV
631  man - kanal 4
632channel_off = 0x84; // kanal 5
633
634  digitalWrite(pin_adress0,
635  LOW);
636  digitalWrite(pin_adress1, LOW);
637  digitalWrite(pin_adress2, LOW);
638  // read 1-st (first) octet
639      for (int i = 0; i <= 7; i++) {
640      Key5[i+0*8]
641  = digitalRead(pin_data[i]);
642     }
643
644  digitalWrite(pin_adress0, HIGH);
645
646  digitalWrite(pin_adress1, LOW);
647  digitalWrite(pin_adress2, LOW); // read 2-st
648  (second) octet
649      for (int i = 0; i <= 7; i++) {
650      Key5[i+1*8] = digitalRead(pin_data[i]);
651
652     }
653  
654  digitalWrite(pin_adress0, LOW);
655  digitalWrite(pin_adress1,
656  HIGH);
657  digitalWrite(pin_adress2, LOW); // read 3-st (thrid) octet
658  
659
660      for (int i = 0; i <= 7; i++) {
661      Key5[i+2*8] = digitalRead(pin_data[i]);
662
663     }
664
665  digitalWrite(pin_adress0, HIGH);
666  digitalWrite(pin_adress1,
667  HIGH);
668  digitalWrite(pin_adress2, LOW); // read 4-st (quad) octet
669  
670
671   for (int i = 0; i <= 7; i++) {
672      Key5[i+3*8] = digitalRead(pin_data[i]);
673
674     }
675  digitalWrite(pin_adress0, LOW);
676  digitalWrite(pin_adress1, LOW);
677
678  digitalWrite(pin_adress2, HIGH); // read 5-st (quad) octet
679   for (int i =
680  0; i <= 7; i++) {
681      Key5[i+4*8] = digitalRead(pin_data[i]);
682     }
683
684
685  digitalWrite(pin_adress0, HIGH);
686  digitalWrite(pin_adress1, LOW);
687  digitalWrite(pin_adress2,
688  HIGH); // read 6-st (qwint) octet
689   for (int i = 0; i <= 7; i++) {
690      Key5[i+5*8]
691  = digitalRead(pin_data[i]);
692     }
693
694  digitalWrite(pin_adress0, LOW);
695
696  digitalWrite(pin_adress1, HIGH);
697  digitalWrite(pin_adress2, HIGH); // read
698  7-st (sext) octet
699   for (int i = 0; i <= 7; i++) {
700      Key5[i+6*8] = digitalRead(pin_data[i]);
701
702     }
703  digitalWrite(pin_adress0, HIGH);
704  digitalWrite(pin_adress1, HIGH);
705
706  digitalWrite(pin_adress2, HIGH); // read 8-st (sept) octet
707   for (int i =
708  0; i <= 7; i++) {
709      Key5[i+7*8] = digitalRead(pin_data[i]);
710     }
711
712  
713  
714
715//****************************************************
716// porównywanie
717  odczytów i wysyłanie komunikatów midi dla man V
718// 
719   for (int i = 0; i <=
720  LiczbaKlawiszy -1; i++) {
721    if(Key5[i] != Key5_last[i] ) {
722    if(Key5[i]
723  == 0)  {
724      noteOn(channel_on, 36+i, vol);
725    }
726    else  {
727      noteOn(channel_off,
728  36+i, 0x00);
729      noteOn(channel_off, 36+i, 0x00);
730    }
731  }
732  }
733
734  //*****************************************************
735  
736  for (int i =
737  0; i <= LiczbaKlawiszy -1; i++) {
738  Key_last[i] = Key[i];
739 }
740 for (int
741  i = 0; i <= LiczbaKlawiszy -1 ; i++) {
742  Key2_last[i] = Key2[i];
743 }
744 for
745  (int i = 0; i <= LiczbaKlawiszy -1 ; i++) {
746  Key3_last[i] = Key3[i];
747 }  
748
749  for (int i = 0; i <= LiczbaKlawiszy -1 ; i++) {
750  Key4_last[i] = Key4[i];
751
752  }  
753  for (int i = 0; i <= LiczbaKlawiszy -1 ; i++) {
754  Key5_last[i] = Key5[i];
755
756  }  
757 //**************************************
758
759 // moduł sygnalizacji działania
760  
761 //----------------------------------------------------------
762 unsigned long
763  currentMillis = millis();
764 // szybkość działania programu
765 // Serial.println(currentMillis);
766
767
768  if (currentMillis - previousMillis >= interval) {
769    // save the last time
770  you blinked the LED
771    previousMillis = currentMillis;
772
773    // if the
774  LED is off turn it on and vice-versa:
775    if (ledState == LOW) {
776      ledState
777  = HIGH;
778    } else {
779      ledState = LOW;
780    }
781
782    // set the
783  LED with the ledState of the variable:
784    digitalWrite(LED_BUILTIN, ledState);
785
786  }
787//---------------------------------------------------------------  
788}
789
790
791  void noteOn(byte cmd, byte data1, byte data2) {
792   Serial.write(cmd);
793   Serial.write(data1);
794
795   Serial.write(data2);
796   
797   digitalWrite(LED_BUILTIN, HIGH);
798   delay(5);
799
800   digitalWrite(LED_BUILTIN, LOW);
801 }