Помогите понять момент из скетча

TTIIMMAA
Offline
Зарегистрирован: 09.02.2017

byte y[13] = {B11111100, B01100000, B11011010, B11110010, B01100110, B10110110, B10111110, B11100000, B11111110, B11110110, B00000001, B00000000, B11111111}; 
byte z[13] = {B11111100, B00001100, B11011010, B11110010, B01100110, B10110110, B10111110, B11100000, B11111110, B11110110, B00000001, B00000000, B11111111}; 

void setup() {
  pinMode(switchPin, INPUT); 
  pinMode(mosfetPin, OUTPUT); 
  pinMode(ledPin, OUTPUT); 
  pinMode(sensorPin, INPUT); 

  
  for (int i = 6; i <= 13; i++) 
    pinMode(i, OUTPUT);


  digitalWrite(ledPin, HIGH);
  segments(z[12]);
  delay(2000);
  digitalWrite(ledPin, LOW);
  segments(z[11]);

 

Добрый день, прошу помощи , вот кусок кода, код не мой, вроде все понятно, задаются числа и пины для индикатора, но не понятно про segments что это?, а Именно :

 digitalWrite(ledPin, HIGH);
  segments(z[12]);
  delay(2000);
  digitalWrite(ledPin, LOW);
  segments(z[11]);

Кстати изза этого кусочка скетч компиляцию не проходит

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

полный код публикуй или самостоятельно смотри код функции segments

TTIIMMAA
Offline
Зарегистрирован: 09.02.2017

Оригинал Скетча

int mosfetPin = 5;  // Pin that controls the mosfet drivers
int ledPin = 4;   // Pin to control the status led
int switchPin = 2;  // Pin to trigger a pulse with the foot switch
int sensorPin = A7;  // Pin where the potentiometer value is read
int previous_pulse_time; // Previous pulse time so display can skip to ones digit
int pulse_time;   // Variable to store the pulse time
int pulse_short;  // Variable to store the short pulse time
int displayStep = 0; // The step the display function should complete next
unsigned long previousMillis = millis(); // The milliseconds where the timer starts counting from
int tens = 0; // Tens place digit
int ones = 0; // Ones place digit

// Defines the possible characters to be displayed on the 7-segment display in an array
//            0          1          2          3          4          5          6          7          8          9          .          None       All
byte y[13] = {B11111100, B01100000, B11011010, B11110010, B01100110, B10110110, B10111110, B11100000, B11111110, B11110110, B00000001, B00000000, B11111111}; // Ones
byte z[13] = {B11111100, B00001100, B11011010, B11110010, B01100110, B10110110, B10111110, B11100000, B11111110, B11110110, B00000001, B00000000, B11111111}; // Tens


//-------------------------------------------------------------------------------------------

void setup() {
  pinMode(switchPin, INPUT); // Set switchPin as Input
  pinMode(mosfetPin, OUTPUT); // Set mosfetPin as Output
  pinMode(ledPin, OUTPUT); // Set ledPin as Output
  pinMode(sensorPin, INPUT); // Set sensorPin as Input

  // Set up 7 Segment Pins
  for (int i = 6; i <= 13; i++) // Pins 6-13 are set as Outputs
    pinMode(i, OUTPUT);

  // Light up the led and the display 2 seconds to verify correct placement and function
  digitalWrite(ledPin, HIGH);
  segments(z[12]);
  delay(2000);
  digitalWrite(ledPin, LOW);
  segments(z[11]);
}

//-------------------------------------------------------------------------------------------

void loop() {

  // Read pulse time from analog input
  read_pulse_time();

  // Display time on 7-segment display
  time_display();

  // Impulse activated by switch
  if (digitalRead(switchPin) == HIGH && pulse_time > 0) {
    double_pulse();
    // Wait until switch has been released
    do {
      digitalWrite(mosfetPin, LOW);
      digitalWrite(ledPin, LOW);
    } while (digitalRead(switchPin) == HIGH);
    // Delay before impulse can be triggered again
    delay(500);
  }
  else
  {
    digitalWrite(mosfetPin, LOW);
    digitalWrite(ledPin, LOW);
  }
}

//-------------------------------------------------------------------------------------------

void segments(byte n) {
  // controll all 7 Segments

  for (int k = 6; k <= 13; k++) {
    if ((n & B10000000) > 0)
      digitalWrite(k, HIGH);
    else
      digitalWrite(k, LOW);
    n = n << 1;
  }
}

//-------------------------------------------------------------------------------------------

void read_pulse_time() {
  // Read the potentiometer and shift the value to correct the midpoint
  // This allows 20 to be selected without the value having to be exactly 1023
  int sensorValue = analogRead(sensorPin) + 51.15/2;

  // Add a small amount of hysteresis
  if ((sensorValue - 3) / 51.15 > pulse_time) {
    // Makes a pulse of max 20 mS because SensorValue can max become 1023
    pulse_time = sensorValue / 51.15;
  }
  if ((sensorValue + 3) / 51.15 < pulse_time) {
    pulse_time = sensorValue / 51.15;
  }
}

//-------------------------------------------------------------------------------------------

void reset_timer() {
  // Set timer to start counting from current time
  previousMillis = millis();
}

//-------------------------------------------------------------------------------------------

bool delay_done(unsigned long delay) {
  // If difference between current time and previous time is more than the delay
  if ((unsigned long)(millis() - previousMillis) >= delay) {
    return true;
  }
  return false;
}

//-------------------------------------------------------------------------------------------

void time_display() { // 7 segment pulse time displaying
  if (pulse_time != previous_pulse_time) {
    previous_pulse_time = pulse_time;

    // Skip to ones digit
    displayStep = 2;
  }

  if (tens == 0) {
    // Skip to ones digit
    displayStep = 2;
  }

  tens = (pulse_time % 100) / 10; // Tens place
  ones = pulse_time % 10; // Ones place

  //delay(500);

  switch (displayStep) {
    // Display tens digit
    case 0:
      // Time to clear display after displaying both digits
      if (delay_done(400)) {
        // Display tens digit
        segments(z[tens]);

        reset_timer();
        displayStep = 1;
      }
      break;

    // Delay after showing tens digit
    case 1:
      if (delay_done(300)) {
        // Clear display
        segments(z[11]);

        displayStep = 2;
      }
      break;

    // Display ones digit
    case 2:
      segments(y[ones]);

      reset_timer();
      displayStep = 3;

      break;

    // Delay after showing ones digit
    case 3:
      if (delay_done(300)) {
        // Clear display
        segments(z[11]);

        reset_timer();
        displayStep = 0;
      }
      break;
  }
}

//-------------------------------------------------------------------------------------------

void double_pulse() {

  pulse_short = (pulse_time / 8); // Impulse with 1/8 the time of pulse_time

  if (pulse_short < 1) // Makes the short pulse at least one millisecond
    pulse_short = 1;

  digitalWrite(ledPin, HIGH);
  digitalWrite(mosfetPin, HIGH);
  delay(pulse_short);
  digitalWrite(mosfetPin, LOW);
  delay(pulse_short);
  digitalWrite(mosfetPin, HIGH);
  delay(pulse_time);
  digitalWrite(mosfetPin, LOW);

  // Keep LED on for extra 50ms
  delay(50);
  digitalWrite(ledPin, LOW);

}

 

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

ну, и где ошибку выдаёт?

Скетч использует 2926 байт (47%) памяти устройства. Всего доступно 6144 байт.
Глобальные переменные используют 51 байт (2%) динамической памяти, оставляя 1997 байт для локальных переменных. Максимум: 2048 байт.

 

Mr.Privet
Mr.Privet аватар
Offline
Зарегистрирован: 17.11.2015

Перенесите строки 69-81 выше setup то есть на место 20 строки

TTIIMMAA
Offline
Зарегистрирован: 09.02.2017

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

ну, и где ошибку выдаёт?

Скетч использует 2926 байт (47%) памяти устройства. Всего доступно 6144 байт.
Глобальные переменные используют 51 байт (2%) динамической памяти, оставляя 1997 байт для локальных переменных. Максимум: 2048 байт.

 

Странно, хотел попробовать залить оригинал, перед тем как под себя Скетч редактировать, но он не прошел компиляцию, кстати этот проект в оригинале под Arduino nano, а у меня UNO R3 , возможно что в этом дело? хотя мне кажется разницы то нет

TTIIMMAA
Offline
Зарегистрирован: 09.02.2017

Mr.Privet пишет:

Перенесите строки 69-81 выше setup то есть на место 20 строки

Сделать то это просто, дома буду попробую, Спасибо

Но и хотелось бы понимать смысл зачем нужно перенести?

ЕвгенийП
ЕвгенийП аватар
Offline
Зарегистрирован: 25.05.2015

TTIIMMAA пишет:

Но и хотелось бы понимать смысл зачем нужно перенести?

Функция должна быть описана ДО использования, а у Вас функция segments описана в строках 69-79, а используется в строке 33 (и далее). В некоторых версиях IDE такие фокусы проходят, в некоторых нет.

Если писать правильно, то работает всегда.

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

ЕвгенийП пишет:

В некоторых версиях IDE такие фокусы проходят, в некоторых нет.

верно - я запретил.

valera678
Offline
Зарегистрирован: 04.11.2016

TTIIMMAA пишет:

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

ну, и где ошибку выдаёт?

Скетч использует 2926 байт (47%) памяти устройства. Всего доступно 6144 байт.
Глобальные переменные используют 51 байт (2%) динамической памяти, оставляя 1997 байт для локальных переменных. Максимум: 2048 байт.

 

Странно, хотел попробовать залить оригинал, перед тем как под себя Скетч редактировать, но он не прошел компиляцию, кстати этот проект в оригинале под Arduino nano, а у меня UNO R3 , возможно что в этом дело? хотя мне кажется разницы то нет

в версии 1.0.6 компилируется

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

valera678 пишет:

TTIIMMAA пишет:

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

ну, и где ошибку выдаёт?

Скетч использует 2926 байт (47%) памяти устройства. Всего доступно 6144 байт.
Глобальные переменные используют 51 байт (2%) динамической памяти, оставляя 1997 байт для локальных переменных. Максимум: 2048 байт.

 

Странно, хотел попробовать залить оригинал, перед тем как под себя Скетч редактировать, но он не прошел компиляцию, кстати этот проект в оригинале под Arduino nano, а у меня UNO R3 , возможно что в этом дело? хотя мне кажется разницы то нет

в версии 1.0.6 компилируется

как так?! - я же запгетил.

valera678
Offline
Зарегистрирован: 04.11.2016

Лев запретил зверям в лесу пить. За нарушение приказа - смерть. День первый. Собрались звери на поляне для проверки. Все трезвые, один заяц слегка навеселе. Лев к нему:

- Ты почему выпил?!

- Э-э-э... Понимаете, сын у меня родился, грех не выпить...

- Ладно, прощаю.

День второй. Опять собрались звери на поляне. Все трезвые, один заяц стоит - шатается. Лев к нему:

- Ты опять пьяный??!

- Э-э-э... Понимаешь, сегодня у тёщи день рождения был... Ну выпили немного...

- Ну смотри, Заяц, если завтра опять напьёшься, я тебя съем!!!

День третий. Все звери на поляне, трезвые. Зайца нигде нет. Пошёл Лев его искать. Нет нигде. Вдруг видит из воды уши торчат. Лев хватает его за уши и вытягивает. Заец в нулину пьяный. Лев:

- Заец, я тебя вчера предупреждал?!!! Всё, сейчас я тебя съем!

- Ты, Лев, ик, для своих зверей приказ издал? Ик!.. А нас, рыбов, не трогай!

TTIIMMAA
Offline
Зарегистрирован: 09.02.2017

ЕвгенийП пишет:

TTIIMMAA пишет:

Но и хотелось бы понимать смысл зачем нужно перенести?

Функция должна быть описана ДО использования, а у Вас функция segments описана в строках 69-79, а используется в строке 33 (и далее). В некоторых версиях IDE такие фокусы проходят, в некоторых нет.

Если писать правильно, то работает всегда.

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

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

TTIIMMAA пишет:

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

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

TTIIMMAA
Offline
Зарегистрирован: 09.02.2017
Arduino: 1.6.12 (Windows 7), Плата:"Arduino/Genuino Uno"
 
E:\Users\РўРёРјСѓСЂ\Documents\Arduino\sketch_feb1\sketch_feb1.ino: In function 'void loop()':
 
sketch_feb1:56: error: 'read_pulse_time' was not declared in this scope
 
sketch_feb1:59: error: 'time_display' was not declared in this scope
 
sketch_feb1:63: error: 'double_pulse' was not declared in this scope
 
exit status 1
'read_pulse_time' was not declared in this scope
 
Этот отчёт будет иметь больше информации с
включенной опцией Файл -> Настройки ->
"Показать подробный вывод во время компиляции"
 
ЕвгенийП
ЕвгенийП аватар
Offline
Зарегистрирован: 25.05.2015

TTIIMMAA пишет:

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

 

Вы напоминаете чукчу из анекдота про "трыста дацат адын малэнкий, кругленький, краснэнький".

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

Более того, Вам объяснили общее правило

ЕвгенийП пишет:

Функция должна быть описана ДО использовани

И теперь, (о ужас!!!!) оказалось. что функция read_pulse_time тоже используется до определения!!!! Это ж кошмар! Надо срочно спрашивать у сообщества что делать!

Вам самому не смешно?

Переносите, а если ещё какая окажется, то запомните, наконец, любая функция должна быть определена до использования. Любая!

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

ЕвгенийП пишет:

Переносите,

я запретил!

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

Скоро народ будет недоумевать,почему скетч сейчас не работает, который они напишут потом в будущем. Ведь если в будущем он написан, то и должен работать сейчас.

TTIIMMAA
Offline
Зарегистрирован: 09.02.2017

ЕвгенийП пишет:

TTIIMMAA пишет:

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

 

Вы напоминаете чукчу из анекдота про "трыста дацат адын малэнкий, кругленький, краснэнький".

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

Более того, Вам объяснили общее правило

ЕвгенийП пишет:

Функция должна быть описана ДО использовани

И теперь, (о ужас!!!!) оказалось. что функция read_pulse_time тоже используется до определения!!!! Это ж кошмар! Надо срочно спрашивать у сообщества что делать!

Вам самому не смешно?

Переносите, а если ещё какая окажется, то запомните, наконец, любая функция должна быть определена до использования. Любая!

Я разобрался, спасибо, все работает

ua6em
ua6em аватар
Offline
Зарегистрирован: 17.08.2016
int mosfetPin = 5;  // Pin that controls the mosfet drivers
int ledPin = 4;   // Pin to control the status led
int switchPin = 2;  // Pin to trigger a pulse with the foot switch
int sensorPin = A7;  // Pin where the potentiometer value is read
int previous_pulse_time; // Previous pulse time so display can skip to ones digit
int pulse_time;   // Variable to store the pulse time
int pulse_short;  // Variable to store the short pulse time
int displayStep = 0; // The step the display function should complete next
unsigned long previousMillis = millis(); // The milliseconds where the timer starts counting from
int tens = 0; // Tens place digit
int ones = 0; // Ones place digit

// Defines the possible characters to be displayed on the 7-segment display in an array
//            0          1          2          3          4          5          6          7          8          9          .          None       All
byte y[13] = {B11111100, B01100000, B11011010, B11110010, B01100110, B10110110, B10111110, B11100000, B11111110, B11110110, B00000001, B00000000, B11111111}; // Ones
byte z[13] = {B11111100, B00001100, B11011010, B11110010, B01100110, B10110110, B10111110, B11100000, B11111110, B11110110, B00000001, B00000000, B11111111}; // Tens



//-------------------------------------------------------------------------------------------

void segments(byte n) {
  // controll all 7 Segments

  for (int k = 6; k <= 13; k++) {
    if ((n & B10000000) > 0)
      digitalWrite(k, HIGH);
    else
      digitalWrite(k, LOW);
    n = n << 1;
  }
}

//-------------------------------------------------------------------------------------------

void read_pulse_time() {
  // Read the potentiometer and shift the value to correct the midpoint
  // This allows 20 to be selected without the value having to be exactly 1023
  int sensorValue = analogRead(sensorPin) + 51.15/2;

  // Add a small amount of hysteresis
  if ((sensorValue - 3) / 51.15 > pulse_time) {
    // Makes a pulse of max 20 mS because SensorValue can max become 1023
    pulse_time = sensorValue / 51.15;
  }
  if ((sensorValue + 3) / 51.15 < pulse_time) {
    pulse_time = sensorValue / 51.15;
  }
}

//-------------------------------------------------------------------------------------------

void reset_timer() {
  // Set timer to start counting from current time
  previousMillis = millis();
}

//-------------------------------------------------------------------------------------------

bool delay_done(unsigned long delay) {
  // If difference between current time and previous time is more than the delay
  if ((unsigned long)(millis() - previousMillis) >= delay) {
    return true;
  }
  return false;
}

//-------------------------------------------------------------------------------------------

void time_display() { // 7 segment pulse time displaying
  if (pulse_time != previous_pulse_time) {
    previous_pulse_time = pulse_time;

    // Skip to ones digit
    displayStep = 2;
  }

  if (tens == 0) {
    // Skip to ones digit
    displayStep = 2;
  }

  tens = (pulse_time % 100) / 10; // Tens place
  ones = pulse_time % 10; // Ones place

  //delay(500);

  switch (displayStep) {
    // Display tens digit
    case 0:
      // Time to clear display after displaying both digits
      if (delay_done(400)) {
        // Display tens digit
        segments(z[tens]);

        reset_timer();
        displayStep = 1;
      }
      break;

    // Delay after showing tens digit
    case 1:
      if (delay_done(300)) {
        // Clear display
        segments(z[11]);

        displayStep = 2;
      }
      break;

    // Display ones digit
    case 2:
      segments(y[ones]);

      reset_timer();
      displayStep = 3;

      break;

    // Delay after showing ones digit
    case 3:
      if (delay_done(300)) {
        // Clear display
        segments(z[11]);

        reset_timer();
        displayStep = 0;
      }
      break;
  }
}

//-------------------------------------------------------------------------------------------

void double_pulse() {

  pulse_short = (pulse_time / 8); // Impulse with 1/8 the time of pulse_time

  if (pulse_short < 1) // Makes the short pulse at least one millisecond
    pulse_short = 1;

  digitalWrite(ledPin, HIGH);
  digitalWrite(mosfetPin, HIGH);
  delay(pulse_short);
  digitalWrite(mosfetPin, LOW);
  delay(pulse_short);
  digitalWrite(mosfetPin, HIGH);
  delay(pulse_time);
  digitalWrite(mosfetPin, LOW);

  // Keep LED on for extra 50ms
  delay(50);
  digitalWrite(ledPin, LOW);

}

//-------------------------------------------------------------------------------------------

void setup() {
  pinMode(switchPin, INPUT); // Set switchPin as Input
  pinMode(mosfetPin, OUTPUT); // Set mosfetPin as Output
  pinMode(ledPin, OUTPUT); // Set ledPin as Output
  pinMode(sensorPin, INPUT); // Set sensorPin as Input

  // Set up 7 Segment Pins
  for (int i = 6; i <= 13; i++) // Pins 6-13 are set as Outputs
    pinMode(i, OUTPUT);

  // Light up the led and the display 2 seconds to verify correct placement and function
  digitalWrite(ledPin, HIGH);
  segments(z[12]);
  delay(2000);
  digitalWrite(ledPin, LOW);
  segments(z[11]);
}

//-------------------------------------------------------------------------------------------

void loop() {

  // Read pulse time from analog input
  read_pulse_time();

  // Display time on 7-segment display
  time_display();

  // Impulse activated by switch
  if (digitalRead(switchPin) == HIGH && pulse_time > 0) {
    double_pulse();
    // Wait until switch has been released
    do {
      digitalWrite(mosfetPin, LOW);
      digitalWrite(ledPin, LOW);
    } while (digitalRead(switchPin) == HIGH);
    // Delay before impulse can be triggered again
    delay(500);
  }
  else
  {
    digitalWrite(mosfetPin, LOW);
    digitalWrite(ledPin, LOW);
  }
}

А так? )))

