Arduino.ru

Вооот, теперь понял. Спасибо Вам за быстрой и понятный ответ. Ато голову уже сломал колдуя с цифрами) Сделали бы 5х5х5 rgb было бы супер) нашел ваш пост с кубиками на Гиктаймс, код мало понял т.к в програмирование слабоват. но код оформлен красиво.

125 RGB светодиодов дороговато получается :) Пока ограничусь одноцветными, всё же.

А про код. Спасибо за добрые слова. Я сам пока не очень в программировании, поэтому стараюсь более-менее комментировать код и структурировать его для удобства чтения. Главное, сильно не вчитываться в сам код, чтобы не возникло желания побить меня :)

Я пожалуй закажу с алика потом ргб,уж больно эффектно светится). Ну чтож, Буду ждать вашу новую работу)

Спасибо огромное за эту статью. В основном, благодаря этой статье, я разбирался с моим первым кубиком.

Я купил китайский набор для 4х4х4 (купил тут https://ru.aliexpress.com/item/4X4X4-3D-Light-Cube-Kit-Blue-Shield-LED-Precise-DIY-Kit/32630720293.html?spm=2114.10010208.1000016.1.UWRNRn&isOrigTitle=true)  и залил их стандартный пример (взято отсюда http://www.icstation.com/icstation-4x4x4-light-cube-arduino-p-5312.html)

В примере не разобрался от слова вообще. Начал с нуля :) со сдвиговых регистров http://arduino.ru/Tutorial/registr_74HC595 по совету из этого топика, кстати. Вот по чуть и разбирался. Схема  моего кубика почти как у ТС, только без ключевых транзисторов. И я добавил еще одну кнопку - чтобы регулировать частоту морганий. Корпус из крышек от CD дисков.

Код легко управляем, все завязано непосредственно на управление каждым диодом и слоями. Намного более тяжелый чем у  jeka_tm

Но, мне так было легче и понятнее. Может кому-нибудь тоже поможет разобраться с подобным кубиком.

Вот, в общем, что получилось

ну и мой код с 10 эффектами, которые легко можно править и изменять

const int latchPin = 8;        // Пин подключен к ST_CP входу 74HC595
const int clockPin = 12;       // Пин подключен к SH_CP входу 74HC595
const int dataPin = 11;        // Пин подключен к DS входу 74HC595
int LayerPin[] = {4, 5, 6, 7}; // указываем пины, к которым подключены слои кубика

int ButPin1 = 2;               // подключаем кнопку к выходу 2
int ButPin2 = 3;               // подключаем кнопку к выходу 3
int flag1 = 0;                  // флаг состояния
volatile int rejim1 = 0;        // Переключалка
int flag2 = 0;                  // флаг состояния
volatile int rejim2 = 0;        // Переключалка

int lastLayer = 0;
int layer = 0;                 //номер вертикального слоя
unsigned int bitsToSend = 0;    // переменная для хранения состояния каждого пина

int g = 0;
int h = 0;


int State1 = 0; // HIGH=1; LOW=0
int timeStop = 200;   //задержка внутри циклов подпрограмм

void setup() {
  Serial.begin(9600);

  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(ButPin1, INPUT);
  pinMode(ButPin2, INPUT);

  // все слои: LOW - вкл ,  HIGH - выкл
  for (layer = 0; layer < 4; layer++) {
    pinMode(LayerPin[layer], OUTPUT);
    digitalWrite(LayerPin[layer], HIGH);
  }
  attachInterrupt(INT0, ChangeRejim1, CHANGE);
  attachInterrupt(INT1, ChangeRejim2, CHANGE);
}   //конец setup

void loop() {

  //  ChangeRejim1();
  //  //  setRejim1();
  ChangeRejim2();

  Serial.print("R1- ");
  Serial.print(rejim1);
  Serial.print("  R2-  ");
  Serial.println(rejim2);


  switch (rejim2) {
    //************
    case 0:
      Serial.println("AllOn");
      hLayersAll(0) ;
      vLayersAll(1) ;
      break;
    //************
    case 1:
      Serial.println("fallDown");
      vLayersAll(0) ;
      fallDown (random(0, 15));
      break;
    //************
    case 2:
      Serial.println("raiseUP");
      vLayersAll(0) ;
      raiseUP (random(0, 15));
      break;
    //************
    case 3:
      Serial.println("Spiral");
      vLayersAll(0) ;

      for (layer = 0; layer < 4; layer++) {     // цикл для включения слоев свверху вниз
        //   for (layer = -3; layer <=0; layer++) {    // цикл для включения слоев снизу вверх
        digitalWrite(LayerPin[abs(layer)], LOW); // включаем слой
        //    }

        spiral2 (1);// в следующей подпрограмме включаем столбцы

        spiral1 (0);// в следующей подпрограмме вЫключаем столбцы
        digitalWrite(LayerPin[abs(layer)], HIGH);  // вЫключаем слой - для цикла движения по слоям
      }
      break;

    //************
    case 4:    // your hand is nowhere near the sensor
      Serial.println("circle1");
      vLayersAll(0) ;
      for (layer = 0; layer < 4; layer++) {     // цикл для включения слоев свверху вниз
        digitalWrite(LayerPin[abs(layer)], LOW); // включаем слой
        //    }
        circle1 ();
        digitalWrite(LayerPin[abs(layer)], HIGH);  // вЫключаем слой - для цикла движения по слоям
        lastLayer = abs(layer);
      }

      digitalWrite(LayerPin[lastLayer], LOW); // включаем слой
      circle1 ();
      digitalWrite(LayerPin[lastLayer], HIGH);  // вЫключаем слой - для цикла движения по слоям

      for (layer = -3; layer <= 0; layer++) {   // цикл для включения слоев снизу вверх
        digitalWrite(LayerPin[abs(layer)], LOW); // включаем слой
        //    }
        circle1 ();
        digitalWrite(LayerPin[abs(layer)], HIGH);  // вЫключаем слой - для цикла движения по слоям
      }

      //      fallDown (6);
      break;
    //************
    case 5:
      Serial.println("LineEvolution");
      for (int i = 0; i < 4; i++) {
        hLayersSingle (i, 0);
        vLayersSingle (i, 1);
        delay (timeStop);
        vLayersSingle (i, 0);
        hLayersSingle (i, 1);
      }

      for (int i = 3; i >= 0; i--) {
        hLayersSingle (i, 0);
        vLayersSingle (i, 1);
        delay (timeStop);
        vLayersSingle (i, 0);
      }

      for (int i = 0; i < 4; i++) {
        vLayersSingle (i, 1);
        delay (timeStop);
      }
      break;


    //************
    case 6:
      Serial.println("spiralFull");
      vLayersAll(0) ;                  //State1 = 0 -выкл, =1 - вкл
      hLayersAll(0) ;                      //State1 = 1 -выкл, =0 - вкл
      spiral1 (1);                   //State1 = 1 -вкл, =0 - выкл
      //  vLayersAll(0) ;                  //State1 = 0 -выкл, =1 - вкл
      //      delay (timeStop);
      //      spiral2 (0);
      break;

    //************
    case 7:
      Serial.println(" 7777");
      hLayersAll(0);
      vLayersAll(0);
      for (int i = 0; i < 4; i++) {
        vLayersSingle(i, 1);
        delay (timeStop);
        vLayersSingle(i, 0);
      }
      for (int i = 3; i >= 0 ; i--) {
        vLayersSingle(i, 1);
        delay (timeStop);
        vLayersSingle(i, 0);
      }

      for (int i = 0; i < 4; i++) {
        v2LayersSingle(i, 1);
        delay (timeStop);
        v2LayersSingle(i, 0);
      }
      for (int i = 3; i >= 0 ; i--) {
        v2LayersSingle(i, 1);
        delay (timeStop);
        v2LayersSingle(i, 0);
      }
      break;
    //************
    case 8:
      PointGrow (random(1, 8));
      break;

    //************ хаоссс
    case 9:
      vLayersAll (0);
      hLayersAll(1);

      g = random(0, 15);
      h = random(0, 4);

      hLayersSingle( h, 0);    //State1 = 1 -выкл, =0 - вкл
      bitToSend ( g, 1);
      sendToRegister ();    // Шлем в регистр
      delay (timeStop);
      hLayersSingle( h, 1);    //State1 = 1 -выкл, =0 - вкл
      bitToSend ( g, 0);
      sendToRegister ();    // Шлем в регистр
      delay (timeStop);

      break;

    //************
    case 10:
      Serial.println("AllOff");
      hLayersAll(1);                   //State1 = 1 -выкл, =0 - вкл
      vLayersAll(0) ;                  //State1 = 0 -выкл, =1 - вкл
      break;
  }     //конец  switch (rejim2)


}     //конец loop


/******************gthtxtym подпрограмм
  bitToSend ( Point,  State1);
  hLayersSingle( hLayer,  State1);    //State1 = 1 -выкл, =0 - вкл
  hLayersAll( State1);                //State1 = 1 -выкл, =0 - вкл
  vLayersAll( State1);                //State1 = 0 -выкл, =1 - вкл
  vLayersSingle(vLayer, State1);      //State1 = 0 -выкл, =1 - вкл
  v2LayersSingle(vLayer, State1)      //State1 = 0 -выкл, =1 - вкл


  snake1(State1);
  snake2(State1);
  spiral1( State1);
  spiral2( State1);
  circle1();
  fallDown (Point);
  raiseUP (Point);
  PointGrow (Point);
*/

