Выход из функций. Как не ждать ее завершения?

Пнд, 23/11/2015 - 10:13

#1

Gippopotam

Offline

Зарегистрирован: 12.09.2014

Выход из функции - оператор return.

Но правильно - построить логику так, чтобы функция нормально завершалась по одному из условий. Но это не требования ЯП, а просто правило хорошего стиля.

Пнд, 23/11/2015 - 10:14

#2

vvadim

Offline

Зарегистрирован: 23.05.2012

а кто видел ваш код ?

Пнд, 23/11/2015 - 10:38

#3

Tomasina

Offline

Зарегистрирован: 09.03.2013

http://arduino.ru/Reference/Break

Пнд, 23/11/2015 - 10:41

#4

Timofei-Iridium

Offline

Зарегистрирован: 20.11.2015

int foton = A4; //фоторезистор на аналоговом порту

void setup()
{
  pinMode(foton, INPUT);
 }

void loop(){
 
int raw = analogRead(foton); 

if (raw<200) //если света в комнате почти нету , то
 runAll(); //запускаем функцию (запуск всех эффектов  )

if (raw>200) //если в комнате горит свет то отключаем аналоговые порты ноль, тем самым отключатся куб
  digitalWrite(A0,LOW);
  digitalWrite(A1,LOW);
  digitalWrite(A2,LOW);
  digitalWrite(A3,LOW);

void runAll(){    //список всех функций (световых эффектов)
 turnEverythingOff();//turn all off
  flickerOn();
  turnEverythingOn();//turn all on
  delay(time);
  turnOnAndOffAllByLayerUpAndDownNotTimed();
  layerstompUpAndDown();
  turnOnAndOffAllByColumnSideways();
  delay(time);
  aroundEdgeDown();
  turnEverythingOff();
  randomflicker();
  randomRain();
  diagonalRectangle();
  goThroughAllLedsOneAtATime();
  propeller();
  spiralInAndOut();
  flickerOff();
  turnEverythingOff();
  delay(2000);
  }

void turnEverythingOff() //один из циклов из для примера
 {
   for(int i = 0; i<16; i++)
   {
     digitalWrite(column[i], 1);
   }
   for(int i = 0; i<4; i++)
   {
     digitalWrite(layer[i], 0);
   }
 }

Пнд, 23/11/2015 - 10:42

#5

Timofei-Iridium

Offline

Зарегистрирован: 20.11.2015

я нестал приводить как подключены пины цифровых выходов и аналоговых, описал вкоде суть

Пнд, 23/11/2015 - 10:46

#6

ЕвгенийП

Offline

Зарегистрирован: 25.05.2015

Timofei-Iridium пишет:

я нестал приводить как подключены пины цифровых выходов и аналоговых, описал вкоде суть

Простите, но это не суть, а поток сознания, который даже не компилируется. Вы решили в прятки поиграть? Боитесь, что мы Ваш код украдём? Ну, играйте сами, чего нас-то всех привлекать к этому?

Пнд, 23/11/2015 - 10:49

#7

Timofei-Iridium

Offline

Зарегистрирован: 20.11.2015

Насчет оператора break читал. Но как же сделать чтоб из общей функции выйти , не присваивая каждому циклу оператор break.

Я сделал функцию runAll() , которая все функции из списка запускает. Вот как внезапно из runALL() выйти недожидаясь исполнения всег функци

Пнд, 23/11/2015 - 10:51

#8

Timofei-Iridium

Offline

Зарегистрирован: 20.11.2015

Да нет же. сейчас скину, тем более я его из инета скачал. Просто решил что много будет в нем лишнего написано

int column[16]={13,12,11,10,9,8,7,6,5,4,3,2,1,0};
//initializing and declaring led layers
  int layer[4]={A3,A2,A1,A0};

  int time = 250;
  
  int foton = A4;
  
  int i;
 
void setup()
{
  pinMode(foton, INPUT);
  
  
 
 
  for(int i = 0; i<16; i++)
  {
    pinMode(column[i], OUTPUT);
  }
  
  for(int i = 0; i<4; i++)
  {
    pinMode(layer[i], OUTPUT);
  }
  //seeding random for random pattern
  randomSeed(analogRead(10));
  
  
}
//xxxxxxxxxxxxxxxxxxxxFUNCTION LOOPxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
void loop(){
 
int raw = analogRead(foton);

delay(200);

 if (raw<200)
 runAll();
 
 if (raw>200)
  digitalWrite(A0,LOW);
  digitalWrite(A1,LOW);
  digitalWrite(A2,LOW);
  digitalWrite(A3,LOW);
  return 0;
 
}



void runAll(){
 turnEverythingOff();//turn all off
  flickerOn();
  turnEverythingOn();//turn all on
  delay(time);
  turnOnAndOffAllByLayerUpAndDownNotTimed();
  layerstompUpAndDown();
  turnOnAndOffAllByColumnSideways();
  delay(time);
  aroundEdgeDown();
  turnEverythingOff();
  randomflicker();
  randomRain();
  diagonalRectangle();
  goThroughAllLedsOneAtATime();
  propeller();
  spiralInAndOut();
  flickerOff();
  turnEverythingOff();
  delay(2000);
  }

 // if (raw>80){
 // digitalWrite(A0,LOW);
  //digitalWrite(A1,LOW);
  //digitalWrite(A2,LOW);
 // digitalWrite(A3,LOW);
  



//xxxxxxxxxxxxxxxxxxxxFUNCTIONSxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

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

Пнд, 23/11/2015 - 11:09

#9

ЕвгенийП

Offline

Зарегистрирован: 25.05.2015

Timofei-Iridium пишет:

Я сделал функцию runAll() , ... тем более я его из инета скачал.

Так сделал или скачал?

Теперь по сути.

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

Но если Вам так уж невмоготу сделать экстренный выход из пачки вложенных функций сразу, то Ваша тема функции setjmp/longjmp. Первая устанавливает точку глобального (откуда угодно) перехода, а вторая на эту точку переходит. Объяснений и примеров в сети полно - ройтесь.

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

Пнд, 23/11/2015 - 11:24

#10

Timofei-Iridium

Offline

Зарегистрирован: 20.11.2015

Код весь скачал, но немного изменил его в плане написания runAll() - для эктреннего завершения.

За функции setjmp/longjmp спасибо. буду искать.

На счет .......Коллеги Вам тут правильно сказали, лучше не полениться и выписать условия.... Я так понял Вы имели ввиду вписать в каждый цикл "break"?чтобы можно было выходить из любой функции когда она выполняется.

Пнд, 23/11/2015 - 11:33

#11

Tomasina

Offline

Зарегистрирован: 09.03.2013

какова длительность самого продолжитльного эффекта?

Допустимо ли выключение куба (при включении света) по завершении текущего эффекта, или обязательно выключение куба "прям сразу" при обнаружении света?

Первое сделать легко - перед запуском любого эффекта проверять флаг (либо мерять освещенность).

Второе сложнее - использовать прерывания (допустим, каждые 100 мс), в которых читать значение фоторезистора. Но так как процесс аналогового чтения занимает около 18000 тактов, то возможны визуальные "подрагивания" во время измерений.

Пнд, 23/11/2015 - 11:44

#12

ЕвгенийП

Offline

Зарегистрирован: 25.05.2015

Timofei-Iridium пишет:

На счет .......Коллеги Вам тут правильно сказали, лучше не полениться и выписать условия.... Я так понял Вы имели ввиду вписать в каждый цикл "break"?чтобы можно было выходить из любой функции когда она выполняется.

Есть 10500 способов сделать это. Можно и так, как Вы сказали. Я бы сделал не так. Я бы завёл глобальный флаг, который изначально был бы, например false, а в случае необходимости немедленного выхода, становился бы true. А в условие КАЖДОГО цикла в эффектах добавил бы проверку этого флага. Примерно так:

static bool ShuherValim = false; // глобальный флаг.

// В КАЖДОМ цикле ставим дополнительное условие типа такого (на примере цикла из строки 721)
for(int count = 4; count != 0 && ! ShuherValim; count--)

Ну, теперь осталось просто в том месте, где программа понимает, что пора выходить, вставить присаивание ShuherValim = true; и всё немедленно вывалится из всех циклов (а те, что ещё не начиналиь, и не начнутся).

Пнд, 23/11/2015 - 11:56

#13

Timofei-Iridium

Offline

Зарегистрирован: 20.11.2015

Длительность по разному. 10 - 15 секунд. Если ставить break в конкретном цикле то куб выключится. Я на примере в коде пару циклов оставлял и break вписал в них.

Пнд, 23/11/2015 - 11:57

#14

Gippopotam

Offline

Зарегистрирован: 12.09.2014

Tomasina пишет:

http://arduino.ru/Reference/Break

так из функции-же...

Пнд, 23/11/2015 - 12:21

#15

Tomasina

Offline

Зарегистрирован: 09.03.2013

Gippopotam пишет:

так из функции-же...

Из цикла выходим по break (с присваиванием флага), из функции по return (по анализу флага).

Пнд, 23/11/2015 - 12:28

#16

Timofei-Iridium

Offline

Зарегистрирован: 20.11.2015

по ретурну не получалось выходить. В ретурне писал if (raw>200) то return(runAll()) . Может это не верно

Пнд, 23/11/2015 - 12:33

#17

Timofei-Iridium

Offline

Зарегистрирован: 20.11.2015

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

Пнд, 23/11/2015 - 12:34

#18

Araris

Offline

Зарегистрирован: 09.11.2012

http://arduino.ru/Reference/Return читали ?

Пнд, 23/11/2015 - 12:39

#19

Timofei-Iridium

Offline

Зарегистрирован: 20.11.2015

Да читал. Я новичок в ардуино . может что не правильно делаю

if (raw>200) 
runAll();
return 1;
 }