TTIIMMAA
Offline
Зарегистрирован: 09.02.2017

А не подскажите как изменить шаг регулировки, сейчас 1мс, а хотелось бы 100мс, тоесть сейчас на индикаторе цифра 5 а импульс 5мс, а хотелось бы, на индикаторе цифра 3 а импульс 300 мс

TTIIMMAA
Offline
Зарегистрирован: 09.02.2017

да так и перенес

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

TTIIMMAA пишет:

А не подскажите как изменить шаг регулировки, сейчас 1мс, а хотелось бы 100мс, тоесть сейчас на индикаторе цифра 5 а импульс 5мс, а хотелось бы, на индикаторе цифра 3 а импульс 300 мс

я так понгимаю править надо здесь:

void double_pulse() {

  pulse_short = (pulse_time *100/ 8); // Impulse with 1/8 the time of pulse_time

  if (pulse_short < 1) // Makes the short pulse at least one millisecond
    pulse_short = 1;

  digitalWrite(ledPin, HIGH);
  digitalWrite(mosfetPin, HIGH);
  delay(pulse_short);
  digitalWrite(mosfetPin, LOW);
  delay(pulse_short);
  digitalWrite(mosfetPin, HIGH);
  delay(pulse_time *100);
  digitalWrite(mosfetPin, LOW);

  // Keep LED on for extra 50ms
  delay(50);
  digitalWrite(ledPin, LOW);

}

 

