if (myDataOut & (1< pinState= 1;  
}else{  
pinState= 0;  
}

        if ((myDataOut >> i) & 0x01 ) pinState= 1;     
         else pinState= 0;   

//"32CH Programmable Sequencer". On the basis of Arduino the controler.   
//The author of the program alexval2007, Asstoxa , Open_Pyro. 2.10.2010 V3.   
//******************************************************************************************************   
    #define CueHIGH 500 // Time of a starting impulse for igniters, 500ms.   
      
      
//******************************************************************************************************    
    int dataPin = 2;    // Подключаем вывод к DS of 74HC595   
    int latchPin = 3;   // Подключаем вывод к ST_CP of 74HC595   
    int clockPin = 4;   // Подключаем вывод к SH_CP of 74HC595   
    int BUTTON = 19;   
    int val = 0; // variable for reading the pin status   
//******************************************************************************************************   
// Инициализация   
    void setup(){   
      pinMode(BUTTON, INPUT);     // Настраиваю Pin на ввод
      digitalWrite(BUTTON, HIGH); // Включаю подтягивающий резистор по входу к лог 1
      pinMode(latchPin, OUTPUT);  // Настраиваем портына вывод   
      Serial.begin(9600);         // Скорость обмена по UART   
      Serial.println("TEST HELLO");   

      digitalWrite(latchPin, 0);           // Подготавливаем регистр к приёму данных
      shiftOut(dataPin, clockPin, 0x00);   // данные для зеленых светодиодов   
      shiftOut(dataPin, clockPin, 0x00);   // данные я зеленых светодиодов    
      digitalWrite(latchPin, 1);           // Защелкиваем данные в регистре   
      delay(50);
}   
      
//******************************************************************************************************   
// Основной цикл
    void loop(){
      val = digitalRead(BUTTON); // Обработка состояния пускового входного сигнала
      if (val == LOW){   
      digitalWrite(latchPin, 0);           // Подготавливаем регистр к приёму данных
      shiftOut(dataPin, clockPin, 0x03);   // данные для зеленых светодиодов   
      shiftOut(dataPin, clockPin, 0xff);   // данные для зеленых светодиодов   
      digitalWrite(latchPin, 1);           // Защелкиваем данные в регистре   
      delay(CueHIGH);
}
      else{
        delay(50);   
      digitalWrite(latchPin, 0);           // Подготавливаем регистр к приёму данных
      shiftOut(dataPin, clockPin, 0x00);   // данные для зеленых светодиодов   
      shiftOut(dataPin, clockPin, 0x00);   // данные для зеленых светодиодов   
      digitalWrite(latchPin, 1);           // Защелкиваем данные в регистре   
      }
    }    

//******************************************************************************************************
//Подпрограмма вывода на сдвиговый регистр   
    void shiftOut(int myDataPin, int myClockPin, byte myDataOut){
      //Это смещает 8 битов MSB сначала, на нарастающем фронте часов, часы бездействуют низко   
      int i=0;                     // Обявляю внутреннию переменную   
      int pinState;   
      pinMode(myClockPin, OUTPUT); // Настраиваем на вывод   
      pinMode(myDataPin, OUTPUT);  // Настраиваем на вывод   
      digitalWrite(myDataPin, 0);  // Записуем в регистр 0 на всякий случай   
      digitalWrite(myClockPin, 0);   
      for (i=7; i>=0; i--){   
        digitalWrite(myClockPin, 0);   
       if (myDataOut & (1<<i)){
        pinState= 1;
      }
      else{   
        pinState= 0;
      }
        digitalWrite(myDataPin, pinState); // Устанавливает pin данных в ВЫСОКИЙ или НИЗКОЕ в зависимости от pinState   
        digitalWrite(myClockPin, 1);       // установить бит clock pin в лог 1   
        digitalWrite(myDataPin, 0);        // обнулите контакт данных после сдвига, чтобы предотвратить выход за край   
      }   
        digitalWrite(myClockPin, 0);         // остановить сдвиг   
}
//******************************************************************************************************

//"32CH Programmable Sequencer". On the basis of Arduino the controler.    
//The author of the program alexval2007, Asstoxa , Open_Pyro. 2.10.2010 V3.    
//******************************************************************************************************    
     #define CueHIGH 500 // Время импульса на воспламенители 500ms.    
        
     #define Cue1 50    
     #define Cue2 200    
     #define Cue3 50    
     #define Cue4 200    
     #define Cue5 60    
     #define Cue6 100    
     #define Cue7 1000    
     #define Cue8 100    
     #define Cue9 10    
     #define Cue10 10    
     #define Cue11 10    
     #define Cue12 10    
     #define Cue13 10    
     #define Cue14 10    
     #define Cue15 10    
     #define Cue16 10    
//******************************************************************************************************     
     int dataPin = 2;    // Подключаем вывод к DS of 74HC595    
     int latchPin = 3;   // Подключаем вывод к ST_CP of 74HC595    
     int clockPin = 4;   // Подключаем вывод к SH_CP of 74HC595    
     int BUTTON = 19;    

//Обявляю переменные и массивы    
     byte data;                // Обявляю глобальные переменные массива    
     byte dataArray[8];        // Обявляю битовый массив из 8 элементов      
     int val = 0;              // перменная состояния кнопки
     int CueNumber=16;         // количество каналов.    
     int x,y,j,i;              // переменные цыклов
     int CueDelay[2][8] = {{ Cue1, Cue2, Cue3, Cue4, Cue5, Cue6, Cue7, Cue8}, {Cue9, Cue10, Cue11, Cue12, Cue13, Cue14, Cue15, Cue16}};    

//******************************************************************************************************    
// Инициализация    
     void setup(){    
       pinMode(BUTTON, INPUT);     // Настраиваю Pin на ввод
       digitalWrite(BUTTON, HIGH); // Включаю подтягивающий резистор по входу к лог 1
       pinMode(latchPin, OUTPUT);  // Настраиваем портына вывод    
       Serial.begin(9600);         // Скорость обмена по UART    
       Serial.println("TEST HELLO");    
       // Записую все состояния элементов Массивов    
       dataArray[0] = 0x01; //00000001
       dataArray[1] = 0x02; //00000010    
       dataArray[2] = 0x04; //00000100       
       dataArray[3] = 0x08; //00001000      
       dataArray[4] = 0x10; //00010000       
       dataArray[5] = 0x20; //00100000       
       dataArray[6] = 0x40; //01000000       
       dataArray[7] = 0x80; //10000000    
//**********************************           
       digitalWrite(latchPin, 0);           // Подготавливаем регистр к приёму данных
       shiftOut(dataPin, clockPin, 0x00);   // обнуляю регистры    
       shiftOut(dataPin, clockPin, 0x00);   //  
       digitalWrite(latchPin, 1);           // Защелкиваем данные в регистре    
       delay(50);
}    
        
//******************************************************************************************************    
// Основной цикл
     void loop(){
       val = digitalRead(BUTTON); // Обработка состояния пускового входного сигнала
       if (val == LOW){    
//******************************************************************************************************       
   
//**********************************                 
         for (y=0; y < 2; y++){
         for (j = 0; j < 8; j++){           // Цикл перебора элементов массива из 8 элементов    
         data = dataArray[j];               // присваиваем переменной data состояние j элемента массива          
         //Выводим данные из масивов в сдвиговые регистры    
         delay(CueDelay[y][j]);              // Временной интервал между включением Сигналов.
         digitalWrite(latchPin, 0);          // Подготавливаем регистр к приёму данных
         shiftOut(dataPin, clockPin, data);  // данные для массива
         shiftOut(dataPin, clockPin, data);  // данные для массива           
         digitalWrite(latchPin, 1);          // Защелкиваем данные в регистре    
         delay(CueHIGH);                     // Время импульса на воспламенители 500ms                  
     }       
    }    
//******************************************************************************************************          
}
else{
       delay(50);    
       digitalWrite(latchPin, 0);           // Подготавливаем регистр к приёму данных
       shiftOut(dataPin, clockPin, 0x00);   // данные для зеленых светодиодов    
       shiftOut(dataPin, clockPin, 0x00);   // данные для зеленых светодиодов    
       digitalWrite(latchPin, 1);           // Защелкиваем данные в регистре    
       }
     }     

//******************************************************************************************************
//Подпрограмма вывода на сдвиговый регистр    
     void shiftOut(int myDataPin, int myClockPin, byte myDataOut){
       //Это смещает 8 битов MSB сначала, на нарастающем фронте часов, часы бездействуют низко    
       int i=0;                     // Обявляю внутреннию переменную    
       int pinState;    
       pinMode(myClockPin, OUTPUT); // Настраиваем на вывод    
       pinMode(myDataPin, OUTPUT);  // Настраиваем на вывод    
       digitalWrite(myDataPin, 0);  // Записуем в регистр 0 на всякий случай    
       digitalWrite(myClockPin, 0);    
       for (i=7; i>=0; i--){    
         digitalWrite(myClockPin, 0);    
        if (myDataOut & (1<<i)){
         pinState= 1;
       }
       else{    
         pinState= 0;
       }
         digitalWrite(myDataPin, pinState); // Устанавливает pin данных в ВЫСОКИЙ или НИЗКОЕ в зависимости от pinState    
         digitalWrite(myClockPin, 1);       // установить бит clock pin в лог 1    
         digitalWrite(myDataPin, 0);        // обнулите контакт данных после сдвига, чтобы предотвратить выход за край    
       }    
         digitalWrite(myClockPin, 0);         // остановить сдвиг    
}
//******************************************************************************************************

//"32CH Programmable Sequencer". On the basis of Arduino the controler.   
//The author of the program alexval2007, Asstoxa , Open_Pyro. 3.10.2010 V4.   
//******************************************************************************************************   
    #define CueHIGH 500 // Время импульса на воспламенители 500ms.   
      
    #define Cue1 50   
    #define Cue2 200   
    #define Cue3 50   
    #define Cue4 200   
    #define Cue5 60   
    #define Cue6 100   
    #define Cue7 1000   
    #define Cue8 100   
    #define Cue9 10   
    #define Cue10 10   
    #define Cue11 10   
    #define Cue12 10   
    #define Cue13 10   
    #define Cue14 10   
    #define Cue15 10   
    #define Cue16 10   
//******************************************************************************************************    
    int dataPin = 2;    // Подключаем вывод к DS of 74HC595   
    int latchPin = 3;   // Подключаем вывод к ST_CP of 74HC595   
    int clockPin = 4;   // Подключаем вывод к SH_CP of 74HC595   
    int BUTTON = 19;   

//Обявляю переменные и массивы   
    byte data;                // Обявляю глобальные переменные массива   
    int val = 0;              // перменная состояния кнопки
    int CueNumber=16;         // количество каналов.   
    int x,y,j,i;              // переменные цыклов
    int CueDelay[2][8] = {{ Cue1, Cue2, Cue3, Cue4, Cue5, Cue6, Cue7, Cue8}, {Cue9, Cue10, Cue11, Cue12, Cue13, Cue14, Cue15, Cue16}};   

//******************************************************************************************************   
// Инициализация   
    void setup(){   
      pinMode(BUTTON, INPUT);     // Настраиваю Pin на ввод
      digitalWrite(BUTTON, HIGH); // Включаю подтягивающий резистор по входу к лог 1
      pinMode(latchPin, OUTPUT);  // Настраиваем портына вывод   
      Serial.begin(9600);         // Скорость обмена по UART   
      Serial.println("TEST HELLO");   
      // Записую все состояния элементов Массивов   
//**********************************          
      digitalWrite(latchPin, 0);           // Подготавливаем регистр к приёму данных
      shiftOut(dataPin, clockPin, 0x00);   // данные для зеленых светодиодов   
      shiftOut(dataPin, clockPin, 0x00);   // данные я зеленых светодиодов    
      digitalWrite(latchPin, 1);           // Защелкиваем данные в регистре   
      delay(50);
}   
      
//******************************************************************************************************   
// Основной цикл
    void loop(){
      val = digitalRead(BUTTON); // Обработка состояния пускового входного сигнала
      if (val == LOW){   
//******************************************************************************************************                   
        for (y=0; y < 2; y++){
         
        for (j = 0; j < 8; j++){           // Цикл перебора элементов массива из 8 элементов   
        data =(1<<j);                      // Сдвиг байта       
        //Выводим данные из масивов в сдвиговые регистры   
        delay(CueDelay[y][j]);              // Временной интервал между включением Сигналов.
        digitalWrite(latchPin, 0);          // Подготавливаем регистр к приёму данных
        shiftOut(dataPin, clockPin, 0);     // данные для массива
        shiftOut(dataPin, clockPin, data);  // данные для массива          
        digitalWrite(latchPin, 1);          // Защелкиваем данные в регистре   
        delay(CueHIGH);                     // Время импульса на воспламенители 500ms                
    }      
          
         
         
         
         
        digitalWrite(latchPin, 0);           // Подготавливаем регистр к приёму данных
        shiftOut(dataPin, clockPin, 0x00);   //  обнуляем   
        shiftOut(dataPin, clockPin, 0x00);   //   
        digitalWrite(latchPin, 1);           // Защелкиваем данные в регистре     
   }       
//******************************************************************************************************         
}
else{
      delay(50);   
      digitalWrite(latchPin, 0);           // Подготавливаем регистр к приёму данных
      shiftOut(dataPin, clockPin, 0x00);   // данные для зеленых светодиодов   
      shiftOut(dataPin, clockPin, 0x00);   // данные для зеленых светодиодов   
      digitalWrite(latchPin, 1);           // Защелкиваем данные в регистре   
      }
    }    

//******************************************************************************************************
//Подпрограмма вывода на сдвиговый регистр   
    void shiftOut(int myDataPin, int myClockPin, byte myDataOut){
      //Это смещает 8 битов MSB сначала, на нарастающем фронте часов, часы бездействуют низко   
      int i=0;                     // Обявляю внутреннию переменную   
      int pinState;   
      pinMode(myClockPin, OUTPUT); // Настраиваем на вывод   
      pinMode(myDataPin, OUTPUT);  // Настраиваем на вывод   
      digitalWrite(myDataPin, 0);  // Записуем в регистр 0 на всякий случай   
      digitalWrite(myClockPin, 0);   
      for (i=7; i>=0; i--){   
        digitalWrite(myClockPin, 0);   
       if (myDataOut & (1<<i)){
        pinState= 1;
      }
      else{   
        pinState= 0;
      }
        digitalWrite(myDataPin, pinState); // Устанавливает pin данных в ВЫСОКИЙ или НИЗКОЕ в зависимости от pinState   
        digitalWrite(myClockPin, 1);       // установить бит clock pin в лог 1   
        digitalWrite(myDataPin, 0);        // обнулите контакт данных после сдвига, чтобы предотвратить выход за край   
      }   
        digitalWrite(myClockPin, 0);       // остановить сдвиг   
}
//******************************************************************************************************

//"32CH Programmable Sequencer". On the basis of Arduino the controler.   
//The author of the program alexval2007, Astoxa , Open_Pyro. 4.11.2010 V5.   
//******************************************************************************************************   
    #define CueHIGH 20 // Время импульса на воспламенители 500ms.   
      
    #define Cue1 50   
    #define Cue2 10
    #define Cue3 50
    #define Cue4 15
    #define Cue5 55
    #define Cue6 20
    #define Cue7 57   
    #define Cue8 58
    #define Cue9 59   
    #define Cue10 60   
    #define Cue11 10   
    #define Cue12 62   
    #define Cue13 63
    #define Cue14 64
    #define Cue15 65   
    #define Cue16 66
    #define Cue17 20
    #define Cue18 20
    #define Cue19 20
    #define Cue20 20
    #define Cue21 20
    #define Cue22 20
    #define Cue23 20
    #define Cue24 20
    #define Cue25 20
    #define Cue26 20
    #define Cue27 20
    #define Cue28 20
    #define Cue29 20
    #define Cue30 20
    #define Cue31 20
    #define Cue32 20    
//******************************************************************************************************    
    int dataPin = 2;    // Подключаем вывод к DS of 74HC595   
    int latchPin = 3;   // Подключаем вывод к ST_CP of 74HC595   
    int clockPin = 4;   // Подключаем вывод к SH_CP of 74HC595   
    int BUTTON = 19;   

//Обявляю переменные и массивы        
   unsigned long data;        // Обявляю глобальные переменные данных
   int val = 0;               // перменная состояния кнопки
   int y;         // переменные цыклов
   int CueDelay[32] = { Cue1, Cue2, Cue3, Cue4, Cue5, Cue6, Cue7, Cue8, Cue9, Cue10, Cue11, Cue12, Cue13, Cue14, Cue15, Cue16,   
                Cue17, Cue18, Cue19, Cue20, Cue21, Cue22, Cue23, Cue24, Cue25, Cue26, Cue27, Cue28, Cue29, Cue30, Cue31, Cue32};   
//******************************************************************************************************   
// Инициализация   
    void setup(){   
      pinMode(BUTTON, INPUT);     // Настраиваю Pin на ввод
      digitalWrite(BUTTON, HIGH); // Включаю подтягивающий резистор по входу к лог 1
      pinMode(latchPin, OUTPUT);  // Настраиваем портына вывод   
      Serial.begin(9600);         // Скорость обмена по UART   
      Serial.println("TEST HELLO");   
      // Записую все состояния элементов Массивов   
//**********************************          
    digitalWrite(latchPin, 0);             // Подготавливаем регистр к приёму данных
    for (y=0; y<4; y++){
      shiftOut(dataPin, clockPin, 0);      
     }   
     digitalWrite(latchPin, 1);           // Защелкиваем данные в регистре       
     delay(50);
}     
//******************************************************************************************************   
// Основной цикл
    void loop(){
      val = digitalRead(BUTTON);                // Обработка состояния пускового входного сигнала
      if (val == LOW){   
//******************************************************************************************************                    
    for (y=0; y<32; y++){
          data=(1<<y);                          // пишем сюда очередную ножку
           Serial.println(CueDelay[y]);   
           digitalWrite(latchPin, 0);           // Подготавливаем регистр к приёму данных
           shiftOut(dataPin, clockPin, data);
           digitalWrite(latchPin, 1);           // Защелкиваем данные в регистре     
           Serial.println("CueHIGH");
           delay(CueHIGH);
           delay(CueDelay[y]);    
}                     
//******************************************************************************************************         
}
else{     
      delay(50) ;
      digitalWrite(latchPin, 0);             // Подготавливаем регистр к приёму данных
      for (y=0; y<4; y++){
      shiftOut(dataPin, clockPin, 0);      
    }   
     digitalWrite(latchPin, 1);           // Защелкиваем данные в регистре       
    }
}    

//******************************************************************************************************
//Подпрограмма вывода на сдвиговый регистр   
    void shiftOut(int myDataPin, int myClockPin, unsigned long myDataOut){
      //Это смещает 32 битов MSB сначала, на нарастающем фронте часов, часы бездействуют низко   
      int i=0;                     // Обявляю внутреннию переменную   
      int pinState;   
      pinMode(myClockPin, OUTPUT); // Настраиваем на вывод   
      pinMode(myDataPin, OUTPUT);  // Настраиваем на вывод   
      digitalWrite(myDataPin, 0);  // Записуем в регистр 0 на всякий случай   
      digitalWrite(myClockPin, 0);   
      for (i=31; i>=0; i--){   
      digitalWrite(myClockPin, 0);   
      if (myDataOut & (1<<i)){
        pinState= 1;
      }
      else{      
        pinState= 0;
      }
        digitalWrite(myDataPin, pinState); // Устанавливает pin данных в ВЫСОКИЙ или НИЗКОЕ в зависимости от pinState   
        digitalWrite(myClockPin, 1);       // установить бит clock pin в лог 1   
        digitalWrite(myDataPin, 0);        // обнулите контакт данных после сдвига, чтобы предотвратить выход за край   
      }   
        digitalWrite(myClockPin, 0);       // остановить сдвиг   
}
//******************************************************************************************************

//"32CH Programmable Sequencer". On the basis of Arduino the controler.     
//The author of the program alexval2007, Asstoxa , Open_Pyro.  V6 (4.10.2010)     
//******************************************************************************************************
// История версий:
//     
// V6.1 (04.10.20010) Open_Pyro. alexval2007
// 0.1 убран баг с типом переменной   int i=0; заработало но выводит только первые 16битв регистры хотя в UART отдаёт весь массив
// 1. Изменен тип переменных:     
//     - там где число явно не будет выходит за предел 255 используется "unsigned char"
//     - изменен тип хранения данных "CueDelay[32]" времени задержки между запусками каналов с "int"     
//       (максимальное значение 32 768 или 32.8 сек задержки) на "unsigned long" которое возможно в     
//       в функции "delay()" (максимальное значение 4 294 967 296 или 4294967.2 сек задержки).
//
// 2. Из функции "void shiftOut(int myDataPin, int myClockPin, unsigned long myDataOut)" выкинул передаваемые         
//    параметры ножек "myDataPin" и "myClockPin", так как регистры у нас подключены на фиксированные ножки МК.     
//    Функция теперь имеет вид "void shiftOut( unsigned long myDataOut)", а выводы инициализируемый при старте     
//    процессора. Что ускоряет работу и уменьшает код.
//
// 3. "Подготавливаем регистр к приёму данных" и "Защелкиваем данные в регистре" перенесено в функцию
//    "void shiftOut( unsigned long myDataOut)".
//
// 4. Теперь выходы не работают постоянно в состоянии "1" а обнуляются перед запуском следующего канала.
//    Так же заработала временная задержка "Время импульса на воспламенители ххх мсек."
//
// 5. По тексту программы добавлены описания и пояснения, а тек же отформатирован код для лучшей читаемости.

      #define CueHIGH 50 // Время импульса на воспламенители ххх мсек.     
          
      #define Cue1 40    // Время задержки между запусками первого и следующего за ним канала в ххх мсек     
      #define Cue2 40    // !обязательно отнимите время импульса на воспламенители!!!!!!!!!!!!!!!!!!!!       
      #define Cue3 40    // Если Время импульса 100 мсек (0,1 сек) а следующий канал нужно запустит через 0,5 сек,
      #define Cue4 40    // то Cue1 должно иметь значение 400 мсек (500 мсек - 100 мсек = 400 мсек)     
      #define Cue5 40
      #define Cue6 40     
      #define Cue7 40
      #define Cue8 40
      #define Cue9 40
      #define Cue10 40
      #define Cue11 40
      #define Cue12 40     
      #define Cue13 40
      #define Cue14 40
      #define Cue15 40     
      #define Cue16 40
      #define Cue17 40
      #define Cue18 40
      #define Cue19 40
      #define Cue20 40
      #define Cue21 40
      #define Cue22 40
      #define Cue23 40
      #define Cue24 40
      #define Cue25 40
      #define Cue26 40
      #define Cue27 40
      #define Cue28 40
      #define Cue29 40
      #define Cue30 40
      #define Cue31 40
      #define Cue32 10       
//******************************************************************************************************      
      unsigned char dataPin  = 2;   // Подключаем вывод к DS of 74HC595     
      unsigned char latchPin = 3;   // Подключаем вывод к ST_CP of 74HC595     
      unsigned char clockPin = 4;   // Подключаем вывод к SH_CP of 74HC595     
      unsigned char BUTTON   = 19;  // Вход кнопки "старт"

//Обявляю переменные и массивы          
      unsigned long data = 0;       // Переменная состоит из 4 байт которые пишутся в 4-ре регистра
      unsigned char val = 0;        // Переменная состояния кнопки
      unsigned char y;              // Переменные циклов
      unsigned char pinState;
      int CueHIGH_delay = CueHIGH; //  Время импульса на воспламенители
      int CueDelay[32] = { Cue1,  Cue2,  Cue3,  Cue4,  Cue5,  Cue6,  Cue7,  Cue8,  Cue9,  Cue10,     
                       Cue11, Cue12, Cue13, Cue14, Cue15, Cue16, Cue17, Cue18, Cue19, Cue20,
                       Cue21, Cue22, Cue23, Cue24, Cue25, Cue26, Cue27, Cue28, Cue29, Cue30,     
                       Cue31, Cue32}; //  Время задержки между запусками за вычетом времени
                       //  импульса на воспламенители
//******************************************************************************************************     
// Инициализация ***************************************************************************************     
      void setup(){     
        pinMode(BUTTON , INPUT);    // Настраиваю Pin на ввод
        digitalWrite(BUTTON, HIGH); // Включаю подтягивающий резистор по входу к лог         
        pinMode(dataPin, OUTPUT);   // Настраиваем порты сдвигового регистра на вывод     
        pinMode(latchPin, OUTPUT);      
        pinMode(clockPin, OUTPUT);     
        digitalWrite(dataPin, 0);   // Обнуляем порты сдвигового регистра
        digitalWrite(latchPin, 0);     
        digitalWrite(clockPin, 0);
        Serial.begin(9600);         // Скорость обмена по UART     
        Serial.println("TEST HELLO");
            
        //**********************************     
        // Обнуление выходов регистров после запуска МК        
        shiftOut(0);               // Данные пишутся в регистр (все биты "0")     
        delay(50);
      }     
//******************************************************************************************************     
// Основной цикл ***************************************************************************************
      void loop(){
        val = digitalRead(BUTTON); // Обработка состояния пускового входного сигнала
        if (val == LOW){     
        //********************************************                      
          for (y=0; y<32; y++){
            data=(1<<y);           // пишем сюда очередную ножку
            Serial.println((CueHIGH_delay + CueDelay[y]));     
            shiftOut(data);        // Ставим ножку в единицу
            delay(CueHIGH_delay);  // Время импульса на воспламенители     
            shiftOut(0);           // Сбрасываем ножку     
            delay(CueDelay[y]);
          }             
        //*******************************************          
        }
        else{       
          delay(50);
          //  Обнуление регистров     
          shiftOut(0);               // Данные пишутся в регистр (все биты "0")     
       }
}      
//******************************************************************************************************
//Подпрограмма вывода на сдвиговый регистр *************************************************************     
      void shiftOut(unsigned long myDataOut ){        
        digitalWrite(latchPin, 0);         // Подготавливаем регистр к приёму данных        
       int i=0;
        for (i=31; i>=0; i--){     
          digitalWrite(clockPin, 0);
          if (myDataOut & (1<<i)){     
          pinState= 1;
        }else{     
          pinState= 0;     
        }       
                
          digitalWrite(dataPin, pinState); // Устанавливает pin данных в ВЫСОКИЙ или НИЗКОЕ в зависимости от pinState     
          digitalWrite(clockPin, 1);       // установить бит clock pin в лог 1     
        }     
        digitalWrite(clockPin, 0);         // остановить сдвиг     
        digitalWrite(dataPin, 0);     

        digitalWrite(latchPin, 1);         // Защелкиваем данные в регистре         
}
//******************************************************************************************************

//"32CH Programmable Sequencer". On the basis of Arduino the controler.  
//The author of the program alexval2007, Asstoxa , Open_Pyro.  V8 (6.10.2010)  
//******************************************************************************************************
// История версий:
// V8 (06.10.20010) Open_Pyro
//    - Поправил цикл вывода в регистр теперь работают все 32 канала. ПО уарту передает "CueDelay[y]+CueHIGH_delay"
//      задержку между запусками каналов в мсек.
//
// V7 (06.10.20010) alexval2007
//
// V6 (04.10.20010) Open_Pyro
// 1. Изменен тип переменных:  
//     - там где число явно не будет выходит за предел 255 используется "unsigned char"
//     - изменен тип хранения данных "CueDelay[32]" времени задержки между запусками каналов с "int"  
//       (максимальное значение 32 768 или 32.8 сек задержки) на "unsigned long" которое возможно в  
//       в функции "delay()" (максимальное значение 4 294 967 296 или 4294967.2 сек задержки).
//
// 2. Из функции "void shiftOut(int myDataPin, int myClockPin, unsigned long myDataOut)" выкинул передаваемые      
//    параметры ножек "myDataPin" и "myClockPin", так как регистры у нас подключены на фиксированные ножки МК.  
//    Функция теперь имеет вид "void shiftOut( unsigned long myDataOut)", а выводы инициализируемый при старте  
//    процессора. Что ускоряет работу и уменьшает код.
//
// 3. "Подготавливаем регистр к приёму данных" и "Защелкиваем данные в регистре" перенесено в функцию
//    "void shiftOut( unsigned long myDataOut)".
//
// 4. Теперь выходы не работают постоянно в состоянии "1" а обнуляются перед запуском следующего канала.
//    Так же заработала временная задержка "Время импульса на воспламенители ххх мсек."
//
// 5. По тексту программы добавлены описания и пояснения, а тек же отформатирован код для лучшей читаемости.

   #define CueHIGH 60 // Время импульса на воспламенители ххх мсек.  
    
   #define Cue1 240    // Время задержки между запусками первого и следующего за ним канала в ххх мсек  
   #define Cue2 240    // то Cue1 должно иметь значение 400 мсек (500 мсек - 100 мсек = 400 мсек)  
   #define Cue3 240
   #define Cue4 240
   #define Cue5 240
   #define Cue6 240
   #define Cue7 240
   #define Cue8 240
   #define Cue9 240
   #define Cue10 240
   #define Cue11 240
   #define Cue12 240
   #define Cue13 240
   #define Cue14 240
   #define Cue15 240
   #define Cue16 240
   #define Cue17 240
   #define Cue18 240
   #define Cue19 240
   #define Cue20 240
   #define Cue21 240
   #define Cue22 240
   #define Cue23 240
   #define Cue24 240
   #define Cue25 240
   #define Cue26 240
   #define Cue27 240
   #define Cue28 240
   #define Cue29 240
   #define Cue30 240
   #define Cue31 240
   #define Cue32 240  
//******************************************************************************************************   
   unsigned char dataPin  = 2;   // Подключаем вывод к DS of 74HC595  
   unsigned char latchPin = 3;   // Подключаем вывод к ST_CP of 74HC595  
   unsigned char clockPin = 4;   // Подключаем вывод к SH_CP of 74HC595  
   unsigned char BUTTON   = 19;  // Вход кнопки "старт"

//Обявляю переменные и массивы       
   unsigned long data = 0;       // Переменная состоит из 4 байт которые пишутся в 4-ре регистра
   unsigned long data1 = 0;       // Переменная состоит из 4 байт которые пишутся в 4-ре регистра
   unsigned char val = 0;        // Переменная состояния кнопки
   unsigned int y;              // Переменные циклов
   int pinState;
   unsigned long CueHIGH_delay = CueHIGH; //  Время импульса на воспламенители
   unsigned long CueDelay[32] = { Cue1,  Cue2,  Cue3,  Cue4,  Cue5,  Cue6,  Cue7,  Cue8,  Cue9,  Cue10,  
                    Cue11, Cue12, Cue13, Cue14, Cue15, Cue16, Cue17, Cue18, Cue19, Cue20,
                    Cue21, Cue22, Cue23, Cue24, Cue25, Cue26, Cue27, Cue28, Cue29, Cue30,  
                    Cue31, Cue32}; //  Время задержки между запусками за вычетом времени
                    //  импульса на воспламенители
//******************************************************************************************************  
// Инициализация ***************************************************************************************  
   void setup(){  
     pinMode(BUTTON , INPUT);    // Настраиваю Pin на ввод
     digitalWrite(BUTTON, HIGH); // Включаю подтягивающий резистор по входу к лог 1
   
     digitalWrite(dataPin, 0);   // Обнуляем порты сдвигового регистра
     digitalWrite(latchPin, 0);  
     digitalWrite(clockPin, 0);
      
     pinMode(dataPin, OUTPUT);   // Настраиваем порты сдвигового регистра на вывод  
     pinMode(latchPin, OUTPUT);   
     pinMode(clockPin, OUTPUT);  
      
     Serial.begin(9600);         // Скорость обмена по UART  
     Serial.println("TEST HELLO");
      
     //**********************************  
     // Обнуление выходов регистров после запуска МК     
     send_data(0);               // Данные пишутся в регистр (все биты "0")  
     delay(50);
   }  
//******************************************************************************************************  
// Основной цикл ***************************************************************************************
   void loop(){
     val = digitalRead(BUTTON); // Обработка состояния пускового входного сигнала
     if (val == LOW){  
     //********************************************  
     data1 = 1;
     for (y=0; y<32; y++){
      Serial.println(CueDelay[y]+CueHIGH_delay);  
      send_data(data1);        // Ставим ножку в единицу
      delay(CueHIGH_delay);  // Время импульса на воспламенители  
      send_data(0);           // Сбрасываем ножку  
      delay(CueDelay[y]);
      data1=(data1<<1);  
     }          
     //*******************************************      
   }else{    
     delay(50);
       //  Обнуление регистров  
    send_data(0);               // Данные пишутся в регистр (все биты "0")  
    }
}   
//******************************************************************************************************
//Подпрограмма вывода на сдвиговый регистр *************************************************************  
     void send_data (long long data){
     unsigned char i;
       for (i=0;i<32;i++){
   if ((data&0x80000000)==0x00) PORTD&=~_BV(dataPin); //Выставляем данные на PD0
          else PORTD|=_BV(dataPin);
          asm("nop");
          PORTD|=_BV(clockPin); //Импульс на CLK
          asm("nop");
          PORTD&=~_BV(clockPin);
          asm("nop");
          data=(data<<1);
       }
         
       PORTD|=_BV(latchPin); // Импульс на Latch
       asm("nop");
       PORTD&=~_BV(latchPin);
      }    
//******************************************************************************************************

//"32CH Programmable Sequencer". On the basis of Arduino the controler.        
//The author of the program alexval2007, Asstoxa , Open_Pyro.  V9 (7.10.2010)        
//******************************************************************************************************
// История версий:
// V9 (07.10.20010) alexval2007
//    - Добавил работу по внешнему прерыванию INT0 для чего изменил подключение к портам в следствии чего
//      изменю схему. Сиквенсор запускаться как и раньше по нажатию кнопки "лог 0 " на вход а вот после
//      ее отпускания когда стояние измениться с 0 на 1 произойдет запуск внешнего прерывания которое потушит
//      светодиод работа и даст лог 0 на RESET что приведет к сбросу микроконтроллера а следовательно останове
//      работы сиквенсора с возвратом к начальному состоянию. Такой вот аварийный режим типа. В начале кода
//      переделал некоторые переменные в #define для уменьшения занимаемого места в коде в результате сэкономил
//      целых 3байта во как для меги 8 это важно мало места. Убрал по коду еще несколько косячков мелких с
//      инициализацией, а также выкинул лишние задержки.
// V8 (06.10.20010) Open_Pyro
//    - Поправил цикл вывода в регистр теперь работают все 32 канала. ПО уарту передает "CueDelay[y]+CueHIGH_delay"
//      задержку между запусками каналов в мсек.
//
// V7 (06.10.20010) alexval2007
//
// V6 (04.10.20010) Open_Pyro
// 1. Изменен тип переменных:        
//     - там где число явно не будет выходит за предел 255 используется "unsigned char"
//     - изменен тип хранения данных "CueDelay[32]" времени задержки между запусками каналов с "int"        
//       (максимальное значение 32 768 или 32.8 сек задержки) на "unsigned long" которое возможно в        
//       в функции "delay()" (максимальное значение 4 294 967 296 или 4294967.2 сек задержки).
//
// 2. Из функции "void shiftOut(int myDataPin, int myClockPin, unsigned long myDataOut)" выкинул передаваемые            
//    параметры ножек "myDataPin" и "myClockPin", так как регистры у нас подключены на фиксированные ножки МК.        
//    Функция теперь имеет вид "void shiftOut( unsigned long myDataOut)", а выводы инициализируемый при старте        
//    процессора. Что ускоряет работу и уменьшает код.
//
// 3. "Подготавливаем регистр к приёму данных" и "Защелкиваем данные в регистре" перенесено в функцию
//    "void shiftOut( unsigned long myDataOut)".
//
// 4. Теперь выходы не работают постоянно в состоянии "1" а обнуляются перед запуском следующего канала.
//    Так же заработала временная задержка "Время импульса на воспламенители ххх мсек."
//
// 5. По тексту программы добавлены описания и пояснения, а тек же отформатирован код для лучшей читаемости.
//****************************************************************************************************************       
         #define CueHIGH 100 // Время импульса на воспламенители ххх мсек.        
//----------------------------------------------------------------------------------------------------------------          
         #define Cue1 40     // Время задержки между запусками первого и следующего за ним канала в ххх мсек        
         #define Cue2 240    // то Cue1 должно иметь значение 400 мсек (500 мсек - 100 мсек = 400 мсек)        
         #define Cue3 140
         #define Cue4 240
         #define Cue5 140
         #define Cue6 240
         #define Cue7 40
         #define Cue8 240
         #define Cue9 140
         #define Cue10 240
         #define Cue11 40
         #define Cue12 240
         #define Cue13 40
         #define Cue14 240
         #define Cue15 240
         #define Cue16 40
         #define Cue17 240
         #define Cue18 140
         #define Cue19 240
         #define Cue20 140
         #define Cue21 240
         #define Cue22 140
         #define Cue23 240
         #define Cue24 140
         #define Cue25 240
         #define Cue26 240
         #define Cue27 240
         #define Cue28 140
         #define Cue29 240
         #define Cue30 240
         #define Cue31 140
         #define Cue32 240        
//******************************************************************************************************         
         #define nop() {asm("nop");}   // Задержка в один такт процесора
//******************************************************************************************************         
          unsigned char dataPin  = 4;  // Подключаем вывод к DS of 74HC595 данные       
          #define clockPin 5           // Подключаем вывод к SH_CP of 74HC595 тактовые импульсы
          #define latchPin 6           // Подключаем вывод к ST_CP of 74HC595 защёлка
          #define BUTTON  2            // Вход кнопки "старт"

// Обявляю переменные и массивы             
         int int0 = 18;                // Светодиод работа и сигнал RESET для аварийной остановки отсчёта
         unsigned long data = 0;       // Переменная состоит из 4 байт которые пишутся в 4-ре регистра
         unsigned long data1 = 0;      // Переменная состоит из 4 байт которые пишутся в 4-ре регистра
         unsigned char val = 0;        // Переменная состояния кнопки
         unsigned int y;               // Переменные циклов
         int pinState;
         unsigned long CueHIGH_delay = CueHIGH; //  Время импульса на воспламенители
         unsigned long CueDelay[32] = { Cue1,  Cue2,  Cue3,  Cue4,  Cue5,  Cue6,  Cue7,  Cue8,  Cue9,  Cue10,        
                          Cue11, Cue12, Cue13, Cue14, Cue15, Cue16, Cue17, Cue18, Cue19, Cue20,
                          Cue21, Cue22, Cue23, Cue24, Cue25, Cue26, Cue27, Cue28, Cue29, Cue30,        
                          Cue31, Cue32}; // Масив со временем задержки между включением каналов за вычетом времени
                         // импульса на воспламенители
//******************************************************************************************************        
// Инициализация ***************************************************************************************        
         void setup(){        
           pinMode(BUTTON , INPUT);      // Настраиваю Pin на ввод
           pinMode(dataPin, OUTPUT);     // Настраиваем порты сдвигового регистра на вывод        
           pinMode(latchPin, OUTPUT);         
           pinMode(clockPin, OUTPUT);        
           pinMode(int0, OUTPUT);         // Светодиод работа и сигнал RESET для аварийной остановки отсчёта
//**********************************            
           digitalWrite(dataPin, LOW);    // Обнуляем порты сдвигового регистра
           digitalWrite(latchPin, LOW);        
           digitalWrite(clockPin, LOW);           
           digitalWrite(int0, HIGH);      // Зажгаю светодиод Работа       
           digitalWrite(BUTTON, HIGH);   // Включаю подтягивающий резистор по входу к лог 1
//**********************************            
           Serial.begin(9600);            // Скорость обмена по UART        
           Serial.println("TEST HELLO");  // Тестовое сообщение отправляемое по UART            
//**********************************          
           send_data(0); // Данные пишутся в регистр (все биты "0")        
         }        
//******************************************************************************************************        
// ВНЕШНЕЕ ПРЕРЫВАНИЕ INTO
ISR(INT0_vect){//обработка прерываний INT0
cli();//запрещение прерываний на время обработки прерывания
digitalWrite(int0, LOW);       
sei();//разрешение прерываний
}

//**Основной цикл ***************************************************************************************
         void loop(){
         GIMSK |=0b01000000;   // разрешаем прерывание int0 кнопка
         MCUCR |=0b00001111;   // прерывание по переднему фронту импульса - для кнопки 1 преывание срабатывает после отпускания кнопки
//********************************************         
           val = digitalRead(BUTTON); // Обработка состояния пускового входного сигнала
           if (val == LOW){        
//********************************************        
           data1 = 1;
           for (y=0; y<32; y++){
            Serial.println(CueDelay[y]+CueHIGH_delay);        
            send_data(data1);        // Ставим ножку в единицу
            delay(CueHIGH_delay);    // Время импульса на воспламенители        
            send_data(0);            // Сбрасываем ножку        
            delay(CueDelay[y]);
            data1=(data1<<1);        
           }                
//*******************************************            
         }else{           // иначе
          send_data(0);  //  Обнуление регистров.  Данные пишутся в регистр (все биты "0").        
          }
}         
//******************************************************************************************************
//Подпрограмма вывода на сдвиговый регистр *************************************************************        
           void send_data (unsigned long data){
           unsigned char i;
             for (i=0;i<32;i++){
         if ((data&0x80000000)==0x00) PORTD&=~_BV(dataPin); // Выводим данные на dataPin       
                else PORTD|=_BV(dataPin);
                nop();       
                PORTD|=_BV(clockPin); // Импульс на CLK Даем один тактовый импульс
                nop();       
                PORTD&=~_BV(clockPin);
                nop();       
                data=(data<<1);
             }
                     
             PORTD|=_BV(latchPin); // Даем Импульс на Latch защелкиваем данные в регистрах
             nop();       
             PORTD&=~_BV(latchPin);
            }          
//******************************************************************************************************

//"32CH Programmable Sequencer". On the basis of Arduino the controler.     
//The author of the program alexval2007, Asstoxa , Open_Pyro.  V8,1 (7.10.2010)     
//******************************************************************************************************
// История версий:
// V8,1 (07.10.20010) alexval2007
//    - В начале кода переделал некоторые переменные в #define для уменьшения занимаемого места в коде в результате
//      сэкономил целых 3байта во как для меги 8 это важно мало места. Убрал по коду еще несколько косячков мелких с
//      инициализацией, а также выкинул лишние задержки.
// V8 (06.10.20010) Open_Pyro
//    - Поправил цикл вывода в регистр теперь работают все 32 канала. ПО уарту передает "CueDelay[y]+CueHIGH_delay"
//      задержку между запусками каналов в мсек.
//
// V7 (06.10.20010) alexval2007
//
// V6 (04.10.20010) Open_Pyro
// 1. Изменен тип переменных:     
//     - там где число явно не будет выходит за предел 255 используется "unsigned char"
//     - изменен тип хранения данных "CueDelay[32]" времени задержки между запусками каналов с "int"     
//       (максимальное значение 32 768 или 32.8 сек задержки) на "unsigned long" которое возможно в     
//       в функции "delay()" (максимальное значение 4 294 967 296 или 4294967.2 сек задержки).
//
// 2. Из функции "void shiftOut(int myDataPin, int myClockPin, unsigned long myDataOut)" выкинул передаваемые         
//    параметры ножек "myDataPin" и "myClockPin", так как регистры у нас подключены на фиксированные ножки МК.     
//    Функция теперь имеет вид "void shiftOut( unsigned long myDataOut)", а выводы инициализируемый при старте     
//    процессора. Что ускоряет работу и уменьшает код.
//
// 3. "Подготавливаем регистр к приёму данных" и "Защелкиваем данные в регистре" перенесено в функцию
//    "void shiftOut( unsigned long myDataOut)".
//
// 4. Теперь выходы не работают постоянно в состоянии "1" а обнуляются перед запуском следующего канала.
//    Так же заработала временная задержка "Время импульса на воспламенители ххх мсек."
//
// 5. По тексту программы добавлены описания и пояснения, а тек же отформатирован код для лучшей читаемости.
//****************************************************************************************************************    
      #define CueHIGH 100 // Время импульса на воспламенители ххх мсек.     
//----------------------------------------------------------------------------------------------------------------       
      #define Cue1 40     // Время задержки между запусками первого и следующего за ним канала в ххх мсек     
      #define Cue2 240    // то Cue1 должно иметь значение 400 мсек (500 мсек - 100 мсек = 400 мсек)     
      #define Cue3 140
      #define Cue4 240
      #define Cue5 140
      #define Cue6 240
      #define Cue7 40
      #define Cue8 240
      #define Cue9 140
      #define Cue10 240
      #define Cue11 40
      #define Cue12 240
      #define Cue13 40
      #define Cue14 240
      #define Cue15 240
      #define Cue16 40
      #define Cue17 240
      #define Cue18 140
      #define Cue19 240
      #define Cue20 140
      #define Cue21 240
      #define Cue22 140
      #define Cue23 240
      #define Cue24 140
      #define Cue25 240
      #define Cue26 240
      #define Cue27 240
      #define Cue28 140
      #define Cue29 240
      #define Cue30 240
      #define Cue31 140
      #define Cue32 240     
//******************************************************************************************************      
      #define nop() {asm("nop");}   // Задержка в один такт процесора
//******************************************************************************************************      
       unsigned char dataPin  = 2;  // Подключаем вывод к DS of 74HC595 данные    
       #define clockPin 4           // Подключаем вывод к SH_CP of 74HC595 тактовые импульсы
       #define latchPin 3           // Подключаем вывод к ST_CP of 74HC595 защёлка
       #define BUTTON  19            // Вход кнопки "старт"

// Обявляю переменные и массивы          
      unsigned long data = 0;       // Переменная состоит из 4 байт которые пишутся в 4-ре регистра
      unsigned long data1 = 0;      // Переменная состоит из 4 байт которые пишутся в 4-ре регистра
      unsigned char val = 0;        // Переменная состояния кнопки
      unsigned int y;               // Переменные циклов
      int pinState;
      unsigned long CueHIGH_delay = CueHIGH; //  Время импульса на воспламенители
      unsigned long CueDelay[32] = { Cue1,  Cue2,  Cue3,  Cue4,  Cue5,  Cue6,  Cue7,  Cue8,  Cue9,  Cue10,     
                       Cue11, Cue12, Cue13, Cue14, Cue15, Cue16, Cue17, Cue18, Cue19, Cue20,
                       Cue21, Cue22, Cue23, Cue24, Cue25, Cue26, Cue27, Cue28, Cue29, Cue30,     
                       Cue31, Cue32}; // Масив со временем задержки между включением каналов за вычетом времени
                      // импульса на воспламенители
//******************************************************************************************************     
// Инициализация ***************************************************************************************     
      void setup(){     
        pinMode(BUTTON , INPUT);      // Настраиваю Pin на ввод
        pinMode(dataPin, OUTPUT);     // Настраиваем порты сдвигового регистра на вывод     
        pinMode(latchPin, OUTPUT);      
        pinMode(clockPin, OUTPUT);     
//**********************************         
        digitalWrite(dataPin, LOW);    // Обнуляем порты сдвигового регистра
        digitalWrite(latchPin, LOW);     
        digitalWrite(clockPin, LOW);        
        digitalWrite(BUTTON, HIGH);   // Включаю подтягивающий резистор по входу к лог 1
//**********************************         
        Serial.begin(9600);            // Скорость обмена по UART     
        Serial.println("TEST HELLO");  // Тестовое сообщение отправляемое по UART         
//**********************************       
        send_data(0); // Данные пишутся в регистр (все биты "0")     
      }     
//**Основной цикл ***************************************************************************************
      void loop(){    
        val = digitalRead(BUTTON); // Обработка состояния пускового входного сигнала
        if (val == LOW){     
//********************************************     
        data1 = 1;
        for (y=0; y<32; y++){
         Serial.println(CueDelay[y]+CueHIGH_delay);     
         send_data(data1);        // Ставим ножку в единицу
         delay(CueHIGH_delay);    // Время импульса на воспламенители     
         send_data(0);            // Сбрасываем ножку     
         delay(CueDelay[y]);
         data1=(data1<<1);     
        }             
//*******************************************         
      }else{           // иначе
       send_data(0);  //  Обнуление регистров.  Данные пишутся в регистр (все биты "0").     
       }
}      
//******************************************************************************************************
//Подпрограмма вывода на сдвиговый регистр *************************************************************     
        void send_data (unsigned long data){
        unsigned char i;
          for (i=0;i<32;i++){
      if ((data&0x80000000)==0x00) PORTD&=~_BV(dataPin); // Выводим данные на dataPin    
             else PORTD|=_BV(dataPin);
             nop();    
             PORTD|=_BV(clockPin); // Импульс на CLK Даем один тактовый импульс
             nop();    
             PORTD&=~_BV(clockPin);
             nop();    
             data=(data<<1);
          }
               
          PORTD|=_BV(latchPin); // Даем Импульс на Latch защелкиваем данные в регистрах
          nop();    
          PORTD&=~_BV(latchPin);
         }       
//******************************************************************************************************

//"32CH Programmable Sequencer". On the basis of Arduino the controler.     
//The author of the program alexval2007, Asstoxa , Open_Pyro.  V8,2 (14.11.2010)     
//******************************************************************************************************
// История версий:
//V8,2 (14.11.20010) alexval2007
//    - Убрал проблему с задержками для формирования импульсов на сдвиговые регистры изза высокой тактовой частоты мк
//      регистры неуспевали переключатся заменил функцию asm("nop"); на delay(1); полёт нормальный
//V8,1 (07.10.20010) alexval2007
//    - В начале кода переделал некоторые переменные в #define для уменьшения занимаемого места в коде в результате
//      сэкономил целых 3байта во как для меги 8 это важно мало места. Убрал по коду еще несколько косячков мелких с
//      инициализацией, а также выкинул лишние задержки.
// V8 (06.10.20010) Open_Pyro
//    - Поправил цикл вывода в регистр теперь работают все 32 канала. ПО уарту передает "CueDelay[y]+CueHIGH_delay"
//      задержку между запусками каналов в мсек.
//
// V7 (06.10.20010) alexval2007
//
// V6 (04.10.20010) Open_Pyro
// 1. Изменен тип переменных:     
//     - там где число явно не будет выходит за предел 255 используется "unsigned char"
//     - изменен тип хранения данных "CueDelay[32]" времени задержки между запусками каналов с "int"     
//       (максимальное значение 32 768 или 32.8 сек задержки) на "unsigned long" которое возможно в     
//       в функции "delay()" (максимальное значение 4 294 967 296 или 4294967.2 сек задержки).
//
// 2. Из функции "void shiftOut(int myDataPin, int myClockPin, unsigned long myDataOut)" выкинул передаваемые         
//    параметры ножек "myDataPin" и "myClockPin", так как регистры у нас подключены на фиксированные ножки МК.     
//    Функция теперь имеет вид "void shiftOut( unsigned long myDataOut)", а выводы инициализируемый при старте     
//    процессора. Что ускоряет работу и уменьшает код.
//
// 3. "Подготавливаем регистр к приёму данных" и "Защелкиваем данные в регистре" перенесено в функцию
//    "void shiftOut( unsigned long myDataOut)".
//
// 4. Теперь выходы не работают постоянно в состоянии "1" а обнуляются перед запуском следующего канала.
//    Так же заработала временная задержка "Время импульса на воспламенители ххх мсек."
//
// 5. По тексту программы добавлены описания и пояснения, а тек же отформатирован код для лучшей читаемости.
//****************************************************************************************************************    
      #define CueHIGH 100 // Время импульса на воспламенители ххх мсек.     
//----------------------------------------------------------------------------------------------------------------       
      #define Cue1 40     // Время задержки между запусками первого и следующего за ним канала в ххх мсек     
      #define Cue2 140    // то Cue1 должно иметь значение 400 мсек (500 мсек - 100 мсек = 400 мсек)     
      #define Cue3 140
      #define Cue4 40
      #define Cue5 140
      #define Cue6 40
      #define Cue7 40
      #define Cue8 40
      #define Cue9 140
      #define Cue10 40
      #define Cue11 40
      #define Cue12 140
      #define Cue13 40
      #define Cue14 40
      #define Cue15 140
      #define Cue16 40
      #define Cue17 140
      #define Cue18 140
      #define Cue19 40
      #define Cue20 140
      #define Cue21 40
      #define Cue22 140
      #define Cue23 40
      #define Cue24 140
      #define Cue25 40
      #define Cue26 140
      #define Cue27 40
      #define Cue28 140
      #define Cue29 40
      #define Cue30 240
      #define Cue31 140
      #define Cue32 40     
//******************************************************************************************************      
       unsigned char dataPin  = 2;  // Подключаем вывод к DS of 74HC595 данные    
       #define clockPin 3           // Подключаем вывод к SH_CP of 74HC595 тактовые импульсы
       #define latchPin 4           // Подключаем вывод к ST_CP of 74HC595 защёлка
       #define BUTTON   19           // Вход кнопки "старт"

// Обявляю переменные и массивы          
      unsigned long data = 0;       // Переменная состоит из 4 байт которые пишутся в 4-ре регистра
      unsigned long data1 = 0;      // Переменная состоит из 4 байт которые пишутся в 4-ре регистра
      unsigned char val = 0;        // Переменная состояния кнопки
      unsigned int y;               // Переменные циклов
      int pinState;
      unsigned long CueHIGH_delay = CueHIGH; //  Время импульса на воспламенители
      unsigned long CueDelay[32] = { Cue1,  Cue2,  Cue3,  Cue4,  Cue5,  Cue6,  Cue7,  Cue8,  Cue9,  Cue10,     
                       Cue11, Cue12, Cue13, Cue14, Cue15, Cue16, Cue17, Cue18, Cue19, Cue20,
                       Cue21, Cue22, Cue23, Cue24, Cue25, Cue26, Cue27, Cue28, Cue29, Cue30,     
                       Cue31, Cue32}; // Масив со временем задержки между включением каналов за вычетом времени
                      // импульса на воспламенители
//******************************************************************************************************     
// Инициализация ***************************************************************************************     
      void setup(){     
        pinMode(BUTTON , INPUT);      // Настраиваю Pin на ввод
        pinMode(dataPin, OUTPUT);     // Настраиваем порты сдвигового регистра на вывод     
        pinMode(latchPin, OUTPUT);      
        pinMode(clockPin, OUTPUT);     
//**********************************         
        digitalWrite(dataPin, LOW);    // Обнуляем порты сдвигового регистра
        digitalWrite(latchPin, LOW);     
        digitalWrite(clockPin, LOW);        
        digitalWrite(BUTTON, HIGH);   // Включаю подтягивающий резистор по входу к лог 1
//**********************************         
        Serial.begin(9600);            // Скорость обмена по UART     
        Serial.println("TEST HELLO");  // Тестовое сообщение отправляемое по UART         
//**********************************       
        send_data(0); // Данные пишутся в регистр (все биты "0")     
      }     
//**Основной цикл ***************************************************************************************
      void loop(){    
        val = digitalRead(BUTTON); // Обработка состояния пускового входного сигнала
        if (val == LOW){     
//********************************************     
        data1 = 1;
        for (y=0; y<32; y++){
         Serial.println(CueDelay[y]+CueHIGH_delay);     
         send_data(data1);        // Ставим ножку в единицу
         delay(CueHIGH_delay);    // Время импульса на воспламенители     
         send_data(0);            // Сбрасываем ножку     
         delay(CueDelay[y]);
         data1=(data1<<1);     
        }             
//*******************************************         
      }else{           // иначе
       send_data(0);  //  Обнуление регистров.  Данные пишутся в регистр (все биты "0").     
      delay(1);
     }
}      
//******************************************************************************************************
//Подпрограмма вывода на сдвиговый регистр *************************************************************     
        void send_data (unsigned long data){
        unsigned char i;
          for (i=0;i<32;i++){
      if ((data&0x80000000)==0x00) PORTD&=~_BV(dataPin); // Выводим данные на dataPin    
             else PORTD|=_BV(dataPin);
             delay(1);
             PORTD|=_BV(clockPin); // Импульс на CLK Даем один тактовый импульс
             delay(1);
             PORTD&=~_BV(clockPin);
             delay(1);
             data=(data<<1);
          }    
          PORTD|=_BV(latchPin); // Даем Импульс на Latch защелкиваем данные в регистрах
          delay(1);
          PORTD&=~_BV(latchPin);
         }       
//******************************************************************************************************