В общем не компилируется ардуино пишет "fpermissive]"

Пнд, 23/11/2015 - 12:40

#20

Timofei-Iridium

Offline

Зарегистрирован: 20.11.2015

или даже если пишу return 0 тоже не компилируется

Пнд, 23/11/2015 - 12:46

#21

ЕвгенийП

Offline

Зарегистрирован: 25.05.2015

Timofei-Iridium пишет:

или даже если пишу return 0 тоже не компилируется

Не скомпилируется даже, если написать "return 2" или, страшно сказать, "return 100500".

Вы это делаете в функции loop, которая у Вас void (читайте что это такое).

Только неясно для чего Вам return в loop после runAll - сама-то runAll от этого не прервётся.

Пнд, 23/11/2015 - 13:03

#22

Timofei-Iridium

Offline

Зарегистрирован: 20.11.2015

А как когда можно выключить исполнение функции оператором return . Я пытаюсь разобраться , читаю разные статьи. Но пока не нашел про ретурн чтобы можно было функцию отключить .

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

Пнд, 23/11/2015 - 13:12

#23

ЕвгенийП

Offline

Зарегистрирован: 25.05.2015

Timofei-Iridium пишет:

А как когда можно выключить исполнение функции оператором return . Я пытаюсь разобраться , читаю разные статьи. Но пока не нашел про ретурн чтобы можно было функцию отключить .