Mr.Privet
Mr.Privet аватар
Offline
Зарегистрирован: 17.11.2015

TTIIMMAA пишет:

А не подскажите как изменить шаг регулировки, сейчас 1мс, а хотелось бы 100мс, тоесть сейчас на индикаторе цифра 5 а импульс 5мс, а хотелось бы, на индикаторе цифра 3 а импульс 300 мс


Делите на 100

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

Mr.Privet пишет:
TTIIMMAA пишет:

А не подскажите как изменить шаг регулировки, сейчас 1мс, а хотелось бы 100мс, тоесть сейчас на индикаторе цифра 5 а импульс 5мс, а хотелось бы, на индикаторе цифра 3 а импульс 300 мс

Делите на 100

а не умножать разве?

Mr.Privet
Mr.Privet аватар
Offline
Зарегистрирован: 17.11.2015

Интересно нсли разделить на 0.01 комптлятор попоравит или будет во float переводить?

TTIIMMAA
Offline
Зарегистрирован: 09.02.2017

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

int mosfetPin = 5;  // Pin that controls the mosfet drivers
int ledPin = 4;   // Pin to control the status led
int switchPin = 2;  // Pin to trigger a pulse with the foot switch
int sensorPin = A7;  // Pin where the potentiometer value is read
int previous_pulse_time; // Previous pulse time so display can skip to ones digit
int pulse_time;   // Variable to store the pulse time
int pulse_short;  // Variable to store the short pulse time
int displayStep = 0; // The step the display function should complete next
unsigned long previousMillis = millis(); // The milliseconds where the timer starts counting from
int tens = 0; // Tens place digit
int ones = 0; // Ones place digit

