Midi Setzer for Organ (Pipe Organ)

1#include <PCF8574.h>
2#include <Wire.h>
3#include <EEPROM.h>
4
5PCF8574  expander1;
6PCF8574 expander2;
7PCF8574 expander3;
8PCF8574 expander4;
9PCF8574  expander5;
10PCF8574 expander6;
11PCF8574 expander7;
12PCF8574 expander8;
13PCF8574  expander9;
14PCF8574 expander10;
15PCF8574 expander11;
16PCF8574 expander12;
17
18const  int cmdOn = 0x93; // definicja stałej okresłajacej komendę noteON for chanel 4 (  0x80 dla kanał 1)
19const int cmdOff = 0x83; // definicja stałej okresłajacej komendę  noteON for for chanel 4 ( 0x80 dla kanał 1)
20
21byte a;
22byte b;
23// byte  c;
24// int value;
25//byte b2;
26//byte b3;
27//byte b6;
28//byte b7;
29//byte  b10;
30
31byte nastawa_expander1[6];
32byte nastawa_expander4[6];
33byte nastawa_expander5[6];
34byte  nastawa_expander8[6];
35byte nastawa_expander9[6];
36
37byte cresc_expander1[20];
38byte  cresc_expander4[20];
39byte cresc_expander5[20];
40byte cresc_expander8[20];
41byte  cresc_expander9[20];
42
43
44
45 // byte value1_5;
46 // byte value1_6;
47  // byte value1_7;
48 // byte value2_5;
49 // byte value2_6;
50 // byte value2_7;
51  // int stanReg1 = 0;
52 // int stanReg2 = 0;
53 
54// the setup function runs  once when you press reset or power the board
55void setup() {
56   expander1.begin(0x20);  //   expander.begin(0x20) dla wersji A
57   expander2.begin(0x21); 
58   expander3.begin(0x22);  
59   expander4.begin(0x23); 
60   expander5.begin(0x24); 
61   expander6.begin(0x25);  
62   expander7.begin(0x26); 
63   expander8.begin(0x27);  
64   expander9.begin(0x38);  //   expander.begin(0x38) dla wersji B
65   expander10.begin(0x39);
66   expander11.begin(0x3A);
67   expander12.begin(0x3B);
68   
69  // initialize digital pin's for OUTPUT or  INPUT
70  //  pinMode(13, OUTPUT); //dioda arduino
71  //  pinMode(12, OUTPUT);  
72  //  pinMode(3, INPUT_PULLUP); 
73  //  pinMode(4, INPUT_PULLUP); 
74
75  pinMode(8, INPUT_PULLUP); //set
76  
77  pinMode(9, INPUT_PULLUP); //set to  EPROM
78
79  pinMode(10, INPUT_PULLUP); // jesli LOW to zapis do eprom prog crescendo
80
81  
82  pinMode(11, INPUT_PULLUP); // jesli LOW to programowanie crescendo
83  
84//  Odczyt nastaw z EPROM-u dla WK
85 for (int i = 0; i < 6; i++){
86  nastawa_expander1[i]  = EEPROM.read(i + 10);
87  nastawa_expander4[i] = EEPROM.read(i + 20);
88  nastawa_expander5[i]  = EEPROM.read(i + 30);
89  nastawa_expander8[i] = EEPROM.read(i + 40);
90  nastawa_expander9[i]  = EEPROM.read(i + 50);
91} 
92// Odczyt nastaw z EPROM-u dla crescendo
93 for  (int i = 0; i < 20; i++){
94  cresc_expander1[i] = EEPROM.read(i + 100);
95  cresc_expander4[i]  = EEPROM.read(i + 125);
96  cresc_expander5[i] = EEPROM.read(i + 150);
97  cresc_expander8[i]  = EEPROM.read(i + 175);
98  cresc_expander9[i] = EEPROM.read(i + 200);
99} 
100
101                // Ustawienia wyjść (out) expanderów
102 for (int i=0; i<8; i++){
103  expander1.pinMode(i, OUTPUT); // ustawia piny expandera nr 1 jako wyjścia - sterowanie  diodami i elektromagnesami głosowymi
104 }       
105 for (int i=0; i<8; i++){
106  expander4.pinMode(i, OUTPUT); // ustawia piny expandera nr 4 jako wyjścia - sterowanie  diodami i elektromagnesami głosowymi
107 }       
108 for (int i=0; i<8; i++){
109  expander5.pinMode(i, OUTPUT); // ustawia piny expandera nr 5 jako wyjścia - elektromagnesy  głosowe
110 }       
111 for (int i=0; i<8; i++){
112  expander8.pinMode(i, OUTPUT);  //ustawia piny expandera nr 8 jako wyjścia - elektromagnesy głosowe
113 }       
114  for (int i=0; i<8; i++){
115  expander9.pinMode(i, OUTPUT); // ustawia piny expandera  nr 9 jako wyjścia - elektromagnesy głosowe
116 }       
117 for (int i=0; i<8; i++){
118  expander12.pinMode(i, OUTPUT); //ustawia piny expandera nr 12 jako wyjścia (lamoki  WK 1 - WK6, C, CR)
119 }       
120 
121              // Ustawienia wejść (in) expanderów
122  for (int i=0; i<8; i++){
123      expander2.pinMode(i, INPUT_PULLUP); //ustawia  piny expandera nr 2 jako wejscia i podciaga je do HIGH - manubria registrowe
124  }    
125  for (int i=0; i<8; i++){
126      expander3.pinMode(i, INPUT_PULLUP);  // ustawia piny expandera nr 3 jako wejscia manubria registrowe
127  }    
128   for  (int i=0; i<8; i++){
129      expander6.pinMode(i, INPUT_PULLUP); // ustawia piny  expandera nr 6 jako wejscia manubria registrowe
130  }    
131   for (int i=0; i<8;  i++){
132      expander7.pinMode(i, INPUT_PULLUP); // ustawia piny expandera nr  7 jako wejscia manubria registrowe
133  }    
134   for (int i=0; i<8; i++){
135      expander10.pinMode(i, INPUT_PULLUP); // ustawia piny expandera nr 10 jako  wejsciamanubria registrowe
136  }    
137   for (int i=0; i<8; i++){
138      expander11.pinMode(i,  INPUT_PULLUP); // ustawia piny expandera nr 1 jako wejscia
139                                           //  przyciski WK 1- WK6, C, CR 
140  }    
141
142  // ustawienia startowe expanderów
143  expander1.write(0); 
144 expander4.write(0); 
145 expander5.write(0); 
146 expander8.write(0);
147  expander9.write(0);
148 expander12.write(64);
149  
150  Serial.begin(31250); //Ustawienie  prędkości transmisji (dla Midi Serial.begin(31250), dla monitora portu szeregowego  Serial.begin(9600)
151  // Serial.println("Setzer Ver.2");
152  
153} 
154
155//  the loop function runs over and over again forever
156
157void loop()
158{
159  zmiana_registrow();
160  
161  if (digitalRead(8) == LOW){
162    delay(10);
163    memory_WK(); 
164    //  Serial.println("memory");
165  }
166  else{  
167    zmiana_WK();
168    // Serial.println("zmiana  WK");
169  }
170  
171   if (digitalRead(9) == LOW){ // przycisk 9 włącza zapis  nastawien do EPROM
172    delay(10);
173    set_to_EPROM(); 
174    while (digitalRead(9)  == LOW) {} // pusta pętla while zapobiegająca ponownemu wpisowi do eprom
175    delay(10);
176   }
177   
178   if (digitalRead(10) == LOW){ // przycisk 10 włącza zapis nastawien  cresc do EPROM
179    delay(10);
180    cresc_to_EPROM(); 
181    while (digitalRead(10)  == LOW) {} // pusta pętla while zapobiegająca ponownemu wpisowi do eprom
182    delay(10);
183   }
184   
185   if (digitalRead(11) == LOW){ // przycisk 11 włącza programowanie  cresc
186    delay(10);
187    prog_crescendo(); 
188   }
189}
190
191
192/*
193
194  
195  //sprawdzanie stanu przycisków
196//  byte value3 = digitalRead(3); // WK  1
197//  byte value4 = digitalRead(4); // WK 2
198//  byte value8 = digitalRead(8);  // Set
199  
200 // jesli wcisniety WK1 i set - zapis stanu registrów do zmiennej  stan_reg1
201  //if (value3 == LOW && value8 == LOW){
202//stanReg1 = spr_reg();
203  //   // Serial.println("Zapamietano stan registrów dla WK-1");
204 //   // Serial.println(stanReg1);  
205 // }
206 // jesli wcisniety WK2 i set - zapis stanu registrów do zmiennej stan_reg2  
207 // if (value4 == LOW && value8 == LOW){
208stanReg2 = spr_reg(); 
209  
210  //   // Serial.println("Zapamietano stan registrów dla WK-2");
211 //   // Serial.println(stanReg2);
212//  }
213  // WK1
214//  if (value3 == LOW){
215//  digitalWrite(13, LOW); // zapala  diode WK1
216//  digitalWrite(12, HIGH);
217//  ust_wyj(stanReg1);
218//  // Serial.println("Włączono  WK-1");
219//  // Serial.println(stanReg1);
220//  }
221//  // turn the LED on  (HIGH is the voltage level)
222//  delay(100);                       // wait for  a second
223  // WK2
224 // if (value4 == LOW){
225 // digitalWrite(13, HIGH);
226  // digitalWrite(12, LOW);  // zapala diodę WK2
227//  ust_wyj(stanReg2);
228//  //  Serial.println("Włączono WK-2");
229 // // Serial.println(stanReg2);
230 // }
231  // turn the LED on (HIGH is the voltage level)
232 // delay(100);                       //  wait for a second
233//}
234
235
236// ---- koniec sekcji loop-----
237// ---- rozpoczyna  sie obszar funkcji 
238
239
240//funkcja zapisu stanu registrów
241int spr_reg()
242{
243  int a = 0;
244  
245  // jesli wlączony register 1
246  if (expander1.digitalRead(0)  == LOW){
247    bitSet(a,0);
248  }
249  else{
250    bitClear(a,0);
251  }
252    // jesli wlączony register 2
253  if (expander.digitalRead(1) == LOW) {
254    bitSet(a,1);
255  }
256   else{
257    bitClear(a,1);
258  }
259    // jesli  wlączony register 3
260  if (expander.digitalRead(2) == LOW){
261    bitSet(a,2);
262  }
263
264  else{
265    bitClear(a,2);
266  }
267    // jesli wlączony register  3
268  if (expander.digitalRead(3) == LOW){
269    bitSet(a,2);
270  }
271
272  else{
273    bitClear(a,2);
274  }
275  // Serial.println("Odczytano stan registrów");
276  // Serial.println(a);
277  return a;
278  }
279  
280// ustawienie wyjść do sterowania  elektromagnesami w/g stałej value_sum
281void ust_wyj(int stan_reg){
282  if bitRead(stan_reg,0){
283       expander.digitalWrite(4,LOW); // jeśli najmniejznaczacy bit jest ustawiony  włącz elektromagnes nr  1 
284  }
285    else{
286      expander.digitalWrite(4,HIGH);
287    }
288    if bitRead(stan_reg,1){
289       expander.digitalWrite(5,LOW); //  włącza elektromagness nr 2
290  }
291    else{
292      expander.digitalWrite(5,HIGH);
293    }
294    if bitRead(stan_reg,2){
295       expander.digitalWrite(6,LOW); //  włącza elektromagnes nr 3
296       
297  }
298    else{
299      expander.digitalWrite(6,HIGH);
300    } 
301    if bitRead(stan_reg,3){
302       expander.digitalWrite(7,LOW); //  włącza elektromagnes nr 3
303       
304  }
305    else{
306      expander.digitalWrite(7,HIGH);
307    } 
308    
309}
310*/
311
312// funkcja zmienia stan registru po przycisnienciu  manubrium i wysyła komunikat midi
313 void zmiana_registrow() {
314  
315 // I para  expanderów - sprawdzanie pinów expandera nr 2 i ustaiwanie pinów expandera nr 1
316   for (int i=0; i<8; i++){
317      
318       if (expander2.digitalRead(i) ==  LOW) { 
319        delay(20);
320       
321                   expander1.toggle(i);
322             if (expander1.digitalRead(i) == HIGH){
323                noteSend(cmdOn,  i+36, 0x45);
324             }
325             else{
326                noteSend(cmdOff,  i+36, 0x00);
327             }
328              delay(300);
329           // while  (expander2.digitalRead(i)) {}
330      
331          //a = expander1.read();
332          // Serial.println("stan registrów na 2-1");
333          // Serial.println(a);
334          // Serial.println(b2); 
335          }
336    }   
337  
338 // II para  expanderów - sprawdzanie pinów expandera nr 3 i ustaiwanie pinów expandera nr 4   
339    for (int i=0; i<8; i++){
340      
341      if (expander3.digitalRead(i)  == LOW) { 
342        delay(20);
343
344             expander4.toggle(i);
345            if  (expander4.digitalRead(i) == HIGH){
346                noteSend(cmdOn, i+44, 0x45);
347             }
348             else{
349                noteSend(cmdOff, i+44, 0x00);
350             }
351              delay(300);
352          
353        // while (expander3.digitalRead(i))  {}
354          // a = expander4.read();
355          // Serial.println("stan registrów  na 3-4");
356          // Serial.println(a);
357          // Serial.println(b);  
358          
359     }  
360   }
361   
362// III para expanderów -  sprawdzanie  pinów expandera nr 6 i ustaiwanie pinów expandera nr 5     
363    for (int i=0;  i<8; i++){
364      
365      if (expander6.digitalRead(i) == LOW) { 
366        delay(20);
367          expander5.toggle(i);
368          if (expander5.digitalRead(i) == HIGH){
369                noteSend(cmdOn, i+52, 0x45);
370             }
371             else{
372                noteSend(cmdOff, i+52, 0x00);
373             }
374              delay(300);
375        //  while (expander6.digitalRead(i)) {}
376        //  a = expander5.read();
377          // Serial.println("stan registrów na 6-5");
378          // Serial.println(a);
379          // Serial.println(b6); 
380         
381     }  
382   }
383   
384
385//  IV para expanderów - sprawdzanie pinów expandera nr 7 i ustaiwanie pinów expandera  nr 8     
386    for (int i=0; i<8; i++){
387      
388      if (expander7.digitalRead(i)  == LOW) { 
389        delay(20);
390          expander8.toggle(i);
391          if  (expander8.digitalRead(i) == HIGH){
392                noteSend(cmdOn, i+60, 0x45);
393             }
394             else{
395               noteSend(cmdOff, i+60, 0x00);
396             }
397              delay(300);
398            // while (expander7.digitalRead(i))  {} 
399          //a = expander8.read();
400          // Serial.println("stan registrów  na 7-8");
401          // Serial.println(a);
402          // Serial.println(b7);  
403         
404     }  
405   }     
406   
407 // V para expanderów - sprawdzanie  pinów expandera nr 10 i ustaiwanie pinów expandera nr 9    
408    for (int i=0;  i<8; i++){
409      
410      if (expander10.digitalRead(i) == LOW) { 
411        delay(20);
412         expander9.toggle(i);
413         
414           if (expander9.digitalRead(i)  == HIGH){
415                noteSend(cmdOn, i + 68, 0x45);
416             }
417             else{
418                noteSend(cmdOff, i + 68, 0x00);
419             }
420              delay(300);
421           //   while (expander10.digitalRead(i)) {}
422          // a = expander9.read();
423          // Serial.println("stan registrów  na 10-9");
424          // Serial.println(a);
425          // Serial.println(b10);  
426        
427     }  
428   }
429 } 
430
431// ************** procedura zmian  WK *****************     
432 void zmiana_WK(){
433 b = expander11.read();    
434    
435// włączenie WK
436  for (int i=0; i<8; i++){
437      if (expander11.digitalRead(i)  == LOW) { // sprawdza piny expandera nr 11, jesli LOW to
438         delay(20);
439         switch (i) {    // usrawia expandery registrowe nr 1,4,5,6,9 wg zapamietanej  nastawy 
440  case 0:
441    // WK 1
442    expander12.write(1); // zapala lampkę  pod przyciskiem WK 1
443b = expander1.read();
444  expander1.write(nastawa_expander1[i]);
445    operacjaNaBitach(b, nastawa_expander1[i], 36);
446b = expander4.read();    
447  expander4.write(nastawa_expander4[i]);
448    operacjaNaBitach(b, nastawa_expander4[i],  44);
449b = expander5.read();
450 expander5.write(nastawa_expander5[i]);
451  operacjaNaBitach(b,  nastawa_expander5[i], 52) ;
452b = expander8.read();
453 expander8.write(nastawa_expander8[i]);
454  operacjaNaBitach(b, nastawa_expander8[i], 60);
455b = expander9.read();
456  expander9.write(nastawa_expander9[i]);
457    operacjaNaBitach(b, nastawa_expander9[i], 68);
458    break;
459  case 1:
460    // WK 2
461    expander12.write(2);
462b = expander1.read();
463  expander1.write(nastawa_expander1[i]);
464    operacjaNaBitach(b, nastawa_expander1[i], 36);
465b = expander4.read();    
466  expander4.write(nastawa_expander4[i]);
467    operacjaNaBitach(b, nastawa_expander4[i],  44);
468b = expander5.read();
469 expander5.write(nastawa_expander5[i]);
470  operacjaNaBitach(b,  nastawa_expander5[i], 52);
471b = expander8.read();
472 expander8.write(nastawa_expander8[i]);
473  operacjaNaBitach(b, nastawa_expander8[i], 60);
474b = expander9.read();
475  expander9.write(nastawa_expander9[i]);
476    operacjaNaBitach(b, nastawa_expander9[i], 68);
477    break;
478      case 2:
479    // WK 3
480    expander12.write(4);
481b = expander1.read();
482  expander1.write(nastawa_expander1[i]);
483    operacjaNaBitach(b, nastawa_expander1[i], 36);
484b = expander4.read();    
485  expander4.write(nastawa_expander4[i]);
486    operacjaNaBitach(b, nastawa_expander4[i],  44);
487b = expander5.read();
488 expander5.write(nastawa_expander5[i]);
489  operacjaNaBitach(b,  nastawa_expander5[i], 52);
490b = expander8.read();
491 expander8.write(nastawa_expander8[i]);
492  operacjaNaBitach(b, nastawa_expander8[i], 60);
493b = expander9.read();
494  expander9.write(nastawa_expander9[i]);
495    operacjaNaBitach(b, nastawa_expander9[i], 68);
496    break;
497      case 3:
498    // WK 4
499    expander12.write(8);
500b = expander1.read();
501  expander1.write(nastawa_expander1[i]);
502    operacjaNaBitach(b, nastawa_expander1[i], 36);
503b = expander4.read();    
504  expander4.write(nastawa_expander4[i]);
505    operacjaNaBitach(b, nastawa_expander4[i],  44);
506b = expander5.read();
507 expander5.write(nastawa_expander5[i]);
508  operacjaNaBitach(b,  nastawa_expander5[i], 52);
509b = expander8.read();
510 expander8.write(nastawa_expander8[i]);
511  operacjaNaBitach(b, nastawa_expander8[i], 60);
512b = expander9.read();
513  expander9.write(nastawa_expander9[i]);
514    operacjaNaBitach(b, nastawa_expander9[i], 68);    
515    break;
516      case  4:
517    // WK 5
518    expander12.write(16);
519b = expander1.read();
520  expander1.write(nastawa_expander1[i]);
521    operacjaNaBitach(b, nastawa_expander1[i], 36);
522b = expander4.read();    
523  expander4.write(nastawa_expander4[i]);
524    operacjaNaBitach(b, nastawa_expander4[i],  44);
525b = expander5.read();
526 expander5.write(nastawa_expander5[i]);
527  operacjaNaBitach(b,  nastawa_expander5[i], 52);
528b = expander8.read();
529 expander8.write(nastawa_expander8[i]);
530  operacjaNaBitach(b, nastawa_expander8[i], 60);
531b = expander9.read();
532  expander9.write(nastawa_expander9[i]);
533    operacjaNaBitach(b, nastawa_expander9[i], 68);    
534    break;
535      case  5:
536    // WK 6
537    expander12.write(32);
538b = expander1.read();
539  expander1.write(nastawa_expander1[i]);
540    operacjaNaBitach(b, nastawa_expander1[i], 36);
541b = expander4.read();    
542  expander4.write(nastawa_expander4[i]);
543    operacjaNaBitach(b, nastawa_expander4[i],  44);
544b = expander5.read();
545 expander5.write(nastawa_expander5[i]);
546  operacjaNaBitach(b,  nastawa_expander5[i], 52);
547b = expander8.read();
548 expander8.write(nastawa_expander8[i]);
549  operacjaNaBitach(b, nastawa_expander8[i], 60);
550b = expander9.read();
551  expander9.write(nastawa_expander9[i]);
552    operacjaNaBitach(b, nastawa_expander9[i], 68);   
553    break;
554      case  6:
555          // C - kasownik
556          expander12.write(64);
557expander1.write(0);
558expander4.write(0);
559expander5.write(0);
560expander8.write(0);
561expander9.write(0);
562          noteSendAllNoteOff();
563    break;  
564      case 7:
565      // CR  - crescendo
566        expander12.write(128);
567    
568        crescendo();
569    
570    break;
571
572}
573         
574           delay(200);
575           a  = expander12.read();
576           // Serial.println("stan WK na 11-12");
577           // Serial.println(a);
578           // Serial.println(b); 
579           
580}
581  
582}
583}
584
585// ****************** Procedura zmian i zapamietania ustawień  dla WK ( programowanie WK) ************
586// zapamiętanie ustawień WK ( SET )
587void  memory_WK(){
588 // // Serial.println("wewnątrz funkcji memory");
589 b = expander11.read();    
590    
591// set WK
592  for (int i=0; i<8; i++){
593      if (expander11.digitalRead(i)  == LOW) { 
594         delay(20);
595         switch (i) {
596  case 0:
597    //  odczyt i zapamiętanie nastawy dla WK 1
598    expander12.write(1);
599nastawa_expander1[i]  = expander1.read();
600nastawa_expander4[i] = expander4.read();
601nastawa_expander5[i]  = expander5.read();
602nastawa_expander8[i] = expander8.read();
603nastawa_expander9[i]  = expander9.read();
604    break;
605  case 1:
606    // odczyt i zapamiętanie nastawy  dla WK 2
607    expander12.write(2);
608nastawa_expander1[i] = expander1.read();
609nastawa_expander4[i]  = expander4.read();
610nastawa_expander5[i] = expander5.read();
611nastawa_expander8[i]  = expander8.read();
612nastawa_expander9[i] = expander9.read();
613    break;
614      case 2:
615    // odczyt i zapamiętanie nastawy dla WK 3
616    expander12.write(4);
617nastawa_expander1[i]  = expander1.read();
618nastawa_expander4[i] = expander4.read();
619nastawa_expander5[i]  = expander5.read();
620nastawa_expander8[i] = expander8.read();
621nastawa_expander9[i]  = expander9.read();
622    break;
623      case 3:
624    // odczyt i zapamiętanie  nastawy dla WK 4
625    expander12.write(8);
626nastawa_expander1[i] = expander1.read();
627nastawa_expander4[i]  = expander4.read();
628nastawa_expander5[i] = expander5.read();
629nastawa_expander8[i]  = expander8.read();
630nastawa_expander9[i] = expander9.read();    
631    break;
632      case 4:
633    // odczyt i zapamiętanie nastawy dla WK 5
634    expander12.write(16);
635nastawa_expander1[i]  = expander1.read();
636nastawa_expander4[i] = expander4.read();
637nastawa_expander5[i]  = expander5.read();
638nastawa_expander8[i] = expander8.read();
639nastawa_expander9[i]  = expander9.read();    
640    break;
641      case 5:
642    // odczyt i zapamiętanie  nastawy dla WK 6
643    expander12.write(32);
644nastawa_expander1[i] = expander1.read();
645nastawa_expander4[i]  = expander4.read();
646nastawa_expander5[i] = expander5.read();
647nastawa_expander8[i]  = expander8.read();
648nastawa_expander9[i] = expander9.read();   
649    break;
650      case 6:
651          // odczyt i zapamiętanie nastawy dla C 
652          expander12.write(64);
653nastawa_expander1[i]  = expander1.read();
654nastawa_expander4[i] = expander4.read();
655nastawa_expander5[i]  = expander5.read();
656nastawa_expander8[i] = expander8.read();
657nastawa_expander9[i]  = expander9.read();
658    break;  
659    case 7:
660    // odczyt i zapamiętanie  nastawy dla CR
661    expander12.write(128);
662nastawa_expander1[i] = expander1.read();
663nastawa_expander4[i]  = expander4.read();
664nastawa_expander5[i] = expander5.read();
665nastawa_expander8[i]  = expander8.read();
666nastawa_expander9[i] = expander9.read();   
667    break;
668
669}
670          
671           delay(200);
672           a = expander12.read();
673           //  Serial.println("stan WK na 11-12");
674           // Serial.println(a);
675           //  Serial.println(b); 
676          // }
677      }
678 }
679}  
680void set_to_EPROM()  {
681    for (int i = 0; i < 6; i++){ // zapis nastaw dla do EPROM
682      EEPROM.write(i  + 10, nastawa_expander1[i]);
683      EEPROM.write(i + 20, nastawa_expander4[i]);
684      EEPROM.write(i + 30, nastawa_expander5[i]);
685      EEPROM.write(i + 40,  nastawa_expander8[i]);
686      EEPROM.write(i + 50, nastawa_expander9[i]);
687      EEPROM.write(i + 60, nastawa_expander9[i]);
688   } 
689   
690    for (int  i = 0; i < 5; i++){ // znak że zapisano - mryganie lampek
691    expander12.write(255);
692    delay(30);
693    expander12.write(0); 
694    delay(30); 
695    delay(2000);
696    }
697}
698
699void noteSend(int cmd, int pitch, int velocity) {
700  Serial.write(cmd);
701  Serial.write(pitch);
702  Serial.write(velocity);
703}  
704void noteSendAllNoteOff()  {
705  Serial.write(0xB3);
706  Serial.write(123);
707  Serial.write(0);
708} 
709      
710// fonkcja operacjaNaBitach porównuje nastawy przed wciśnienciem WK i  po i wysyła odpowiednie komunikaty midi
711void operacjaNaBitach(int przed, int  po, int ofset){
712        
713   if (przed != po){
714    
715      for (int i  = 0; i < 8; i++){
716       if (bitRead(po,i) != bitRead(przed,i)){
717        
718           if bitRead(po,i){
719              noteSend(cmdOn, i + ofset, 0x45);
720            }
721            else{
722               noteSend(cmdOff, i + ofset,  0x00);
723            }
724        }
725      }
726    }
727}
728
729// **** Procedura  obsługi crescendo *********
730void crescendo(){ 
731  // Serial.println("wejscie  do procedury crescendo");
732  int value;
733  int c;
734  while ( expander12.digitalRead(7)  == HIGH ){
735    
736     if (digitalRead(11) == LOW) { 
737      prog_crescendo();
738     
739     }
740     
741      if (digitalRead(10) == LOW){ // przycisk 9 włącza  zapis nastawien do EPROM
742      delay(10);
743      cresc_to_EPROM(); 
744      while  (digitalRead(10) == LOW) {} // pusta petla zapobiega ponownemu wpisaniu do EPROM
745      delay(10);
746      }
747      
748      zmiana_WK();
749
750     while (c  == value) {
751     c = value; 
752     value = analogRead(A0); //Odczytujemy wartość  napięcia na pinie A0
753     delay(10);
754     value = map(value, 0, 1000, 0, 19);//Przeskalowanie  wartości
755     //value = value / 51;
756     zmiana_registrow(); 
757     zmiana_WK();
758     // return value; 
759     }
760     c = value;
761     
762
763b = expander1.read();
764  expander1.write(cresc_expander1[value]);
765    operacjaNaBitach(b, cresc_expander1[value],  36);
766b = expander4.read();    
767  expander4.write(cresc_expander4[value]);
768    operacjaNaBitach(b, cresc_expander4[value], 44);
769b = expander5.read();
770  expander5.write(cresc_expander5[value]);
771  operacjaNaBitach(b, cresc_expander5[value],  52);
772b = expander8.read();
773 expander8.write(cresc_expander8[value]);
774  operacjaNaBitach(b,  cresc_expander8[value], 60);
775b = expander9.read();
776  expander9.write(cresc_expander9[value]);
777    operacjaNaBitach(b, cresc_expander9[value], 68);
778     // Serial.println(value);
779     delay(100);
780    
781  }
782}
783
784// **** Procedura programowania crescendo  *********
785void prog_crescendo(){ 
786  expander12.write(128+64);
787
788   for  (int i=0; i<20; i++){
789      
790         delay(20);
791         while (digitalRead(8)  == HIGH) { 
792          zmiana_registrow();
793          }
794         delay(500);
795         
796    // odczyt i zapamiętanie nastawy dla 20-stopniowego crescendo
797    expander12.write(i+1+64+128);
798cresc_expander1[i] = expander1.read();
799cresc_expander4[i]  = expander4.read();
800cresc_expander5[i] = expander5.read();
801cresc_expander8[i]  = expander8.read();
802cresc_expander9[i] = expander9.read();
803          delay(500);  
804   }   
805expander12.write(0); 
806delay(1000); 
807expander12.write(128);  
808}
809
810// Zapis ustawień crescendo do EPROM
811void cresc_to_EPROM() {
812    for (int i = 0; i < 20; i++){ // zapis nastaw dla do EPROM
813      EEPROM.write(i  + 100, cresc_expander1[i]);
814      EEPROM.write(i + 125, cresc_expander4[i]);
815      EEPROM.write(i + 150, cresc_expander5[i]);
816      EEPROM.write(i + 175,  cresc_expander8[i]);
817      EEPROM.write(i + 200, cresc_expander9[i]);
818      
819   } 
820   
821    for (int i = 0; i < 5; i++){ // znak że zapisano - mryganie  lampek
822    expander12.write(255);
823    delay(200);
824    expander12.write(0);  
825    delay(200); 
826    }
827    delay(2000);
828    
829}
830// while (digitalRead(7)  == LOW) {} //Jeśli przycisk 7 jest wciśnięty program nic nie robi 

