Помогите разобраться с кодом, что делаю не так?

dj-toxa
Offline
Зарегистрирован: 06.04.2016

Arduino только познаю, так что сильно не пинайте. Застрял вроде на элементарном, нужно прикрутить к скетчу четыре кнопки которые при замыкании пина на GND будут выводить то или иное изображение на матрицу 8*32. Мои попытки это сделать удались лишь на 50% не пойму где что упустил или не так делаю ткните носом уважаемые гуру ))

#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(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(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(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);}
//====================================================================================================          
}              
                           

 

dj-toxa
Offline
Зарегистрирован: 06.04.2016

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

Voodoo Doll
Voodoo Doll аватар
Offline
Зарегистрирован: 18.09.2016

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

dj-toxa
Offline
Зарегистрирован: 06.04.2016

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

dj-toxa
Offline
Зарегистрирован: 06.04.2016

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

dj-toxa
Offline
Зарегистрирован: 06.04.2016

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

Voodoo Doll
Voodoo Doll аватар
Offline
Зарегистрирован: 18.09.2016

dj-toxa пишет:
то есть delay вообще убираем?

Не вообще, а заменив на систему условий, определящих "кадры" событий. Смотрим на функцию, допустим 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) не люблю.

dj-toxa
Offline
Зарегистрирован: 06.04.2016

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

Voodoo Doll
Voodoo Doll аватар
Offline
Зарегистрирован: 18.09.2016

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

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

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

dj-toxa
Offline
Зарегистрирован: 06.04.2016

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

Voodoo Doll
Voodoo Doll аватар
Offline
Зарегистрирован: 18.09.2016

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

  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.

dj-toxa пишет:
сделал по аналогии для levo

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

dj-toxa
Offline
Зарегистрирован: 06.04.2016

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

01 void pravo(byte param){
02   byte i;
03   if (param != 1) return;
04   for(i=0;i<=3;i++) lc.clearDisplay(i);
05   delay(delaytime2);
06   for(i=0;i<=7;i++) lc.setRow(3, i, pravo1[i]);
07   delay(delaytime3);
08   for(i=0;i<=7;i++) lc.setRow(2, i, pravo1[i]);
09   delay(delaytime3);
10   for(i=0;i<=7;i++) lc.setRow(1, i, pravo1[i]);
11   delay(delaytime3);
12   for(i=0;i<=7;i++) lc.setRow(0, i, pravo1[i]);
13   for(i=3;i>=0;i--){
14     delay(delaytime3);
15     lc.clearDisplay(i);
16   }
17 }

 

dj-toxa
Offline
Зарегистрирован: 06.04.2016

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);
}}

 

Voodoo Doll
Voodoo Doll аватар
Offline
Зарегистрирован: 18.09.2016

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

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); 
}
и в setup() это, скажете что выводится в сериал:
Serial.begin(57600);
Serial.println(freeRam());
3. Весь скетч сюда целиком. Так. Не. Бы. Ва. Ет. Что-то, что ускользнуло от вашего внимания, воздействует на функцию, на её переменные, на вывод в экран или на условия, запускающие функцию, извне.
dj-toxa
Offline
Зарегистрирован: 06.04.2016

вот целиком в сериале 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);}
//====================================================================================================          
}              
                           

 

Voodoo Doll
Voodoo Doll аватар
Offline
Зарегистрирован: 18.09.2016

Пробуем так:

#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, не знаю... я вернусь.

fogary
Offline
Зарегистрирован: 05.03.2016

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

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

dj-toxa
Offline
Зарегистрирован: 06.04.2016

что по первому варианту, что по второму ситуация одинаковая: зажигаем 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 тухнет) и больше не горят

Voodoo Doll
Voodoo Doll аватар
Offline
Зарегистрирован: 18.09.2016

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

dj-toxa
Offline
Зарегистрирован: 06.04.2016

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

dj-toxa
Offline
Зарегистрирован: 06.04.2016

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

Voodoo Doll
Voodoo Doll аватар
Offline
Зарегистрирован: 18.09.2016

Что будет если в цикле гасить не от 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);, но тогда порядок в котором гаснет, изменится.

dj-toxa
Offline
Зарегистрирован: 06.04.2016

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

Voodoo Doll
Voodoo Doll аватар
Offline
Зарегистрирован: 18.09.2016

dj-toxa пишет:
так работает

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

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

dj-toxa
Offline
Зарегистрирован: 06.04.2016

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

dj-toxa
Offline
Зарегистрирован: 06.04.2016

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

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

 

dj-toxa
Offline
Зарегистрирован: 06.04.2016

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

dj-toxa
Offline
Зарегистрирован: 06.04.2016

мучал сегодня кнопки все равно что-то не то получается. одно не выключает другое (например включен 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();}     


}
Voodoo Doll
Voodoo Doll аватар
Offline
Зарегистрирован: 18.09.2016

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

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]);
}
dj-toxa
Offline
Зарегистрирован: 06.04.2016

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

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 или как?

fogary
Offline
Зарегистрирован: 05.03.2016

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

Voodoo Doll
Voodoo Doll аватар
Offline
Зарегистрирован: 18.09.2016

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.

qwone
qwone аватар
Offline
Зарегистрирован: 03.07.2016

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

Полный скетч здесь 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() {

}

 

dj-toxa
Offline
Зарегистрирован: 06.04.2016

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

Voodoo Doll
Voodoo Doll аватар
Offline
Зарегистрирован: 18.09.2016

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

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

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

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

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

dj-toxa
Offline
Зарегистрирован: 06.04.2016

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

Voodoo Doll
Voodoo Doll аватар
Offline
Зарегистрирован: 18.09.2016

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

qwone
qwone аватар
Offline
Зарегистрирован: 03.07.2016

Вот мои наброски лежат здесь 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();
}

 

andriano
andriano аватар
Offline
Зарегистрирован: 20.06.2015

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

qwone
qwone аватар
Offline
Зарегистрирован: 03.07.2016

andriano пишет:

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

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

andriano
andriano аватар
Offline
Зарегистрирован: 20.06.2015

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

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

dj-toxa
Offline
Зарегистрирован: 06.04.2016

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

dj-toxa
Offline
Зарегистрирован: 06.04.2016

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

qwone
qwone аватар
Offline
Зарегистрирован: 03.07.2016

dj-toxa пишет:

я вот пробовал подружить 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();
}

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

andriano
andriano аватар
Offline
Зарегистрирован: 20.06.2015

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

Клапауций 112
Offline
Зарегистрирован: 01.03.2017

andriano пишет:

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

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

ua6em
ua6em аватар
Offline
Зарегистрирован: 17.08.2016

Voodoo Doll пишет:

Думайте в 4х измерениях пространственно-временного континуума, как-то так.

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

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

andriano
andriano аватар
Offline
Зарегистрирован: 20.06.2015

ua6em пишет:

Voodoo Doll пишет:

Думайте в 4х измерениях пространственно-временного континуума, как-то так.

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

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

Клапауций 112
Offline
Зарегистрирован: 01.03.2017

andriano пишет:

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

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

andriano
andriano аватар
Offline
Зарегистрирован: 20.06.2015

Клапауций 112 пишет:

andriano пишет:

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

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

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

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