// Defines the possible characters to be displayed on the 7-segment display in an array
//            0          1          2          3          4          5          6          7          8          9          .          None       All
byte y[13] = {B11111100, B01100000, B11011010, B11110010, B01100110, B10110110, B10111110, B11100000, B11111110, B11110110, B00000001, B00000000, B11111111}; // Ones
byte z[13] = {B11111100, B00001100, B11011010, B11110010, B01100110, B10110110, B10111110, B11100000, B11111110, B11110110, B00000001, B00000000, B11111111}; // Tens


заменил 0 на 1 и 1 на 0, так как на индикаторе у меня общий плюс оказался

 

и в четвертой строке ошибка под УНО

Хотелось бы схему и код переделать под два индикатора, пока курю статьи, но ничего не выходит.

valera678
Offline
Зарегистрирован: 04.11.2016

 

ЕвгенийП пишет:

Функция должна быть описана ДО использовани

 

И теперь, (о ужас!!!!) оказалось. что функция read_pulse_time тоже используется до определения!!!! Это ж кошмар! Надо срочно спрашивать у сообщества что делать!

Вам самому не смешно?

Переносите, а если ещё какая окажется, то запомните, наконец, любая функция должна быть определена до использования. Любая!



#include <avr/pgmspace.h>
#include <SPI.h>
int p  = 500;
int latchPin = 8;
int clockPin = 13;
int dataPin  = 11;
void GrowingCube();
void CountDown();
void  CubeDiman();
void ClearOut();
void MovingCube();
void shift_out(const byte  animation[5][6], int animationTime);

void setup()
{
  SPI.setBitOrder(MSBFIRST);
  SPI.setDataMode(SPI_MODE0);
  SPI.setClockDivider(SPI_CLOCK_DIV2);
  SPI.begin();
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);  
  pinMode(latchPin, OUTPUT);
//  ClearOut();
 // CountDown();
}

void loop(){
         CountDown();
            MovingCube();
         CubeDiman();
  GrowingCube();
       CubeDiman();
      MovingCube();
        CubeDiman();
  
   
      ClearOut();

  int randomAnimation = random(4);
  switch(randomAnimation){
    case 0:
      GrowingCube();
      break;
    case 1:
      MovingCube();
      break;
      case 2:
      CountDown();
      break;
      case 3:
      ClearOut();
      break;
  }
}


void CubeDiman(){
   const byte cubeD1 [5][6] PROGMEM = {{B00001, B11111, B10001, B10001, B10001, B11111},
                                      {B00010, B10001, B00000, B00000, B00000, B10001},
                                      {B00100, B10001, B00000, B00000, B00000, B10001},
                                      {B01000, B10001, B00000, B00000, B00000, B10001},
                                      {B10000, B11111, B10001, B10001, B10001, B11111}};
                                      
                           
                                      
                                       
  shift_out(cubeD1, 4000);

  ClearOut();
}