http://people.toiit.sgu.ru/Sinelnikov/PT/C/Kern_Ritch.pdf - От корки до корки! С запуском и разбором всех примеров.

Пока не прочитаете, про свой скетч просто забудьте. Кога же прочитаете и разберёте все примеры - посмеётесь над тем, что Вы писали здесь и над своими нынешними проблемами.

Если будут вопросы по книге - готов проконсультировать. Пишите сюда. Но именно по книге. Консультаций по скетчу до изучения книги от меня больше не будет - нет смысла - Вы просто не понимаете, что Вам говорят из-за недостатка знаний. Пополните их сначала.

Пнд, 23/11/2015 - 13:16

#24

Gippopotam

Offline

Зарегистрирован: 12.09.2014

ЕвгенийП, за все время хоть кто-нибудь послушался и прочитал?

Пнд, 23/11/2015 - 13:22

#25

Timofei-Iridium

Offline

Зарегистрирован: 20.11.2015

Буду изучать. Спасибо за наставление

Пнд, 23/11/2015 - 13:23

#26

ЕвгенийП

Offline

Зарегистрирован: 25.05.2015

Gippopotam пишет:

ЕвгенийП, за все время хоть кто-нибудь послушался и прочитал?

Не знаю, за консультациями типа "что писать вместо main и printf" никто не обращался.

