// общая инициализация
#include <FastLED.h> // Работа со светодиодами

//  ==================  Для организации виртуальной линии для бегущего светодиода  ===================================
#define MAX_ARAY 75    // Размер максимального байтового массива (можно менять)
#define ML 255         // максимальная яркость
#define LS (ML-20)/4   // шаг затухания хвоста (не исправлять) 

unsigned long currentTime;   // Переменная времени для задержек
const uint8_t pattern[5] PROGMEM = {ML-LS*4,ML-LS*3,ML-LS*2,ML-LS, ML}; // Значения: точка (255) и 4 хвостовых байта с затуханием
uint8_t pixels[MAX_ARAY];    // Массив для хранения текущих значений
static uint8_t menu_num = 0; //начальная инициализация меню всей программы
static uint8_t head1 = 0 ;   // положение головы бегущей строки
static uint8_t headRing = 0 ;// положение головы бегущей строки кольца
static uint8_t old_menu_num = 0;  // Предыдущий режим
static boolean direction = true;

#define LED_TYPE    WS2812B  // Тип LED-ленты (WS2812B, WS2811, SK6812, и т.д.)
#define COLOR_ORDER GRB      // Порядок цветов ленты 

#define R_DATA_PIN  5        // Пин, к которому подключено кольцо
#define RingLED 12           // Количество светодиодов в кольце
#define RLI_DATA_PIN 6       // Пин, к которому подключена лента РЛИ
#define RliLED 66            // Количество светодиодов в РЛИ канале
#define ZGL_DATA_PIN  7      // Пин, к которому подключена лента ЗГЛ
#define Zgl_PboLED 73        // Количество светодиодов в левой части ЗГЛ и части ПБО
#define PBO_DATA_PIN  8      // Пин, к которому подключена лента ПБО, ПБЛ
#define PboLED 71            // Количество светодиодов ПБО канале
#define NRZ_DATA_PIN  9      // Пин, к которому подключена лента НРЗ
#define NrzLED 60            // Количество светодиодов НРЗ канала
#define BLOCKS_DATA_PIN 4    // Пин, к которому подключены светодиоды блоков
#define BlockLED 124         // количество светодиодов в блоках
//====================================================================================================================
CRGB ringLEDs[RingLED];      // массив для диодов (кольцо)
CRGB RliLEDs[RliLED];        // массив для диодов (РЛИ)
CRGB ZglLEDs[Zgl_PboLED];    // массив для диодов (ЗГЛ и кусочек ПБО и ...)
CRGB PboLEDs[PboLED];        // массив для диодов (ПБО)
CRGB NrzLEDs[NrzLED];        // массив для диодов (НРЗ)
CRGB BlcLEDs[BlockLED];      // массив для диодов (Блоки)



void setup() {
   Serial.begin(9600);
   memset(pixels, 0, sizeof(pixels));
   head1 = 0;  // Текущая позиция "головы" (точки) 
   headRing = 0;  // Текущая позиция "головы" в кольце 
   menu_num = 0;
   pinMode(A0,INPUT);
   pinMode(A1,INPUT);
   pinMode(A2,INPUT);
   pinMode(A3,INPUT);
   pinMode(A4,OUTPUT);
   pinMode(13,INPUT);
   FastLED.addLeds<LED_TYPE, R_DATA_PIN, COLOR_ORDER>(ringLEDs, RingLED);// Инициализируем кольцо
   FastLED.addLeds<LED_TYPE, RLI_DATA_PIN, COLOR_ORDER>(RliLEDs, RliLED);// Инициализируем РЛИ
   FastLED.addLeds<LED_TYPE, ZGL_DATA_PIN, COLOR_ORDER>(ZglLEDs, Zgl_PboLED);// Инициализируем ЗГЛ
   FastLED.addLeds<LED_TYPE, PBO_DATA_PIN, COLOR_ORDER>(PboLEDs, PboLED);// Инициализируем ПБО
   FastLED.addLeds<LED_TYPE, NRZ_DATA_PIN, COLOR_ORDER>(NrzLEDs, NrzLED);// Инициализируем НРЗ
   FastLED.addLeds<LED_TYPE, BLOCKS_DATA_PIN, COLOR_ORDER>(BlcLEDs, BlockLED);// Инициализируем БЛОКИ
   FastLED.setBrightness(90); // Общая яркость светодиодов
}