void CountDown(){
  
   const byte FiveRow5 [5][6] PROGMEM = {{ B10000, B01111, B00000, B00000, B00000, B00000},
                                          {B01000, B01000, B00000, B00000, B00000, B00000},
                                          {B00100, B01110, B00000, B00000, B00000, B00000},
                                          {B00010, B00001, B00000, B00000, B00000, B00000},
                                          {B00001, B01110, B00000, B00000, B00000, B00000}};
                        
  const byte FiveRow4 [5][6] PROGMEM =  {{ B10000, B00000, B01111, B00000, B00000, B00000},
                                          {B01000, B00000, B01000, B00000, B00000, B00000},
                                          {B00100, B00000, B01110, B00000, B00000, B00000},
                                          {B00010, B00000, B00001, B00000, B00000, B00000},
                                          {B00001, B00000, B01110, B00000, B00000, B00000}};   
                          
  const byte FiveRow3 [5][6] PROGMEM =  {{ B10000, B00000, B00000, B01111, B00000, B00000},
                                          {B01000, B00000, B00000, B01000, B00000, B00000},
                                          {B00100, B00000, B00000, B01110, B00000, B00000},
                                          {B00010, B00000, B00000, B00001, B00000, B00000},
                                          {B00001, B00000, B00000, B01110, B00000, B00000}}; 
                          
  const byte FiveRow2 [5][6] PROGMEM =   {{B10000, B00000, B00000, B00000, B01111, B00000},
                                          {B01010, B00000, B00000, B00000, B01000, B00000},
                                          {B00100, B00000, B00000, B00000, B01110, B00000},
                                          {B00010, B00000, B00000, B00000, B00001, B00000},
                                          {B00001, B00000, B00000, B00000, B01110, B00000}}; 
                          
  const byte FiveRow1 [5][6] PROGMEM =  {{ B10000, B00000, B00000, B00000, B00000, B01111},
                                          {B01000, B00000, B00000, B00000, B00000, B01000},
                                          {B00100, B00000, B00000, B00000, B00000, B01110},
                                          {B00010, B00000, B00000, B00000, B00000, B00001},
                                          {B00001, B00000, B00000, B00000, B00000, B01110}};
                                          
                                          
                                          
                                          
                                          
    const byte FourRow5 [5][6] PROGMEM = {{B10000, B01001, B00000, B00000, B00000, B00000},
                                          {B01000, B01001, B00000, B00000, B00000, B00000},
                                          {B00100, B01111, B00000, B00000, B00000, B00000},
                                          {B00010, B00001, B00000, B00000, B00000, B00000},
                                          {B00001, B00001, B00000, B00000, B00000, B00000}};
                        
  const byte FourRow4 [5][6] PROGMEM =  {{ B10000, B00000, B01001, B00000, B00000, B00000},
                                          {B01000, B00000, B01001, B00000, B00000, B00000},
                                          {B00100, B00000, B01111, B00000, B00000, B00000},
                                          {B00010, B00000, B00001, B00000, B00000, B00000},
                                          {B00001, B00000, B00001, B00000, B00000, B00000}};   
                          
  const byte FourRow3 [5][6] PROGMEM =  {{ B10000, B00000, B00000, B01001, B00000, B00000},
                                          {B01000, B00000, B00000, B01001, B00000, B00000},
                                          {B00100, B00000, B00000, B01111, B00000, B00000},
                                          {B00010, B00000, B00000, B00001, B00000, B00000},
                                          {B00001, B00000, B00000, B00001, B00000, B00000}}; 
                          
  const byte FourRow2 [5][6] PROGMEM =   {{B10000, B00000, B00000, B00000, B01001, B00000},
                                          {B01000, B00000, B00000, B00000, B01001, B00000},
                                          {B00100, B00000, B00000, B00000, B01111, B00000},
                                          {B00010, B00000, B00000, B00000, B00001, B00000},
                                          {B00001, B00000, B00000, B00000, B00001, B00000}}; 
                          
  const byte FourRow1 [5][6] PROGMEM =  {{ B10000, B00000, B00000, B00000, B00000, B01001},
                                          {B01000, B00000, B00000, B00000, B00000, B01001},
                                          {B00100, B00000, B00000, B00000, B00000, B01111},
                                          {B00010, B00000, B00000, B00000, B00000, B00001},
                                          {B00001, B00000, B00000, B00000, B00000, B00001}};
                                          
                                          
                                          
                                          
  const byte ThreeRow5 [5][6] PROGMEM =  {{B00001, B01110, B00000, B00000, B00000, B00000},
                                          {B00010, B00001, B00000, B00000, B00000, B00000},
                                          {B00100, B00110, B00000, B00000, B00000, B00000},
                                          {B01000, B00001, B00000, B00000, B00000, B00000},
                                          {B10000, B01110, B00000, B00000, B00000, B00000}};
                        
  const byte ThreeRow4 [5][6] PROGMEM =  {{B00001, B00000, B01110, B00000, B00000, B00000},
                                          {B00010, B00000, B00001, B00000, B00000, B00000},
                                          {B00100, B00000, B00110, B00000, B00000, B00000},
                                          {B01000, B00000, B00001, B00000, B00000, B00000},
                                          {B10000, B00000, B01110, B00000, B00000, B00000}};   
                          
  const byte ThreeRow3 [5][6] PROGMEM =  {{B00001, B00000, B00000, B01110, B00000, B00000},
                                          {B00010, B00000, B00000, B00001, B00000, B00000},
                                          {B00100, B00000, B00000, B00110, B00000, B00000},
                                          {B01000, B00000, B00000, B00001, B00000, B00000},
                                          {B10000, B00000, B00000, B01110, B00000, B00000}}; 
                          
  const byte ThreeRow2 [5][6] PROGMEM =   {{B00001, B00000, B00000, B00000, B01110, B00000},
                                          {B00010, B00000, B00000, B00000, B00001, B00000},
                                          {B00100, B00000, B00000, B00000, B00110, B00000},
                                          {B01000, B00000, B00000, B00000, B00001, B00000},
                                          {B10000, B00000, B00000, B00000, B01110, B00000}}; 
                          
  const byte ThreeRow1 [5][6] PROGMEM =  {{B00001, B00000, B00000, B00000, B00000, B01110},
                                          {B00010, B00000, B00000, B00000, B00000, B00001},
                                          {B00100, B00000, B00000, B00000, B00000, B00110},
                                          {B01000, B00000, B00000, B00000, B00000, B00001},
                                          {B10000, B00000, B00000, B00000, B00000, B01110}};
                         
  const byte TwoRow5 [5][6] PROGMEM =    {{B10000, B00110, B00000, B00000, B00000, B00000},
                                          {B01000, B01001, B00000, B00000, B00000, B00000},
                                          {B00100, B00010, B00000, B00000, B00000, B00000},
                                          {B00010, B00100, B00000, B00000, B00000, B00000},
                                          {B00001, B01111, B00000, B00000, B00000, B00000}};
                          
  const byte TwoRow4 [5][6] PROGMEM =    {{B10000, B00000, B00110, B00000, B00000, B00000},
                                          {B01000, B00000, B01001, B00000, B00000, B00000},
                                          {B00100, B00000, B00010, B00000, B00000, B00000},
                                          {B00010, B00000, B00100, B00000, B00000, B00000},
                                          {B00001, B00000, B01111, B00000, B00000, B00000}};  
                          
  const byte TwoRow3 [5][6] PROGMEM =    {{B10000, B00000, B00000, B00110, B00000, B00000},
                                          {B01000, B00000, B00000, B01001, B00000, B00000},
                                          {B00100, B00000, B00000, B00010, B00000, B00000},
                                          {B00010, B00000, B00000, B00100, B00000, B00000},
                                          {B00001, B00000, B00000, B01111, B00000, B00000}}; 
                          
  const byte TwoRow2 [5][6] PROGMEM =    {{B10000, B00000, B00000, B00000, B00110, B00000},
                                          {B01000, B00000, B00000, B00000, B01001, B00000},
                                          {B00100, B00000, B00000, B00000, B00010, B00000},
                                          {B00010, B00000, B00000, B00000, B00100, B00000},
                                          {B00001, B00000, B00000, B00000, B01111, B00000}}; 
                          
  const byte TwoRow1 [5][6] PROGMEM =    {{B10000, B00000, B00000, B00000, B00000, B00110},
                                          {B01000, B00000, B00000, B00000, B00000, B01001},
                                          {B00100, B00000, B00000, B00000, B00000, B00010},
                                          {B00010, B00000, B00000, B00000, B00000, B00100},
                                          {B00001, B00000, B00000, B00000, B00000, B01111}}; 

  const byte OneRow5 [5][6] PROGMEM =    {{B10000, B00010, B00000, B00000, B00000, B00000},
                                          {B01000, B00110, B00000, B00000, B00000, B00000},
                                          {B00100, B00010, B00000, B00000, B00000, B00000},
                                          {B00010, B00010, B00000, B00000, B00000, B00000},
                                          {B00001, B00111, B00000, B00000, B00000, B00000}};
                          
  const byte OneRow4 [5][6] PROGMEM =    {{B10000, B00000, B00010, B00000, B00000, B00000},
                                          {B01000, B00000, B00110, B00000, B00000, B00000},
                                          {B00100, B00000, B00010, B00000, B00000, B00000},
                                          {B00010, B00000, B00010, B00000, B00000, B00000},
                                          {B00001, B00000, B00111, B00000, B00000, B00000}};
                          
  const byte OneRow3 [5][6] PROGMEM =    {{B10000, B00000, B00000, B00010, B00000, B00000},
                                          {B01000, B00000, B00000, B00110, B00000, B00000},
                                          {B00100, B00000, B00000, B00010, B00000, B00000},
                                          {B00010, B00000, B00000, B00010, B00000, B00000},
                                          {B00001, B00000, B00000, B00111, B00000, B00000}};
                          
  const byte OneRow2 [5][6]PROGMEM =     {{B10000, B00000, B00000, B00000, B00010, B00000},
                                          {B01000, B00000, B00000, B00000, B00110, B00000},
                                          {B00100, B00000, B00000, B00000, B00010, B00000},
                                          {B00010, B00000, B00000, B00000, B00010, B00000},
                                          {B00001, B00000, B00000, B00000, B00111, B00000}};
                          
  const byte OneRow1 [5][6] PROGMEM =    {{B10000, B00000, B00000, B00000, B00000, B00010},
                                          {B01000, B00000, B00000, B00000, B00000, B00110},
                                          {B00100, B00000, B00000, B00000, B00000, B00010},
                                          {B00010, B00000, B00000, B00000, B00000, B00010},
                                          {B00001, B00000, B00000, B00000, B00000, B00111}};
//shift_out(Animation you want to run, how long the animation should be runned in milliseconds); 
 
  shift_out(FiveRow5, p);
  shift_out(FiveRow4, p);
  shift_out(FiveRow3, p);
  shift_out(FiveRow2, p);
  shift_out(FiveRow1, p);
  shift_out(FourRow5, p);
  shift_out(FourRow4, p);
  shift_out(FourRow3, p);
  shift_out(FourRow2, p);
  shift_out(FourRow1, p);
  shift_out(ThreeRow5, p);
  shift_out(ThreeRow4, p);
  shift_out(ThreeRow3, p);
  shift_out(ThreeRow2, p);
  shift_out(ThreeRow1, p);
  shift_out(TwoRow5, p);
  shift_out(TwoRow4, p);
  shift_out(TwoRow3, p);
  shift_out(TwoRow2, p);
  shift_out(TwoRow1, p);
  shift_out(OneRow5, p);
  shift_out(OneRow4, p);
  shift_out(OneRow3, p);
  shift_out(OneRow2, p);
  shift_out(OneRow1, p);
  ClearOut();
}