//****функция передачи данных в сдвиговый регистр для зажигания светодиодов
void sendToRegister () {   // Шлем в регистр
  //Отключаем вывод на регистре
  digitalWrite(latchPin, LOW);

  // разбиваем наши 16 бит на два байта
  // для записи в первый и второй регистр
  byte registerOne = lowByte(bitsToSend);
  byte registerTwo = highByte(bitsToSend);

  // "проталкиваем" байты в регистры  - сначало в дальний
  shiftOut(dataPin, clockPin, MSBFIRST, registerTwo);
  shiftOut(dataPin, clockPin, MSBFIRST, registerOne);

  // "защелкиваем" регистр, чтобы биты появились на выходах регистра
  digitalWrite(latchPin, HIGH);
}

void bitToSend (int Point, int State1) {  //Запись в байт каждой точки
  bitWrite(bitsToSend, Point, State1);
  //        sendToRegister ();    // Шлем в регистр
}


//*********** функция смены режима по кнопке 1
void ChangeRejim1() {
  if (digitalRead(ButPin1) == HIGH && flag1 == 0)
  {
    rejim1 ++;
    flag1 = 1;
    if (rejim1 > 6)           // Если номер режима превышает количество эффектов,
    {
      rejim1 = 0;  // то отсчет начинается с нуля
    }
  }
  if (digitalRead(ButPin1) == LOW && flag1 == 1)
  {
    flag1 = 0;
  }
  switch (rejim1) {
    case 0:
      Serial.println("Light Speed");
      timeStop = 1;
      break;
    case 1:
      Serial.println("Fastest");
      timeStop = 25;
      break;
    case 2:
      Serial.println("Fast");
      timeStop = 50;
      break;
    case 3:
      Serial.println("Medium");
      timeStop = 100;
      break;
    case 4:
      Serial.println("Slow");
      timeStop = 200;
      break;
    case 5:
      Serial.println("Slowest");
      timeStop = 300;
      break;
    case 6:
      Serial.println("Slowest");
      timeStop = 500;
      break;
  }
}
//**********функция смены режима по кнопке 2
void ChangeRejim2() {
  if (digitalRead(ButPin2) == HIGH && flag2 == 0)
  {
    rejim2 ++;
    flag2 = 1;
    if (rejim2 > 10)           // Если номер режима превышает количество эффектов,
    {
      rejim2 = 0;  // то отсчет начинается с нуля
    }
  }
  if (digitalRead(ButPin2) == LOW && flag2 == 1)
  {
    flag2 = 0;
  }
}
//********
void hLayersSingle(int hLayer, int State1) { // функция для одиночных слоёв горизонтальных
  digitalWrite(LayerPin[hLayer], State1);
}
//********
void hLayersAll(int State1) { // функция для всех слоёв горизонтальных
  for (layer = 0; layer < 4; layer++) {
    digitalWrite(LayerPin[layer], State1);
  }
}
//******** функция для включения/выключения (State1) всех слоёв вертикальных
void vLayersAll(int State1) {
  for (int i = 0; i < 16; i++) {
    bitWrite(bitsToSend, i, State1);
    sendToRegister ();    // Шлем в регистр
  }
}
//******** функция для включения/выключения (State1) слоёв вертикальных по одному поперек
void vLayersSingle(int vLayer, int State1) {
  switch (vLayer) {
    case 0:
      for (int i = 0; i < 4; i++) {
        bitWrite(bitsToSend, i, State1);
        sendToRegister ();    // Шлем в регистр
      }
      break;
    case 1:
      for (int i = 4; i < 8; i++) {
        bitWrite(bitsToSend, i, State1);
        sendToRegister ();    // Шлем в регистр
      }
      break;
    case 2:
      for (int i = 8; i < 12; i++) {
        bitWrite(bitsToSend, i, State1);
        sendToRegister ();    // Шлем в регистр
      }
      break;
    case 3:
      for (int i = 12; i < 16; i++) {
        bitWrite(bitsToSend, i, State1);
        sendToRegister ();    // Шлем в регистр
      }
      break;

  }
}
//******** функция для включения/выключения (State1) слоёв вертикальных по одному вдоль
void v2LayersSingle(int vLayer, int State1) {
  switch (vLayer) {
    case 0:
      for (int i = 0; i < 16; ) {
        bitWrite(bitsToSend, i, State1);
        sendToRegister ();    // Шлем в регистр
        i = i + 4;
      }
      break;
    case 1:
      for (int i = 1; i < 16; ) {
        bitWrite(bitsToSend, i, State1);
        sendToRegister ();    // Шлем в регистр
        i = i + 4;
      }
      break;
    case 2:
      for (int i = 2; i < 16; ) {
        bitWrite(bitsToSend, i, State1);
        sendToRegister ();    // Шлем в регистр
        i = i + 4;
      }
      break;
    case 3:
      for (int i = 3; i < 16;) {
        bitWrite(bitsToSend, i, State1);
        sendToRegister ();    // Шлем в регистр
        i = i + 4;
      }
      break;
  }
}

// ЭФФЕКТЫ