void loop() {
     //определяемся с пунктом меню считываем управление 
     //Serial.print(" номер меню - ")); Serial.print(menu_num);Serial.println();
    currentTime = millis(); // организуем задержку, чтобы она была одинаковая при любых условиях
    if ((digitalRead(A0)==HIGH) & (digitalRead(13)==LOW)) {
        menu_num = digitalRead(A1)+digitalRead(A2)*2+digitalRead(A3)*4;
        if (old_menu_num != menu_num) { // Проверяем переходим ли в какое в другой пункт меню
             // если здесь значит преходим
             ClearAllRGB(); // чистим все ленты
             old_menu_num = menu_num; // при следующем нажатии уже нынешнее заначение 
                                      // меню будат предыдущим
             head1=0; // так, как ленты разные а 0 есть у всех, сбрасываем указатель головы змейки
             headRing = 10;
        }
    	  switch (menu_num) { // определяемся где мы в меню рисуем нужную змейку
            case 0 :  // Переходим в основном меню
                { 
	                  // Serial.println(F(" Переходим в основном меню "));
                    break;
                }
                
            case 1 :  // Переходим в канал приема РЛИ  
                {
                    //Serial.println(F(" Переходим РЛИ прием"));
                    //устанавливаем подсветку 1-го блока
                    SetBlockBlue(menu_num);
                    SetBlockBlue(8);
                    SetBlockBlue(10);
                    SetBlockBlue(11);
                    SetBlockBlue(12);
                    SetBlockBlue(13);
                    SetBlockBlue(14);
                    break;
                }
                
            case 2 :  // Переходим в канал передачи РЛИ
                {   
                    //  Serial.println(F(" Переходим РЛИ передача"));
                    //устанавливаем подсветку 2-го блока
                    SetBlockBlue(menu_num);
                    SetBlockBlue(8);
                    SetBlockBlue(10);
                    SetBlockBlue(11);
                    SetBlockBlue(15);
                    SetBlockBlue(16);
                    break;
                }
            case 3 :  // Переходим в канал ЗГЛ
                {
	                  // Serial.println(F(" Переходим ЗГЛ прием"));
                    //устанавливаем подсветку 3-го блока
                    SetBlockBlue(menu_num); SetBlockGreen(menu_num);
                    SetBlockBlue(17); SetBlockGreen(17);
                    SetBlockBlue(18); SetBlockGreen(18);
                    SetBlockBlue(19); SetBlockGreen(19);
                    SetBlockBlue(23); SetBlockGreen(23);
                    SetBlockBlue(24); SetBlockGreen(24);
                    SetBlockBlue(9);  SetBlockGreen(9);
                    SetBlockBlue(26); SetBlockGreen(26);
                    break;
                }
            case 4 :  // Переходим в канал ПБО
                {
                    //Serial.println(F(" Переходим ПБО прием"));
                    //устанавливаем подсветку 4-го блока
                    SetBlockGreen(menu_num);
                    SetBlockGreen(20);
                    SetBlockGreen(21);
                    SetBlockGreen(22);
                    SetBlockGreen(23);
                    SetBlockGreen(24);
                    SetBlockGreen(9);
                    SetBlockGreen(26);
                    break;
                }
            case 5 :  // Переходим в канал приема НРЗ
                {
	                  //Serial.println(F(" Переходим НРЗ прием"));
                    //устанавливаем подсветку 5-го блока
                    SetBlockRed(menu_num);
                    SetBlockRed(24);
                    SetBlockRed(9);
                    SetBlockRed(26);
                    SetBlockRed(27);
                    SetBlockRed(28);
                    break;
                }
            case 6 :  // Переходим в канал передачи НРЗ
                {
	                  //Serial.println(F(" Переходим НРЗ передача"));
                    //устанавливаем подсветку 6-го блока
                    SetBlockRed(menu_num);
                    SetBlockRed(24);
                    SetBlockRed(9);
                    SetBlockRed(26);
                    SetBlockRed(27);
                    SetBlockRed(28);
                    break;
                }
            case 7 :  // Переходим в канал ПБЛ НРЗ
                {
	                  //Serial.println(F(" Переходим ПБЛ НРЗ  прием"));
                    //устанавливаем подсветку 7-го блока
                    SetBlockRed(menu_num);
                    SetBlockRed(25);
                    SetBlockRed(24);
                    SetBlockRed(9);
                    SetBlockRed(26);
                    SetBlockRed(29);
                    SetBlockRed(30);
                    SetBlockRed(31);
                    break;
                }
            default : // если вдруг номер меню станет странным
                { 
                    //Serial.println(F(" ++++++++++++ Резкий глюк +++++++++++"));
                    menu_num = 0;  // код по умолчанию (если совпадений нет, что очень маловероятно)
                    break;
                }   
        }
        //delay(200);
        digitalWrite(A4,HIGH);
    }
    if ((digitalRead(A0)==LOW) & (digitalRead(13)==HIGH))  digitalWrite(A4,LOW); 
 	
    switch (menu_num) { // определяемся где мы в меню рисуем нужную змейку
      case 0 :  // Находимся в основном меню
          { 
              //Serial.println(F(" Находимся в основном меню "));
              // дышым зеленым цветом
              if (direction) {headRing = headRing+5;} else {headRing = headRing-5;}
              if (headRing<5) {direction = true;}
              if (headRing>150) {direction = false;}
              memset(ringLEDs, 0, sizeof(ringLEDs)); // просто очень быстро стираем данные ленты
              for (uint8_t i=0; i<RingLED; i++) ringLEDs[i].g = headRing;
              FastLED.show();   // Данные уходят на все пины одновременно
              break;  
          }
      case 1 :  // Отсвечиваем змейку канала на прием РЛИ
          { 
              //Serial.println(F(" Находимся РЛИ прием"));
              // Вращаем кольцо по часовой синим цветом
              headRing = move_head(headRing,RingLED,true); // сформировали змейку
              memset(ringLEDs, 0, sizeof(ringLEDs)); // просто очень быстро стираем данные ленты
              // и заполняем только нужные элементы
              for (uint8_t i=0; i<RingLED; i++) ringLEDs[i].b = pixels[i];
              // Бегим змейкой в прямом направлении синим цветом.
              // Т.к. приемо-передающая линия у нас одна, а нам надо 
              // подсвечивать только приём. Расчитываем размер буфера для 
              // змейки: первые 9 светодиодов и 13 следующих параллельны,
              // следоватально - 13 + (общая линия для приема и передачи) 19 
              // (далее приемная часть с 41 по 56) + 15 - итого 47. 
              head1 = move_head(head1,47,true);  // сформировали виртуальную змейку
              memset(RliLEDs, 0, sizeof(RliLEDs)); // очень быстро стираем данные ленты
              // и заполняем только нужные элементы СИНИМ цветом
              // заполняем 1-е 4 светодиода из 13
              for (uint8_t i=0; i<4; i++) RliLEDs[9+i].b = pixels[i]; 
               // заполняем параллельные 1-е 9 светодиодов и с 14 по 22
              for (uint8_t i=0; i<9; i++) {
                RliLEDs[i].b = pixels[i+3]; 
                RliLEDs[13+i].b = pixels[i+3]; 
              }
              // заполняем с 14(змейка) (23 в ленте) следующие 19 светодиодов
              for (uint8_t i=0; i<19; i++) RliLEDs[22+i].b = pixels[i+13];
              // заполняем с 33(зменйка) (41 в ленте)следующие 15 светодиодов
              for (uint8_t i=0; i<15; i++) RliLEDs[41+i].b = pixels[i+32];
              // а диоды с 56 до 66 (следующие 10 светодиодов) уже очищены memset-ом
              FastLED.show();   // Данные уходят на все пины одновременно
              break;
         }
      case 2 :  // Отсвечиваем змейку канала на передачу РЛИ
          {
	          //  Serial.println(F(" Находимся РЛИ передача"));
            // Вращаем кольцо против часовой синим цветом
              headRing = move_head(headRing,RingLED,false);
              memset(ringLEDs, 0, sizeof(ringLEDs)); // просто очень быстро стираем данные ленты
              // и заполняем ее нужной информацией
              for (uint8_t i=0; i<RingLED; i++) ringLEDs[i].b = pixels[i];
              // Бегим змейкой в обратном направлении синим цветом.
              // Т.к. приемо-передающая линия у нас одна, а нам надо 
              // подсвечивать только передачу. Расчитываем размер буфера для 
              // змейки: первые 9 светодиодов и 13 следующих параллельны,
              // следоватально - 13 + (общая линия для приема и передачи) 19 
              // (далее приемная часть с 57 по 66) + 10 - итого 42. 
              head1 = move_head(head1,42,false);  // сформировали виртуальную змейку
              memset(RliLEDs, 0, sizeof(RliLEDs)); // очень быстро стираем данные ленты
              // и заполняем только нужные элементы СИНИМ цветом
              // заполняем 1-е 4 светодиода из 13
              for (uint8_t i=0; i<4; i++) RliLEDs[9+i].b = pixels[i]; 
               // заполняем параллельные 1-е 9 светодиодов и с 14 по 22
              for (uint8_t i=0; i<9; i++) {
                RliLEDs[i].b = pixels[i+3]; 
                RliLEDs[13+i].b = pixels[i+3]; 
              }
              // заполняем с 14 следующие 19 светодиодов
              for (uint8_t i=0; i<19; i++) RliLEDs[22+i].b = pixels[i+13];
              // заполняем с 56 следующие 10 светодиодов
              for (uint8_t i=0; i<10; i++) RliLEDs[56+i].b = pixels[i+32];
              // а диоды с 41 до 55 (предыдущие 15 светодиодов) уже очищены memset-ом
              FastLED.show();   // Данные уходят на все пина одновременно
              break;
          }
          
      case 3 :  // Отсвечиваем змейку канала ЗГЛ
          {
 	            // Serial.println(F(" Находимся ЗГЛ прием"));
              // Вращаем кольцо против часовой бирюзовым цветом
              headRing = move_head(headRing,RingLED,false);
              memset(ringLEDs, 0, sizeof(ringLEDs)); // просто очень быстро стираем данные ленты
              // и заполняем ее нужной информацией
              for (uint8_t i=0; i<RingLED; i++) {
                  ringLEDs[i].b = pixels[i];
                  ringLEDs[i].g = pixels[i];
              }
              // Бегим змейкой в прямом направлении берюзой.
              // Расчитываем размер буфера для змейки: первые 7 и 8 следующих 
              // светодиодов параллельны, следоватально - 8 + (диоды между блоками) 5
              // и затем пропуская ПБО еще 17 - итого 30. 
              head1 = move_head(head1,30,true);  // сформировали виртуальную змейку
              memset(ZglLEDs, 0, sizeof(ZglLEDs)); // очень быстро стираем данные ленты
              // и заполняем только нужные элементы БИРЮЗОЙ
              // заполняем 8-й светодиод
              ZglLEDs[7].b = pixels[0]; 
              ZglLEDs[7].g = pixels[0]; 
              // Заполняем первые 7 и 7 после 8-го параллельно
              for (uint8_t i=0; i<7; i++) {
                  ZglLEDs[i].b = pixels[i]; ZglLEDs[i+8].b = pixels[i]; 
                  ZglLEDs[i].g = pixels[i]; ZglLEDs[i+8].g = pixels[i];
              }
              // заполняем следующие 5
              for (uint8_t i=8; i<13; i++) {
                  ZglLEDs[i+7].b = pixels[i]; 
                  ZglLEDs[i+7].g = pixels[i];
              }
              // заполняем с 32 по 48 (следующие 17)
              for (uint8_t i=13; i<30; i++) {
                  ZglLEDs[i+19].b = pixels[i]; 
                  ZglLEDs[i+19].g = pixels[i];
              }
              FastLED.show();   // Данные уходят на все пина одновременно
              break;
          }
          
      case 4 :  // Отсвечиваем змейку канала ПБО 
          {
	            //Serial.println(F(" Находимся ПБО прием"));
              // Вращаем кольцо против часовой зеленым цветом
              headRing = move_head(headRing,RingLED,false);
              memset(ringLEDs, 0, sizeof(ringLEDs)); // просто очень быстро стираем данные ленты
              // и заполняем ее нужной информацией
              for (uint8_t i=0; i<RingLED; i++) ringLEDs[i].g = pixels[i];
              // Бегим змейкой в прямом направлении зеленым цветом.
              // Расчитываем размер буфера для змейки: первые 28 и 10 следующих 
              // светодиодов параллельны (лента ПБО), следоватально - 28 + 
              //(диоды между блоками) с 20, 29 шт (лента ЗГЛ)- итого 57. 
              head1 = move_head(head1,54,true);  // сформировали виртуальную змейку
              memset(PboLEDs, 0, sizeof(PboLEDs)); // очень быстро стираем данные ленты
              memset(ZglLEDs, 0, sizeof(ZglLEDs)); // работаем с 2--мя лентами
              // и заполняем только нужные элементы зеленым
              // Заполняем первые 18 диодов в ленте ПБО
              for (uint8_t i=0; i<18; i++) PboLEDs[i].g = pixels[i];
              // Заполняем следующие 10 параллельно с 10-ю начиния с 28 в ленте ПБО
              for (uint8_t i=18; i<28; i++) {
                  PboLEDs[i].g = pixels[i];
                  PboLEDs[i+26].g = pixels[i];
              }
              // заполняем светодиод нр20 в ЗГЛ
              ZglLEDs[20].g = pixels[28];
              // 3 следующий и 3 за следующими :-) заполняем параллельно || (лента ЗГЛ)
              for (uint8_t i=21; i<24; i++) {
                  ZglLEDs[i].g = pixels[i+8];
                  ZglLEDs[i+3].g = pixels[i+8];
              }
              // оставшиеся 22 переносим в ленту ЗГЛ начиная с 23 позиции
              for (uint8_t i=0; i<23; i++) ZglLEDs[i+26].g = pixels[i+31];

              FastLED.show();   // Данные уходят на все пины одновременно
              break;    
          }
          
      case 5 :  // Отсвечиваем змейку канала НРЗ
          {
              //Serial.println(F(" Находимся НРЗ прием"));
              // Вращаем кольцо против часовой красным цветом
              headRing = move_head(headRing,RingLED,false);
              memset(ringLEDs, 0, sizeof(ringLEDs)); // просто очень быстро стираем данные ленты
              // и заполняем ее нужной информацией
              for (uint8_t i=0; i<RingLED; i++) ringLEDs[i].r = pixels[i];
              // Бегим змейкой в прямом направлении красным цветом.
              // Расчитываем размер буфера для змейки: первые 31 и 29 следующих 
              // светодиодов параллельны (лента ПБО), следоватально - 31 + 
              //(диоды между блоками) с 31, 12 шт (лента ЗГЛ) + 5 на фильтры итого 48. 
              head1 = move_head(head1,48,true);  // сформировали виртуальную змейку
              memset(NrzLEDs, 0, sizeof(NrzLEDs)); // очень быстро стираем данные ленты
              memset(ZglLEDs, 0, sizeof(ZglLEDs)); // работаем с 2--мя лентами
              // и заполняем только нужные элементы зеленым
              // Заполняем первые 31 (2 вначале) и 29 следующих параллельно диодов в ленте ПБО
              NrzLEDs[0].r = pixels[0]; NrzLEDs[1].r = pixels[1];
              for (uint8_t i=2; i<31; i++) {
                  NrzLEDs[i].r = pixels[i];
                  NrzLEDs[i+29].r = pixels[i];
              }
              // Заполняем 12 светодиодов в ленте ЗГЛ  с 33 по 45
              for (uint8_t i=0; i<12; i++) ZglLEDs[i+34].r = pixels[i+32];
              // заполняем светодиод нр20 в ЗГЛ
              // 10 следующих через 3 за следующими :-) заполняем параллельно || (по 5)
              for (uint8_t i=0; i<5; i++) {
                  ZglLEDs[i+49].r = pixels[i+43];
                  ZglLEDs[i+54].r = pixels[i+43];
              }
              FastLED.show();   // Данные уходят на все пины одновременно
              break;    
          }
      case 6 :  // Отсвечиваем змейку канала НРЗ
          {
	            // Serial.println(F(" Находимся НРЗ передача"));
              // Вращаем кольцо против часовой красным цветом
              headRing = move_head(headRing,RingLED,true);
              memset(ringLEDs, 0, sizeof(ringLEDs)); // просто очень быстро стираем данные ленты
              // и заполняем ее нужной информацией
              for (uint8_t i=0; i<RingLED; i++) ringLEDs[i].r = pixels[i];
              // Бегим змейкой в прямом направлении красным цветом.
              // Расчитываем размер буфера для змейки: первые 31 и 29 следующих 
              // светодиодов параллельны (лента ПБО), следоватально - 31 + 
              //(диоды между блоками) с 31, 12 шт (лента ЗГЛ) + 5 на фильтры итого 48. 
              head1 = move_head(head1,48,false);  // сформировали виртуальную змейку
              memset(NrzLEDs, 0, sizeof(NrzLEDs)); // очень быстро стираем данные ленты
              memset(ZglLEDs, 0, sizeof(ZglLEDs)); // работаем с 2--мя лентами
              // и заполняем только нужные элементы зеленым
              // Заполняем первые 31 (2 вначале) и 29 следующих параллельно диодов в ленте ПБО
              NrzLEDs[0].r = pixels[0]; NrzLEDs[1].r = pixels[1];
              for (uint8_t i=2; i<31; i++) {
                  NrzLEDs[i-1].r = pixels[i];
                  NrzLEDs[i+29].r = pixels[i];
              }
              // Заполняем 12 светодиодов в ленте ЗГЛ  с 33 по 45
              for (uint8_t i=0; i<12; i++) ZglLEDs[i+34].r = pixels[i+32];
              // заполняем светодиод нр20 в ЗГЛ
              // 10 следующих через 3 за следующими :-) заполняем параллельно || (по 5)
              for (uint8_t i=0; i<5; i++) {
                  ZglLEDs[i+49].r = pixels[i+43];
                  ZglLEDs[i+54].r = pixels[i+43];
              }
              FastLED.show();   // Данные уходят на все пины одновременно
              break;    
          }
          break;
      case 7 :  // Отсвечиваем змейку канала ПБЛ НРЗ
          {
	            //    Serial.println(F(" Находимся НРЗ ПБЛ прием"));
              // Вращаем кольцо против часовой красным цветом
              headRing = move_head(headRing,RingLED,false);
              memset(ringLEDs, 0, sizeof(ringLEDs)); // просто очень быстро стираем данные ленты
              // и заполняем ее нужной информацией
              for (uint8_t i=0; i<RingLED; i++) ringLEDs[i].r = pixels[i];
              // Бегим змейкой в прямом направлении красным цветом.
              // Расчитываем размер буфера для змейки: первые 44 и 25 следующих 
              // светодиодов параллельны (лента ПБО), следоватально - 44 + 2 
              // (диоды между блоками). Далее лента ЗГЛ с 35, 12 шт + 6 и 
              // 4(2||) на фильтры итого 68. 
              head1 = move_head(head1,68,true);  // сформировали виртуальную змейку
              memset(PboLEDs, 0, sizeof(PboLEDs)); // очень быстро стираем данные ленты
              memset(ZglLEDs, 0, sizeof(ZglLEDs)); // работаем с 2--мя лентами
              // и заполняем только нужные элементы красным
              for (uint8_t i=0; i<19; i++)  PboLEDs[i].r = pixels[i];
              // заполняем параллельные части    
              for (uint8_t i=19; i<44; i++) {
                  PboLEDs[i].r = pixels[i];
                  PboLEDs[i+25].r = pixels[i];
              }
              PboLEDs[69].r = pixels[44]; PboLEDs[70].r = pixels[45];
              // Заполняем 12 светодиодов в ленте ЗГЛ  с 33 по 45
              for (uint8_t i=0; i<12; i++) ZglLEDs[i+34].r = pixels[i+46];
              // 6 следующих через 13 за следующими :-) 
              for (uint8_t i=0; i<6; i++) ZglLEDs[i+59].r = pixels[i+58];
              //заполняем параллельно || (по 5)
              for (uint8_t i=0; i<4; i++) {
                  ZglLEDs[i+65].r = pixels[i+64];
                  ZglLEDs[i+69].r = pixels[i+64];
              }
              FastLED.show();   // Данные уходят на все пины одновременно
              break;    
          }
      default :   // если вдруг номер меню станет странным
          { 
          //     Serial.println(F(" ---------- Резкий глюк --------------"));
              menu_num = 0; 
              break;    
          }
         
    }


// head1 = move_head(head1,12); 

// Пауза для контроля скорости
// currentTime = millis();
        while ((millis()-currentTime) < 50) {};
//  delay (20);
}
void SetBlockBlue(uint8_t num) { // установка блока в голубой цвет
    BlcLEDs[(num-1)<<2].b = 255;
    BlcLEDs[((num-1)<<2)+1].b = 255;
    BlcLEDs[((num-1)<<2)+2].b = 255;
    BlcLEDs[((num-1)<<2)+3].b = 255;
}
void SetBlockGreen(uint8_t num) { // установка блока в зеленый цвет
    BlcLEDs[(num-1)<<2].g = 255;
    BlcLEDs[((num-1)<<2)+1].g = 255;
    BlcLEDs[((num-1)<<2)+2].g = 255;
    BlcLEDs[((num-1)<<2)+3].g = 255;
}
void SetBlockRed(uint8_t num) { // установка блока в красный цвет
    BlcLEDs[(num-1)<<2].r = 255;
    BlcLEDs[((num-1)<<2)+1].r = 255;
    BlcLEDs[((num-1)<<2)+2].r = 255;
    BlcLEDs[((num-1)<<2)+3].r = 255;
}
void ClearAllRGB() { // Процедурка для очистки всех лент (при переключении)
    memset(ringLEDs, 0, sizeof(ringLEDs));
    memset(RliLEDs, 0, sizeof(RliLEDs));
    memset(ZglLEDs, 0, sizeof(ZglLEDs)); 
    memset(PboLEDs, 0, sizeof(PboLEDs));
    memset(NrzLEDs, 0, sizeof(NrzLEDs));
    memset(BlcLEDs, 0, sizeof(BlcLEDs));
}