void GrowingCube(){
  const byte cube1 [5][6] PROGMEM =  {{B00001, B00000, B00000, B00000, B00011, B00011},
                                      {B00010, B00000, B00000, B00000, B00011, B00011},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                        
  const byte cube2 [5][6] PROGMEM =  {{B00001, B00000, B00000, B00111, B00111, B00111},
                                      {B00010, B00000, B00000, B00111, B00111, B00111},
                                      {B00100, B00000, B00000, B00111, B00111, B00111},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  const byte cube3 [5][6] PROGMEM =  {{B00001, B00000, B01111, B01111, B01111, B01111},
                                      {B00010, B00000, B01111, B01111, B01111, B01111},
                                      {B00100, B00000, B01111, B01111, B01111, B01111},
                                      {B01000, B00000, B01111, B01111, B01111, B01111},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  const byte cube4 [5][6] PROGMEM =  {{B00001, B11111, B11111, B11111, B11111, B11111},
                                      {B00010, B11111, B11111, B11111, B11111, B11111},
                                      {B00100, B11111, B11111, B11111, B11111, B11111},
                                      {B01000, B11111, B11111, B11111, B11111, B11111},
                                      {B10000, B11111, B11111, B11111, B11111, B11111}};
                      
  const byte cube5 [5][6] PROGMEM =  {{B00001, B11111, B11111, B11111, B11111, B11111},
                                      {B00010, B11111, B11111, B11111, B11111, B11111},
                                      {B00100, B11111, B11111, B11111, B11111, B11111},
                                      {B01000, B11111, B11111, B11111, B11111, B11111},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  const byte cube6 [5][6] PROGMEM =  {{B00001, B11111, B11111, B11111, B11111, B11111},
                                      {B00010, B11111, B11111, B11111 ,B11111, B11111},
                                      {B00100, B11111, B11111, B11111, B11111, B11111},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  const byte cube7 [5][6] PROGMEM =  {{B00001, B11111, B11111, B11111, B11111, B11111},
                                      {B00010, B11111, B11111, B11111, B11111, B11111},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
  
  // To avoid different brightness I always shiftout an array with a 5*6 dimension                    
  const byte cube8 [5][6] PROGMEM =  {{B00001, B11111, B11111, B11111, B11111, B11111},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  shift_out(cube1, 1000);
  shift_out(cube2, 1000);
  shift_out(cube3, 1000);
  shift_out(cube4, 1000);
  shift_out(cube5, 1000);
  shift_out(cube6, 1000);
  shift_out(cube7, 1000);
  shift_out(cube8, 1000); 
  ClearOut();
}

void MovingCube(){
   const byte cube1 [5][6] PROGMEM = {{B00001, B00000, B00000, B00000, B00011, B00011},
                                      {B00010, B00000, B00000, B00000, B00011, B00011},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
   const byte cube2 [5][6] PROGMEM = {{B00001, B00000, B00000, B00011, B00011, B00000},
                                      {B00010, B00000, B00000, B00011, B00011, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
   const byte cube3 [5][6]PROGMEM =  {{B00001, B00000, B00011, B00011, B00000, B00000},
                                      {B00010, B00000, B00011, B00011, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                                      
   const byte cube4 [5][6] PROGMEM = {{B00001, B00011, B00011, B00000, B00000, B00000},
                                      {B00010, B00011, B00011, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
   const byte cube5 [5][6] PROGMEM =  {{B00010, B00000, B00011, B00011, B00000, B00000},
                                      {B00100, B00000, B00011, B00011, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
   const byte cube6 [5][6] PROGMEM = {{B00010, B00000, B00110, B00110, B00000, B00000},
                                      {B00100, B00000, B00110, B00110, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
   const byte cube7 [5][6] PROGMEM = {{B00010, B00000, B01100, B01100, B00000, B00000},
                                      {B00100, B00000, B01100, B01100, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                        
   const byte cube8 [5][6] PROGMEM = {{B00100, B00000, B01100, B01100, B00000, B00000},
                                      {B01000, B00000, B01100, B01100, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
   const byte cube9 [5][6] PROGMEM = {{B01000, B00000, B01100, B01100, B00000, B00000},
                                      {B10000, B00000, B01100, B01100, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  const byte cube10 [5][6] PROGMEM = {{B01000, B00000, B00000, B00110, B00110, B00000},
                                      {B10000, B00000, B00000, B00110, B00110, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                                      
  const byte cube11 [5][6] PROGMEM = {{B01000, B00000, B00000, B00000, B00011, B00011},
                                      {B10000, B00000, B00000, B00000, B00011, B00011},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  const byte cube12 [5][6] PROGMEM = {{B01000, B00000, B00000, B00011, B00011, B00000},
                                      {B10000, B00000, B00000, B00011, B00011, B00011},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  const byte cube13 [5][6] PROGMEM = {{B01000, B00000, B00011, B00011, B00000, B00000},
                                      {B10000, B00000, B00011, B00011, B00011, B00011},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  const byte cube14 [5][6] PROGMEM = {{B01000, B00011, B00011, B00000, B00000, B00000},
                                      {B10000, B00011, B00011, B00011, B00011, B00011},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  const byte cube15 [5][6] PROGMEM = {{B01000, B00110, B00110, B00000, B00000, B00000},
                                      {B10000, B00111, B00111, B00011, B00011, B00011},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  const byte cube16 [5][6] PROGMEM = {{B01000, B00000, B00110, B00110, B00000, B00000},
                                      {B10000, B00111, B00111, B00111, B00011, B00011},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  const byte cube17 [5][6] PROGMEM = {{B01000, B00000, B00000, B00110, B00110, B00000},
                                      {B10000, B00111, B00111, B00111, B00111, B00011},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  const byte cube18 [5][6] PROGMEM = {{B01000, B00000, B00000, B00000, B00110, B00110},
                                      {B10000, B00111, B00111, B00111, B00111, B00111},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
       
  const byte cube19 [5][6] PROGMEM = {{B01000, B00000, B00000, B00000, B01100, B01100},
                                      {B10000, B00111, B00111, B00111, B01111, B01111},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  const byte cube20 [5][6] PROGMEM = {{B01000, B00000, B00000, B01100, B01100, B00000},
                                      {B10000, B00111, B00111, B01111, B01111, B01111},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  const byte cube21 [5][6] PROGMEM = {{B01000, B00000, B01100, B01100, B00000, B00000},
                                      {B10000, B00111, B01111, B01111, B01111, B01111},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  const byte cube22 [5][6] PROGMEM = {{B01000, B01100, B01100, B00000, B00000, B00000},
                                      {B10000, B01111, B01111, B01111, B01111, B01111},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  const byte cube23 [5][6] PROGMEM = {{B01000, B11000, B11000, B00000, B00000, B00000},
                                      {B10000, B11111, B11111, B01111, B01111, B01111},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  const byte cube24 [5][6] PROGMEM = {{B01000, B00000, B11000, B11000, B00000, B00000},
                                      {B10000, B11111, B11111, B11111, B01111, B01111},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  const byte cube25 [5][6] PROGMEM = {{B01000, B00000, B00000, B11000, B11000, B00000},
                                      {B10000, B11111, B11111, B11111, B11111, B01111},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  const byte cube26 [5][6]PROGMEM =  {{B01000, B00000, B00000, B00000, B11000, B11000},
                                      {B10000, B11111, B11111, B11111, B11111, B11111},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                                      
  const byte cube27 [5][6] PROGMEM = {{B10000, B11111, B11111, B11111, B11111, B11111},
                                      {B01000, B11111, B11111, B11111, B11111, B11111},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  const byte cube28 [5][6]PROGMEM =  {{B10000, B11111, B11111, B11111, B11111, B11111},
                                      {B01000, B11111, B11111, B11111, B11111, B11111},
                                      {B00100, B11111, B11111, B11111, B11111, B11111},
                                      {B00000, B00000, B00000, B00000, B00000, B00000},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                      
  const byte cube29 [5][6] PROGMEM=  {{B10000, B11111, B11111, B11111, B11111, B11111},
                                      {B01000, B11111, B11111, B11111, B11111, B11111},
                                      {B00100, B11111, B11111, B11111, B11111, B11111},
                                      {B00010, B11111, B11111, B11111, B11111, B11111},
                                      {B00000, B00000, B00000, B00000, B00000, B00000}};
                                      
  const byte cube30 [5][6]PROGMEM =  {{B10000, B11111, B11111, B11111, B11111, B11111},
                                      {B01000, B11111, B11111, B11111, B11111, B11111},
                                      {B00100, B11111, B11111, B11111, B11111, B11111},
                                      {B00010, B11111, B11111, B11111, B11111, B11111},
                                      {B00001, B11111, B11111, B11111, B11111, B11111}};

  shift_out(cube1, 100);
  shift_out(cube2, 100);
  shift_out(cube3, 100);
  shift_out(cube4, 100);
  shift_out(cube5, 100);
  shift_out(cube6, 100);
  shift_out(cube7, 100);
  shift_out(cube8, 100);
  shift_out(cube9, 100);
  shift_out(cube10, 100); 
  shift_out(cube11, 100);
  shift_out(cube12, 100);
  shift_out(cube13, 100);
  shift_out(cube14, 100);
  shift_out(cube15, 100);
  shift_out(cube16, 100);
  shift_out(cube17, 100);
  shift_out(cube18, 100);
  shift_out(cube19, 100);
  shift_out(cube20, 100);
  shift_out(cube21, 100);
  shift_out(cube22, 100);
  shift_out(cube23, 100);
  shift_out(cube24, 100);
  shift_out(cube25, 100);
  shift_out(cube26, 100);
  shift_out(cube27, 100);
  shift_out(cube28, 100);
  shift_out(cube29, 100);
  shift_out(cube30, 100);
  ClearOut();                    
}


void ClearOut(){
  digitalWrite(latchPin, LOW);
  for(int b=0; b<6; b++){
    SPI.transfer(B00000);
  }
  digitalWrite(latchPin, HIGH);
  digitalWrite(latchPin, LOW);
}

void shift_out(const byte  animation[5][6], int animationTime){
  for(int i=0; i<(animationTime*0.2);i++){ 
    for(int a=0; a<5; a++){
      digitalWrite(latchPin, LOW);
      for(int b=0; b<6; b++){
        SPI.transfer(animation[a][b]);
      }
      digitalWrite(latchPin, HIGH);
      delay(1);
    }
  }
}

а вот здесь не должна?   Бросьте вы уже упиваться верой в свою непогрешимость.

скетч компилируется и в железе работает

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

valera678 пишет:

скетч компилируется и в железе работает

я же запретил?!

valera678
Offline
Зарегистрирован: 04.11.2016

да ..я помню.. А когда вы уже начнете разрешать?)

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

valera678 пишет:

да ..я помню.. А когда вы уже начнете разрешать?)

мы Клапауций ХХХ - никогда

ЕвгенийП
ЕвгенийП аватар
Offline
Зарегистрирован: 25.05.2015

valera678 пишет:

а вот здесь не должна?   

скетч компилируется и в железе работает

Должна. Вы посмотрите во временных файлах IDE, файл с названием как у Вашего скетча и расширением ".cpp". Увидите, что IDE просто добавило предварителное описание функции в начало текста, так что она оказалась объявленной до использования.

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

На самом деле, правило про предварительное объявление - это правило языка. Оно железное. Если его соблюдать, то работает всегда. А если плевать на него, то работает только в тех версиях IDE, где о его (правила) соблюдении позаботились разработчики IDE. Как раз типа того примера, который Вы привели.

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

ЕвгенийП пишет:

Должна. Вы посмотрите во временных файлах IDE, файл с названием как у Вашего скетча и расширением ".cpp". Увидите, что IDE просто добавило предварителное описание функции в начало текста, так что она оказалась объявленной до использования.

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

На самом деле, правило про предварительное объявление - это правило языка. Оно железное. Если его соблюдать, то работает всегда. А если плевать на него, то работает только в тех версиях IDE, где о его (правила) соблюдении позаботились разработчики IDE. Как раз типа того примера, который Вы привели.

я один наблюдаю процесс дискредитации педагогики, как науки на Руси?

*как можно умудриться в дюжине строк напороть столько взаимоисключающих утверждений и надеяться, что подаван останется в дравом уме и трезвой памяти?

---------------------------------------------

arduino-1.8.1 *.cpp

# 1 "C:\\temp\\arduino_modified_sketch_496745\\sketch_feb15a.ino"
# 1 "C:\\temp\\arduino_modified_sketch_496745\\sketch_feb15a.ino"

void setup() {
pinMode(14, 0x1);
digitalWrite(14, 1);
}

void loop() {blink();}

void blink(){digitalWrite(14, !((millis() >> 10) & 1));} 

----------------------------

arduino-1.0.6 *.cpp

#line 1 "sketch_feb15a.ino"

#include "Arduino.h"
void setup();
void loop();
void blink();
#line 2
void setup() {
pinMode(14, OUTPUT);
digitalWrite(14, 1);
}

void loop() {blink();}

void blink(){digitalWrite(14, !((millis() >> 10) & 1));}

===================

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

ЕвгенийП
ЕвгенийП аватар
Offline
Зарегистрирован: 25.05.2015

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

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

Мне казалось, что я Вам давно объяснил, что Вам я консультаций не даю. Зачем вопросы задавать?

Arduino: 1.6.12 (Windows 7), Плата:"Arduino Nano, ATmega328"

Изменены опции сборки, пересобираем все
C:\Users\Admin\Google Диск\Soft\kaka\kaka.ino: In function 'void loop()':

kaka:6: error: 'blink' was not declared in this scope

exit status 1
'blink' was not declared in this scope

 

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

Mr.Privet пишет:
Интересно нсли разделить на 0.01 комптлятор попоравит или будет во float переводить?

По логике, формат принимается в соответствии с форматом получающей значение переменной

ЕвгенийП
ЕвгенийП аватар
Offline
Зарегистрирован: 25.05.2015

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

---------------------------------------------

arduino-1.8.1 *.cpp

# 1 "C:\\temp\\arduino_modified_sketch_496745\\sketch_feb15a.ino"
# 1 "C:\\temp\\arduino_modified_sketch_496745\\sketch_feb15a.ino"

void setup() {
pinMode(14, 0x1);
digitalWrite(14, 1);
}

void loop() {blink();}

void blink(){digitalWrite(14, !((millis() >> 10) & 1));} 

===================

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

Вы чего фуфло-то подсунули?

Вам ясно сказали

ЕвгенийП пишет:

 файл с названием как у Вашего скетча и расширением ".cpp". 

Так нахрена Вы пихаете ctags_target_for_gcc_minus_e.cpp ?

В подпапке sketch лежи тот самый файл с правильным названием (в моём случае proba.ino.cpp) и выглядит он вот так

#include <Arduino.h>
#line 1 "C:\\sketches\\proba\\proba.ino"
#line 1 "C:\\sketches\\proba\\proba.ino"
#line 1 "C:\\sketches\\proba\\proba.ino"
void setup();
#line 6 "C:\\sketches\\proba\\proba.ino"
void loop();
#line 8 "C:\\sketches\\proba\\proba.ino"
void blink();
#line 1 "C:\\sketches\\proba\\proba.ino"
void setup() {
	pinMode(14, OUTPUT);
	digitalWrite(14, 1);
}

void loop() {blink();}

void blink(){digitalWrite(14, !((millis() >> 10) & 1));}

Строки 5, 7 и 9 видите? Вот про них Вам и говорили.

А теперь, пожалуйста, ясно, внятно, чтобы все слышали - кто здесь кретин?

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

ЕвгенийП пишет:

Вы чего фуфло-то подсунули?

А теперь, пожалуйста, ясно, внятно, чтобы все слышали - кто здесь кретин?

ок. признаю, промахнулся с файлом.

но, что это доказывает, что это правило С++ или что часть версий Дуино ИДЕ бажная, или эта версия так же бажная и баг лечится, указанным тобой костылём?

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

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

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

ЕвгенийП
ЕвгенийП аватар
Offline
Зарегистрирован: 25.05.2015

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

если это правило С++, то нужно указывать ссылку первоисточник правил С++,

Кому нужно? Мне не нужно, я эти "правила" и так знаю. Вам нужно? Вы меня об этом хоть раз вежливо попросили? Дать Вам ссылку на такого рода документацию?

Значит, так, дорогой, я Вам уже говорил, Вас я готов консультировать только на коммерческой основе. Задавайте вопросы и оплачивайте время которое я на Вас потрачу. Не хотите - ищите свои правила сами.

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

ЕвгенийП пишет:

Кому нужно? Мне не нужно, я эти "правила" и так знаю. Вам нужно?

да никому не нужно - я с самого начала тебе это сказал

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

дыбил, это был риторический вопрос и демонстрация твоего кретинизма - если ты решил нарыть бажную версию Дуино ИДЕ и таскать ея труп по форуму, как демонстрацию непонятно чего, то кото тебе доктор? твои ракеты отречены падать в Туву.

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

крылатые точно не должны, там софт еще Тихонов-Козлов писали, если не изменяет память на 1000км в пятак попадали, а движок, он жеж двухконтурный, его гений Люлька придумал )))

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

ua6em пишет:

крылатые точно не должны, там софт еще Тихонов-Козлов писали, если не изменяет память на 1000км в пятак попадали, а движок, он жеж двухконтурный, его гений Люлька придумал )))

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