///************* Зажечь/потушить змейку от 0 до 15
void snake1(int State1) {
  for (int i = 0; i < 4; i++) {
    bitWrite(bitsToSend, i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  for (int i = 7; i > 3; i--) {
    bitWrite(bitsToSend, i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  for (int i = 8; i < 12; i++) {
    bitWrite(bitsToSend, i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  for (int i = 15; i > 11; i--) {
    bitWrite(bitsToSend, i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
}
//************** Зажечь/потушить змейку от 15 до 0
void snake2(int State1) {
  for (int i = 12; i < 16; i++) {
    bitWrite(bitsToSend, i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  for (int i = 12; i > 7; i--) {
    bitWrite(bitsToSend, i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  for (int i = 4; i < 8; i++) {
    bitWrite(bitsToSend, i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  for (int i = 3; i >= 0; i--) {
    bitWrite(bitsToSend, i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
}
//************* Зажечь/потушить закручивающююся спираль снаружи внутрь
//по часовой стрелке
void spiral1(int State1) {
  for (int i = 0; i < 4; i++) {
    bitWrite(bitsToSend, i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  bitWrite(bitsToSend, 7, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);

  bitWrite(bitsToSend, 11, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);

  for (int i = 15; i > 11; i--) {
    bitWrite(bitsToSend, i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  bitWrite(bitsToSend, 8, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);

  bitWrite(bitsToSend, 4, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);

  bitWrite(bitsToSend, 5, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitWrite(bitsToSend, 6, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitWrite(bitsToSend, 10, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitWrite(bitsToSend, 9, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
}
///************Зажечь/потушить Раскручивающуюся спираль изнутри наружу
//против часовой стрелки
void spiral2(int State1) {

  bitWrite(bitsToSend, 5,  State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitWrite(bitsToSend, 6, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitWrite(bitsToSend, 10, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitWrite(bitsToSend, 9, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);

  bitWrite(bitsToSend, 8, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitWrite(bitsToSend, 4, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  for (int i = 0; i < 4; i++) {
    bitWrite(bitsToSend, i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  bitWrite(bitsToSend, 7, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);

  bitWrite(bitsToSend, 11, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);

  for (int i = 15; i > 10; i--) {
    bitWrite(bitsToSend, i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);

    bitWrite(bitsToSend, 10, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
}
///********** одиночный огонек по кругу по часовой стрелке
void circle1() {
  for (int i = 0; i < 4; i++) {
    bitWrite(bitsToSend, i, HIGH);            //включили диод (столбик) 0-4
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
    bitWrite(bitsToSend, i, LOW);            //вЫключили диод 0-4
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  bitWrite(bitsToSend, 7, HIGH);            //включили диод 7
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitWrite(bitsToSend, 7, LOW);              //вЫключили диод 7
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitWrite(bitsToSend, 11, HIGH);           //и т.д.
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitWrite(bitsToSend, 11, LOW);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  for (int i = 15; i > 11; i--) {
    bitWrite(bitsToSend, i, HIGH);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
    bitWrite(bitsToSend, i, LOW);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  bitWrite(bitsToSend, 8, HIGH);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitWrite(bitsToSend, 8, LOW);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);

  bitWrite(bitsToSend, 4, HIGH);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitWrite(bitsToSend, 4, LOW);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
}
//******************** Звездопад
void fallDown (int Point) {
  bitWrite(bitsToSend, Point, HIGH);
  // bitWrite(bitsToSend, random(0, 15), HIGH);

  sendToRegister ();    // Шлем в регистр
  for (layer = -3; layer <= 0; layer++) {   // цикл для включения слоев  свверху вниз
    digitalWrite(LayerPin[abs(layer)], LOW); // включаем слой
    delay (timeStop);
    digitalWrite(LayerPin[abs(layer)], HIGH);  // вЫключаем слой - для цикла движения по слоям
  }       //Если нужно включить все слои и работать со столбцами
  bitWrite(bitsToSend, Point, LOW);
  sendToRegister ();    // Шлем в регистр
}
//******************** Звездопад наоборот
void raiseUP (int Point) {
  bitWrite(bitsToSend, Point, HIGH);
  sendToRegister ();    // Шлем в регистр
  for (layer = 0; layer < 4; layer++) {     // цикл для включения слоев снизу вверх
    digitalWrite(LayerPin[abs(layer)], LOW); // включаем слой
    delay (timeStop);
    digitalWrite(LayerPin[abs(layer)], HIGH);  // вЫключаем слой - для цикла движения по слоям
  }
  bitWrite(bitsToSend, Point, LOW);
  sendToRegister ();    // Шлем в регистр
}
//***********рост из угла
void PointGrow (int Point) {

  switch (Point) {
    //**************
    case (1):
      //***рост из 1 (0,0)
      hLayersAll (1);
      for (int i = 0; i < 4; i++) {
        vLayersAll(1);
        hLayersSingle (i, 0);
        for (int y = 1 + i; y < 4; y++) {
          vLayersSingle(y, 0);
          v2LayersSingle(y, 0);
        }
        delay (timeStop);
      }
      break;
    //***************
    case (2):
      //***рост из 2 (3,0)
      hLayersAll (1);
      for (int i = 0; i < 4; i++) {
        vLayersAll(1);
        hLayersSingle (i, 0);
        for (int y = 1 + i; y < 4; y++) {
          vLayersSingle(y, 0);
          v2LayersSingle(3 - y, 0);
        }
        delay (timeStop);
      }
      break;

    //***************
    case (3):
      //***рост из 3 (15,0)
      hLayersAll (1);
      for (int i = 0; i < 4; i++) {
        vLayersAll(1);
        hLayersSingle (i, 0);
        for (int y = 0; y < 3 - i; y++) {
          vLayersSingle(y, 0);
          v2LayersSingle(y, 0);
        }
        delay (timeStop);
      }
      break;

    //***************
    case (4):
      //***рост из 4 ( 12,0)
      hLayersAll (1);
      for (int i = 0; i < 4; i++) {
        vLayersAll(1);
        hLayersSingle (i, 0);
        for (int y = 0; y < 3 - i; y++) {
          vLayersSingle(y, 0);
          v2LayersSingle(3 - y, 0);
        }
        delay (timeStop);
      }
      break;

    //**************
    case (5):
      //***рост из 5 (0,4)
      hLayersAll( 1);
      for (int i = 3; i >= 0; i--) {
        vLayersAll(1);
        hLayersSingle (i, 0);
        for (int y = 4 - i; y < 4; y++) {
          vLayersSingle(y, 0);
          v2LayersSingle(y, 0);
        }
        delay (timeStop);
      }
      break;

    //**************
    case (6):
      //***рост из 6 (3,4)
      hLayersAll( 1);
      for (int i = 3; i >= 0; i--) {
        vLayersAll(1);
        hLayersSingle (i, 0);

        for (int y = 0; y < i; y++) {
          vLayersSingle(3 - y, 0);
          v2LayersSingle(y, 0);
        }
        delay (timeStop);
      }
      break;


    //**************
    case (7):
      //***рост из 7 (15,4)
      hLayersAll( 1);
      for (int i = 3; i >= 0; i--) {
        vLayersAll(1);
        hLayersSingle (i, 0);
        for (int y = 0; y < i; y++) {
          vLayersSingle(y, 0);
          v2LayersSingle(y, 0);
        }
        delay (timeStop);
      }
      break;

    //**************
    case (8):
      //***рост из 8 (12,4)
      hLayersAll( 1);
      for (int i = 3; i >= 0; i--) {
        vLayersAll(1);
        hLayersSingle (i, 0);
        for (int y = 4 - i; y < 4; y++) {
          vLayersSingle(3 - y, 0);
          v2LayersSingle(y, 0);
        }
        delay (timeStop);
      }
      break;
  } // end of switch
} // end of PointGrow (int Point, int Layer)

да уж)) ты всю графику математикой сделал. и не лень было так много писать)) молодчик что довел до конца

Я просо еще не понял, как графику использовать :)

Подскажите, для 3 сдвиговых регистров и более, принцип тот же? или в случае такого же РГБ куба лучше использовать что-то другое?

И еще удручают слои, хочется управлять КАЖДЫМ и ВСЕМИ диодами отдельно :)

принцип тот же. так управлять каждым светодиодом или слоем несложно, делаются функции и делов то

для ргб сложнее в случае если тебе 8 цветов достаточно, и еще сложнее если нужно с переливами. там уже контроллер для цветных светодиодов лучше использовать

Не очень понимаю, как управлять каждым светодиодом при слоях. Например одновременно засветить столбик 1 слой 2 и столбик 2 слой 4. Получается что в обоих столбиках 1 и 2 светятся диоды в слоях 2 и 4. А если делать не послойно - то количество ног увеличивается в 2 раза, мне так кажется.

А что за контроллеры для цветных светодиодов вы рекомендуете? какое-нибудь наименование, если не сложно, или ссылочку :)

Прочитал ... увлекли... задумался... 

а не проще WS2812B использовать ? заказал 200 штук на али ... буду экспериментировать... 1 минус они в SMD корпусах... пока сажусь рисовать схемку соединений чтоб представить что будет по проводам ) 

popUP посмотри мой код, в начале массив сгенерированный из 16 байт. просто так программа генерит, а так можно сократить до 8 байт. любой меняй бит, изменишь светодиод, определенные биты столбец или строка. просто надо представить это

насчет контроллеров ничего не рекомендую, надо разбираться что оптимальнее подойдет

flat с какой то стороны проще

jeka_tm я смотрел ваш код. думал. 

я правильно понимаю, что таким образом получается быстрое мигание диодов. за счет этого и складывается картинка. В этом случае, у меня свечение диодов какое то слабое.  В моем коде диод включается и горит все отведенное время.

Но я все равно не представляю, как можно ОДНОВРЕМЕННО включить только  2 диода -  1 слой 1 столбец и второй слой 2 столбец. У меня другое соединение, чем в вашей схеме, наверное. Отдельно могу управлять каждым диобом  в рамках одного столбца - только отключая слои. Поэтому, если включен один диод это означает, что включен весь столбец и отключены слои выше и ниже диода. если я включаю еще один любой столбец - то в нем горят все диоды , находящиеся на включенном слое.

Что-то путано, но , в общем, зажечь диагональ в любой вертикальной плоскости куба чтобы диоды горели одновременно, я не могу. только "быстро бегущие огни, сливающиеся визуально в линию, но и свечение тогда неяркое, и мерцание видно 

а

конечно не одновременно. динамическая индикация. за раз максимум горит один слой. у меня так сделано

свечение сильно падает потому что ты, если правильно понял, управляешь какой слой включить напрямую пином ардуины, а ардуина не может потянуть ток такого количества светодиодов. во вторых R500 это 500ом наверно. если да то неправильная запись. надо писать 500R. так как R500 это 0,5ома. итак если это 500ом то ток сильно уменьшен и яркость конечно будет очень слабая. дорабатывай схему

Хорошо пошутили! 

Где я и где схема :) Я сложнее мультивибратора ничего не нарисую.

А схема была готовая, детальки подобраны , тока спаять аккуратно

http://www.icstation.com/icstation-4x4x4-light-cube-arduino-p-5312.html

даже пример кода был, правда как библиотека оформлен - я в такие дебри залезть не сумел, но, слава богу, тут нашел почти все ответы что и как программировать.

С кубиком временно наигрался, жду комплект РГБ диодов, буду думать как дальше и больше.

Возвращаюсь к машинке, на фотке хвастаюсь 

ну так и есть. китайцы съэкономили на копеечных транзисторах. а чтобы не спалить выход поставили более высокоомный резистор чем нужно. халтуру продают

Китайская продукция - она такая :) Халтура, но работает. Плохо и недолго :)

А мне этот набор в радость. Я не представляю себе как бы я плату делал, а поэкспериментировать с кодом хотелось. Теперь убедился - что мне по силам им управлять, можно и железяку самому собирать.

Свой следующий кубик уже сам с транзисторами собирать буду, встанет вопрос платы , поиска компонентов, травления, и прочих радостей начинающего электромонтера.

Спасибо всем, кто принял участие в этой теме, очень помогли

С уважением, 

я

Апну темку.

Малому моему вдруг захотелось научится паять. Нет чтоб с чего попросче, так сразу куб 4х4х4. Не воспользоватся его желанием было бы глупо. Вобщем запаял он куб, а подключали к ардуине и код начинали писать ;) вместе. Я штук 8 эффектов выродил. Потом решил - зачем напрягатся, если можна украсть)) Доцепил код из этой  темы и еще с одного проекта, адаптировал на скорую руку, вобщем за содержимое loop_NeT102rus()  и loop_popUP и тех ф-ий что они напридумывали пинать не меня, а тех у кого я сп..ил )))) 

#define PIN_LED 13

#define PIN_ST   A1   // 12 pin 74hc595
#define PIN_SH   A2  //  11 pin 74hc595
#define PIN_DATA 2   //  14 pin 74hc595

const byte led[]={1,2,3,4,13,14,5,8,9,6,16,7,15,11,10,12};
//const byte led[] ={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
#define LED_COLUMN_ON(n) (~(1<<(led[n]-1)))



#define BSET(a,b) a|=_BV(b);
#define BCLR(a,b) a&=~(_BV(b));

#define  ARDUINO_PORT(a)    ((a<8)?PORTD:(a<14?PORTB:PORTC))
#define  ARDUINO_PIN(a)     ((a<8)?PIND:(a<14?PINB:PINC))
#define  ARDUINO_DDR(a)     ((a<8)?DDRD:(a<14?DDRB:DDRC))
#define  ARDUINO_PIN_NUM(a) ((a<8)?a:(a<14?(a-8):(a-14)))

#define PINSET(a) BSET(ARDUINO_PORT(a),ARDUINO_PIN_NUM(a))  
#define PINCLR(a) BCLR(ARDUINO_PORT(a),ARDUINO_PIN_NUM(a))  

#define BIT_IS_SET(a)  (bit_is_set(ARDUINO_PIN(a),ARDUINO_PIN_NUM(a)))
#define BIT_IS_CLR(a)  (bit_is_clear(ARDUINO_PIN(a),ARDUINO_PIN_NUM(a)))

void OutByte_(byte b)
{  
  for(byte i=8;i;i--)
  {
      if(b&128)
        PINSET(PIN_DATA)
      else
        PINCLR(PIN_DATA);

      PINSET(PIN_SH);
      b=b<<1;
      PINCLR(PIN_SH);
  }
}

void EndOut(byte b)
{
  PINSET(PIN_ST);
  PINCLR(PIN_ST);
}


void Out1Byte(byte b)
{
  OutByte_(b);
  EndOut(b);
}


void Out3Byte(byte b, byte c,byte d)
{
  OutByte_(b);
  OutByte_(c);
  OutByte_(d);
  EndOut(b);
}

void OutKub(byte b, uint16_t a)
{
  Out3Byte(b, a >> 8, a & 0b11111111);
  EndOut(b);
}

#define L1 0b00000001
#define L2 0b00000100
#define L3 0b00001000
#define L4 0b00000010
const byte ley[]={0,2,3,1};
#define LEY_SET(l) (1<<ley[l])

void GoPoint()
{
    
  for(byte s=0; s<16;s++)
  {
     for(byte l=0;l<4;l++)
     {
       OutKub(LEY_SET(l), LED_COLUMN_ON(s));
       delay(50);          
     }
  }

}

uint16_t KUB[4];

#define LED_ALL_OFF {KUB[0]=0xffff;KUB[1]=0xffff;KUB[2]=0xffff;KUB[3]=0xffff;}
#define LED_ON(n) {KUB[(n)&3]&=LED_COLUMN_ON((n)>>2);}

#define LA1 (LED_COLUMN_ON(0))
#define LA2 (LED_COLUMN_ON(1))
#define LA3 (LED_COLUMN_ON(2))
#define LA4 (LED_COLUMN_ON(3))
#define LB1 (LED_COLUMN_ON(4))
#define LB2 (LED_COLUMN_ON(5))
#define LB3 (LED_COLUMN_ON(6))
#define LB4 (LED_COLUMN_ON(7))
#define LC1 (LED_COLUMN_ON(8))
#define LC2 (LED_COLUMN_ON(9))
#define LC3 (LED_COLUMN_ON(10))
#define LC4 (LED_COLUMN_ON(11))
#define LD1 (LED_COLUMN_ON(12))
#define LD2 (LED_COLUMN_ON(13))
#define LD3 (LED_COLUMN_ON(14))
#define LD4 (LED_COLUMN_ON(15))



byte ProcessKub(byte T)
{
  static byte l=0;
  static byte t;

  if((byte)(T-t)>5)
  {


    t=T;

    for(;KUB[l]==0xffff;l++)
    {
      if (l==3)
      {
        l=0;
        return 2;
      }
    }

    OutKub(LEY_SET(l), KUB[l]);
 
    l++;

    if(l>=4)
    {
      l=0;
      return 2;
    }
    return 1;
  }
  return 0;
}
void setup() {
  // put your setup code here, to run once:
  pinMode(PIN_ST, OUTPUT);
  pinMode(PIN_SH, OUTPUT);
  pinMode(PIN_DATA, OUTPUT);

  Out3Byte(0b00000000, 0b00000000,0b00000000);
  delay(200); 
  GoPoint(); 

  LED_ALL_OFF;
    KUB[0]=0xfffe;
}

byte mod2[]={0,5,10,15,31,47, 63,58,53,48,32,16};
byte mod3[]={60,57,54,51,35,19, 3,6,9,12, 28,44};

void loop_();

void loop() 
{
  int T;
  static byte n=0;
  static byte m=0;
  static byte v=0;

  T=millis();
  
  if(ProcessKub(T)==2)
  {
    if(!v--)
    {
      v=3;
  /*  LED_COLUMN_ON(n);*/
    n++;
    n=n & 63;

    if(!n)
     m++;

     if(m==11)
       m=0;
       
     switch(m)
     {
      case 0:
        LED_ALL_OFF;
        LED_ON((n&4?n&3:(3-n&3))*16+((n&32)?0:12));
        LED_ON((n&4?n&3:(3-n&3))*16+((n&32)?5:9));
        LED_ON((n&4?n&3:(3-n&3))*16+((n&32)?10:6));
        LED_ON((n&4?n&3:(3-n&3))*16+((n&32)?15:3));
      break;
      case 1:
        LED_ALL_OFF;
        LED_ON(n);
        LED_ON((n+16)&63);
        LED_ON((n+32)&63);
        LED_ON((n+48)&63);
       break;
   
      case 2:
        LED_ALL_OFF;
        LED_ON(mod2[n%12]);
       break;
      case 3:
        LED_ALL_OFF;
        LED_ON(mod2[11-n%12]);
       break;
      case 4:
        LED_ALL_OFF;
        LED_ON(mod3[n%12]);
       break;
      case 5:
        LED_ALL_OFF;
        LED_ON(mod3[11-n%12]);
       break;
       case 6:
        LED_ALL_OFF;
        LED_ON(mod2[n%12]);
        LED_ON(mod3[n%12]);
       break;
       case 7:
        LED_ALL_OFF;
        LED_ON(mod2[11-n%12]);
        LED_ON(mod3[11-n%12]);
       break;
      case 8:
        LED_ALL_OFF;
        LED_ON((n&3)*4+0);
        LED_ON((n&3)*4+1);
        LED_ON((n&3)*4+2);
        LED_ON((n&3)*4+3);
        LED_ON((n&3)*4+0+16);
        LED_ON((n&3)*4+1+16);
        LED_ON((n&3)*4+2+16);
        LED_ON((n&3)*4+3+16);
        LED_ON((n&3)*4+0+32);
        LED_ON((n&3)*4+1+32);
        LED_ON((n&3)*4+2+32);
        LED_ON((n&3)*4+3+32);
        LED_ON((n&3)*4+0+48);
        LED_ON((n&3)*4+1+48);
        LED_ON((n&3)*4+2+48);
        LED_ON((n&3)*4+3+48);
       break;
   
       case 9:
         n=63;
         loop_NeT102rus(); // блокирующий вызов
       break;
       
       case 10:
         n=63;
         for(uint8_t a=0;a<=10;a++)
         {
           loop_popUP(a); // блокирующий вызов
         }
       break;
      
     }
     
   /*
   */


   }
  }

/*
    OutKub(L1, 0b1111111111111110);
     delay(5);    
    OutKub(L2, 0b1111111111111101);
     delay(5);    
    OutKub(L3, 0b1111111111111011);
     delay(5);    
    OutKub(L4, 0b1111111111110111);
     delay(5);    
  */      
}

// Виртуализация вывода из loop_NeT102rus
// Весь вывод в порты заменен сохранением в переменные.
// Реальное отображение происходит перед формированием паузы.
const byte column[]={0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
const byte layer[]={20, 21, 22, 23};


byte VLeyer;
uint16_t VPort;

void VirtualWrite(const byte pin, const byte mode)
{
 byte p;
 uint16_t u;

   if(pin<20)
   {
     u=LED_COLUMN_ON(pin);
     if(mode) VPort|=~u; else VPort&=u;
   }
   else
   {
     p=LEY_SET(pin-20);
     if(mode) VLeyer|=p; else VLeyer&=~p;
   }
}

void SendAndPause(uint16_t t)
{
  OutKub(VLeyer, VPort);
  delay(t);
}

  int time = 250;

void loop_NeT102rus()  //https://pikabu.ru/story/svetodiodnyiy_kub_4kh4kh4_svoimi_rukami_4467218
{
  turnEverythingOff();//turn all off
  flickerOn();
  turnEverythingOn();//turn all on
  SendAndPause(time);
  turnOnAndOffAllByLayerUpAndDownNotTimed();
  layerstompUpAndDown();
  turnOnAndOffAllByColumnSideways();
  SendAndPause(time);
  aroundEdgeDown();
  turnEverythingOff();
  randomflicker();
  randomRain();
  diagonalRectangle();
  goThroughAllLedsOneAtATime();
  propeller();
  spiralInAndOut();
  flickerOff();
  turnEverythingOff();
  SendAndPause(2000);
}


//xxxxxxxxxxxxxxxxxxxxFUNCTIONSxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

///////////////////////////////////////////////////////////turn all off
void turnEverythingOff()
 {
   for(int i = 0; i<16; i++)
   {
     VirtualWrite(column[i], 1);
   }
   for(int i = 0; i<4; i++)
   {
     VirtualWrite(layer[i], 0);
   }
 }
 
////////////////////////////////////////////////////////////turn all on
void turnEverythingOn()
{
  for(int i = 0; i<16; i++)
  {
    VirtualWrite(column[i], 0);
  }
  //turning on layers
  for(int i = 0; i<4; i++)
  {
    VirtualWrite(layer[i], 1);
  }
}
///////////////////////////////////////////////////////turn columns off
void turnColumnsOff()
{
  for(int i = 0; i<16; i++)
  {
    VirtualWrite(column[i], 1);
  }
}
/////////////////////////////////////////////////////////////flicker on
void flickerOn()
{
  int i = 150;
  while(i != 0)
  {
    turnEverythingOn();
    SendAndPause(i);
    turnEverythingOff();
    SendAndPause(i);
    i-= 5;
  }
}
//////////////turn everything on and off by layer up and down NOT TIMED
void turnOnAndOffAllByLayerUpAndDownNotTimed()
{
  int x = 75;
  for(int i = 5; i != 0; i--)
  {
    turnEverythingOn();
    for(int i = 4; i!=0; i--)
    {
      VirtualWrite(layer[i-1], 0);
      SendAndPause(x);
    }
    for(int i = 0; i<4; i++)
    {
      VirtualWrite(layer[i], 1);
      SendAndPause(x);
    }
      for(int i = 0; i<4; i++)
    {
      VirtualWrite(layer[i], 0);
      SendAndPause(x);
    }
    for(int i = 4; i!=0; i--)
    {
      VirtualWrite(layer[i-1], 1);
      SendAndPause(x);
    }
  }
}
//////////////////////////turn everything on and off by column sideways
void turnOnAndOffAllByColumnSideways()
{
  int x = 75;
  turnEverythingOff();
  //turn on layers
  for(int i = 0; i<4; i++)
  {
    VirtualWrite(layer[i], 1);
  }
  for(int y = 0; y<3; y++)
  {
    //turn on 0-3
    for(int i = 0; i<4; i++)
    {
      VirtualWrite(column[i], 0);
      SendAndPause(x);
    }
    //turn on 4-7
    for(int i = 4; i<8; i++)
    {
      VirtualWrite(column[i], 0);
      SendAndPause(x);
    }
    //turn on 8-11
    for(int i = 8; i<12; i++)
    {
      VirtualWrite(column[i], 0);
      SendAndPause(x);
    }
    //turn on 12-15
    for(int i = 12; i<16; i++)
    {
      VirtualWrite(column[i], 0);
      SendAndPause(x);
    }
    //turn off 0-3
    for(int i = 0; i<4; i++)
    {
      VirtualWrite(column[i], 1);
      SendAndPause(x);
    }
    //turn off 4-7
    for(int i = 4; i<8; i++)
    {
      VirtualWrite(column[i], 1);
      SendAndPause(x);
    }
    //turn off 8-11
    for(int i = 8; i<12; i++)
    {
      VirtualWrite(column[i], 1);
      SendAndPause(x);
    }
    //turn off 12-15
    for(int i = 12; i<16; i++)
    {
      VirtualWrite(column[i], 1);
      SendAndPause(x);
    }
    //turn on 12-15
    for(int i = 12; i<16; i++)
    {
      VirtualWrite(column[i], 0);
      SendAndPause(x);
    }
    //turn on 8-11
    for(int i = 8; i<12; i++)
    {
      VirtualWrite(column[i], 0);
      SendAndPause(x);
    }
    //turn on 4-7
    for(int i = 4; i<8; i++)
    {
      VirtualWrite(column[i], 0);
      SendAndPause(x);
    }
    //turn on 0-3
    for(int i = 0; i<4; i++)
    {
      VirtualWrite(column[i], 0);
      SendAndPause(x);
    }
    //turn off 12-15
    for(int i = 12; i<16; i++)
    {
      VirtualWrite(column[i], 1);
      SendAndPause(x);
    }
    //turn off 8-11
    for(int i = 8; i<12; i++)
    {
      VirtualWrite(column[i], 1);
      SendAndPause(x);
    }
    //turn off 4-7
    for(int i = 4; i<8; i++)
    {
      VirtualWrite(column[i], 1);
      SendAndPause(x);
    }
    //turn off 0-3
    for(int i = 0; i<4; i++)
    {
      VirtualWrite(column[i], 1);
      SendAndPause(x);
    }
  }
}
/////////////////////////////////////////up and down single layer stomp
void layerstompUpAndDown()
{
  int x = 75;
  for(int i = 0; i<4; i++)
  {
    VirtualWrite(layer[i], 0);
  }
  for(int y = 0; y<5; y++)
  {
    for(int count = 0; count<1; count++)
    { 
      for(int i = 0; i<4; i++)
      {
        VirtualWrite(layer[i], 1);
        SendAndPause(x);
        VirtualWrite(layer[i], 0);
      }
      for(int i = 4; i !=0; i--)
      {
        VirtualWrite(layer[i-1], 1);
        SendAndPause(x);
        VirtualWrite(layer[i-1], 0);
      }
    }
    for(int i = 0; i<4; i++)
    {
      VirtualWrite(layer[i], 1);
      SendAndPause(x);
    }
    for(int i = 4; i!=0; i--)
    {
      VirtualWrite(layer[i-1], 0);
      SendAndPause(x);
    }
  }
}
////////////////////////////////////////////////////////////flicker off
void flickerOff()
{
  turnEverythingOn();
  for(int i = 0; i!= 150; i+=5)
  {
    turnEverythingOff();
    SendAndPause(i+50);
    turnEverythingOn();
    SendAndPause(i);
  }
}
///////////////////////////////////////////around edge of the cube down
void aroundEdgeDown()
{
  for(int x = 200; x != 0; x -=50)
  {
    turnEverythingOff();
    for(int i = 4; i != 0; i--)
    {
      VirtualWrite(layer[i-1], 1);
      VirtualWrite(column[5], 0);
      VirtualWrite(column[6], 0);
      VirtualWrite(column[9], 0);
      VirtualWrite(column[10], 0);
      
      VirtualWrite(column[0], 0);
      SendAndPause(x);
      VirtualWrite(column[0], 1);
      VirtualWrite(column[4], 0);
      SendAndPause(x);
      VirtualWrite(column[4], 1);
      VirtualWrite(column[8], 0);
      SendAndPause(x);
      VirtualWrite(column[8], 1);
      VirtualWrite(column[12], 0);
      SendAndPause(x);
      VirtualWrite(column[12], 1);
      VirtualWrite(column[13], 0);
      SendAndPause(x);
      VirtualWrite(column[13], 1);
      VirtualWrite(column[15], 0);
      SendAndPause(x);
      VirtualWrite(column[15], 1);
      VirtualWrite(column[14], 0);
      SendAndPause(x);
      VirtualWrite(column[14], 1);
      VirtualWrite(column[11], 0);
      SendAndPause(x);
      VirtualWrite(column[11], 1);
      VirtualWrite(column[7], 0);
      SendAndPause(x);
      VirtualWrite(column[7], 1);
      VirtualWrite(column[3], 0);
      SendAndPause(x);
      VirtualWrite(column[3], 1);
      VirtualWrite(column[2], 0);
      SendAndPause(x);
      VirtualWrite(column[2], 1);
      VirtualWrite(column[1], 0);
      SendAndPause(x);
      VirtualWrite(column[1], 1);
    }
  }
}
/////////////////////////////////////////////////////////random flicker
void randomflicker()
{
  turnEverythingOff();
  int x = 10;
  for(int i = 0; i !=750; i+=2)
  {
  int randomLayer = random(0,4);
  int randomColumn = random(0,16);
  
  VirtualWrite(layer[randomLayer], 1);
  VirtualWrite(column[randomColumn], 0);
  SendAndPause(x);
  VirtualWrite(layer[randomLayer], 0);
  VirtualWrite(column[randomColumn], 1);
  SendAndPause(x); 
  }
}
////////////////////////////////////////////////////////////random rain
void randomRain()
{
  turnEverythingOff();
  int x = 100;
  for(int i = 0; i!=60; i+=2)
  {
    int randomColumn = random(0,16);
    VirtualWrite(column[randomColumn], 0);
    VirtualWrite(layer[0], 1);
    SendAndPause(x+50);
    VirtualWrite(layer[0], 0);
    VirtualWrite(layer[1], 1);
    SendAndPause(x);
    VirtualWrite(layer[1], 0);
    VirtualWrite(layer[2], 1);
    SendAndPause(x);
    VirtualWrite(layer[2], 0);
    VirtualWrite(layer[3], 1);
    SendAndPause(x+50);
    VirtualWrite(layer[3], 0);
    VirtualWrite(column[randomColumn], 1);
  }
}
/////////////////////////////////////////////////////diagonal rectangle
void diagonalRectangle()
{
  int x = 350;
  turnEverythingOff();
  for(int count = 0; count<5; count++)
  {
    //top left
    for(int i = 0; i<8; i++)
    {
      VirtualWrite(column[i], 0);
    }
    VirtualWrite(layer[3], 1);
    VirtualWrite(layer[2], 1);
    SendAndPause(x);
    turnEverythingOff();
    //middle middle
    for(int i = 4; i<12; i++)
    {
      VirtualWrite(column[i], 0);
    }
    VirtualWrite(layer[1], 1);
    VirtualWrite(layer[2], 1);
    SendAndPause(x);
    turnEverythingOff();
    //bottom right
    for(int i = 8; i<16; i++)
    {
      VirtualWrite(column[i], 0);
    }
    VirtualWrite(layer[0], 1);
    VirtualWrite(layer[1], 1);
    SendAndPause(x);
    turnEverythingOff();
    //bottom middle
    for(int i = 4; i<12; i++)
    {
      VirtualWrite(column[i], 0);
    }
    VirtualWrite(layer[0], 1);
    VirtualWrite(layer[1], 1);
    SendAndPause(x);
    turnEverythingOff();
    //bottom left
    for(int i = 0; i<8; i++)
    {
      VirtualWrite(column[i], 0);
    }
    VirtualWrite(layer[0], 1);
    VirtualWrite(layer[1], 1);
    SendAndPause(x);
    turnEverythingOff();
    //middle middle
    for(int i = 4; i<12; i++)
    {
      VirtualWrite(column[i], 0);
    }
    VirtualWrite(layer[1], 1);
    VirtualWrite(layer[2], 1);
    SendAndPause(x);
    turnEverythingOff();
    //top right
    for(int i = 8; i<16; i++)
    {
      VirtualWrite(column[i], 0);
    }
    VirtualWrite(layer[2], 1);
    VirtualWrite(layer[3], 1);
    SendAndPause(x);
    turnEverythingOff();
    //top middle
    for(int i = 4; i<12; i++)
    {
      VirtualWrite(column[i], 0);
    }
    VirtualWrite(layer[2], 1);
    VirtualWrite(layer[3], 1);
    SendAndPause(x);
    turnEverythingOff();
  }
  //top left
  for(int i = 0; i<8; i++)
  {
    VirtualWrite(column[i], 0);
  }
  VirtualWrite(layer[3], 1);
  VirtualWrite(layer[2], 1);
  SendAndPause(x);
  turnEverythingOff();
}
//////////////////////////////////////////////////////////////propeller
void propeller()
{
  turnEverythingOff();
  int x = 90;
  for(int y = 4; y>0; y--)
  {
    for(int i = 0; i<6; i++)
    {
      //turn on layer
      VirtualWrite(layer[y-1], 1);
      //a1
      turnColumnsOff();
      VirtualWrite(column[0], 0);
      VirtualWrite(column[5], 0);
      VirtualWrite(column[10], 0);
      VirtualWrite(column[15], 0);
      SendAndPause(x);
      //b1
      turnColumnsOff();
      VirtualWrite(column[4], 0);
      VirtualWrite(column[5], 0);
      VirtualWrite(column[10], 0);
      VirtualWrite(column[11], 0);
      SendAndPause(x);
      //c1
      turnColumnsOff();
      VirtualWrite(column[6], 0);
      VirtualWrite(column[7], 0);
      VirtualWrite(column[8], 0);
      VirtualWrite(column[9], 0);
      SendAndPause(x);
      //d1
      turnColumnsOff();
      VirtualWrite(column[3], 0);
      VirtualWrite(column[6], 0);
      VirtualWrite(column[9], 0);
      VirtualWrite(column[12], 0);
      SendAndPause(x);
      //d2
      turnColumnsOff();
      VirtualWrite(column[2], 0);
      VirtualWrite(column[6], 0);
      VirtualWrite(column[9], 0);
      VirtualWrite(column[13], 0);
      SendAndPause(x);
      //d3
      turnColumnsOff();
      VirtualWrite(column[1], 0);
      VirtualWrite(column[5], 0);
      VirtualWrite(column[10], 0);
      VirtualWrite(column[14], 0);
      SendAndPause(x);
    }
  }
  //d4
  turnColumnsOff();
  VirtualWrite(column[0], 0);
  VirtualWrite(column[5], 0);
  VirtualWrite(column[10], 0);
  VirtualWrite(column[15], 0);
  SendAndPause(x);
}
//////////////////////////////////////////////////////spiral in and out
void spiralInAndOut()
{
  turnEverythingOn();
  int x = 60;
  for(int i = 0; i<6; i++)
  {
    //spiral in clockwise
    VirtualWrite(column[0], 1);
    SendAndPause(x);
    VirtualWrite(column[1], 1);
    SendAndPause(x);
    VirtualWrite(column[2], 1);
    SendAndPause(x);
    VirtualWrite(column[3], 1);
    SendAndPause(x);
    VirtualWrite(column[7], 1);
    SendAndPause(x);
    VirtualWrite(column[11], 1);
    SendAndPause(x);
    VirtualWrite(column[15], 1);
    SendAndPause(x);
    VirtualWrite(column[14], 1);
    SendAndPause(x);
    VirtualWrite(column[13], 1);
    SendAndPause(x);
    VirtualWrite(column[12], 1);
    SendAndPause(x);
    VirtualWrite(column[8], 1);
    SendAndPause(x);
    VirtualWrite(column[4], 1);
    SendAndPause(x);
    VirtualWrite(column[5], 1);
    SendAndPause(x);
    VirtualWrite(column[6], 1);
    SendAndPause(x);
    VirtualWrite(column[10], 1);
    SendAndPause(x);
    VirtualWrite(column[9], 1);
    SendAndPause(x);
    ///////////////////////////////////////spiral out counter clockwise
    VirtualWrite(column[9], 0);
    SendAndPause(x);
    VirtualWrite(column[10], 0);
    SendAndPause(x);
    VirtualWrite(column[6], 0);
    SendAndPause(x);
    VirtualWrite(column[5], 0);
    SendAndPause(x);
    VirtualWrite(column[4], 0);
    SendAndPause(x);
    VirtualWrite(column[8], 0);
    SendAndPause(x);
    VirtualWrite(column[12], 0);
    SendAndPause(x);
    VirtualWrite(column[13], 0);
    SendAndPause(x);
    VirtualWrite(column[14], 0);
    SendAndPause(x);
    VirtualWrite(column[15], 0);
    SendAndPause(x);
    VirtualWrite(column[11], 0);
    SendAndPause(x);
    VirtualWrite(column[7], 0);
    SendAndPause(x);
    VirtualWrite(column[3], 0);
    SendAndPause(x);
    VirtualWrite(column[2], 0);
    SendAndPause(x);
    VirtualWrite(column[1], 0);
    SendAndPause(x);
    VirtualWrite(column[0], 0);
    SendAndPause(x);
    ///////////////////////////////////////spiral in counter clock wise
    VirtualWrite(column[0], 1);
    SendAndPause(x);
    VirtualWrite(column[4], 1);
    SendAndPause(x);
    VirtualWrite(column[8], 1);
    SendAndPause(x);
    VirtualWrite(column[12], 1);
    SendAndPause(x);
    VirtualWrite(column[13], 1);
    SendAndPause(x);
    VirtualWrite(column[14], 1);
    SendAndPause(x);
    VirtualWrite(column[15], 1);
    SendAndPause(x);
    VirtualWrite(column[11], 1);
    SendAndPause(x);
    VirtualWrite(column[7], 1);
    SendAndPause(x);
    VirtualWrite(column[3], 1);
    SendAndPause(x);
    VirtualWrite(column[2], 1);
    SendAndPause(x);
    VirtualWrite(column[1], 1);
    SendAndPause(x);
    VirtualWrite(column[5], 1);
    SendAndPause(x);
    VirtualWrite(column[9], 1);
    SendAndPause(x);
    VirtualWrite(column[10], 1);
    SendAndPause(x);
    VirtualWrite(column[6], 1);
    SendAndPause(x);
    //////////////////////////////////////////////spiral out clock wise
    VirtualWrite(column[6], 0);
    SendAndPause(x);
    VirtualWrite(column[10], 0);
    SendAndPause(x);
    VirtualWrite(column[9], 0);
    SendAndPause(x);
    VirtualWrite(column[5], 0);
    SendAndPause(x);
    VirtualWrite(column[1], 0);
    SendAndPause(x);
    VirtualWrite(column[2], 0);
    SendAndPause(x);
    VirtualWrite(column[3], 0);
    SendAndPause(x);
    VirtualWrite(column[7], 0);
    SendAndPause(x);
    VirtualWrite(column[11], 0);
    SendAndPause(x);
    VirtualWrite(column[15], 0);
    SendAndPause(x);
    VirtualWrite(column[14], 0);
    SendAndPause(x);
    VirtualWrite(column[13], 0);
    SendAndPause(x);
    VirtualWrite(column[12], 0);
    SendAndPause(x);
    VirtualWrite(column[8], 0);
    SendAndPause(x);
    VirtualWrite(column[4], 0);
    SendAndPause(x);
    VirtualWrite(column[0], 0);
    SendAndPause(x);
  }
}
//////////////////////////////////////go through all leds one at a time
void goThroughAllLedsOneAtATime()
{
  int x = 15;
  turnEverythingOff();
  for(int y = 0; y<5; y++)
  {
    //0-3
    for(int count = 4; count != 0; count--)
    {
      VirtualWrite(layer[count-1], 1);
      for(int i = 0; i<4; i++)
      {
        VirtualWrite(column[i], 0);
        SendAndPause(x);
        VirtualWrite(column[i], 1);
        SendAndPause(x);
      }
    VirtualWrite(layer[count-1], 0);
    }
    //4-7
    for(int count = 0; count < 4; count++)
    {
      VirtualWrite(layer[count], 1);
      for(int i = 4; i<8; i++)
      {
        VirtualWrite(column[i], 0);
        SendAndPause(x);
        VirtualWrite(column[i], 1);
        SendAndPause(x);
      }
    VirtualWrite(layer[count], 0);
    }
    //8-11
    for(int count = 4; count != 0; count--)
    {
      VirtualWrite(layer[count-1], 1);
      for(int i = 8; i<12; i++)
      {
        VirtualWrite(column[i], 0);
        SendAndPause(x);
        VirtualWrite(column[i], 1);
        SendAndPause(x);
      }
    VirtualWrite(layer[count-1], 0);
    }
    //12-15
    for(int count = 0; count < 4; count++)
    {
      VirtualWrite(layer[count], 1);
      for(int i = 12; i<16; i++)
      {
        VirtualWrite(column[i], 0);
        SendAndPause(x);
        VirtualWrite(column[i], 1);
        SendAndPause(x);
      }
    VirtualWrite(layer[count], 0);
    }
  }
}


/*
const int latchPin = 8;        // Пин подключен к ST_CP входу 74HC595
const int clockPin = 12;       // Пин подключен к SH_CP входу 74HC595
const int dataPin = 11;        // Пин подключен к DS входу 74HC595
const uint8_t LayerPin[] = {4, 5, 6, 7}; // указываем пины, к которым подключены слои кубика
*/

const uint8_t LayerPin[] = {20, 21, 22, 23};

int ButPin1 = 2;               // подключаем кнопку к выходу 2
int ButPin2 = 3;               // подключаем кнопку к выходу 3
int flag1 = 0;                  // флаг состояния
volatile int rejim1 = 0;        // Переключалка
int flag2 = 0;                  // флаг состояния
volatile int rejim2 = 0;        // Переключалка

int lastLayer = 0;
//int layer = 0;                 //номер вертикального слоя
unsigned int bitsToSend = 0;    // переменная для хранения состояния каждого пина

int g = 0;
int h = 0;


int State1 = 0; // HIGH=1; LOW=0
int timeStop = 100;   //задержка внутри циклов подпрограмм

void digitalWriteLayerPin(const uint8_t p, const uint8_t m)
{
  VirtualWrite(p, m?LOW:HIGH);
}

void sendToRegister () // Шлем в регистр
{   
  OutKub(VLeyer, bitsToSend);
}

void bitToSend (const int Point, const int State1)  //Запись в байт каждой точки
{
  if(State1)
   bitsToSend&=LED_COLUMN_ON(Point);
  else
   bitsToSend|=~LED_COLUMN_ON(Point);
}

void loop_popUP(byte rejim2) {

  switch (rejim2) {
    //************
    case 0:
      hLayersAll(0) ;
      vLayersAll(1) ;
      delay (timeStop);

      break;
    //************
    case 1:
       vLayersAll(0) ;
      fallDown (random(0, 15));
      break;
    //************
    case 2:
      vLayersAll(0) ;
      raiseUP (random(0, 15));
      break;
    //************
    case 3:
       vLayersAll(0) ;

      for (int8_t layer = 0; layer < 4; layer++)      // цикл для включения слоев свверху вниз
      {
        digitalWriteLayerPin(LayerPin[abs(layer)], LOW); // включаем слой
      
        spiral2 (1);// в следующей подпрограмме включаем столбцы

        spiral1 (0);// в следующей подпрограмме вЫключаем столбцы
        digitalWriteLayerPin(LayerPin[abs(layer)], HIGH);  // вЫключаем слой - для цикла движения по слоям
      }
      
      /*
        VPort=0xbfff;
VLeyer=1;SendAndPause(1000);
        
VLeyer=4;SendAndPause(1000);
       
VLeyer=8;SendAndPause(1000);
        
VLeyer=2;SendAndPause(1000);
  */    
      break;

    //************
    case 4:    // your hand is nowhere near the sensor
      vLayersAll(0) ;
      for (int8_t layer = 0; layer < 4; layer++) {     // цикл для включения слоев свверху вниз
        digitalWriteLayerPin(LayerPin[abs(layer)], LOW); // включаем слой
        //    }
        circle1 ();
        digitalWriteLayerPin(LayerPin[abs(layer)], HIGH);  // вЫключаем слой - для цикла движения по слоям
        lastLayer = abs(layer);
      }

      digitalWriteLayerPin(LayerPin[lastLayer], LOW); // включаем слой
      circle1 ();
      digitalWriteLayerPin(LayerPin[lastLayer], HIGH);  // вЫключаем слой - для цикла движения по слоям

      for (int8_t layer = -3; layer <= 0; layer++) {   // цикл для включения слоев снизу вверх
        digitalWriteLayerPin(LayerPin[abs(layer)], LOW); // включаем слой
        //    }
        circle1 ();
        digitalWriteLayerPin(LayerPin[abs(layer)], HIGH);  // вЫключаем слой - для цикла движения по слоям
      }

      //      fallDown (6);
      break;
    //************
    case 5:
      for (int i = 0; i < 4; i++) {
        hLayersSingle (i, 0);
        vLayersSingle (i, 1);
        delay (timeStop);
        vLayersSingle (i, 0);
        hLayersSingle (i, 1);
      }

      for (int i = 3; i >= 0; i--) {
        hLayersSingle (i, 0);
        vLayersSingle (i, 1);
        delay (timeStop);
        vLayersSingle (i, 0);
      }

      for (int i = 0; i < 4; i++) {
        vLayersSingle (i, 1);
        delay (timeStop);
      }
      break;


    //************
    case 6:
      vLayersAll(0) ;                  //State1 = 0 -выкл, =1 - вкл
      hLayersAll(0) ;                      //State1 = 1 -выкл, =0 - вкл
      spiral1 (1);                   //State1 = 1 -вкл, =0 - выкл
      //  vLayersAll(0) ;                  //State1 = 0 -выкл, =1 - вкл
      //      delay (timeStop);
      //      spiral2 (0);
      break;

    //************
    case 7:
      hLayersAll(0);
      vLayersAll(0);
      for (int i = 0; i < 4; i++) {
        vLayersSingle(i, 1);
        delay (timeStop);
        vLayersSingle(i, 0);
      }
      for (int i = 3; i >= 0 ; i--) {
        vLayersSingle(i, 1);
        delay (timeStop);
        vLayersSingle(i, 0);
      }

      for (int i = 0; i < 4; i++) {
        v2LayersSingle(i, 1);
        delay (timeStop);
        v2LayersSingle(i, 0);
      }
      for (int i = 3; i >= 0 ; i--) {
        v2LayersSingle(i, 1);
        delay (timeStop);
        v2LayersSingle(i, 0);
      }
      break;
    //************
    case 8:
      PointGrow (random(1, 8));
      break;

    //************ хаоссс
    case 9:
      vLayersAll (0);
      hLayersAll(1);

      g = random(0, 15);
      h = random(0, 4);

      hLayersSingle( h, 0);    //State1 = 1 -выкл, =0 - вкл
      bitToSend ( g, 1);
      sendToRegister ();    // Шлем в регистр
      delay (timeStop);
      hLayersSingle( h, 1);    //State1 = 1 -выкл, =0 - вкл
      bitToSend ( g, 0);
      sendToRegister ();    // Шлем в регистр
      delay (timeStop);

      break;

    //************
    case 10:
      hLayersAll(1);                   //State1 = 1 -выкл, =0 - вкл
      vLayersAll(0) ;                  //State1 = 0 -выкл, =1 - вкл
      break;
  }     //конец  switch (rejim2)


}     //конец loop



//********
void hLayersSingle(int hLayer, int State1) { // функция для одиночных слоёв горизонтальных
  digitalWriteLayerPin(LayerPin[hLayer], State1);
}
//********
void hLayersAll(int State1) { // функция для всех слоёв горизонтальных
  for (int8_t layer = 0; layer < 4; layer++) {
    digitalWriteLayerPin(LayerPin[layer], State1);
  }
}
//******** функция для включения/выключения (State1) всех слоёв вертикальных
void vLayersAll(int State1) {
  for (int i = 0; i < 16; i++) {
    bitToSend( i, State1);
    sendToRegister ();    // Шлем в регистр
  }
}
//******** функция для включения/выключения (State1) слоёв вертикальных по одному поперек
void vLayersSingle(int vLayer, int State1) {
  switch (vLayer) {
    case 0:
      for (int i = 0; i < 4; i++) {
        bitToSend( i, State1);
        sendToRegister ();    // Шлем в регистр
      }
      break;
    case 1:
      for (int i = 4; i < 8; i++) {
        bitToSend( i, State1);
        sendToRegister ();    // Шлем в регистр
      }
      break;
    case 2:
      for (int i = 8; i < 12; i++) {
        bitToSend( i, State1);
        sendToRegister ();    // Шлем в регистр
      }
      break;
    case 3:
      for (int i = 12; i < 16; i++) {
        bitToSend( i, State1);
        sendToRegister ();    // Шлем в регистр
      }
      break;

  }
}
//******** функция для включения/выключения (State1) слоёв вертикальных по одному вдоль
void v2LayersSingle(int vLayer, int State1) {
  switch (vLayer) {
    case 0:
      for (int i = 0; i < 16; ) {
        bitToSend( i, State1);
        sendToRegister ();    // Шлем в регистр
        i = i + 4;
      }
      break;
    case 1:
      for (int i = 1; i < 16; ) {
        bitToSend( i, State1);
        sendToRegister ();    // Шлем в регистр
        i = i + 4;
      }
      break;
    case 2:
      for (int i = 2; i < 16; ) {
        bitToSend( i, State1);
        sendToRegister ();    // Шлем в регистр
        i = i + 4;
      }
      break;
    case 3:
      for (int i = 3; i < 16;) {
        bitToSend( i, State1);
        sendToRegister ();    // Шлем в регистр
        i = i + 4;
      }
      break;
  }
}

// ЭФФЕКТЫ

///************* Зажечь/потушить змейку от 0 до 15
void snake1(int State1) {
  for (int i = 0; i < 4; i++) {
    bitToSend( i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  for (int i = 7; i > 3; i--) {
    bitToSend( i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  for (int i = 8; i < 12; i++) {
    bitToSend( i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  for (int i = 15; i > 11; i--) {
    bitToSend( i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
}
//************** Зажечь/потушить змейку от 15 до 0
void snake2(int State1) {
  for (int i = 12; i < 16; i++) {
    bitToSend( i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  for (int i = 12; i > 7; i--) {
    bitToSend( i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  for (int i = 4; i < 8; i++) {
    bitToSend( i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  for (int i = 3; i >= 0; i--) {
    bitToSend( i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
}
//************* Зажечь/потушить закручивающююся спираль снаружи внутрь
//по часовой стрелке
void spiral1(int State1) {
  for (int i = 0; i < 4; i++) {
    bitToSend( i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  bitToSend( 7, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);

  bitToSend( 11, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);

  for (int i = 15; i > 11; i--) {
    bitToSend( i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  bitToSend( 8, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);

  bitToSend( 4, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);

  bitToSend( 5, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitToSend( 6, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitToSend( 10, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitToSend( 9, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
}
///************Зажечь/потушить Раскручивающуюся спираль изнутри наружу
//против часовой стрелки
void spiral2(int State1) {

  bitToSend( 5,  State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitToSend( 6, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitToSend( 10, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitToSend( 9, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);

  bitToSend( 8, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitToSend( 4, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  for (int i = 0; i < 4; i++) {
    bitToSend( i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  bitToSend( 7, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);

  bitToSend( 11, State1);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);

  for (int i = 15; i > 10; i--) {
    bitToSend( i, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);

  }
    bitToSend( 10, State1);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
}
///********** одиночный огонек по кругу по часовой стрелке
void circle1() {
  for (int i = 0; i < 4; i++) {
    bitToSend( i, HIGH);            //включили диод (столбик) 0-4
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
    bitToSend( i, LOW);            //вЫключили диод 0-4
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  bitToSend( 7, HIGH);            //включили диод 7
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitToSend( 7, LOW);              //вЫключили диод 7
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitToSend( 11, HIGH);           //и т.д.
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitToSend( 11, LOW);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  for (int i = 15; i > 11; i--) {
    bitToSend( i, HIGH);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
    bitToSend( i, LOW);
    sendToRegister ();    // Шлем в регистр
    delay (timeStop);
  }
  bitToSend( 8, HIGH);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitToSend( 8, LOW);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);

  bitToSend( 4, HIGH);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
  bitToSend( 4, LOW);
  sendToRegister ();    // Шлем в регистр
  delay (timeStop);
}
//******************** Звездопад
void fallDown (int Point) {
  bitToSend( Point, HIGH);
  // bitToSend( random(0, 15), HIGH);

  sendToRegister ();    // Шлем в регистр
  for (int8_t layer = -3; layer <= 0; layer++) {   // цикл для включения слоев  свверху вниз
    digitalWriteLayerPin(LayerPin[abs(layer)], LOW); // включаем слой
    delay (timeStop);
    digitalWriteLayerPin(LayerPin[abs(layer)], HIGH);  // вЫключаем слой - для цикла движения по слоям
  }       //Если нужно включить все слои и работать со столбцами
  bitToSend( Point, LOW);
  sendToRegister ();    // Шлем в регистр
}
//******************** Звездопад наоборот
void raiseUP (int Point) {
  bitToSend( Point, HIGH);
  sendToRegister ();    // Шлем в регистр
  for (int8_t layer = 0; layer < 4; layer++) {     // цикл для включения слоев снизу вверх
    digitalWriteLayerPin(LayerPin[abs(layer)], LOW); // включаем слой
    delay (timeStop);
    digitalWriteLayerPin(LayerPin[abs(layer)], HIGH);  // вЫключаем слой - для цикла движения по слоям
  }
  bitToSend( Point, LOW);
  sendToRegister ();    // Шлем в регистр
}
//***********рост из угла
void PointGrow (int Point) {

  switch (Point) {
    //**************
    case (1):
      //***рост из 1 (0,0)
      hLayersAll (1);
      for (int i = 0; i < 4; i++) {
        vLayersAll(1);
        hLayersSingle (i, 0);
        for (int y = 1 + i; y < 4; y++) {
          vLayersSingle(y, 0);
          v2LayersSingle(y, 0);
        }
        delay (timeStop);
      }
      break;
    //***************
    case (2):
      //***рост из 2 (3,0)
      hLayersAll (1);
      for (int i = 0; i < 4; i++) {
        vLayersAll(1);
        hLayersSingle (i, 0);
        for (int y = 1 + i; y < 4; y++) {
          vLayersSingle(y, 0);
          v2LayersSingle(3 - y, 0);
        }
        delay (timeStop);
      }
      break;

    //***************
    case (3):
      //***рост из 3 (15,0)
      hLayersAll (1);
      for (int i = 0; i < 4; i++) {
        vLayersAll(1);
        hLayersSingle (i, 0);
        for (int y = 0; y < 3 - i; y++) {
          vLayersSingle(y, 0);
          v2LayersSingle(y, 0);
        }
        delay (timeStop);
      }
      break;

    //***************
    case (4):
      //***рост из 4 ( 12,0)
      hLayersAll (1);
      for (int i = 0; i < 4; i++) {
        vLayersAll(1);
        hLayersSingle (i, 0);
        for (int y = 0; y < 3 - i; y++) {
          vLayersSingle(y, 0);
          v2LayersSingle(3 - y, 0);
        }
        delay (timeStop);
      }
      break;

    //**************
    case (5):
      //***рост из 5 (0,4)
      hLayersAll( 1);
      for (int i = 3; i >= 0; i--) {
        vLayersAll(1);
        hLayersSingle (i, 0);
        for (int y = 4 - i; y < 4; y++) {
          vLayersSingle(y, 0);
          v2LayersSingle(y, 0);
        }
        delay (timeStop);
      }
      break;

    //**************
    case (6):
      //***рост из 6 (3,4)
      hLayersAll( 1);
      for (int i = 3; i >= 0; i--) {
        vLayersAll(1);
        hLayersSingle (i, 0);

        for (int y = 0; y < i; y++) {
          vLayersSingle(3 - y, 0);
          v2LayersSingle(y, 0);
        }
        delay (timeStop);
      }
      break;


    //**************
    case (7):
      //***рост из 7 (15,4)
      hLayersAll( 1);
      for (int i = 3; i >= 0; i--) {
        vLayersAll(1);
        hLayersSingle (i, 0);
        for (int y = 0; y < i; y++) {
          vLayersSingle(y, 0);
          v2LayersSingle(y, 0);
        }
        delay (timeStop);
      }
      break;

    //**************
    case (8):
      //***рост из 8 (12,4)
      hLayersAll( 1);
      for (int i = 3; i >= 0; i--) {
        vLayersAll(1);
        hLayersSingle (i, 0);
        for (int y = 4 - i; y < 4; y++) {
          vLayersSingle(3 - y, 0);
          v2LayersSingle(y, 0);
        }
        delay (timeStop);
      }
      break;
  } // end of switch
} // end of PointGrow (int Point, int Layer)

Про адаптацию кода - восновном из-за аппаратных особенностей. У меня куб на трех 74рс595. Это для перспективы перехода с наны на esp, ну чтоб через веб интерфейс рулить.

Вполне можна рассматривать это как пример современного индустриального говноко... , ну программирования. Когда разраб разгильдяй на все забил и лепил абы по быстрому и работало или трудозатраты урезали или дидлайн придвинули или просто отфрилансить и забыть.

всё лучшее - детям!(с)

Так он паять захотел, а не говнокодить. Учится код писать еще рано. И я ему без делеев показывал как нужно, когда свои эффекты писал. А понос я потом тихо подкинул, для объема ;)  чтоб блымало больше разного.