Arduino.ru

Приоритеты для кнопок я так понимаю задаются через &&,|| и !

Что-то там мигает, да? Особенно судя по этой тысяче в unsigned long delaytime. Код правильный, но синхронный, блокирующий. То есть то следующее, что стоит ниже в loop(), начнёт рисоваться не раньше чем завершится то, что в loop() стоит выше. Счастья же прибавит код асинхронный, вам сюда...

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

то есть delay вообще убираем?

всё равно не пойму как этот millis привязать к моему коду, ща моск лопнет ((

Не вообще, а заменив на систему условий, определящих "кадры" событий. Смотрим на функцию, допустим pravo() (с вашего позволения, я её сокращу) и выделяем куски, выполняющиеся в конкретный достаточно короткий момент времени (примем ничтожно малые задержки между выполнением каждой новой строки равными нулю) - то есть код, находящийся между вызовами delay().

void pravo(byte param){
  byte i;
  if (param != 1) return;
  for(i=0;i<=3;i++) lc.clearDisplay(i);
  delay(delaytime2);
  for(i=0;i<=7;i++) lc.setRow(3, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(2, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(1, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(0, i, pravo1[i]);
  for(i=3;i>=0;i--){
    delay(delaytime3);
    lc.clearDisplay(i);
  }
}

Далее заводим глобальную переменную в которой поместится значение millis(), и такого же типа локальную переменную, в которой будем хранить разницу millis() и первой переменной, и каждый очередной кусок будем выполнять в условии, которое ограничивает время между второй переменной, и суммой второй переменной с очередной задержкой, которая прежде была параметром delay(). Чтобы код внутри этих условий не выполнился больше одного раза, можно завести максимально короткие (bool) глобальные переменные, которые будут служить флагом. Таких переменных понадобится много, но это потому что кадров (кусков, находящихся между вызовами delay()) тоже много. Это увеличит расход оперативной памяти на несколько байт, но зато код не будет повторять вызовы вывода.

Например:

unsigned long time_1=millis();
bool flag_1[8]={0,0,0,0,0,0,0,0};

void pravo(byte param){
  byte i;
  unsigned long time_cmp=millis()-time_1;
  if (param != 1) return;
  if (time_cmp>=0 && time_cmp<delaytime2 && !flag_1[0]){
    for(i=0;i<=3;i++) lc.clearDisplay(i);
    flag_1[0]=1;
  }
  if (time_cmp>=time_cmp<delaytime2 && time_cmp<delaytime2+delaytime3 && !flag_1[1]){
    for(i=0;i<=7;i++) lc.setRow(3, i, pravo1[i]);
    flag_1[1]=1;
  }
  if (time_cmp>=time_cmp<delaytime2+delaytime3 && time_cmp<delaytime2+(delaytime3*2) && !flag_1[2]){
    for(i=0;i<=7;i++) lc.setRow(2, i, pravo1[i]);
    flag_1[2]=1;
  }
  if (time_cmp>=time_cmp<delaytime2+(delaytime3*2) && time_cmp<delaytime2+(delaytime3*3) && !flag_1[3]){
    for(i=0;i<=7;i++) lc.setRow(1, i, pravo1[i]);
    flag_1[3]=1;
  }
  if (time_cmp>=time_cmp<delaytime2+(delaytime3*3) && time_cmp<delaytime2+(delaytime3*4) && !flag_1[4]){
    for(i=0;i<=7;i++) lc.setRow(0, i, pravo1[i]);
    flag_1[4]=1;
  }
  for(i=3;i>=0;i--){
    if (time_cmp>=time_cmp<delaytime2+(delaytime3*(3+(4-i))) && time_cmp<delaytime2+(delaytime3*(4+(4-i))) && !flag_1[4+(4-i)]){
      lc.clearDisplay(i);
      flag_1[4+(4-i)]=1;
    }
  }
}

Для повторного запуска функции надо:

- записать в глобальную переменную со временем новое значение millis(), то есть в условии нажатия кнопки будет запись time_1=millis();

- сбросить все флаги.

Дальше писать не собираюсь (попросите, и я скажу куда платить), глупые вопросы типа откуда взялось 4+(4-i) не люблю.

спасибо за пример, буду мучить моск дальше.не думал что это будет так сложно. если не допру сколько будет стоить данная работа?

Один косячок, размер массива flag_1[] будет не 8 а 9, т. к. самый последний флаг окажется 4+4-(i=0)=4+4=8, то есть девятый элемент т. к. счёт начинается с нуля.

Это не сложно, просто требует множества почти одинаковых действий. Посмотрите внимательно - увидите что темпоральные рамки одинаковы в концах одних условий и началах следующих условий, то есть разница между ними равна точно интервалу, прежде указанному в качестве параметра delay() - delaytime3 (в этой функции он оказался одинаковым, поэтому не так наглядно).

Навскидку напишу от 1.5k до 2k, но код линейный, останавливающий/возобновляющий вывод. Если всё что нужно делать - показывать на экране, то процесс "миганий" может существовать в цикле постоянно, а кнопки будут запрещать/разрешать его. Такой код будет проще.

сделал по аналогии для levo

Должно работать так же, в логике ничего не поменялось. А как оно вообще собралось в скетч и не показало ошибок? Вот в этом куске

  for(i=3;i>=0;i--){
    delay(delaytime3);
    lc.clearDisplay(i);
}}
 
/*

фигурная скобка должна быть только одна т. к. скобки убраны из условия if(param==1)

вот так:

  for(i=3;i>=0;i--){
    delay(delaytime3);
    lc.clearDisplay(i);
}
 
/*

UPD. Не, всё верно. У вас очень дурная привычка скобки, стоящие в разных строках и с различным отступом, склеивать в одну строку. Не. Делайте. Этого. Пожалуйста. Ибо сбивает с толку очень сильно.

Возвращаемся к теме. Переменная i - локальная, она уничтожается всякий раз при выходе из функции, так что работа циклов нарушаться не может. Return сработает только при param не равном 1, то есть выполнение прекратится при 0, 2 и т. д. Всё должно работать.

UPD.

работает так же как исходник или как-то иначе?

ну так тут же void pravo(byte param){ еще одна

pravo делает один цикл и не мигает, levo мигает пока не отпущу кнопку

void pravo(byte param){
  byte i;
  if (param != 1) return;
  for(i=0;i<=3;i++) lc.clearDisplay(i);
  delay(delaytime2);
  for(i=0;i<=7;i++) lc.setRow(3, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(2, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(1, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(0, i, pravo1[i]);
  for(i=3;i>=0;i--){
    delay(delaytime3);
    lc.clearDisplay(i);
}}


//====================================================================================================
void levo(byte param){
  byte i;
  if (param != 1) return;
  for(i=0;i<=3;i++) lc.clearDisplay(i);
  delay(delaytime2);
  for(i=0;i<=7;i++) lc.setRow(0, i, levo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(1, i, levo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(2, i, levo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(3, i, levo1[i]);
  for(i=0;i<=3;i++){
    delay(delaytime3);
    lc.clearDisplay(i);
}}

Невозможно. Функции одинаковы.

1. Закомментируйте условия if(param!=1) return; и else{levo(0);}, else{pravo(0);} в loop(), посмотрите как работает.

2. Добавьте функцию

int freeRam () {
  extern int __heap_start, *__brkval; 
  int v; 
  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval); 
}

Serial.begin(57600);
Serial.println(freeRam());

вот целиком в сериале 1638

#include "LedControl.h"//подключаем библиотеку LedControl.h
#define STOP_button 2
#define gabarit_button 3
#define levo_button 5
#define pravo_button 7
//====================================================================================================
LedControl lc = LedControl(11, 13, 10, 4);//к D11 подключаем DIN, к D13 подключаем CLK, к D10 подключаем CS
//====================================================================================================
unsigned long delaytime = 1000;//временные переменные delay
unsigned long delaytime2 = 30;
unsigned long delaytime3 = 100;
// =========================================================================
int STOP_light = LOW;   // Статус нажатия тормоза
int gabarit_light = LOW;// Статус включения габарита
int levo_light = LOW;   // Статус включения левого поворотника
int pravo_light = LOW;  // Статус включения правого поворотника
// =========================================================================
void setup() {  //задаём параметры дисплеев
  lc.shutdown(0, false);//первого
  lc.setIntensity(0, 1);
  lc.clearDisplay(0);
  lc.shutdown(1, false);//второго
  lc.setIntensity(1, 1);
  lc.clearDisplay(1);
  lc.shutdown(2, false);//третьего
  lc.setIntensity(2, 1);
  lc.clearDisplay(2);
  lc.shutdown(3, false);//четвертого
  lc.setIntensity(3, 1);
  lc.clearDisplay(3);
pinMode(2,INPUT_PULLUP);
pinMode(3,INPUT_PULLUP);
pinMode(5,INPUT_PULLUP);
pinMode(7,INPUT_PULLUP);
digitalWrite(2,HIGH);
digitalWrite(3,HIGH);
digitalWrite(5,HIGH);
digitalWrite(7,HIGH);
}
//====================================================================================================
//пишем значения для каждой фигуры или символа
byte gabarit1[8] = {B11111111,B00000000,B11111111,B11111111,B11111111,B11111111,B00000000,B11111111};//центральные матрицы габарита
byte gabarit2[8] = {B11111111,B10000000,B10111111,B10111111,B10111111,B10111111,B10000000,B11111111};//левая матрица габарита
byte gabarit3[8] = {B11111111,B00000001,B11111101,B11111101,B11111101,B11111101,B00000001,B11111111};//правая матрица габарита
//====================================================================================================
byte pravo1[8] = {B00001000,B00001100,B01111110,B01111111,B01111111,B01111110,B00001100,B00001000};//правый поворот
//====================================================================================================                 
byte levo1[8] =  {B00010000,B00110000,B01111110,B11111110,B11111110,B01111110,B00110000,B00010000};//левый поворот
//====================================================================================================                 
byte S[8] = {B00000000,B00111100,B01100110,B01100000,B01100000,B01100110,B00111100,B00000000};//стоп простой
byte T[8] = {B00000000,B01111110,B00011000,B00011000,B00011000,B00011000,B00011000,B00000000};
byte O[8] = {B00000000,B00111100,B01100110,B01100110,B01100110,B01100110,B00111100,B00000000};
byte P[8] = {B00000000,B01111110,B01100110,B01100110,B01100110,B01100110,B01100110,B00000000};
//====================================================================================================
byte Si[8] = {B11111111,B11000011,B10011001,B10011111,B10011111,B10011001,B11000011,B11111111};//стоп с инверсией
byte Ti[8] = {B11111111,B10000001,B11100111,B11100111,B11100111,B11100111,B11100111,B11111111};
byte Oi[8] = {B11111111,B11000011,B10011001,B10011001,B10011001,B10011001,B11000011,B11111111};
byte Pi[8] = {B11111111,B10000001,B10011001,B10011001,B10011001,B10011001,B10011001,B11111111};
//====================================================================================================
/*void pusto(int param){//стираем всё
  if (param == 1){
  lc.clearDisplay(0);  
  lc.clearDisplay(1); 
  lc.clearDisplay(2); 
  lc.clearDisplay(3);
}}*/
//====================================================================================================
void STOP(int param){//задаём параметры для стопа
  if (param == 1){
  lc.setRow(0, 0, Pi[0]);
  lc.setRow(0, 1, Pi[1]);
  lc.setRow(0, 2, Pi[2]);
  lc.setRow(0, 3, Pi[3]);
  lc.setRow(0, 4, Pi[4]);
  lc.setRow(0, 5, Pi[5]);
  lc.setRow(0, 6, Pi[6]);
  lc.setRow(0, 7, Pi[7]);
  lc.setRow(1, 0, Oi[0]);
  lc.setRow(1, 1, Oi[1]);
  lc.setRow(1, 2, Oi[2]);
  lc.setRow(1, 3, Oi[3]);
  lc.setRow(1, 4, Oi[4]);
  lc.setRow(1, 5, Oi[5]);
  lc.setRow(1, 6, Oi[6]);
  lc.setRow(1, 7, Oi[7]);
  lc.setRow(2, 0, Ti[0]);
  lc.setRow(2, 1, Ti[1]);
  lc.setRow(2, 2, Ti[2]);
  lc.setRow(2, 3, Ti[3]);
  lc.setRow(2, 4, Ti[4]);
  lc.setRow(2, 5, Ti[5]);
  lc.setRow(2, 6, Ti[6]);
  lc.setRow(2, 7, Ti[7]);
  lc.setRow(3, 0, Si[0]);
  lc.setRow(3, 1, Si[1]);
  lc.setRow(3, 2, Si[2]);
  lc.setRow(3, 3, Si[3]);
  lc.setRow(3, 4, Si[4]);
  lc.setRow(3, 5, Si[5]);
  lc.setRow(3, 6, Si[6]);
  lc.setRow(3, 7, Si[7]);
  delay(delaytime2);
  lc.setRow(0, 0, P[0]);
  lc.setRow(0, 1, P[1]);
  lc.setRow(0, 2, P[2]);
  lc.setRow(0, 3, P[3]);
  lc.setRow(0, 4, P[4]);
  lc.setRow(0, 5, P[5]);
  lc.setRow(0, 6, P[6]);
  lc.setRow(0, 7, P[7]);
  lc.setRow(1, 0, O[0]);
  lc.setRow(1, 1, O[1]);
  lc.setRow(1, 2, O[2]);
  lc.setRow(1, 3, O[3]);
  lc.setRow(1, 4, O[4]);
  lc.setRow(1, 5, O[5]);
  lc.setRow(1, 6, O[6]);
  lc.setRow(1, 7, O[7]);
  lc.setRow(2, 0, T[0]);
  lc.setRow(2, 1, T[1]);
  lc.setRow(2, 2, T[2]);
  lc.setRow(2, 3, T[3]);
  lc.setRow(2, 4, T[4]);
  lc.setRow(2, 5, T[5]);
  lc.setRow(2, 6, T[6]);
  lc.setRow(2, 7, T[7]);
  lc.setRow(3, 0, S[0]);
  lc.setRow(3, 1, S[1]);
  lc.setRow(3, 2, S[2]);
  lc.setRow(3, 3, S[3]);
  lc.setRow(3, 4, S[4]);
  lc.setRow(3, 5, S[5]);
  lc.setRow(3, 6, S[6]);
  lc.setRow(3, 7, S[7]);
  delay(delaytime2);
  lc.clearDisplay(0);  
  lc.clearDisplay(1); 
  lc.clearDisplay(2); 
  lc.clearDisplay(3);
  lc.setRow(0, 0, Pi[0]);
  lc.setRow(0, 1, Pi[1]);
  lc.setRow(0, 2, Pi[2]);
  lc.setRow(0, 3, Pi[3]);
  lc.setRow(0, 4, Pi[4]);
  lc.setRow(0, 5, Pi[5]);
  lc.setRow(0, 6, Pi[6]);
  lc.setRow(0, 7, Pi[7]);
  lc.setRow(1, 0, Oi[0]);
  lc.setRow(1, 1, Oi[1]);
  lc.setRow(1, 2, Oi[2]);
  lc.setRow(1, 3, Oi[3]);
  lc.setRow(1, 4, Oi[4]);
  lc.setRow(1, 5, Oi[5]);
  lc.setRow(1, 6, Oi[6]);
  lc.setRow(1, 7, Oi[7]);
  lc.setRow(2, 0, Ti[0]);
  lc.setRow(2, 1, Ti[1]);
  lc.setRow(2, 2, Ti[2]);
  lc.setRow(2, 3, Ti[3]);
  lc.setRow(2, 4, Ti[4]);
  lc.setRow(2, 5, Ti[5]);
  lc.setRow(2, 6, Ti[6]);
  lc.setRow(2, 7, Ti[7]);
  lc.setRow(3, 0, Si[0]);
  lc.setRow(3, 1, Si[1]);
  lc.setRow(3, 2, Si[2]);
  lc.setRow(3, 3, Si[3]);
  lc.setRow(3, 4, Si[4]);
  lc.setRow(3, 5, Si[5]);
  lc.setRow(3, 6, Si[6]);
  lc.setRow(3, 7, Si[7]);
}}
//====================================================================================================
/*void gabarit(byte param){
  byte i;
  if (param == 1);
  for(i=0;i<=7;i++) lc.setRow(0, i, gabarit3[i]);
  for(i=0;i<=7;i++) lc.setRow(1, i, gabarit1[i]);
  for(i=0;i<=7;i++) lc.setRow(2, i, gabarit1[i]);
  for(i=0;i<=7;i++) lc.setRow(3, i, gabarit2[i]);
                        }
*/                        
/*
void gabarit(int param){//задаём параметры для габарита
  if (param == 1){
  lc.setRow(0, 0, gabarit3[0]);
  lc.setRow(0, 1, gabarit3[1]);
  lc.setRow(0, 2, gabarit3[2]);
  lc.setRow(0, 3, gabarit3[3]);
  lc.setRow(0, 4, gabarit3[4]);
  lc.setRow(0, 5, gabarit3[5]);
  lc.setRow(0, 6, gabarit3[6]);
  lc.setRow(0, 7, gabarit3[7]);
  lc.setRow(1, 0, gabarit1[0]);
  lc.setRow(1, 1, gabarit1[1]);
  lc.setRow(1, 2, gabarit1[2]);
  lc.setRow(1, 3, gabarit1[3]);
  lc.setRow(1, 4, gabarit1[4]);
  lc.setRow(1, 5, gabarit1[5]);
  lc.setRow(1, 6, gabarit1[6]);
  lc.setRow(1, 7, gabarit1[7]);
  lc.setRow(2, 0, gabarit1[0]);
  lc.setRow(2, 1, gabarit1[1]);
  lc.setRow(2, 2, gabarit1[2]);
  lc.setRow(2, 3, gabarit1[3]);
  lc.setRow(2, 4, gabarit1[4]);
  lc.setRow(2, 5, gabarit1[5]);
  lc.setRow(2, 6, gabarit1[6]);
  lc.setRow(2, 7, gabarit1[7]);
  lc.setRow(3, 0, gabarit2[0]);
  lc.setRow(3, 1, gabarit2[1]);
  lc.setRow(3, 2, gabarit2[2]);
  lc.setRow(3, 3, gabarit2[3]);
  lc.setRow(3, 4, gabarit2[4]);
  lc.setRow(3, 5, gabarit2[5]);
  lc.setRow(3, 6, gabarit2[6]);
  lc.setRow(3, 7, gabarit2[7]);
}}
*/
//====================================================================================================
void pravo(byte param){
  byte i;
  if (param != 1) return;
  for(i=0;i<=3;i++) lc.clearDisplay(i);
  delay(delaytime2);
  for(i=0;i<=7;i++) lc.setRow(3, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(2, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(1, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(0, i, pravo1[i]);
  for(i=3;i>=0;i--)
    {delay(delaytime3);
    lc.clearDisplay(i);
    }
                    }

/*
void pravo(int param){//задаём параметры для поворота в право
    if (param == 1){
    lc.clearDisplay(0);  
    lc.clearDisplay(1); 
    lc.clearDisplay(2); 
    lc.clearDisplay(3);
    delay(delaytime2);
    lc.setRow(3, 0, pravo1[0]);
    lc.setRow(3, 1, pravo1[1]);
    lc.setRow(3, 2, pravo1[2]);
    lc.setRow(3, 3, pravo1[3]);
    lc.setRow(3, 4, pravo1[4]);
    lc.setRow(3, 5, pravo1[5]);
    lc.setRow(3, 6, pravo1[6]);
    lc.setRow(3, 7, pravo1[7]);
    delay(delaytime3);
    lc.setRow(2, 0, pravo1[0]);
    lc.setRow(2, 1, pravo1[1]);
    lc.setRow(2, 2, pravo1[2]);
    lc.setRow(2, 3, pravo1[3]);
    lc.setRow(2, 4, pravo1[4]);
    lc.setRow(2, 5, pravo1[5]);
    lc.setRow(2, 6, pravo1[6]);
    lc.setRow(2, 7, pravo1[7]);
    delay(delaytime3);
    lc.setRow(1, 0, pravo1[0]);
    lc.setRow(1, 1, pravo1[1]);
    lc.setRow(1, 2, pravo1[2]);
    lc.setRow(1, 3, pravo1[3]);
    lc.setRow(1, 4, pravo1[4]);
    lc.setRow(1, 5, pravo1[5]);
    lc.setRow(1, 6, pravo1[6]);
    lc.setRow(1, 7, pravo1[7]);
    delay(delaytime3);
    lc.setRow(0, 0, pravo1[0]);
    lc.setRow(0, 1, pravo1[1]);
    lc.setRow(0, 2, pravo1[2]);
    lc.setRow(0, 3, pravo1[3]);
    lc.setRow(0, 4, pravo1[4]);
    lc.setRow(0, 5, pravo1[5]);
    lc.setRow(0, 6, pravo1[6]);
    lc.setRow(0, 7, pravo1[7]);
    delay(delaytime3);
    lc.clearDisplay(3);
    delay(delaytime3);
    lc.clearDisplay(2);
    delay(delaytime3);
    lc.clearDisplay(1);
    delay(delaytime3);
    lc.clearDisplay(0);
  }}
  */
//====================================================================================================
void levo(byte param){
  byte i;
  if (param != 1) return;
  for(i=0;i<=3;i++) lc.clearDisplay(i);
  delay(delaytime2);
  for(i=0;i<=7;i++) lc.setRow(0, i, levo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(1, i, levo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(2, i, levo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(3, i, levo1[i]);
  for(i=0;i<=3;i++)
    {delay(delaytime3);
    lc.clearDisplay(i);
    }
                    }
/*
void levo(int param){//задаём параметры для поворота в лево
    if (param == 1){
    lc.clearDisplay(0);  
    lc.clearDisplay(1); 
    lc.clearDisplay(2); 
    lc.clearDisplay(3);
    delay(delaytime2);
    lc.setRow(0, 0, levo1[0]);
    lc.setRow(0, 1, levo1[1]);
    lc.setRow(0, 2, levo1[2]);
    lc.setRow(0, 3, levo1[3]);
    lc.setRow(0, 4, levo1[4]);
    lc.setRow(0, 5, levo1[5]);
    lc.setRow(0, 6, levo1[6]);
    lc.setRow(0, 7, levo1[7]);
    delay(delaytime3);
    lc.setRow(1, 0, levo1[0]);
    lc.setRow(1, 1, levo1[1]);
    lc.setRow(1, 2, levo1[2]);
    lc.setRow(1, 3, levo1[3]);
    lc.setRow(1, 4, levo1[4]);
    lc.setRow(1, 5, levo1[5]);
    lc.setRow(1, 6, levo1[6]);
    lc.setRow(1, 7, levo1[7]);
    delay(delaytime3);
    lc.setRow(2, 0, levo1[0]);
    lc.setRow(2, 1, levo1[1]);
    lc.setRow(2, 2, levo1[2]);
    lc.setRow(2, 3, levo1[3]);
    lc.setRow(2, 4, levo1[4]);
    lc.setRow(2, 5, levo1[5]);
    lc.setRow(2, 6, levo1[6]);
    lc.setRow(2, 7, levo1[7]);
    delay(delaytime3);
    lc.setRow(3, 0, levo1[0]);
    lc.setRow(3, 1, levo1[1]);
    lc.setRow(3, 2, levo1[2]);
    lc.setRow(3, 3, levo1[3]);
    lc.setRow(3, 4, levo1[4]);
    lc.setRow(3, 5, levo1[5]);
    lc.setRow(3, 6, levo1[6]);
    lc.setRow(3, 7, levo1[7]);
    delay(delaytime3);
    lc.clearDisplay(0);
    delay(delaytime3);
    lc.clearDisplay(1);
    delay(delaytime3);
    lc.clearDisplay(2);
    delay(delaytime3);
    lc.clearDisplay(3);
}}
*/
//====================================================================================================
void loop() {
STOP_light = digitalRead(STOP_button);
gabarit_light = digitalRead(gabarit_button);
levo_light = digitalRead(levo_button);
pravo_light = digitalRead(pravo_button);   
//====================================================================================================    
    if (STOP_light == LOW)        
       {STOP(1);}
    else   
       {STOP(0);}
//====================================================================================================           
    if (gabarit_light == LOW)        
       {gabarit(1);}
    else    
       {gabarit(0);}  
//====================================================================================================    
    if (levo_light == LOW)           
       {levo(1);}
     else
       {levo(0);}
//====================================================================================================     
    if (pravo_light == LOW)           
       {pravo(1);}
    else
       {pravo(0);}
//====================================================================================================          
}              
                           

Пробуем так:

#include "LedControl.h"//подключаем библиотеку LedControl.h
#define STOP_button 2
#define gabarit_button 3
#define levo_button 5
#define pravo_button 7
//====================================================================================================
LedControl lc = LedControl(11, 13, 10, 4);//к D11 подключаем DIN, к D13 подключаем CLK, к D10 подключаем CS
//====================================================================================================
unsigned long delaytime = 1000;//временные переменные delay
unsigned long delaytime2 = 30;
unsigned long delaytime3 = 100;
// =========================================================================
int STOP_light = LOW;   // Статус нажатия тормоза
int gabarit_light = LOW;// Статус включения габарита
int levo_light = LOW;   // Статус включения левого поворотника
int pravo_light = LOW;  // Статус включения правого поворотника
// =========================================================================
void setup() {  //задаём параметры дисплеев
  lc.shutdown(0, false);//первого
  lc.setIntensity(0, 1);
  lc.clearDisplay(0);
  lc.shutdown(1, false);//второго
  lc.setIntensity(1, 1);
  lc.clearDisplay(1);
  lc.shutdown(2, false);//третьего
  lc.setIntensity(2, 1);
  lc.clearDisplay(2);
  lc.shutdown(3, false);//четвертого
  lc.setIntensity(3, 1);
  lc.clearDisplay(3);
  pinMode(2,INPUT_PULLUP);
  pinMode(3,INPUT_PULLUP);
  pinMode(5,INPUT_PULLUP);
  pinMode(7,INPUT_PULLUP);
}
//====================================================================================================
//пишем значения для каждой фигуры или символа
byte gabarit1[8] = {B11111111,B00000000,B11111111,B11111111,B11111111,B11111111,B00000000,B11111111};//центральные матрицы габарита
byte gabarit2[8] = {B11111111,B10000000,B10111111,B10111111,B10111111,B10111111,B10000000,B11111111};//левая матрица габарита
byte gabarit3[8] = {B11111111,B00000001,B11111101,B11111101,B11111101,B11111101,B00000001,B11111111};//правая матрица габарита
//====================================================================================================
byte pravo1[8] = {B00001000,B00001100,B01111110,B01111111,B01111111,B01111110,B00001100,B00001000};//правый поворот
//====================================================================================================                 
byte levo1[8] =  {B00010000,B00110000,B01111110,B11111110,B11111110,B01111110,B00110000,B00010000};//левый поворот
//====================================================================================================                 
byte S[8] = {B00000000,B00111100,B01100110,B01100000,B01100000,B01100110,B00111100,B00000000};//стоп простой
byte T[8] = {B00000000,B01111110,B00011000,B00011000,B00011000,B00011000,B00011000,B00000000};
byte O[8] = {B00000000,B00111100,B01100110,B01100110,B01100110,B01100110,B00111100,B00000000};
byte P[8] = {B00000000,B01111110,B01100110,B01100110,B01100110,B01100110,B01100110,B00000000};
//====================================================================================================
byte Si[8] = {B11111111,B11000011,B10011001,B10011111,B10011111,B10011001,B11000011,B11111111};//стоп с инверсией
byte Ti[8] = {B11111111,B10000001,B11100111,B11100111,B11100111,B11100111,B11100111,B11111111};
byte Oi[8] = {B11111111,B11000011,B10011001,B10011001,B10011001,B10011001,B11000011,B11111111};
byte Pi[8] = {B11111111,B10000001,B10011001,B10011001,B10011001,B10011001,B10011001,B11111111};
//====================================================================================================
void pusto(){//стираем всё
  lc.clearDisplay(0);  
  lc.clearDisplay(1); 
  lc.clearDisplay(2); 
  lc.clearDisplay(3);
}
//====================================================================================================
void STOP(){//задаём параметры для стопа
  lc.setRow(0, 0, Pi[0]);
  lc.setRow(0, 1, Pi[1]);
  lc.setRow(0, 2, Pi[2]);
  lc.setRow(0, 3, Pi[3]);
  lc.setRow(0, 4, Pi[4]);
  lc.setRow(0, 5, Pi[5]);
  lc.setRow(0, 6, Pi[6]);
  lc.setRow(0, 7, Pi[7]);
  lc.setRow(1, 0, Oi[0]);
  lc.setRow(1, 1, Oi[1]);
  lc.setRow(1, 2, Oi[2]);
  lc.setRow(1, 3, Oi[3]);
  lc.setRow(1, 4, Oi[4]);
  lc.setRow(1, 5, Oi[5]);
  lc.setRow(1, 6, Oi[6]);
  lc.setRow(1, 7, Oi[7]);
  lc.setRow(2, 0, Ti[0]);
  lc.setRow(2, 1, Ti[1]);
  lc.setRow(2, 2, Ti[2]);
  lc.setRow(2, 3, Ti[3]);
  lc.setRow(2, 4, Ti[4]);
  lc.setRow(2, 5, Ti[5]);
  lc.setRow(2, 6, Ti[6]);
  lc.setRow(2, 7, Ti[7]);
  lc.setRow(3, 0, Si[0]);
  lc.setRow(3, 1, Si[1]);
  lc.setRow(3, 2, Si[2]);
  lc.setRow(3, 3, Si[3]);
  lc.setRow(3, 4, Si[4]);
  lc.setRow(3, 5, Si[5]);
  lc.setRow(3, 6, Si[6]);
  lc.setRow(3, 7, Si[7]);
  delay(delaytime2);
  lc.setRow(0, 0, P[0]);
  lc.setRow(0, 1, P[1]);
  lc.setRow(0, 2, P[2]);
  lc.setRow(0, 3, P[3]);
  lc.setRow(0, 4, P[4]);
  lc.setRow(0, 5, P[5]);
  lc.setRow(0, 6, P[6]);
  lc.setRow(0, 7, P[7]);
  lc.setRow(1, 0, O[0]);
  lc.setRow(1, 1, O[1]);
  lc.setRow(1, 2, O[2]);
  lc.setRow(1, 3, O[3]);
  lc.setRow(1, 4, O[4]);
  lc.setRow(1, 5, O[5]);
  lc.setRow(1, 6, O[6]);
  lc.setRow(1, 7, O[7]);
  lc.setRow(2, 0, T[0]);
  lc.setRow(2, 1, T[1]);
  lc.setRow(2, 2, T[2]);
  lc.setRow(2, 3, T[3]);
  lc.setRow(2, 4, T[4]);
  lc.setRow(2, 5, T[5]);
  lc.setRow(2, 6, T[6]);
  lc.setRow(2, 7, T[7]);
  lc.setRow(3, 0, S[0]);
  lc.setRow(3, 1, S[1]);
  lc.setRow(3, 2, S[2]);
  lc.setRow(3, 3, S[3]);
  lc.setRow(3, 4, S[4]);
  lc.setRow(3, 5, S[5]);
  lc.setRow(3, 6, S[6]);
  lc.setRow(3, 7, S[7]);
  delay(delaytime2);
  lc.clearDisplay(0);  
  lc.clearDisplay(1); 
  lc.clearDisplay(2); 
  lc.clearDisplay(3);
  lc.setRow(0, 0, Pi[0]);
  lc.setRow(0, 1, Pi[1]);
  lc.setRow(0, 2, Pi[2]);
  lc.setRow(0, 3, Pi[3]);
  lc.setRow(0, 4, Pi[4]);
  lc.setRow(0, 5, Pi[5]);
  lc.setRow(0, 6, Pi[6]);
  lc.setRow(0, 7, Pi[7]);
  lc.setRow(1, 0, Oi[0]);
  lc.setRow(1, 1, Oi[1]);
  lc.setRow(1, 2, Oi[2]);
  lc.setRow(1, 3, Oi[3]);
  lc.setRow(1, 4, Oi[4]);
  lc.setRow(1, 5, Oi[5]);
  lc.setRow(1, 6, Oi[6]);
  lc.setRow(1, 7, Oi[7]);
  lc.setRow(2, 0, Ti[0]);
  lc.setRow(2, 1, Ti[1]);
  lc.setRow(2, 2, Ti[2]);
  lc.setRow(2, 3, Ti[3]);
  lc.setRow(2, 4, Ti[4]);
  lc.setRow(2, 5, Ti[5]);
  lc.setRow(2, 6, Ti[6]);
  lc.setRow(2, 7, Ti[7]);
  lc.setRow(3, 0, Si[0]);
  lc.setRow(3, 1, Si[1]);
  lc.setRow(3, 2, Si[2]);
  lc.setRow(3, 3, Si[3]);
  lc.setRow(3, 4, Si[4]);
  lc.setRow(3, 5, Si[5]);
  lc.setRow(3, 6, Si[6]);
  lc.setRow(3, 7, Si[7]);
}
//====================================================================================================
void gabarit(){
  byte i;
  for(i=0;i<=7;i++) lc.setRow(0, i, gabarit3[i]);
  for(i=0;i<=7;i++) lc.setRow(1, i, gabarit1[i]);
  for(i=0;i<=7;i++) lc.setRow(2, i, gabarit1[i]);
  for(i=0;i<=7;i++) lc.setRow(3, i, gabarit2[i]);
}
//====================================================================================================
void pravo(){
  byte i;
  for(i=0;i<=3;i++) lc.clearDisplay(i);
  delay(delaytime2);
  for(i=0;i<=7;i++) lc.setRow(3, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(2, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(1, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(0, i, pravo1[i]);
  for(i=3;i>=0;i--){
    delay(delaytime3);
    lc.clearDisplay(i);
  }
}
//====================================================================================================
void levo(){
  byte i;
  for(i=0;i<=3;i++) lc.clearDisplay(i);
  delay(delaytime2);
  for(i=0;i<=7;i++) lc.setRow(0, i, levo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(1, i, levo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(2, i, levo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(3, i, levo1[i]);
  for(i=0;i<=3;i++){
    delay(delaytime3);
    lc.clearDisplay(i);
  }
}
//====================================================================================================
void loop() {
  STOP_light = digitalRead(STOP_button);
  gabarit_light = digitalRead(gabarit_button);
  levo_light = digitalRead(levo_button);
  pravo_light = digitalRead(pravo_button);   
  if (STOP_light == LOW) STOP();
  if (gabarit_light == LOW) gabarit();
  if (levo_light == LOW) levo();
  if (pravo_light == LOW) pravo();
}

Потом так:

#include "LedControl.h"//подключаем библиотеку LedControl.h
#define STOP_button 2
#define gabarit_button 3
#define levo_button 5
#define pravo_button 7
//====================================================================================================
LedControl lc = LedControl(11, 13, 10, 4);//к D11 подключаем DIN, к D13 подключаем CLK, к D10 подключаем CS
//====================================================================================================
unsigned long delaytime = 1000;//временные переменные delay
unsigned long delaytime2 = 30;
unsigned long delaytime3 = 100;
// =========================================================================
void setup() {  //задаём параметры дисплеев
  byte i;
  for(i=0;i<=7;i++){
    lc.shutdown(i, false);
    lc.setIntensity(i, 1);
    lc.clearDisplay(i);
  }
  pinMode(2,INPUT_PULLUP);
  pinMode(3,INPUT_PULLUP);
  pinMode(5,INPUT_PULLUP);
  pinMode(7,INPUT_PULLUP);
}
//====================================================================================================
//пишем значения для каждой фигуры или символа
byte gabarit1[8] = {B11111111,B00000000,B11111111,B11111111,B11111111,B11111111,B00000000,B11111111};//центральные матрицы габарита
byte gabarit2[8] = {B11111111,B10000000,B10111111,B10111111,B10111111,B10111111,B10000000,B11111111};//левая матрица габарита
byte gabarit3[8] = {B11111111,B00000001,B11111101,B11111101,B11111101,B11111101,B00000001,B11111111};//правая матрица габарита
//====================================================================================================
byte pravo1[8] = {B00001000,B00001100,B01111110,B01111111,B01111111,B01111110,B00001100,B00001000};//правый поворот
//====================================================================================================                 
byte levo1[8] =  {B00010000,B00110000,B01111110,B11111110,B11111110,B01111110,B00110000,B00010000};//левый поворот
//====================================================================================================                 
byte S[8] = {B00000000,B00111100,B01100110,B01100000,B01100000,B01100110,B00111100,B00000000};//стоп простой
byte T[8] = {B00000000,B01111110,B00011000,B00011000,B00011000,B00011000,B00011000,B00000000};
byte O[8] = {B00000000,B00111100,B01100110,B01100110,B01100110,B01100110,B00111100,B00000000};
byte P[8] = {B00000000,B01111110,B01100110,B01100110,B01100110,B01100110,B01100110,B00000000};
//====================================================================================================
byte Si[8] = {B11111111,B11000011,B10011001,B10011111,B10011111,B10011001,B11000011,B11111111};//стоп с инверсией
byte Ti[8] = {B11111111,B10000001,B11100111,B11100111,B11100111,B11100111,B11100111,B11111111};
byte Oi[8] = {B11111111,B11000011,B10011001,B10011001,B10011001,B10011001,B11000011,B11111111};
byte Pi[8] = {B11111111,B10000001,B10011001,B10011001,B10011001,B10011001,B10011001,B11111111};
//====================================================================================================
void pusto(){//стираем всё
  lc.clearDisplay(0);  
  lc.clearDisplay(1); 
  lc.clearDisplay(2); 
  lc.clearDisplay(3);
}
//====================================================================================================
void STOP(){//задаём параметры для стопа
  byte i;
  for(i=0;i<=7;i++) lc.setRow(0, i, Pi[i]);
  for(i=0;i<=7;i++) lc.setRow(1, i, Oi[i]);
  for(i=0;i<=7;i++) lc.setRow(2, i, Ti[i]);
  for(i=0;i<=7;i++) lc.setRow(3, i, Si[i]);
  delay(delaytime2);
  for(i=0;i<=7;i++) lc.setRow(0, i, P[i]);
  for(i=0;i<=7;i++) lc.setRow(1, i, O[i]);
  for(i=0;i<=7;i++) lc.setRow(2, i, T[i]);
  for(i=0;i<=7;i++) lc.setRow(3, i, S[i]);
  delay(delaytime2);
  pusto();
  for(i=0;i<=7;i++) lc.setRow(0, i, Pi[i]);
  for(i=0;i<=7;i++) lc.setRow(1, i, Oi[i]);
  for(i=0;i<=7;i++) lc.setRow(2, i, Ti[i]);
  for(i=0;i<=7;i++) lc.setRow(3, i, Si[i]);
}
//====================================================================================================
void gabarit(){
  byte i;
  for(i=0;i<=7;i++) lc.setRow(0, i, gabarit3[i]);
  for(i=0;i<=7;i++) lc.setRow(1, i, gabarit1[i]);
  for(i=0;i<=7;i++) lc.setRow(2, i, gabarit1[i]);
  for(i=0;i<=7;i++) lc.setRow(3, i, gabarit2[i]);
}
//====================================================================================================
void pravo(){
  byte i;
  for(i=0;i<=3;i++) lc.clearDisplay(i);
  delay(delaytime2);
  for(i=0;i<=7;i++) lc.setRow(3, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(2, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(1, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(0, i, pravo1[i]);
  for(i=3;i>=0;i--){
    delay(delaytime3);
    lc.clearDisplay(i);
  }
}
//====================================================================================================
void levo(){
  byte i;
  for(i=0;i<=3;i++) lc.clearDisplay(i);
  delay(delaytime2);
  for(i=0;i<=7;i++) lc.setRow(0, i, levo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(1, i, levo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(2, i, levo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(3, i, levo1[i]);
  for(i=0;i<=3;i++){
    delay(delaytime3);
    lc.clearDisplay(i);
  }
}
//====================================================================================================
void loop() {
  if (!digitalRead(STOP_button)  ) STOP();
  if (!digitalRead(gabarit_button)) gabarit();
  if (!digitalRead(levo_button)   ) levo();
  if (!digitalRead(pravo_button)  ) pravo();
}

Ничего не должно измениться. Всё должно работать как в самом первом варианте.

UPD. Мне аж любопытно стало, но пора спать. AFK часов 5. Или 11, не знаю... я вернусь.

Автор, проверте ваши функции levo(), pravo(), stop() и gabarit() без кнопок. Т. е. вызывать эти функции (по одной) из loop(), убрав проверку нажатия кнопок, что бы исключить их влияние.

Кстати, после отпускания любой кнопки индикатор гаснет или сохраняет последнее состояние?

что по первому варианту, что по второму ситуация одинаковая: зажигаем gabarit (нажал горит, отпустил горит), STOP (нажал мигает,отпустил горт),levo нажал мигает,отпустил погас), pravo (нажал пробежал один цикл и больше не горит) причем после право больше ни чего не включается пока не нажмешь ресет на arduino. попробую завтра кнопки сменить может и правда в них косяк (по скетчу вроде все правильно), еще вопросик на кнопки по моему скетчу (пин+GND) внешние сопротивления не нужны,пользуем всетроенные в arduino. если запустить в DEMO режиме так сказать вроде всё нормально

#include "LedControl.h"//подключаем библиотеку LedControl.h
#define STOP_button 2
#define gabarit_button 3
#define levo_button 5
#define pravo_button 7
//====================================================================================================
LedControl lc = LedControl(11, 13, 10, 4);//к D11 подключаем DIN, к D13 подключаем CLK, к D10 подключаем CS
//====================================================================================================
unsigned long delaytime = 1000;//временные переменные delay
unsigned long delaytime2 = 1000;
unsigned long delaytime3 = 1000;
// =========================================================================
void setup() {  //задаём параметры дисплеев
  byte i;
  for(i=0;i<=7;i++){
    lc.shutdown(i, false);
    lc.setIntensity(i, 1);
    lc.clearDisplay(i);
  }
  pinMode(2,INPUT_PULLUP);
  pinMode(3,INPUT_PULLUP);
  pinMode(5,INPUT_PULLUP);
  pinMode(7,INPUT_PULLUP);
}
//====================================================================================================
//пишем значения для каждой фигуры или символа
byte gabarit1[8] = {B11111111,B00000000,B11111111,B11111111,B11111111,B11111111,B00000000,B11111111};//центральные матрицы габарита
byte gabarit2[8] = {B11111111,B10000000,B10111111,B10111111,B10111111,B10111111,B10000000,B11111111};//левая матрица габарита
byte gabarit3[8] = {B11111111,B00000001,B11111101,B11111101,B11111101,B11111101,B00000001,B11111111};//правая матрица габарита
//====================================================================================================
byte pravo1[8] = {B00001000,B00001100,B01111110,B01111111,B01111111,B01111110,B00001100,B00001000};//правый поворот
//====================================================================================================                 
byte levo1[8] =  {B00010000,B00110000,B01111110,B11111110,B11111110,B01111110,B00110000,B00010000};//левый поворот
//====================================================================================================                 
byte S[8] = {B00000000,B00111100,B01100110,B01100000,B01100000,B01100110,B00111100,B00000000};//стоп простой
byte T[8] = {B00000000,B01111110,B00011000,B00011000,B00011000,B00011000,B00011000,B00000000};
byte O[8] = {B00000000,B00111100,B01100110,B01100110,B01100110,B01100110,B00111100,B00000000};
byte P[8] = {B00000000,B01111110,B01100110,B01100110,B01100110,B01100110,B01100110,B00000000};
//====================================================================================================
byte Si[8] = {B11111111,B11000011,B10011001,B10011111,B10011111,B10011001,B11000011,B11111111};//стоп с инверсией
byte Ti[8] = {B11111111,B10000001,B11100111,B11100111,B11100111,B11100111,B11100111,B11111111};
byte Oi[8] = {B11111111,B11000011,B10011001,B10011001,B10011001,B10011001,B11000011,B11111111};
byte Pi[8] = {B11111111,B10000001,B10011001,B10011001,B10011001,B10011001,B10011001,B11111111};
//====================================================================================================
void pusto(){//стираем всё
  lc.clearDisplay(0);  
  lc.clearDisplay(1); 
  lc.clearDisplay(2); 
  lc.clearDisplay(3);
}
//====================================================================================================
void STOP(){//задаём параметры для стопа
  byte i;
  for(i=0;i<=7;i++) lc.setRow(0, i, Pi[i]);
  for(i=0;i<=7;i++) lc.setRow(1, i, Oi[i]);
  for(i=0;i<=7;i++) lc.setRow(2, i, Ti[i]);
  for(i=0;i<=7;i++) lc.setRow(3, i, Si[i]);
  delay(delaytime2);
  for(i=0;i<=7;i++) lc.setRow(0, i, P[i]);
  for(i=0;i<=7;i++) lc.setRow(1, i, O[i]);
  for(i=0;i<=7;i++) lc.setRow(2, i, T[i]);
  for(i=0;i<=7;i++) lc.setRow(3, i, S[i]);
  delay(delaytime2);
  pusto();
  for(i=0;i<=7;i++) lc.setRow(0, i, Pi[i]);
  for(i=0;i<=7;i++) lc.setRow(1, i, Oi[i]);
  for(i=0;i<=7;i++) lc.setRow(2, i, Ti[i]);
  for(i=0;i<=7;i++) lc.setRow(3, i, Si[i]);
  delay(delaytime2);
}
//====================================================================================================
void gabarit(){
  byte i;
  for(i=0;i<=3;i++) lc.clearDisplay(i);
  delay(delaytime2);
  for(i=0;i<=7;i++) lc.setRow(0, i, gabarit3[i]);
  for(i=0;i<=7;i++) lc.setRow(1, i, gabarit1[i]);
  for(i=0;i<=7;i++) lc.setRow(2, i, gabarit1[i]);
  for(i=0;i<=7;i++) lc.setRow(3, i, gabarit2[i]);
  delay(delaytime2);
}
//====================================================================================================
void pravo(){
  byte i;
  for(i=0;i<=3;i++) lc.clearDisplay(i);
  delay(delaytime2);
  for(i=0;i<=7;i++) lc.setRow(3, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(2, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(1, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(0, i, pravo1[i]);
  for(i=3;i>=0;i--){
    delay(delaytime3);
    lc.clearDisplay(i);
  }
}
//====================================================================================================
void levo(){
  byte i;
  for(i=0;i<=3;i++) lc.clearDisplay(i);
  delay(delaytime2);
  for(i=0;i<=7;i++) lc.setRow(0, i, levo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(1, i, levo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(2, i, levo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(3, i, levo1[i]);
  for(i=0;i<=3;i++){
    delay(delaytime3);
    lc.clearDisplay(i);
  }
}
//====================================================================================================
void loop() {
gabarit();  
STOP();
levo();
pravo();
}

льзуем  каждый из параметров выполняется по разу (загорается gabarit тухнет, загорается STOP тухнет, пробегает levo тухнет, пробегает pravo тухнет) и больше не горят

Внешние не нужны. Потом можно будет дописать условие, проверяющее что не нажата ни одна кнопка, и по этому условию запускать pusto() - тогда будет выглядеть нормально (не оставляя после себя старое состояние экрана). Но почему pravo() всё вешает, по-прежнему непонятно.

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

если DEMO запустить без pravo оно провторяется, а не завершается. после право что то идет не так ) откинул кнопки осталась ардуинка и матрица та же история после право тишина

Что будет если в цикле гасить не от 3 до 0 а от 0 до 3 как в levo?

Вот так:

  for(i=0;i<=7;i++) lc.setRow(0, i, pravo1[i]);
  for(i=0;i<=3;i++){
    delay(delaytime3);
    lc.clearDisplay(3-i);
  }

Как вариант ещё попробовать lc.clearDisplay(3); вместо lc.clearDisplay(3-i);, но тогда порядок в котором гаснет, изменится.

так работает ща кнопки подкину проверю

Подробнее, пожалуйста.

Upd, ещё ошибка, не lc.clearDisplay(3) а lc.clearDisplay(i).

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

работает вот с этим

for(i=0;i<=7;i++) lc.setRow(0, i, pravo1[i]);
for(i=0;i<=3;i++){
  delay(delaytime3);
  lc.clearDisplay(3-i);
}

на сегодня я всё спать пора пусть мозги остынут )) спасибо огромное за помощь. еще приоритеты для кнопок расставить и будет зер гуд. код конечно намного компактнее стал )

мучал сегодня кнопки все равно что-то не то получается. одно не выключает другое (например включен gabarit,включаю levo лево начинает мигать, но в промежудках между циклами levo мелькает gabarit. и все остальные так же). пытался вникнуть в millis из твоего первого примера ни чего толком не понял, без умного черепа не раскурю.

#include "LedControl.h"//подключаем библиотеку LedControl.h
#define STOP_button 2
#define gabarit_button 3
#define levo_button 5
#define pravo_button 7
//====================================================================================================
LedControl lc = LedControl(11, 13, 10, 4);//к D11 подключаем DIN, к D13 подключаем CLK, к D10 подключаем CS
//====================================================================================================
unsigned long delaytime = 1000;//временные переменные delay
unsigned long delaytime2 = 30;
unsigned long delaytime3 = 100;
// =========================================================================
void setup() {  //задаём параметры дисплеев
  byte i;
  for(i=0;i<=7;i++){
    lc.shutdown(i, false);
    lc.setIntensity(i, 1);
    lc.clearDisplay(i);
  }
  pinMode(2,INPUT_PULLUP);
  pinMode(3,INPUT_PULLUP);
  pinMode(5,INPUT_PULLUP);
  pinMode(7,INPUT_PULLUP);
}
//====================================================================================================
//пишем значения для каждой фигуры или символа
byte gabarit1[8] = {B11111111,B00000000,B11111111,B11111111,B11111111,B11111111,B00000000,B11111111};//центральные матрицы габарита
byte gabarit2[8] = {B11111111,B10000000,B10111111,B10111111,B10111111,B10111111,B10000000,B11111111};//левая матрица габарита
byte gabarit3[8] = {B11111111,B00000001,B11111101,B11111101,B11111101,B11111101,B00000001,B11111111};//правая матрица габарита
//====================================================================================================
byte pravo1[8] = {B00001000,B00001100,B01111110,B01111111,B01111111,B01111110,B00001100,B00001000};//правый поворот
//====================================================================================================                 
byte levo1[8] =  {B00010000,B00110000,B01111110,B11111110,B11111110,B01111110,B00110000,B00010000};//левый поворот
//====================================================================================================                 
byte S[8] = {B00000000,B00111100,B01100110,B01100000,B01100000,B01100110,B00111100,B00000000};//стоп простой
byte T[8] = {B00000000,B01111110,B00011000,B00011000,B00011000,B00011000,B00011000,B00000000};
byte O[8] = {B00000000,B00111100,B01100110,B01100110,B01100110,B01100110,B00111100,B00000000};
byte P[8] = {B00000000,B01111110,B01100110,B01100110,B01100110,B01100110,B01100110,B00000000};
//====================================================================================================
byte Si[8] = {B11111111,B11000011,B10011001,B10011111,B10011111,B10011001,B11000011,B11111111};//стоп с инверсией
byte Ti[8] = {B11111111,B10000001,B11100111,B11100111,B11100111,B11100111,B11100111,B11111111};
byte Oi[8] = {B11111111,B11000011,B10011001,B10011001,B10011001,B10011001,B11000011,B11111111};
byte Pi[8] = {B11111111,B10000001,B10011001,B10011001,B10011001,B10011001,B10011001,B11111111};
//====================================================================================================
void pusto(){//стираем всё
   lc.clearDisplay(0);
   lc.clearDisplay(1);
   lc.clearDisplay(2);
   lc.clearDisplay(3);
}
//====================================================================================================
void STOP(){//задаём параметры для стопа
  byte i;
  for(i=0;i<=7;i++) lc.setRow(0, i, Pi[i]);
  for(i=0;i<=7;i++) lc.setRow(1, i, Oi[i]);
  for(i=0;i<=7;i++) lc.setRow(2, i, Ti[i]);
  for(i=0;i<=7;i++) lc.setRow(3, i, Si[i]);
  delay(delaytime2);
  for(i=0;i<=7;i++) lc.setRow(0, i, P[i]);
  for(i=0;i<=7;i++) lc.setRow(1, i, O[i]);
  for(i=0;i<=7;i++) lc.setRow(2, i, T[i]);
  for(i=0;i<=7;i++) lc.setRow(3, i, S[i]);
  delay(delaytime2);
  pusto();
  for(i=0;i<=7;i++) lc.setRow(0, i, Pi[i]);
  for(i=0;i<=7;i++) lc.setRow(1, i, Oi[i]);
  for(i=0;i<=7;i++) lc.setRow(2, i, Ti[i]);
  for(i=0;i<=7;i++) lc.setRow(3, i, Si[i]);
}
//====================================================================================================
void gabarit(){
  byte i;
  for(i=0;i<=7;i++) lc.setRow(0, i, gabarit3[i]);
  for(i=0;i<=7;i++) lc.setRow(1, i, gabarit1[i]);
  for(i=0;i<=7;i++) lc.setRow(2, i, gabarit1[i]);
  for(i=0;i<=7;i++) lc.setRow(3, i, gabarit2[i]);
}
//====================================================================================================
void pravo(){
  byte i;
  for(i=0;i<=3;i++) lc.clearDisplay(i);
  delay(delaytime2);
  for(i=0;i<=7;i++) lc.setRow(3, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(2, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(1, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(0, i, pravo1[i]);
  for(i=0;i<=3;i++){
  delay(delaytime3);
  lc.clearDisplay(3-i);
 }
}
//====================================================================================================
void levo(){
  byte i;
  for(i=0;i<=3;i++) lc.clearDisplay(i);
  delay(delaytime2);
  for(i=0;i<=7;i++) lc.setRow(0, i, levo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(1, i, levo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(2, i, levo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(3, i, levo1[i]);
  for(i=0;i<=3;i++){
    delay(delaytime3);
    lc.clearDisplay(i);
  }
}
//====================================================================================================
void loop() {


 if (digitalRead(STOP_button)  == LOW && digitalRead(gabarit_button) == LOW)        // если на входе логическая елиница включаем светодиоды, ноль гасим
      {STOP();}
 if (digitalRead(STOP_button) == LOW && digitalRead(gabarit_button) == HIGH)      
      {STOP();}
 if (digitalRead(STOP_button) == HIGH && digitalRead(gabarit_button) == LOW)      
      {gabarit();} 
 if (digitalRead(STOP_button)  == LOW && digitalRead(levo_button)  == LOW && digitalRead(gabarit_button)  == LOW)  
      {STOP();}
 if (digitalRead(STOP_button) == LOW && digitalRead(pravo_button)  == LOW && digitalRead(gabarit_button)  == LOW)       
      {STOP();}
 if (digitalRead(levo_button)  == LOW)      
      {levo();}
 if (digitalRead(levo_button) == HIGH && digitalRead(gabarit_button) == LOW)      
      {gabarit();}  
 if (digitalRead(pravo_button)  == LOW )       
      {pravo();}
 if (digitalRead(pravo_button) == HIGH && digitalRead(gabarit_button) == LOW)      
      {gabarit();}  
 if (digitalRead(gabarit_button)  == LOW && digitalRead(levo_button)  == LOW)  
      {levo();}
 if (digitalRead(gabarit_button) == LOW && digitalRead(pravo_button)  == LOW)      
      {pravo();}
 if (digitalRead(gabarit_button) == LOW)
      {gabarit();}
 else
      {pusto();}     


}

Много лишнего.

void loop() {
  if      (!digitalRead(STOP_button)   ) STOP();
  else if (!digitalRead(gabarit_button)) gabarit();
  else if (!digitalRead(levo_button)   ) levo();
  else if (!digitalRead(pravo_button)  ) pravo();
  else pusto();
}

Пока так, это ещё тоже привязано к синхронности функций, но впоследствии запускающий код будет не сложнее. Ключевой момент - каждое из условий описывается один раз, и вызов функций тоже должен делаться один раз. Иначе никакого мозга не хватит чтобы понять, мы же люди а не отладчики.

Ещё один момент по длине кода - массивы Si,Ti,Oi,Pi и S,T,O,P взаимно инверсны, то есть отличаются только тем что вместо 0 будет 1 и наоборот. Поэтому там где надо выводить Si,Ti,Oi,Pi, можно вывести инвертированные массивы S,T,O,P, а Si,Ti,Oi,Pi удалить. Это делается побитовым "не", оператор ~:

void STOP(){//задаём параметры для стопа
  byte i;
  for(i=0;i<=7;i++) lc.setRow(0, i, ~P[i]);
  for(i=0;i<=7;i++) lc.setRow(1, i, ~O[i]);
  for(i=0;i<=7;i++) lc.setRow(2, i, ~T[i]);
  for(i=0;i<=7;i++) lc.setRow(3, i, ~S[i]);
  delay(delaytime2);
  for(i=0;i<=7;i++) lc.setRow(0, i, P[i]);
  for(i=0;i<=7;i++) lc.setRow(1, i, O[i]);
  for(i=0;i<=7;i++) lc.setRow(2, i, T[i]);
  for(i=0;i<=7;i++) lc.setRow(3, i, S[i]);
  delay(delaytime2);
  pusto();
  for(i=0;i<=7;i++) lc.setRow(0, i, ~P[i]);
  for(i=0;i<=7;i++) lc.setRow(1, i, ~O[i]);
  for(i=0;i<=7;i++) lc.setRow(2, i, ~T[i]);
  for(i=0;i<=7;i++) lc.setRow(3, i, ~S[i]);
}

Дружище огромное спасбо что помогаешь начнающим в этом нелегком деле =) Могу скромненько, но все же   отблагодарть {давай номер карты,переведу тебе моё спасибо за то что не отказался помоч =)} И еще есть вопросик, а как сделать что бы стоп мгнул при нажатии

void STOP(){//задаём параметры для стопа
  byte i;
  for(i=0;i<=7;i++) lc.setRow(0, i, ~P[i]);
  for(i=0;i<=7;i++) lc.setRow(1, i, ~O[i]);
  for(i=0;i<=7;i++) lc.setRow(2, i, ~T[i]);
  for(i=0;i<=7;i++) lc.setRow(3, i, ~S[i]);
  delay(delaytime2);
  for(i=0;i<=7;i++) lc.setRow(0, i, P[i]);
  for(i=0;i<=7;i++) lc.setRow(1, i, O[i]);
  for(i=0;i<=7;i++) lc.setRow(2, i, T[i]);
  for(i=0;i<=7;i++) lc.setRow(3, i, S[i]);
  delay(delaytime2);

и потом просто остался гореть 

void STOP(){//задаём параметры для стопа
  byte i;
  for(i=0;i<=7;i++) lc.setRow(0, i, ~P[i]);
  for(i=0;i<=7;i++) lc.setRow(1, i, ~O[i]);
  for(i=0;i<=7;i++) lc.setRow(2, i, ~T[i]);
  for(i=0;i<=7;i++) lc.setRow(3, i, ~S[i]);
}

эти два состояния нужно разделить в разные void STOP или как?

Попробуйте для цикла "for(i=3;i>=0;i--){" переменную i объявить не byte, а int или int8_t - т. е. как знаковое целое. Натыкался на такое - для i == 0, после i--, значение i становилось 255. В результате получался бесконечный цикл.

fogary, да уже решили проблему ведь.

dj-toxa, делаем глобальную (снаружи setup, loop) переменную с состоянием false:

bool stopflag=0;

по кнопке - не трогаем, но по отпусканию сбрасываем - пока так (возможно код поменяется):

void loop() {
  if (!digitalRead(STOP_button)) STOP();
  else{
    stopflag=0;
    if (!digitalRead(gabarit_button)) gabarit();
    else if (!digitalRead(levo_button)) levo();
    else if (!digitalRead(pravo_button)) pravo();
    else pusto();
  }
}

В функции смотрим переменную, если была false - мигаем и ставим в true, если уже true то просто светим:

void STOP(){//задаём параметры для стопа
  byte i;
  if(!stopflag){
    stopflag=1;
    for(i=0;i<=7;i++) lc.setRow(0, i, ~P[i]);
    for(i=0;i<=7;i++) lc.setRow(1, i, ~O[i]);
    for(i=0;i<=7;i++) lc.setRow(2, i, ~T[i]);
    for(i=0;i<=7;i++) lc.setRow(3, i, ~S[i]);
    delay(delaytime2);
    for(i=0;i<=7;i++) lc.setRow(0, i, P[i]);
    for(i=0;i<=7;i++) lc.setRow(1, i, O[i]);
    for(i=0;i<=7;i++) lc.setRow(2, i, T[i]);
    for(i=0;i<=7;i++) lc.setRow(3, i, S[i]);
    delay(delaytime2);
    pusto();
  }else{
    for(i=0;i<=7;i++) lc.setRow(0, i, ~P[i]);
    for(i=0;i<=7;i++) lc.setRow(1, i, ~O[i]);
    for(i=0;i<=7;i++) lc.setRow(2, i, ~T[i]);
    for(i=0;i<=7;i++) lc.setRow(3, i, ~S[i]);
  }
}

Если что false=0, true=1. Мне длинные слова лень писать :)

ЯД 410011919696337.

Вот я подброшу код . Может вам поможет разабраться в матрице и "забить" на основную библиотеку.

Полный скетч здесь https://yadi.sk/d/3Lqq_OPv3GHryE

Головной файл 

/*Wire_Max7219.ino  
*/
#include "Cl_Wire_Max7219.h"
#include "Cl_Matrix_Max7219.h"
const byte DOUT_pin = 2;
const byte CLK_pin = 4;
const byte CS_pin = 3;
Cl_Wire_Max7219 wire(DOUT_pin, CLK_pin, CS_pin);
Cl_Matrix_Max7219 Matrix(& wire);
void setup() {
  Matrix.setup();
  Matrix.write(40);// вставьте числа от 0 до 40
}

void loop() {

}

кинул вроде сюда ЯД 410011919696337 =) пока разобрался что да где =) хз ни когда на эти яндекс кошельки не кидал и не пользовался. проще с карты на карту)) по такому варианту я понимаю он будет мигать а потом останется гореть после отпускания кнопки, я немного другое имел ввиду. нажал кнопку он (мигнул 1-2 раза к примеру) и потом просто загорелся, кнопка всё еще нажата. отпустил кнопку ко выключился. 

dj-toxa, не совсем. Следим за мыслью:

Idle. мотаем цикл.

Жмут габарит. Кнопка стопа 1, цикл уходит в else, скидывает флаг, делает дела по габариту. И так для остальных двух кнопок.

Жмут стоп. Условие попадёт в первую ветку (true), остальные проигнорируются. Функция выполнится когда флаг 0. Внутри функции она смотрит что флаг 0, ставит 1, мигает, выходит. Следующий loop(), но флаг уже 1 и кнопку не отпустили, соответственно условие не сможет попасть в else, не сможет сбросить флаг. Опять делает функцию, она смотрит что флаг 1 и просто светит. Следующий loop() и повторяется. И в следующем повторяется пока не отпустят кнопку.

Отпустили, тут же флаг 0. Ничего не нажато, по условиям цикл уходит в else else и до самого конца, а там очистка экрана. Так что всё вызывается только пока кнопки. Не жмут ни одну кнопку - будет pusto(). Думайте в 4х измерениях пространственно-временного континуума, как-то так.

Ну ты нагрузил конечно со своим пространственно-временным континуумом и так ни чего не понятно,а тут еще такое =)

Щютка йумора™.

Вот мои наброски лежат здесь https://yadi.sk/d/UJii_RcC3GL8T6. файл знакогенератора у меня кривой, так что если кому надо подпрвьте себе . Ну и головной файл выкладываю. Код рабочий проверял сам.

/*Wire_Max7219_v2.ino 
   подключена матрица с 2,3,4
   кнопка 1->5
   кнопка 2->6
   кнопка 3->8
   кнопка 4->9
*/
#include "Cl_Wire_Max7219.h"
#include "Cl_Matrix_Max7219.h"
const byte DOUT_pin = 2;
const byte CLK_pin = 4;
const byte CS_pin = 3;
Cl_Wire_Max7219 wire(DOUT_pin, CLK_pin, CS_pin, 4); // создать шину из 4 послед соед Max7219
Cl_Matrix_Max7219 Matrix1(& wire, 1); // поставить Matrix1 первой
Cl_Matrix_Max7219 Matrix2(& wire, 2); // поставить Matrix2 второй
Cl_Matrix_Max7219 Matrix3(& wire, 3); // поставить Matrix3 третей
Cl_Matrix_Max7219 Matrix4(& wire, 4); // поставить Matrix4 четвертой
// кнопка 1
#include "Cl_pinin.h"
#include "Cl_do_btn.h"
Cl_pinin In1(5); // сделать вывод 5 входным
void Do_Btn1() {
  Matrix1.blink_OFF();
  Matrix2.blink_OFF();
  Matrix3.blink_OFF();
  Matrix4.blink_OFF();
  Matrix1.write(0x31);// напечатать на 1 матрице '1'    =0x31
  Matrix2.write(0x31);// напечатать на 2 матрице '1'    =0x31
  Matrix3.write(0x31);// напечатать на 3 матрице '1'    =0x31
  Matrix4.write(0x31);// напечатать на 4 матрице '1'    =0x31
}
Cl_do_btn  Btn1(&In1, 0,// подключить к шине кнопку / шина уровень когда кнопка нажата
                & Do_Btn1); // функция выполняющая при нажатии
// кнопка 2
Cl_pinin In2(6); // сделать вывод 6 входным
void Do_Btn2() {
  Matrix1.writeON(0x32); // печатать при вкл на 1 матрице '2'    =0x32
  Matrix1.writeOFF(0x20);// напечатать при выкл на 1 матрице ' ' =0x20
  Matrix2.writeON(0x32); // печатать при вкл на 2 матрице '2'    =0x32
  Matrix2.writeOFF(0x20);// напечатать при выкл на 2 матрице ' ' =0x20
  Matrix3.writeON(0x32); // печатать при вкл на 3 матрице '2'    =0x32
  Matrix3.writeOFF(0x20);// напечатать при выкл на 3 матрице ' ' =0x20
  Matrix4.writeON(0x32); // печатать при вкл на 4 матрице '2'    =0x32
  Matrix4.writeOFF(0x20);// напечатать при выкл на 4 матрице ' ' =0x20
  Matrix1.blink(200);// 0,2 сек вкл 0,2 сек выкл
  Matrix2.blink(200);// 0,2 сек вкл 0,2 сек выкл
  Matrix3.blink(200);// 0,2 сек вкл 0,2 сек выкл
  Matrix4.blink(200);// 0,2 сек вкл 0,2 сек выкл

}
Cl_do_btn  Btn2(&In2, 0,// подключить к шине кнопку / шина уровень когда кнопка нажата
                & Do_Btn2); // функция выполняющая при нажатии
// кнопка 3
Cl_pinin In3(8); // сделать вывод 8 входным
void Do_Btn3() {
  Matrix1.writeON(0x33); // печатать при вкл на 1 матрице '3'    =0x33
  Matrix1.writeOFF(0x20);// напечатать при выкл на 1 матрице ' ' =0x20
  Matrix2.writeON(0x33); // печатать при вкл на 2 матрице '3'    =0x33
  Matrix2.writeOFF(0x20);// напечатать при выкл на 2 матрице ' ' =0x20
  Matrix3.writeON(0x33); // печатать при вкл на 3 матрице '3'    =0x33
  Matrix3.writeOFF(0x20);// напечатать при выкл на 4 матрице ' ' =0x20
  Matrix4.writeON(0x33); // печатать при вкл на 4 матрице '3'    =0x33
  Matrix4.writeOFF(0x20);// напечатать при выкл на 4 матрице ' ' =0x20
  Matrix1.blink(500);// 0,5 сек вкл 0,5 сек выкл
  Matrix2.blink(500);// 0,5 сек вкл 0,5 сек выкл
  Matrix3.blink(500);// 0,5 сек вкл 0,5 сек выкл
  Matrix4.blink(500);// 0,5 сек вкл 0,5 сек выкл
}
Cl_do_btn  Btn3(&In3, 0,// подключить к шине кнопку / шина уровень когда кнопка нажата
                & Do_Btn3); // функция выполняющая при нажатии
// кнопка 4
Cl_pinin In4(9); // сделать вывод 9 входным
void Do_Btn4() {
  Matrix1.blink_OFF();
  Matrix2.blink_OFF();
  Matrix3.blink_OFF();
  Matrix4.blink_OFF();
  Matrix1.write(0x34);// напечатать на 1 матрице '4' =0x34
  Matrix2.write(0x34);// напечатать на 2 матрице '4' =0x34
  Matrix3.write(0x34);// напечатать на 3 матрице '4' =0x34
  Matrix4.write(0x34);// напечатать на 4 матрице '4' =0x34
}
Cl_do_btn  Btn4(&In4, 0,// подключить к шине кнопку / шина уровень когда кнопка нажата
                & Do_Btn4); // функция выполняющая при нажатии
void setup() {
  wire.setup();
  Matrix1.setup();
  Matrix2.setup();
  Matrix3.setup();
  Matrix4.setup();
  Matrix1.write(0x31);// напечатать на 1 матрице '1' =0x31
  Matrix2.write(0x32);// напечатать на 2 матрице '2' =0x32
  Matrix3.write(0x33);// напечатать на 3 матрице '3' =0x33
  Matrix4.write(0x34);// напечатать на 4 матрице '4' =0x34
  Btn1.setup();
  Btn2.setup();
  Btn3.setup();
  Btn4.setup();
}

void loop() {
  Matrix1.loop();
  Matrix2.loop();
  Matrix3.loop();
  Matrix4.loop();
  Btn1.loop();
  Btn2.loop();
  Btn3.loop();
  Btn4.loop();
}

qwone, а массив из Matrix слабо было сделать?

Тогда и из кнопок тоже можно. Но не хочется городить в сетапе и в лупе переборы этих массивов.

Ну да, прямое перечисление всех элементов массива - это, коначно, намного проще, чем перебор в цикле.

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

тоже интерено, тут только другие библиотеки я так понимаю, интересно как одни с другими дружат.

я вот пробовал подружить arduino-Max72xxPanel и LedControl что то не получается ((

А зачем. Мне большинство библиотек бесполезны. Так что приходится самому ручками. Зато позже мне мои же наработки помогают. И я не думаю как их совместить.

/*Wire_Max7219.ino  
   подключена матрица с 2,3,4
   кнопка 1->5
   кнопка 2->6
   кнопка 3->8
   кнопка 4->9
*/
#include "Cl_Wire_Max7219.h"
#include "Cl_Matrix_Max7219.h"
const byte DOUT_pin = 2;
const byte CLK_pin = 4;
const byte CS_pin = 3;
Cl_Wire_Max7219 wire(DOUT_pin, CLK_pin, CS_pin, 4); // создать шину из 4 послед соед Max7219
Cl_Matrix_Max7219 Matrix[] = {
  {& wire, 1}, // поставить Matrix[0] первой
  {& wire, 2}, // поставить Matrix[1] второй
  {& wire, 3}, // поставить Matrix[2] третей
  {& wire, 4}  // поставить Matrix[3] четвертой
};
// кнопки 1,2,3,4
void Do_Btn1() {
  Matrix[0].blink_OFF();
  Matrix[1].blink_OFF();
  Matrix[2].blink_OFF();
  Matrix[3].blink_OFF();
  Matrix[0].write(0x31);// напечатать на 1 матрице '1'    =0x31
  Matrix[1].write(0x31);// напечатать на 2 матрице '1'    =0x31
  Matrix[2].write(0x31);// напечатать на 3 матрице '1'    =0x31
  Matrix[3].write(0x31);// напечатать на 4 матрице '1'    =0x31
}
void Do_Btn2() {
  Matrix[0].writeON(0x32); // печатать при вкл на 1 матрице '2'    =0x32
  Matrix[0].writeOFF(0x20);// напечатать при выкл на 1 матрице ' ' =0x20
  Matrix[1].writeON(0x32); // печатать при вкл на 2 матрице '2'    =0x32
  Matrix[1].writeOFF(0x20);// напечатать при выкл на 2 матрице ' ' =0x20
  Matrix[2].writeON(0x32); // печатать при вкл на 3 матрице '2'    =0x32
  Matrix[2].writeOFF(0x20);// напечатать при выкл на 3 матрице ' ' =0x20
  Matrix[3].writeON(0x32); // печатать при вкл на 4 матрице '2'    =0x32
  Matrix[3].writeOFF(0x20);// напечатать при выкл на 4 матрице ' ' =0x20
  Matrix[0].blink(200);// 0,2 сек вкл 0,2 сек выкл
  Matrix[1].blink(200);// 0,2 сек вкл 0,2 сек выкл
  Matrix[2].blink(200);// 0,2 сек вкл 0,2 сек выкл
  Matrix[3].blink(200);// 0,2 сек вкл 0,2 сек выкл

}
void Do_Btn3() {
  Matrix[0].writeON(0x33); // печатать при вкл на 1 матрице '3'    =0x33
  Matrix[0].writeOFF(0x20);// напечатать при выкл на 1 матрице ' ' =0x20
  Matrix[1].writeON(0x33); // печатать при вкл на 2 матрице '3'    =0x33
  Matrix[1].writeOFF(0x20);// напечатать при выкл на 2 матрице ' ' =0x20
  Matrix[2].writeON(0x33); // печатать при вкл на 3 матрице '3'    =0x33
  Matrix[2].writeOFF(0x20);// напечатать при выкл на 4 матрице ' ' =0x20
  Matrix[3].writeON(0x33); // печатать при вкл на 4 матрице '3'    =0x33
  Matrix[3].writeOFF(0x20);// напечатать при выкл на 4 матрице ' ' =0x20
  Matrix[0].blink(500);// 0,5 сек вкл 0,5 сек выкл
  Matrix[1].blink(500);// 0,5 сек вкл 0,5 сек выкл
  Matrix[2].blink(500);// 0,5 сек вкл 0,5 сек выкл
  Matrix[3].blink(500);// 0,5 сек вкл 0,5 сек выкл
}
void Do_Btn4() {
  Matrix[0].blink_OFF();
  Matrix[1].blink_OFF();
  Matrix[2].blink_OFF();
  Matrix[3].blink_OFF();
  Matrix[0].write(0x34);// напечатать на 1 матрице '4' =0x34
  Matrix[1].write(0x34);// напечатать на 2 матрице '4' =0x34
  Matrix[2].write(0x34);// напечатать на 3 матрице '4' =0x34
  Matrix[3].write(0x34);// напечатать на 4 матрице '4' =0x34
}
#include "Cl_pinin.h"
#include "Cl_do_btn.h"
Cl_pinin In[] = {
  Cl_pinin(5), // сделать вывод 5 входным
  Cl_pinin(6), // сделать вывод 6 входным
  Cl_pinin(8), // сделать вывод 8 входным
  Cl_pinin(9) // сделать вывод 9 входным
};
Cl_do_btn  Btn[] = {
  Cl_do_btn(  &In[0], 0,  // подключить к шине кнопку / шина уровень когда кнопка нажата
  & Do_Btn1),          // функция выполняющая при нажатии
  Cl_do_btn(  &In[1], 0, // подключить к шине кнопку / шина уровень когда кнопка нажата
  & Do_Btn2),          // функция выполняющая при нажатии
  Cl_do_btn(  &In[2], 0, // подключить к шине кнопку / шина уровень когда кнопка нажата
  & Do_Btn3),          // функция выполняющая при нажатии
  Cl_do_btn(  &In[3], 0, // подключить к шине кнопку / шина уровень когда кнопка нажата
  & Do_Btn4)           // функция выполняющая при нажатии
};

void setup() {
  wire.setup();
  Matrix[0].setup();
  Matrix[1].setup();
  Matrix[2].setup();
  Matrix[3].setup();
  Matrix[0].write(0x31);// напечатать на 1 матрице '1' =0x31
  Matrix[1].write(0x32);// напечатать на 2 матрице '2' =0x32
  Matrix[2].write(0x33);// напечатать на 3 матрице '3' =0x33
  Matrix[3].write(0x34);// напечатать на 4 матрице '4' =0x34
  Btn[0].setup();
  Btn[1].setup();
  Btn[2].setup();
  Btn[3].setup();
}
void loop() {
  Matrix[0].loop();
  Matrix[1].loop();
  Matrix[2].loop();
  Matrix[3].loop();
  Btn[0].loop();
  Btn[1].loop();
  Btn[2].loop();
  Btn[3].loop();
}

Вот на основе массивов

Я так понял, что намекать на циклы с моей стороны уже будет неэтично.

неправославно

не, надо в пяти, так как у времени два измерения, прошлое и будущее, настоящего то по сути и нет...

"есть только МИГ между прошлым и будущим, именно он называется жизнь"

И живем мы в 6-мерном пространстве: вперед, назад, влево, вправо, вверх и вниз.

в семимерном - 7-я ось время. но перемещаться мы по этой оси можем только в одну сторону, но есть варианты разной скорости.

Что Вы моежете и что не можете - это Ваши личные проблемы.

Если к шестимерному пространству добавляем время, пространство-время становится восьмимерным.

по эксплуатировал я данный фонарь

#include "LedControl.h"//подключаем библиотеку LedControl.h
#define STOP_button 2
#define gabarit_button 3
#define levo_button 5
#define pravo_button 7
//====================================================================================================
bool stopflag=0;
//====================================================================================================
LedControl lc = LedControl(11, 13, 10, 4);//к D11 подключаем DIN, к D13 подключаем CLK, к D10 подключаем CS
//====================================================================================================
unsigned long delaytime = 1000;//временные переменные delay
unsigned long delaytime2 = 30;
unsigned long delaytime3 = 100;
// =========================================================================
void setup() {  //задаём параметры матриц и кнопок
  byte i;
  for(i=0;i<=7;i++){
  lc.shutdown(i, false);
  lc.setIntensity(i, 5);
  lc.clearDisplay(i);}
  pinMode(2,INPUT_PULLUP);
  pinMode(3,INPUT_PULLUP);
  pinMode(5,INPUT_PULLUP);
  pinMode(7,INPUT_PULLUP);}
//===================================================================================================//задаём значения для каждой фигуры или символа
byte gabarit1[8] = {B11111111,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B11111111};//центральные матрицы габарита
byte gabarit2[8] = {B11111111,B10000000,B10000000,B10000000,B10000000,B10000000,B10000000,B11111111};//левая матрица габарита
byte gabarit3[8] = {B11111111,B00000001,B00000001,B00000001,B00000001,B00000001,B00000001,B11111111};//правая матрица габарита
//====================================================================================================
byte pravo1[8] = {B00001000,B00001100,B01111110,B01111111,B01111111,B01111110,B00001100,B00001000};//правый поворот
//====================================================================================================                 
byte levo1[8] =  {B00010000,B00110000,B01111110,B11111110,B11111110,B01111110,B00110000,B00010000};//левый поворот
//====================================================================================================                 
byte S[8] = {B00000000,B00111100,B01100110,B01100000,B01100000,B01100110,B00111100,B00000000};//стоп простой
byte T[8] = {B00000000,B01111110,B00011000,B00011000,B00011000,B00011000,B00011000,B00000000};
byte O[8] = {B00000000,B00111100,B01100110,B01100110,B01100110,B01100110,B00111100,B00000000};
byte P[8] = {B00000000,B01111110,B01100110,B01100110,B01100110,B01100110,B01100110,B00000000};
//====================================================================================================
/*
byte Si[8] = {B11111111,B11000011,B10011001,B10011111,B10011111,B10011001,B11000011,B11111111};//стоп с инверсией
byte Ti[8] = {B11111111,B10000001,B11100111,B11100111,B11100111,B11100111,B11100111,B11111111};
byte Oi[8] = {B11111111,B11000011,B10011001,B10011001,B10011001,B10011001,B11000011,B11111111};
byte Pi[8] = {B11111111,B10000001,B10011001,B10011001,B10011001,B10011001,B10011001,B11111111};
*/
//====================================================================================================
void pusto(){//стираем всё
  lc.clearDisplay(0);  
  lc.clearDisplay(1); 
  lc.clearDisplay(2); 
  lc.clearDisplay(3);}
//====================================================================================================
void STOP(){//задаём параметры для стопа
  byte i;
  if(!stopflag){
    stopflag=1;
    for(i=0;i<=7;i++) lc.setRow(0, i, ~P[i]);
    for(i=0;i<=7;i++) lc.setRow(1, i, ~O[i]);
    for(i=0;i<=7;i++) lc.setRow(2, i, ~T[i]);
    for(i=0;i<=7;i++) lc.setRow(3, i, ~S[i]);
    delay(delaytime2);
    for(i=0;i<=7;i++) lc.setRow(0, i, P[i]);
    for(i=0;i<=7;i++) lc.setRow(1, i, O[i]);
    for(i=0;i<=7;i++) lc.setRow(2, i, T[i]);
    for(i=0;i<=7;i++) lc.setRow(3, i, S[i]);
    delay(delaytime2);
    for(i=0;i<=7;i++) lc.setRow(0, i, ~P[i]);
    for(i=0;i<=7;i++) lc.setRow(1, i, ~O[i]);
    for(i=0;i<=7;i++) lc.setRow(2, i, ~T[i]);
    for(i=0;i<=7;i++) lc.setRow(3, i, ~S[i]);
    delay(delaytime2);
    for(i=0;i<=7;i++) lc.setRow(0, i, P[i]);
    for(i=0;i<=7;i++) lc.setRow(1, i, O[i]);
    for(i=0;i<=7;i++) lc.setRow(2, i, T[i]);
    for(i=0;i<=7;i++) lc.setRow(3, i, S[i]);
    delay(delaytime2);
    pusto();}
    else{
    for(i=0;i<=7;i++) lc.setRow(0, i, ~P[i]);
    for(i=0;i<=7;i++) lc.setRow(1, i, ~O[i]);
    for(i=0;i<=7;i++) lc.setRow(2, i, ~T[i]);
    for(i=0;i<=7;i++) lc.setRow(3, i, ~S[i]);}
}
//====================================================================================================
void gabarit(){//задаём параметры для габарита
  byte i;
  for(i=0;i<=7;i++) lc.setRow(0, i, gabarit3[i]);
  for(i=0;i<=7;i++) lc.setRow(1, i, gabarit1[i]);
  for(i=0;i<=7;i++) lc.setRow(2, i, gabarit1[i]);
  for(i=0;i<=7;i++) lc.setRow(3, i, gabarit2[i]);
}
//====================================================================================================
void pravo(){//задаём параметры для правого поворота
  byte i;
  for(i=0;i<=3;i++) lc.clearDisplay(i);
  delay(delaytime2);
  for(i=0;i<=7;i++) lc.setRow(3, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(2, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(1, i, pravo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(0, i, pravo1[i]);
  for(i=0;i<=3;i++){
  delay(delaytime3);
  lc.clearDisplay(3-i);}
}
//====================================================================================================
void levo(){//задаём параметры для левого поворота
  byte i;
  for(i=0;i<=3;i++) lc.clearDisplay(i);
  delay(delaytime2);
  for(i=0;i<=7;i++) lc.setRow(0, i, levo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(1, i, levo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(2, i, levo1[i]);
  delay(delaytime3);
  for(i=0;i<=7;i++) lc.setRow(3, i, levo1[i]);
  for(i=0;i<=3;i++){
  delay(delaytime3);
  lc.clearDisplay(i);}
}
//====================================================================================================
void loop() {
  if (!digitalRead(STOP_button)) STOP();
  else{
    stopflag=0;
    if (!digitalRead(levo_button)) levo();
    else if (!digitalRead(pravo_button)) pravo();
    else if (!digitalRead(gabarit_button)) gabarit();
    else pusto();}
}

все отлично, НО захотелось избавиться от проводов. был куплен rf-приемник и передатчик вот такой https://ru.aliexpress.com/item/433-Mhz-Wireless-Receiver-and-Transmitter-Remote-Control-Learning-Code-1527-Decoding-Module-4-Ch-output/32699867811.html?spm=2114.13010708.0.0.8Hm4c0 ршил подкинуть это дело на уровне железа. поскольку у меня кнопки включения срабатывали при подаче на пин 0(GND), а rf-приёмник выдает на выходных пинах 1, в скетче лишь поменял   pinMode(2,INPUT_PULLUP) на pinMode(2,INPUT) и т.д. и подтянул пины к GND через сопротивления 8-10кОм. но чет не фурычит, потоянно горит стоп, а при нажатии на стоп мигает левый поворот. габарит, левый и правый повороты не реагируют вообще. где я промотался?