Пнд, 23/11/2015 - 13:40

#27

Tomasina

Offline

Зарегистрирован: 09.03.2013

#define FOTON_PIN A4
#define FOTON_LIMIT 200
byte column[16]={13,12,11,10,9,8,7,6,5,4,3,2,1,0};
//initializing and declaring led layers
byte layer[4]={A3,A2,A1,A0};
unsigned int time = 250;

void setup()
{
  pinMode(FOTON_PIN, INPUT);
  for(byte i = 0; i<16; i++) pinMode(column[i], OUTPUT);
  for(byte i = 0; i<4; i++) pinMode(layer[i], OUTPUT);
  //seeding random for random pattern
  randomSeed(analogRead(10));  // <=== это шо за фигня?
}

boolean checkSensor(byte sensorPin) // читаем фотосенсор
{
  if (analogRead(sensorPin) > FOTON_LIMIT) return false; // если светло, запрещаем выполнение
  else return true;
}

//xxxxxxxxxxxxxxxxxxxxFUNCTION LOOPxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
void loop()
{
  delay(200);
  if (checkSensor(FOTON_PIN)) runAll();
  else stopAll();
}


void runAll()
{
  turnEverythingOff();//turn all off
  if (checkSensor(FOTON_PIN)) flickerOn();
  if (checkSensor(FOTON_PIN)) turnEverythingOn();//turn all on
  delay(time);
  if (checkSensor(FOTON_PIN)) turnOnAndOffAllByLayerUpAndDownNotTimed();
  if (checkSensor(FOTON_PIN)) layerstompUpAndDown();
  if (checkSensor(FOTON_PIN)) turnOnAndOffAllByColumnSideways();
  delay(time);
  if (checkSensor(FOTON_PIN)) aroundEdgeDown();
  if (checkSensor(FOTON_PIN)) turnEverythingOff();
  if (checkSensor(FOTON_PIN)) randomflicker();
  if (checkSensor(FOTON_PIN)) randomRain();
  if (checkSensor(FOTON_PIN)) diagonalRectangle();
  if (checkSensor(FOTON_PIN)) goThroughAllLedsOneAtATime();
  if (checkSensor(FOTON_PIN)) propeller();
  if (checkSensor(FOTON_PIN)) spiralInAndOut();
  if (checkSensor(FOTON_PIN)) flickerOff();
  if (checkSensor(FOTON_PIN)) turnEverythingOff();
  delay(2000);
}

// if (raw>80){
// digitalWrite(A0,LOW);
//digitalWrite(A1,LOW);
//digitalWrite(A2,LOW);
// digitalWrite(A3,LOW);


void stopAll()
{
    digitalWrite(A0,LOW);
    digitalWrite(A1,LOW);
    digitalWrite(A2,LOW);
    digitalWrite(A3,LOW);
}


//xxxxxxxxxxxxxxxxxxxxFUNCTIONSxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

///////////////////////////////////////////////////////////turn all off
void turnEverythingOff()
{
  for(byte i = 0; i<16; i++)
  {
    digitalWrite(column[i], 1);
  }
  for(byte i = 0; i<4; i++)
  {
    digitalWrite(layer[i], 0);
  }
}

