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

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 или 410011915019172.

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() {

}