uint8_t move_head (uint8_t head, uint8_t len_array, boolean direction) { // процедура для сдвига бегущей строки (циклично)
    uint8_t idx;
    // двигаем бегущий светодиод по виртуальной линии
    memset(pixels, 0, len_array); // Очищаем весь массив максимально эффективно(быстро)
    // Заполняем точку и хвост относительно в нужном месте позиции head
    if (direction) {
        for (uint8_t i = 0; i < 5; i++) { // голова с затухающим хвостом занимает 5 байт
            idx = (head + i);  // сдвиг
            if (idx >= len_array) idx = idx - len_array; // Организуем циклический сдвиг 
            pixels[idx] = pgm_read_byte(&pattern[i]); 
        } 
        //Сдвигаем голову вперёд для следующего шага
        head++;
        if (head >= len_array) head = 0; // сдвигаем циклично, если достигли конца, то опять сбрасываем в 0
    }
    else {
        for (uint8_t i = 0; i < 5; i++) { // голова с затухающим хвостом занимает 5 байт
            if ((head - i) < 0) {idx = len_array - (i - head);} else {idx = (head - i);} // Организуем циклический сдвиг 
            pixels[idx] = pgm_read_byte(&pattern[i]); 
        } 
         //Сдвигаем голову назад для следующего шага
        if (head == 0) { head = len_array - 1; } else {head = head - 1; }// сдвигаем циклично, если достигли начала, то опять отправляем в конец
    }
/*  //-Отладка- Выводим массив в Serial (для визуализации)--------------------------------------------------------
    Serial.print("head(post if) "));
    Serial.println(head);
    for (uint8_t i = 0; i < len_array; i++) { 
      Serial.print(pixels[i]);
      if (i < len_array - 1) Serial.print(" ")); 
    }
    Serial.println();
    //-------------------------------------------------------------------------------------------------------------  
*/
    return head; // Возвращаем из функции новое значение головы бегущей строки  
}