////////////////////////////////////////////////////////////turn all on
void turnEverythingOn()
{
  for(byte i = 0; i<16; i++)
  {
    digitalWrite(column[i], 0);
  }

  for(byte i = 0; i<4; i++)
  {
    digitalWrite(layer[i], 1);
  }
}
///////////////////////////////////////////////////////turn columns off
void turnColumnsOff()
{
  for(byte i = 0; i<16; i++)
  {
    digitalWrite(column[i], 1);
  }
}
/////////////////////////////////////////////////////////////flicker on
void flickerOn()
{
  byte i = 150;
  while(i != 0)
  {
    turnEverythingOn();
    delay(i);
    turnEverythingOff();
    delay(i);
    i-= 5;
  }
}
//////////////turn everything on and off by layer up and down NOT TIMED
void turnOnAndOffAllByLayerUpAndDownNotTimed()
{
  byte x = 75;
  for(int i = 5; i != 0; i--)
  {
    turnEverythingOn();
    for(int i = 4; i!=0; i--)
    {
      digitalWrite(layer[i-1], 0);
      delay(x);
    }
    for(int i = 0; i<4; i++)
    {
      digitalWrite(layer[i], 1);
      delay(x);
    }
    for(int i = 0; i<4; i++)
    {
      digitalWrite(layer[i], 0);
      delay(x);
    }
    for(int i = 4; i!=0; i--)
    {
      digitalWrite(layer[i-1], 1);
      delay(x);
    }
  }
}
//////////////////////////turn everything on and off by column sideways
void turnOnAndOffAllByColumnSideways()
{
  byte x = 75;
  turnEverythingOff();
  //turn on layers
  for(byte i = 0; i<4; i++)
  {
    digitalWrite(layer[i], 1);
  }
  for(byte y = 0; y<3; y++)
  {
    //turn on 0-3
    for(byte i = 0; i<4; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn on 4-7
    for(byte i = 4; i<8; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn on 8-11
    for(byte i = 8; i<12; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn on 12-15
    for(byte i = 12; i<16; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn off 0-3
    for(byte i = 0; i<4; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
    //turn off 4-7
    for(byte i = 4; i<8; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
    //turn off 8-11
    for(byte i = 8; i<12; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
    //turn off 12-15
    for(byte i = 12; i<16; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
    //turn on 12-15
    for(byte i = 12; i<16; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn on 8-11
    for(byte i = 8; i<12; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn on 4-7
    for(byte i = 4; i<8; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn on 0-3
    for(byte i = 0; i<4; i++)
    {
      digitalWrite(column[i], 0);
      delay(x);
    }
    //turn off 12-15
    for(byte i = 12; i<16; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
    //turn off 8-11
    for(byte i = 8; i<12; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
    //turn off 4-7
    for(byte i = 4; i<8; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
    //turn off 0-3
    for(byte i = 0; i<4; i++)
    {
      digitalWrite(column[i], 1);
      delay(x);
    }
  }
}
/////////////////////////////////////////up and down single layer stomp
void layerstompUpAndDown()
{
  byte x = 75;
  for(byte i = 0; i<4; i++)
  {
    digitalWrite(layer[i], 0);
  }
  for(byte y = 0; y<5; y++)
  {
    for(byte count = 0; count<1; count++)
    { 
      for(byte i = 0; i<4; i++)
      {
        digitalWrite(layer[i], 1);
        delay(x);
        digitalWrite(layer[i], 0);
      }
      for(byte i = 4; i !=0; i--)
      {
        digitalWrite(layer[i-1], 1);
        delay(x);
        digitalWrite(layer[i-1], 0);
      }
    }
    for(byte i = 0; i<4; i++)
    {
      digitalWrite(layer[i], 1);
      delay(x);
    }
    for(byte i = 4; i!=0; i--)
    {
      digitalWrite(layer[i-1], 0);
      delay(x);
    }
  }
}
////////////////////////////////////////////////////////////flicker off
void flickerOff()
{
  turnEverythingOn();
  for(byte i = 0; i!= 150; i+=5)
  {
    turnEverythingOff();
    delay(i+50);
    turnEverythingOn();
    delay(i);
  }
}
///////////////////////////////////////////around edge of the cube down
void aroundEdgeDown()
{
  for(byte x = 200; x != 0; x -=50)
  {
    turnEverythingOff();
    for(byte i = 4; i != 0; i--)
    {
      digitalWrite(layer[i-1], 1);
      digitalWrite(column[5], 0);
      digitalWrite(column[6], 0);
      digitalWrite(column[9], 0);
      digitalWrite(column[10], 0);
      digitalWrite(column[0], 0);
      delay(x);
      digitalWrite(column[0], 1);
      digitalWrite(column[4], 0);
      delay(x);
      digitalWrite(column[4], 1);
      digitalWrite(column[8], 0);
      delay(x);
      digitalWrite(column[8], 1);
      digitalWrite(column[12], 0);
      delay(x);
      digitalWrite(column[12], 1);
      digitalWrite(column[13], 0);
      delay(x);
      digitalWrite(column[13], 1);
      digitalWrite(column[15], 0);
      delay(x);
      digitalWrite(column[15], 1);
      digitalWrite(column[14], 0);
      delay(x);
      digitalWrite(column[14], 1);
      digitalWrite(column[11], 0);
      delay(x);
      digitalWrite(column[11], 1);
      digitalWrite(column[7], 0);
      delay(x);
      digitalWrite(column[7], 1);
      digitalWrite(column[3], 0);
      delay(x);
      digitalWrite(column[3], 1);
      digitalWrite(column[2], 0);
      delay(x);
      digitalWrite(column[2], 1);
      digitalWrite(column[1], 0);
      delay(x);
      digitalWrite(column[1], 1);
    }
  }
}
/////////////////////////////////////////////////////////random flicker
void randomflicker()
{
  turnEverythingOff();
  byte x = 10;
  for(int i = 0; i !=750; i+=2)
  {
    byte randomLayer = random(0,4);
    byte randomColumn = random(0,16);

    digitalWrite(layer[randomLayer], 1);
    digitalWrite(column[randomColumn], 0);
    delay(x);
    digitalWrite(layer[randomLayer], 0);
    digitalWrite(column[randomColumn], 1);
    delay(x); 
  }
}
////////////////////////////////////////////////////////////random rain
void randomRain()
{
  turnEverythingOff();
  byte x = 100;
  for(byte i = 0; i!=60; i+=2)
  {
    byte randomColumn = random(0,16);
    digitalWrite(column[randomColumn], 0);
    digitalWrite(layer[0], 1);
    delay(x+50);
    digitalWrite(layer[0], 0);
    digitalWrite(layer[1], 1);
    delay(x);
    digitalWrite(layer[1], 0);
    digitalWrite(layer[2], 1);
    delay(x);
    digitalWrite(layer[2], 0);
    digitalWrite(layer[3], 1);
    delay(x+50);
    digitalWrite(layer[3], 0);
    digitalWrite(column[randomColumn], 1);
  }
}
/////////////////////////////////////////////////////diagonal rectangle
void diagonalRectangle()
{
  int x = 350;
  turnEverythingOff();
  for(byte count = 0; count<5; count++)
  {
    //top left
    for(byte i = 0; i<8; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[3], 1);
    digitalWrite(layer[2], 1);
    delay(x);
    turnEverythingOff();
    //middle middle
    for(byte i = 4; i<12; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[1], 1);
    digitalWrite(layer[2], 1);
    delay(x);
    turnEverythingOff();
    //bottom right
    for(byte i = 8; i<16; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[0], 1);
    digitalWrite(layer[1], 1);
    delay(x);
    turnEverythingOff();
    //bottom middle
    for(byte i = 4; i<12; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[0], 1);
    digitalWrite(layer[1], 1);
    delay(x);
    turnEverythingOff();
    //bottom left
    for(byte i = 0; i<8; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[0], 1);
    digitalWrite(layer[1], 1);
    delay(x);
    turnEverythingOff();
    //middle middle
    for(byte i = 4; i<12; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[1], 1);
    digitalWrite(layer[2], 1);
    delay(x);
    turnEverythingOff();
    //top right
    for(byte i = 8; i<16; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[2], 1);
    digitalWrite(layer[3], 1);
    delay(x);
    turnEverythingOff();
    //top middle
    for(byte i = 4; i<12; i++)
    {
      digitalWrite(column[i], 0);
    }
    digitalWrite(layer[2], 1);
    digitalWrite(layer[3], 1);
    delay(x);
    turnEverythingOff();
  }
  //top left
  for(byte i = 0; i<8; i++)
  {
    digitalWrite(column[i], 0);
  }
  digitalWrite(layer[3], 1);
  digitalWrite(layer[2], 1);
  delay(x);
  turnEverythingOff();
}
//////////////////////////////////////////////////////////////propeller
void propeller()
{
  turnEverythingOff();
  byte x = 90;
  for(byte y = 4; y>0; y--)
  {
    for(byte i = 0; i<6; i++)
    {
      //turn on layer
      digitalWrite(layer[y-1], 1);
      //a1
      turnColumnsOff();
      digitalWrite(column[0], 0);
      digitalWrite(column[5], 0);
      digitalWrite(column[10], 0);
      digitalWrite(column[15], 0);
      delay(x);
      //b1
      turnColumnsOff();
      digitalWrite(column[4], 0);
      digitalWrite(column[5], 0);
      digitalWrite(column[10], 0);
      digitalWrite(column[11], 0);
      delay(x);
      //c1
      turnColumnsOff();
      digitalWrite(column[6], 0);
      digitalWrite(column[7], 0);
      digitalWrite(column[8], 0);
      digitalWrite(column[9], 0);
      delay(x);
      //d1
      turnColumnsOff();
      digitalWrite(column[3], 0);
      digitalWrite(column[6], 0);
      digitalWrite(column[9], 0);
      digitalWrite(column[12], 0);
      delay(x);
      //d2
      turnColumnsOff();
      digitalWrite(column[2], 0);
      digitalWrite(column[6], 0);
      digitalWrite(column[9], 0);
      digitalWrite(column[13], 0);
      delay(x);
      //d3
      turnColumnsOff();
      digitalWrite(column[1], 0);
      digitalWrite(column[5], 0);
      digitalWrite(column[10], 0);
      digitalWrite(column[14], 0);
      delay(x);
    }
  }
  //d4
  turnColumnsOff();
  digitalWrite(column[0], 0);
  digitalWrite(column[5], 0);
  digitalWrite(column[10], 0);
  digitalWrite(column[15], 0);
  delay(x);
}
//////////////////////////////////////////////////////spiral in and out
void spiralInAndOut()
{
  turnEverythingOn();
  byte x = 60;
  for(byte i = 0; i<6; i++)
  {
    if (checkSensor(FOTON_PIN)) 
    {
      //spiral in clockwise
      digitalWrite(column[0], 1);
      delay(x);
      digitalWrite(column[1], 1);
      delay(x);
      digitalWrite(column[2], 1);
      delay(x);
      digitalWrite(column[3], 1);
      delay(x);
      digitalWrite(column[7], 1);
      delay(x);
      digitalWrite(column[11], 1);
      delay(x);
      digitalWrite(column[15], 1);
      delay(x);
      digitalWrite(column[14], 1);
      delay(x);
      digitalWrite(column[13], 1);
      delay(x);
      digitalWrite(column[12], 1);
      delay(x);
      digitalWrite(column[8], 1);
      delay(x);
      digitalWrite(column[4], 1);
      delay(x);
      digitalWrite(column[5], 1);
      delay(x);
      digitalWrite(column[6], 1);
      delay(x);
      digitalWrite(column[10], 1);
      delay(x);
      digitalWrite(column[9], 1);
      delay(x);
    }
    if (checkSensor(FOTON_PIN)) 
    {
      ///////////////////////////////////////spiral out counter clockwise
      digitalWrite(column[9], 0);
      delay(x);
      digitalWrite(column[10], 0);
      delay(x);
      digitalWrite(column[6], 0);
      delay(x);
      digitalWrite(column[5], 0);
      delay(x);
      digitalWrite(column[4], 0);
      delay(x);
      digitalWrite(column[8], 0);
      delay(x);
      digitalWrite(column[12], 0);
      delay(x);
      digitalWrite(column[13], 0);
      delay(x);
      digitalWrite(column[14], 0);
      delay(x);
      digitalWrite(column[15], 0);
      delay(x);
      digitalWrite(column[11], 0);
      delay(x);
      digitalWrite(column[7], 0);
      delay(x);
      digitalWrite(column[3], 0);
      delay(x);
      digitalWrite(column[2], 0);
      delay(x);
      digitalWrite(column[1], 0);
      delay(x);
      digitalWrite(column[0], 0);
      delay(x);
    }
    if (checkSensor(FOTON_PIN)) 
    {
      ///////////////////////////////////////spiral in counter clock wise
      digitalWrite(column[0], 1);
      delay(x);
      digitalWrite(column[4], 1);
      delay(x);
      digitalWrite(column[8], 1);
      delay(x);
      digitalWrite(column[12], 1);
      delay(x);
      digitalWrite(column[13], 1);
      delay(x);
      digitalWrite(column[14], 1);
      delay(x);
      digitalWrite(column[15], 1);
      delay(x);
      digitalWrite(column[11], 1);
      delay(x);
      digitalWrite(column[7], 1);
      delay(x);
      digitalWrite(column[3], 1);
      delay(x);
      digitalWrite(column[2], 1);
      delay(x);
      digitalWrite(column[1], 1);
      delay(x);
      digitalWrite(column[5], 1);
      delay(x);
      digitalWrite(column[9], 1);
      delay(x);
      digitalWrite(column[10], 1);
      delay(x);
      digitalWrite(column[6], 1);
      delay(x);
    }
    if (checkSensor(FOTON_PIN)) 
    {
      //////////////////////////////////////////////spiral out clock wise
      digitalWrite(column[6], 0);
      delay(x);
      digitalWrite(column[10], 0);
      delay(x);
      digitalWrite(column[9], 0);
      delay(x);
      digitalWrite(column[5], 0);
      delay(x);
      digitalWrite(column[1], 0);
      delay(x);
      digitalWrite(column[2], 0);
      delay(x);
      digitalWrite(column[3], 0);
      delay(x);
      digitalWrite(column[7], 0);
      delay(x);
      digitalWrite(column[11], 0);
      delay(x);
      digitalWrite(column[15], 0);
      delay(x);
      digitalWrite(column[14], 0);
      delay(x);
      digitalWrite(column[13], 0);
      delay(x);
      digitalWrite(column[12], 0);
      delay(x);
      digitalWrite(column[8], 0);
      delay(x);
      digitalWrite(column[4], 0);
      delay(x);
      digitalWrite(column[0], 0);
      delay(x);
    }
  }
}
//////////////////////////////////////go through all leds one at a time
void goThroughAllLedsOneAtATime()
{
  byte x = 15;
  turnEverythingOff();
  for(byte y = 0; y<5; y++)
  {
    //0-3
    for(byte count = 4; count != 0; count--)
    {
      digitalWrite(layer[count-1], 1);
      for(byte i = 0; i<4; i++)
      {
        digitalWrite(column[i], 0);
        delay(x);
        digitalWrite(column[i], 1);
        delay(x);
      }
      digitalWrite(layer[count-1], 0);
    }
    //4-7
    for(byte count = 0; count < 4; count++)
    {
      digitalWrite(layer[count], 1);
      for(byte i = 4; i<8; i++)
      {
        digitalWrite(column[i], 0);
        delay(x);
        digitalWrite(column[i], 1);
        delay(x);
      }
      digitalWrite(layer[count], 0);
    }
    //8-11
    for(byte count = 4; count != 0; count--)
    {
      digitalWrite(layer[count-1], 1);
      for(byte i = 8; i<12; i++)
      {
        digitalWrite(column[i], 0);
        delay(x);
        digitalWrite(column[i], 1);
        delay(x);
      }
      digitalWrite(layer[count-1], 0);
    }
    //12-15
    for(byte count = 0; count < 4; count++)
    {
      digitalWrite(layer[count], 1);
      for(byte i = 12; i<16; i++)
      {
        digitalWrite(column[i], 0);
        delay(x);
        digitalWrite(column[i], 1);
        delay(x);
      }
      digitalWrite(layer[count], 0);
    }
  }
}

Пнд, 23/11/2015 - 13:45

#28

ЕвгенийП

Offline

Зарегистрирован: 25.05.2015

Tomasina! Блин! Опять ведь ни хрена не прочитает! :(((((((((

Пнд, 23/11/2015 - 14:04

#29

Tomasina

Offline

Зарегистрирован: 09.03.2013

а мы ему пряников не дадим, пока не объяснит как это работает :)

Пнд, 23/11/2015 - 14:43

#30

bwn

Offline

Зарегистрирован: 25.08.2014

Gippopotam пишет:

ЕвгенийП, за все время хоть кто-нибудь послушался и прочитал?

Я читаю, правда не быстро)))))

Пнд, 23/11/2015 - 18:49

#31

Arhat109-2

Offline

Зарегистрирован: 24.09.2015

А ежели ознакомиться с "Блин без делай", то всю портянку можно упростить в разы. Но .. это наверное уже "высший пилотаж" :)

Arduino.ru

Регистрация новых пользователей и создание новых тем теперь только на новом форуме https://forum.arduino.ru

Выход из функций. Как не ждать ее завершения?