1#include <PCF8574.h>
2#include <Wire.h>
3#include <EEPROM.h>
4
5PCF8574
6  expander1;
7PCF8574 expander2;
8PCF8574 expander3;
9PCF8574 expander4;
10PCF8574
11  expander5;
12PCF8574 expander6;
13PCF8574 expander7;
14PCF8574 expander8;
15PCF8574
16  expander9;
17PCF8574 expander10;
18PCF8574 expander11;
19PCF8574 expander12;
20
21const
22  int cmdOn = 0x93; // definicja stałej okresłajacej komendę noteON for chanel 4 (
23  0x80 dla kanał 1)
24const int cmdOff = 0x83; // definicja stałej okresłajacej komendę
25  noteON for for chanel 4 ( 0x80 dla kanał 1)
26
27byte a;
28byte b;
29// byte
30  c;
31// int value;
32//byte b2;
33//byte b3;
34//byte b6;
35//byte b7;
36//byte
37  b10;
38
39byte nastawa_expander1[6];
40byte nastawa_expander4[6];
41byte nastawa_expander5[6];
42byte
43  nastawa_expander8[6];
44byte nastawa_expander9[6];
45
46byte cresc_expander1[20];
47byte
48  cresc_expander4[20];
49byte cresc_expander5[20];
50byte cresc_expander8[20];
51byte
52  cresc_expander9[20];
53
54
55
56 // byte value1_5;
57 // byte value1_6;
58
59  // byte value1_7;
60 // byte value2_5;
61 // byte value2_6;
62 // byte value2_7;
63
64  // int stanReg1 = 0;
65 // int stanReg2 = 0;
66 
67// the setup function runs
68  once when you press reset or power the board
69void setup() {
70   expander1.begin(0x20);
71  //   expander.begin(0x20) dla wersji A
72   expander2.begin(0x21); 
73   expander3.begin(0x22);
74  
75   expander4.begin(0x23); 
76   expander5.begin(0x24); 
77   expander6.begin(0x25);
78  
79   expander7.begin(0x26); 
80   expander8.begin(0x27);  
81   expander9.begin(0x38);
82  //   expander.begin(0x38) dla wersji B
83   expander10.begin(0x39);
84   expander11.begin(0x3A);
85
86   expander12.begin(0x3B);
87   
88  // initialize digital pin's for OUTPUT or
89  INPUT
90  //  pinMode(13, OUTPUT); //dioda arduino
91  //  pinMode(12, OUTPUT);
92  
93  //  pinMode(3, INPUT_PULLUP); 
94  //  pinMode(4, INPUT_PULLUP); 
95
96
97  pinMode(8, INPUT_PULLUP); //set
98  
99  pinMode(9, INPUT_PULLUP); //set to
100  EPROM
101
102  pinMode(10, INPUT_PULLUP); // jesli LOW to zapis do eprom prog crescendo
103
104
105  
106  pinMode(11, INPUT_PULLUP); // jesli LOW to programowanie crescendo
107  
108//
109  Odczyt nastaw z EPROM-u dla WK
110 for (int i = 0; i < 6; i++){
111  nastawa_expander1[i]
112  = EEPROM.read(i + 10);
113  nastawa_expander4[i] = EEPROM.read(i + 20);
114  nastawa_expander5[i]
115  = EEPROM.read(i + 30);
116  nastawa_expander8[i] = EEPROM.read(i + 40);
117  nastawa_expander9[i]
118  = EEPROM.read(i + 50);
119} 
120// Odczyt nastaw z EPROM-u dla crescendo
121 for
122  (int i = 0; i < 20; i++){
123  cresc_expander1[i] = EEPROM.read(i + 100);
124  cresc_expander4[i]
125  = EEPROM.read(i + 125);
126  cresc_expander5[i] = EEPROM.read(i + 150);
127  cresc_expander8[i]
128  = EEPROM.read(i + 175);
129  cresc_expander9[i] = EEPROM.read(i + 200);
130} 
131
132
133                // Ustawienia wyjść (out) expanderów
134 for (int i=0; i<8; i++){
135
136  expander1.pinMode(i, OUTPUT); // ustawia piny expandera nr 1 jako wyjścia - sterowanie
137  diodami i elektromagnesami głosowymi
138 }       
139 for (int i=0; i<8; i++){
140
141  expander4.pinMode(i, OUTPUT); // ustawia piny expandera nr 4 jako wyjścia - sterowanie
142  diodami i elektromagnesami głosowymi
143 }       
144 for (int i=0; i<8; i++){
145
146  expander5.pinMode(i, OUTPUT); // ustawia piny expandera nr 5 jako wyjścia - elektromagnesy
147  głosowe
148 }       
149 for (int i=0; i<8; i++){
150  expander8.pinMode(i, OUTPUT);
151  //ustawia piny expandera nr 8 jako wyjścia - elektromagnesy głosowe
152 }       
153
154  for (int i=0; i<8; i++){
155  expander9.pinMode(i, OUTPUT); // ustawia piny expandera
156  nr 9 jako wyjścia - elektromagnesy głosowe
157 }       
158 for (int i=0; i<8; i++){
159
160  expander12.pinMode(i, OUTPUT); //ustawia piny expandera nr 12 jako wyjścia (lamoki
161  WK 1 - WK6, C, CR)
162 }       
163 
164              // Ustawienia wejść (in) expanderów
165
166  for (int i=0; i<8; i++){
167      expander2.pinMode(i, INPUT_PULLUP); //ustawia
168  piny expandera nr 2 jako wejscia i podciaga je do HIGH - manubria registrowe
169
170  }    
171  for (int i=0; i<8; i++){
172      expander3.pinMode(i, INPUT_PULLUP);
173  // ustawia piny expandera nr 3 jako wejscia manubria registrowe
174  }    
175   for
176  (int i=0; i<8; i++){
177      expander6.pinMode(i, INPUT_PULLUP); // ustawia piny
178  expandera nr 6 jako wejscia manubria registrowe
179  }    
180   for (int i=0; i<8;
181  i++){
182      expander7.pinMode(i, INPUT_PULLUP); // ustawia piny expandera nr
183  7 jako wejscia manubria registrowe
184  }    
185   for (int i=0; i<8; i++){
186
187      expander10.pinMode(i, INPUT_PULLUP); // ustawia piny expandera nr 10 jako
188  wejsciamanubria registrowe
189  }    
190   for (int i=0; i<8; i++){
191      expander11.pinMode(i,
192  INPUT_PULLUP); // ustawia piny expandera nr 1 jako wejscia
193                                           //
194  przyciski WK 1- WK6, C, CR 
195  }    
196
197  // ustawienia startowe expanderów
198
199  expander1.write(0); 
200 expander4.write(0); 
201 expander5.write(0); 
202 expander8.write(0);
203
204  expander9.write(0);
205 expander12.write(64);
206  
207  Serial.begin(31250); //Ustawienie
208  prędkości transmisji (dla Midi Serial.begin(31250), dla monitora portu szeregowego
209  Serial.begin(9600)
210  // Serial.println("Setzer Ver.2");
211  
212} 
213
214//
215  the loop function runs over and over again forever
216
217void loop()
218{
219  zmiana_registrow();
220
221  
222  if (digitalRead(8) == LOW){
223    delay(10);
224    memory_WK(); 
225    //
226  Serial.println("memory");
227  }
228  else{  
229    zmiana_WK();
230    // Serial.println("zmiana
231  WK");
232  }
233  
234   if (digitalRead(9) == LOW){ // przycisk 9 włącza zapis
235  nastawien do EPROM
236    delay(10);
237    set_to_EPROM(); 
238    while (digitalRead(9)
239  == LOW) {} // pusta pętla while zapobiegająca ponownemu wpisowi do eprom
240    delay(10);
241
242   }
243   
244   if (digitalRead(10) == LOW){ // przycisk 10 włącza zapis nastawien
245  cresc do EPROM
246    delay(10);
247    cresc_to_EPROM(); 
248    while (digitalRead(10)
249  == LOW) {} // pusta pętla while zapobiegająca ponownemu wpisowi do eprom
250    delay(10);
251
252   }
253   
254   if (digitalRead(11) == LOW){ // przycisk 11 włącza programowanie
255  cresc
256    delay(10);
257    prog_crescendo(); 
258   }
259}
260
261
262/*
263
264
265  
266  //sprawdzanie stanu przycisków
267//  byte value3 = digitalRead(3); // WK
268  1
269//  byte value4 = digitalRead(4); // WK 2
270//  byte value8 = digitalRead(8);
271  // Set
272  
273 // jesli wcisniety WK1 i set - zapis stanu registrów do zmiennej
274  stan_reg1
275  //if (value3 == LOW && value8 == LOW){
276//stanReg1 = spr_reg();
277
278  //   // Serial.println("Zapamietano stan registrów dla WK-1");
279 //   // Serial.println(stanReg1);
280  
281 // }
282 // jesli wcisniety WK2 i set - zapis stanu registrów do zmiennej stan_reg2
283  
284 // if (value4 == LOW && value8 == LOW){
285stanReg2 = spr_reg(); 
286  
287
288  //   // Serial.println("Zapamietano stan registrów dla WK-2");
289 //   // Serial.println(stanReg2);
290//
291  }
292  // WK1
293//  if (value3 == LOW){
294//  digitalWrite(13, LOW); // zapala
295  diode WK1
296//  digitalWrite(12, HIGH);
297//  ust_wyj(stanReg1);
298//  // Serial.println("Włączono
299  WK-1");
300//  // Serial.println(stanReg1);
301//  }
302//  // turn the LED on
303  (HIGH is the voltage level)
304//  delay(100);                       // wait for
305  a second
306  // WK2
307 // if (value4 == LOW){
308 // digitalWrite(13, HIGH);
309
310  // digitalWrite(12, LOW);  // zapala diodę WK2
311//  ust_wyj(stanReg2);
312//  //
313  Serial.println("Włączono WK-2");
314 // // Serial.println(stanReg2);
315 // }
316
317  // turn the LED on (HIGH is the voltage level)
318 // delay(100);                       //
319  wait for a second
320//}
321
322
323// ---- koniec sekcji loop-----
324// ---- rozpoczyna
325  sie obszar funkcji 
326
327
328//funkcja zapisu stanu registrów
329int spr_reg()
330{
331
332  int a = 0;
333  
334  // jesli wlączony register 1
335  if (expander1.digitalRead(0)
336  == LOW){
337    bitSet(a,0);
338  }
339  else{
340    bitClear(a,0);
341  }
342
343    // jesli wlączony register 2
344  if (expander.digitalRead(1) == LOW) {
345
346    bitSet(a,1);
347  }
348   else{
349    bitClear(a,1);
350  }
351    // jesli
352  wlączony register 3
353  if (expander.digitalRead(2) == LOW){
354    bitSet(a,2);
355
356  }
357
358  else{
359    bitClear(a,2);
360  }
361    // jesli wlączony register
362  3
363  if (expander.digitalRead(3) == LOW){
364    bitSet(a,2);
365  }
366
367  else{
368
369    bitClear(a,2);
370  }
371  // Serial.println("Odczytano stan registrów");
372
373  // Serial.println(a);
374  return a;
375  }
376  
377// ustawienie wyjść do sterowania
378  elektromagnesami w/g stałej value_sum
379void ust_wyj(int stan_reg){
380  if bitRead(stan_reg,0){
381
382       expander.digitalWrite(4,LOW); // jeśli najmniejznaczacy bit jest ustawiony
383  włącz elektromagnes nr  1 
384  }
385    else{
386      expander.digitalWrite(4,HIGH);
387
388    }
389    if bitRead(stan_reg,1){
390       expander.digitalWrite(5,LOW); //
391  włącza elektromagness nr 2
392  }
393    else{
394      expander.digitalWrite(5,HIGH);
395
396    }
397    if bitRead(stan_reg,2){
398       expander.digitalWrite(6,LOW); //
399  włącza elektromagnes nr 3
400       
401  }
402    else{
403      expander.digitalWrite(6,HIGH);
404
405    } 
406    if bitRead(stan_reg,3){
407       expander.digitalWrite(7,LOW); //
408  włącza elektromagnes nr 3
409       
410  }
411    else{
412      expander.digitalWrite(7,HIGH);
413
414    } 
415    
416}
417*/
418
419// funkcja zmienia stan registru po przycisnienciu
420  manubrium i wysyła komunikat midi
421 void zmiana_registrow() {
422  
423 // I para
424  expanderów - sprawdzanie pinów expandera nr 2 i ustaiwanie pinów expandera nr 1
425
426   for (int i=0; i<8; i++){
427      
428       if (expander2.digitalRead(i) ==
429  LOW) { 
430        delay(20);
431       
432                   expander1.toggle(i);
433
434             if (expander1.digitalRead(i) == HIGH){
435                noteSend(cmdOn,
436  i+36, 0x45);
437             }
438             else{
439                noteSend(cmdOff,
440  i+36, 0x00);
441             }
442              delay(300);
443           // while
444  (expander2.digitalRead(i)) {}
445      
446          //a = expander1.read();
447
448          // Serial.println("stan registrów na 2-1");
449          // Serial.println(a);
450
451          // Serial.println(b2); 
452          }
453    }   
454  
455 // II para
456  expanderów - sprawdzanie pinów expandera nr 3 i ustaiwanie pinów expandera nr 4
457   
458    for (int i=0; i<8; i++){
459      
460      if (expander3.digitalRead(i)
461  == LOW) { 
462        delay(20);
463
464             expander4.toggle(i);
465            if
466  (expander4.digitalRead(i) == HIGH){
467                noteSend(cmdOn, i+44, 0x45);
468
469             }
470             else{
471                noteSend(cmdOff, i+44, 0x00);
472
473             }
474              delay(300);
475          
476        // while (expander3.digitalRead(i))
477  {}
478          // a = expander4.read();
479          // Serial.println("stan registrów
480  na 3-4");
481          // Serial.println(a);
482          // Serial.println(b);
483  
484          
485     }  
486   }
487   
488// III para expanderów -  sprawdzanie
489  pinów expandera nr 6 i ustaiwanie pinów expandera nr 5     
490    for (int i=0;
491  i<8; i++){
492      
493      if (expander6.digitalRead(i) == LOW) { 
494        delay(20);
495
496          expander5.toggle(i);
497          if (expander5.digitalRead(i) == HIGH){
498
499                noteSend(cmdOn, i+52, 0x45);
500             }
501             else{
502
503                noteSend(cmdOff, i+52, 0x00);
504             }
505              delay(300);
506
507        //  while (expander6.digitalRead(i)) {}
508        //  a = expander5.read();
509
510          // Serial.println("stan registrów na 6-5");
511          // Serial.println(a);
512
513          // Serial.println(b6); 
514         
515     }  
516   }
517   
518
519//
520  IV para expanderów - sprawdzanie pinów expandera nr 7 i ustaiwanie pinów expandera
521  nr 8     
522    for (int i=0; i<8; i++){
523      
524      if (expander7.digitalRead(i)
525  == LOW) { 
526        delay(20);
527          expander8.toggle(i);
528          if
529  (expander8.digitalRead(i) == HIGH){
530                noteSend(cmdOn, i+60, 0x45);
531
532             }
533             else{
534               noteSend(cmdOff, i+60, 0x00);
535
536             }
537              delay(300);
538            // while (expander7.digitalRead(i))
539  {} 
540          //a = expander8.read();
541          // Serial.println("stan registrów
542  na 7-8");
543          // Serial.println(a);
544          // Serial.println(b7);
545  
546         
547     }  
548   }     
549   
550 // V para expanderów - sprawdzanie
551  pinów expandera nr 10 i ustaiwanie pinów expandera nr 9    
552    for (int i=0;
553  i<8; i++){
554      
555      if (expander10.digitalRead(i) == LOW) { 
556        delay(20);
557
558         expander9.toggle(i);
559         
560           if (expander9.digitalRead(i)
561  == HIGH){
562                noteSend(cmdOn, i + 68, 0x45);
563             }
564
565             else{
566                noteSend(cmdOff, i + 68, 0x00);
567             }
568
569              delay(300);
570           //   while (expander10.digitalRead(i)) {}
571
572          // a = expander9.read();
573          // Serial.println("stan registrów
574  na 10-9");
575          // Serial.println(a);
576          // Serial.println(b10);
577  
578        
579     }  
580   }
581 } 
582
583// ************** procedura zmian
584  WK *****************     
585 void zmiana_WK(){
586 b = expander11.read();    
587
588    
589// włączenie WK
590  for (int i=0; i<8; i++){
591      if (expander11.digitalRead(i)
592  == LOW) { // sprawdza piny expandera nr 11, jesli LOW to
593         delay(20);
594
595         switch (i) {    // usrawia expandery registrowe nr 1,4,5,6,9 wg zapamietanej
596  nastawy 
597  case 0:
598    // WK 1
599    expander12.write(1); // zapala lampkę
600  pod przyciskiem WK 1
601b = expander1.read();
602  expander1.write(nastawa_expander1[i]);
603
604    operacjaNaBitach(b, nastawa_expander1[i], 36);
605b = expander4.read();    
606
607  expander4.write(nastawa_expander4[i]);
608    operacjaNaBitach(b, nastawa_expander4[i],
609  44);
610b = expander5.read();
611 expander5.write(nastawa_expander5[i]);
612  operacjaNaBitach(b,
613  nastawa_expander5[i], 52) ;
614b = expander8.read();
615 expander8.write(nastawa_expander8[i]);
616
617  operacjaNaBitach(b, nastawa_expander8[i], 60);
618b = expander9.read();
619  expander9.write(nastawa_expander9[i]);
620
621    operacjaNaBitach(b, nastawa_expander9[i], 68);
622    break;
623  case 1:
624
625    // WK 2
626    expander12.write(2);
627b = expander1.read();
628  expander1.write(nastawa_expander1[i]);
629
630    operacjaNaBitach(b, nastawa_expander1[i], 36);
631b = expander4.read();    
632
633  expander4.write(nastawa_expander4[i]);
634    operacjaNaBitach(b, nastawa_expander4[i],
635  44);
636b = expander5.read();
637 expander5.write(nastawa_expander5[i]);
638  operacjaNaBitach(b,
639  nastawa_expander5[i], 52);
640b = expander8.read();
641 expander8.write(nastawa_expander8[i]);
642
643  operacjaNaBitach(b, nastawa_expander8[i], 60);
644b = expander9.read();
645  expander9.write(nastawa_expander9[i]);
646
647    operacjaNaBitach(b, nastawa_expander9[i], 68);
648    break;
649      case 2:
650
651    // WK 3
652    expander12.write(4);
653b = expander1.read();
654  expander1.write(nastawa_expander1[i]);
655
656    operacjaNaBitach(b, nastawa_expander1[i], 36);
657b = expander4.read();    
658
659  expander4.write(nastawa_expander4[i]);
660    operacjaNaBitach(b, nastawa_expander4[i],
661  44);
662b = expander5.read();
663 expander5.write(nastawa_expander5[i]);
664  operacjaNaBitach(b,
665  nastawa_expander5[i], 52);
666b = expander8.read();
667 expander8.write(nastawa_expander8[i]);
668
669  operacjaNaBitach(b, nastawa_expander8[i], 60);
670b = expander9.read();
671  expander9.write(nastawa_expander9[i]);
672
673    operacjaNaBitach(b, nastawa_expander9[i], 68);
674    break;
675      case 3:
676
677    // WK 4
678    expander12.write(8);
679b = expander1.read();
680  expander1.write(nastawa_expander1[i]);
681
682    operacjaNaBitach(b, nastawa_expander1[i], 36);
683b = expander4.read();    
684
685  expander4.write(nastawa_expander4[i]);
686    operacjaNaBitach(b, nastawa_expander4[i],
687  44);
688b = expander5.read();
689 expander5.write(nastawa_expander5[i]);
690  operacjaNaBitach(b,
691  nastawa_expander5[i], 52);
692b = expander8.read();
693 expander8.write(nastawa_expander8[i]);
694
695  operacjaNaBitach(b, nastawa_expander8[i], 60);
696b = expander9.read();
697  expander9.write(nastawa_expander9[i]);
698
699    operacjaNaBitach(b, nastawa_expander9[i], 68);    
700    break;
701      case
702  4:
703    // WK 5
704    expander12.write(16);
705b = expander1.read();
706  expander1.write(nastawa_expander1[i]);
707
708    operacjaNaBitach(b, nastawa_expander1[i], 36);
709b = expander4.read();    
710
711  expander4.write(nastawa_expander4[i]);
712    operacjaNaBitach(b, nastawa_expander4[i],
713  44);
714b = expander5.read();
715 expander5.write(nastawa_expander5[i]);
716  operacjaNaBitach(b,
717  nastawa_expander5[i], 52);
718b = expander8.read();
719 expander8.write(nastawa_expander8[i]);
720
721  operacjaNaBitach(b, nastawa_expander8[i], 60);
722b = expander9.read();
723  expander9.write(nastawa_expander9[i]);
724
725    operacjaNaBitach(b, nastawa_expander9[i], 68);    
726    break;
727      case
728  5:
729    // WK 6
730    expander12.write(32);
731b = expander1.read();
732  expander1.write(nastawa_expander1[i]);
733
734    operacjaNaBitach(b, nastawa_expander1[i], 36);
735b = expander4.read();    
736
737  expander4.write(nastawa_expander4[i]);
738    operacjaNaBitach(b, nastawa_expander4[i],
739  44);
740b = expander5.read();
741 expander5.write(nastawa_expander5[i]);
742  operacjaNaBitach(b,
743  nastawa_expander5[i], 52);
744b = expander8.read();
745 expander8.write(nastawa_expander8[i]);
746
747  operacjaNaBitach(b, nastawa_expander8[i], 60);
748b = expander9.read();
749  expander9.write(nastawa_expander9[i]);
750
751    operacjaNaBitach(b, nastawa_expander9[i], 68);   
752    break;
753      case
754  6:
755          // C - kasownik
756          expander12.write(64);
757expander1.write(0);
758expander4.write(0);
759expander5.write(0);
760expander8.write(0);
761expander9.write(0);
762
763          noteSendAllNoteOff();
764    break;  
765      case 7:
766      // CR
767  - crescendo
768        expander12.write(128);
769    
770        crescendo();
771
772    
773    break;
774
775}
776         
777           delay(200);
778           a
779  = expander12.read();
780           // Serial.println("stan WK na 11-12");
781
782           // Serial.println(a);
783           // Serial.println(b); 
784           
785}
786
787  
788}
789}
790
791// ****************** Procedura zmian i zapamietania ustawień
792  dla WK ( programowanie WK) ************
793// zapamiętanie ustawień WK ( SET )
794void
795  memory_WK(){
796 // // Serial.println("wewnątrz funkcji memory");
797 b = expander11.read();
798    
799    
800// set WK
801  for (int i=0; i<8; i++){
802      if (expander11.digitalRead(i)
803  == LOW) { 
804         delay(20);
805         switch (i) {
806  case 0:
807    //
808  odczyt i zapamiętanie nastawy dla WK 1
809    expander12.write(1);
810nastawa_expander1[i]
811  = expander1.read();
812nastawa_expander4[i] = expander4.read();
813nastawa_expander5[i]
814  = expander5.read();
815nastawa_expander8[i] = expander8.read();
816nastawa_expander9[i]
817  = expander9.read();
818    break;
819  case 1:
820    // odczyt i zapamiętanie nastawy
821  dla WK 2
822    expander12.write(2);
823nastawa_expander1[i] = expander1.read();
824nastawa_expander4[i]
825  = expander4.read();
826nastawa_expander5[i] = expander5.read();
827nastawa_expander8[i]
828  = expander8.read();
829nastawa_expander9[i] = expander9.read();
830    break;
831
832      case 2:
833    // odczyt i zapamiętanie nastawy dla WK 3
834    expander12.write(4);
835nastawa_expander1[i]
836  = expander1.read();
837nastawa_expander4[i] = expander4.read();
838nastawa_expander5[i]
839  = expander5.read();
840nastawa_expander8[i] = expander8.read();
841nastawa_expander9[i]
842  = expander9.read();
843    break;
844      case 3:
845    // odczyt i zapamiętanie
846  nastawy dla WK 4
847    expander12.write(8);
848nastawa_expander1[i] = expander1.read();
849nastawa_expander4[i]
850  = expander4.read();
851nastawa_expander5[i] = expander5.read();
852nastawa_expander8[i]
853  = expander8.read();
854nastawa_expander9[i] = expander9.read();    
855    break;
856
857      case 4:
858    // odczyt i zapamiętanie nastawy dla WK 5
859    expander12.write(16);
860nastawa_expander1[i]
861  = expander1.read();
862nastawa_expander4[i] = expander4.read();
863nastawa_expander5[i]
864  = expander5.read();
865nastawa_expander8[i] = expander8.read();
866nastawa_expander9[i]
867  = expander9.read();    
868    break;
869      case 5:
870    // odczyt i zapamiętanie
871  nastawy dla WK 6
872    expander12.write(32);
873nastawa_expander1[i] = expander1.read();
874nastawa_expander4[i]
875  = expander4.read();
876nastawa_expander5[i] = expander5.read();
877nastawa_expander8[i]
878  = expander8.read();
879nastawa_expander9[i] = expander9.read();   
880    break;
881
882      case 6:
883          // odczyt i zapamiętanie nastawy dla C 
884          expander12.write(64);
885nastawa_expander1[i]
886  = expander1.read();
887nastawa_expander4[i] = expander4.read();
888nastawa_expander5[i]
889  = expander5.read();
890nastawa_expander8[i] = expander8.read();
891nastawa_expander9[i]
892  = expander9.read();
893    break;  
894    case 7:
895    // odczyt i zapamiętanie
896  nastawy dla CR
897    expander12.write(128);
898nastawa_expander1[i] = expander1.read();
899nastawa_expander4[i]
900  = expander4.read();
901nastawa_expander5[i] = expander5.read();
902nastawa_expander8[i]
903  = expander8.read();
904nastawa_expander9[i] = expander9.read();   
905    break;
906
907}
908
909          
910           delay(200);
911           a = expander12.read();
912           //
913  Serial.println("stan WK na 11-12");
914           // Serial.println(a);
915           //
916  Serial.println(b); 
917          // }
918      }
919 }
920}  
921void set_to_EPROM()
922  {
923    for (int i = 0; i < 6; i++){ // zapis nastaw dla do EPROM
924      EEPROM.write(i
925  + 10, nastawa_expander1[i]);
926      EEPROM.write(i + 20, nastawa_expander4[i]);
927
928      EEPROM.write(i + 30, nastawa_expander5[i]);
929      EEPROM.write(i + 40,
930  nastawa_expander8[i]);
931      EEPROM.write(i + 50, nastawa_expander9[i]);
932
933      EEPROM.write(i + 60, nastawa_expander9[i]);
934   } 
935   
936    for (int
937  i = 0; i < 5; i++){ // znak że zapisano - mryganie lampek
938    expander12.write(255);
939
940    delay(30);
941    expander12.write(0); 
942    delay(30); 
943    delay(2000);
944
945    }
946}
947
948void noteSend(int cmd, int pitch, int velocity) {
949  Serial.write(cmd);
950
951  Serial.write(pitch);
952  Serial.write(velocity);
953}  
954void noteSendAllNoteOff()
955  {
956  Serial.write(0xB3);
957  Serial.write(123);
958  Serial.write(0);
959} 
960
961      
962// fonkcja operacjaNaBitach porównuje nastawy przed wciśnienciem WK i
963  po i wysyła odpowiednie komunikaty midi
964void operacjaNaBitach(int przed, int
965  po, int ofset){
966        
967   if (przed != po){
968    
969      for (int i
970  = 0; i < 8; i++){
971       if (bitRead(po,i) != bitRead(przed,i)){
972        
973
974           if bitRead(po,i){
975              noteSend(cmdOn, i + ofset, 0x45);
976
977            }
978            else{
979               noteSend(cmdOff, i + ofset,
980  0x00);
981            }
982        }
983      }
984    }
985}
986
987// **** Procedura
988  obsługi crescendo *********
989void crescendo(){ 
990  // Serial.println("wejscie
991  do procedury crescendo");
992  int value;
993  int c;
994  while ( expander12.digitalRead(7)
995  == HIGH ){
996    
997     if (digitalRead(11) == LOW) { 
998      prog_crescendo();
999
1000     
1001     }
1002     
1003      if (digitalRead(10) == LOW){ // przycisk 9 włącza
1004  zapis nastawien do EPROM
1005      delay(10);
1006      cresc_to_EPROM(); 
1007      while
1008  (digitalRead(10) == LOW) {} // pusta petla zapobiega ponownemu wpisaniu do EPROM
1009
1010      delay(10);
1011      }
1012      
1013      zmiana_WK();
1014
1015     while (c
1016  == value) {
1017     c = value; 
1018     value = analogRead(A0); //Odczytujemy wartość
1019  napięcia na pinie A0
1020     delay(10);
1021     value = map(value, 0, 1000, 0, 19);//Przeskalowanie
1022  wartości
1023     //value = value / 51;
1024     zmiana_registrow(); 
1025     zmiana_WK();
1026
1027     // return value; 
1028     }
1029     c = value;
1030     
1031
1032b = expander1.read();
1033
1034  expander1.write(cresc_expander1[value]);
1035    operacjaNaBitach(b, cresc_expander1[value],
1036  36);
1037b = expander4.read();    
1038  expander4.write(cresc_expander4[value]);
1039
1040    operacjaNaBitach(b, cresc_expander4[value], 44);
1041b = expander5.read();
1042
1043  expander5.write(cresc_expander5[value]);
1044  operacjaNaBitach(b, cresc_expander5[value],
1045  52);
1046b = expander8.read();
1047 expander8.write(cresc_expander8[value]);
1048  operacjaNaBitach(b,
1049  cresc_expander8[value], 60);
1050b = expander9.read();
1051  expander9.write(cresc_expander9[value]);
1052
1053    operacjaNaBitach(b, cresc_expander9[value], 68);
1054     // Serial.println(value);
1055
1056     delay(100);
1057    
1058  }
1059}
1060
1061// **** Procedura programowania crescendo
1062  *********
1063void prog_crescendo(){ 
1064  expander12.write(128+64);
1065
1066   for
1067  (int i=0; i<20; i++){
1068      
1069         delay(20);
1070         while (digitalRead(8)
1071  == HIGH) { 
1072          zmiana_registrow();
1073          }
1074         delay(500);
1075
1076         
1077    // odczyt i zapamiętanie nastawy dla 20-stopniowego crescendo
1078
1079    expander12.write(i+1+64+128);
1080cresc_expander1[i] = expander1.read();
1081cresc_expander4[i]
1082  = expander4.read();
1083cresc_expander5[i] = expander5.read();
1084cresc_expander8[i]
1085  = expander8.read();
1086cresc_expander9[i] = expander9.read();
1087          delay(500);
1088  
1089   }   
1090expander12.write(0); 
1091delay(1000); 
1092expander12.write(128);
1093  
1094}
1095
1096// Zapis ustawień crescendo do EPROM
1097void cresc_to_EPROM() {
1098
1099    for (int i = 0; i < 20; i++){ // zapis nastaw dla do EPROM
1100      EEPROM.write(i
1101  + 100, cresc_expander1[i]);
1102      EEPROM.write(i + 125, cresc_expander4[i]);
1103
1104      EEPROM.write(i + 150, cresc_expander5[i]);
1105      EEPROM.write(i + 175,
1106  cresc_expander8[i]);
1107      EEPROM.write(i + 200, cresc_expander9[i]);
1108      
1109
1110   } 
1111   
1112    for (int i = 0; i < 5; i++){ // znak że zapisano - mryganie
1113  lampek
1114    expander12.write(255);
1115    delay(200);
1116    expander12.write(0);
1117  
1118    delay(200); 
1119    }
1120    delay(2000);
1121    
1122}
1123// while (digitalRead(7)
1124  == LOW) {} //Jeśli przycisk 7 jest wciśnięty program nic nie robi