Arduino.ru

не дважды, а примерно пол цикла по входу и цикл по выходу! так?

пойду читать - Паронджанова "Занимательная информатика"

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

А если навтречу другой чел пойдет? Ему в темноте идти?

Почему "в темноте"? Лампы уже зажжены первым проходом.

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

В этом плане, вариант когда "проходимец" дошел до середины и "встрял" .. вызовет тоже интересные эффекты .. но, решение таких коллизий - уже за пределами схемы и знаний ТС. Мне кажется. :)

Вот вот, он должен сработать, но просто обнулить задержку и начать ее заного! А если потухли ну скажем 4 лампы из 6, то надо оставить гореть эти две и начать включать с 3-4-5-6 лампы(так как 2 уже горят) или же начать с другого конца, включить 6-5-4-3 лампы (так как 2 уже горят)! В зависимости от того какой датчик сработал!

Тогда получится что если ходить туды-сюды, свет просто будет гореть, а пауза обнуляться и начинаться заного! Так?

Вообще мысль пришла отсюда, принцып почти похож https://www.youtube.com/watch?v=eBius-KsbDU

здесь еще понятнее, только задержки нет https://www.youtube.com/watch?v=8oDwhsmF-NA

В предложенном алгоритме, если сработал 1-й датчик (пусть будет левый), то лампы начинают включаться по одной слева-направо. А по истечении задержки (если ничего не произошло) они будут выключаться в том же самом порядке "слева направо". То есть, когда наш "проходимец" доходит до правого конца коридора, сзади него лампы начинают выключаться.

Если в этот момнент сработал правый (второй) датчик, то он запустит свой режим "справа-налево" и начнет включать лампы в этом направлении. А первый режим - будет продолжать их выключение. В итоге получится примерно так, лампы слева-направо 1..6:

1 .. 6 включены проходом "слева-направо", прошла пауза,

1,2 успели выключиться и тут сработал второй датчик: он пробует включить лампы в порядке 6,5,4,3,2,1 .. но они уже горят и ничего не изменится. А первый режим в это же время будет продолжать выключение ламп 3,4,5,6 .. итого имеем по шагам:

3 выкл + 6 вкл; 4 выкл + 5 вкл; 5 выкл + 4вкл; 6 выкл + 3вкл; всё + 2 вкл; все + 1вкл; все + пауза вкл. .. после паузы выключение в порядке 6,5,4,3,2,1.

Если правый датчик сработал по выходу единственного прохожего, то за его спиной будет вот такой "салют" в его честь. А если он сработал на входе второго прохожего, то он первые 2 лампы пройдет в темноте. Не забываем что время включения у нас 10миллисекунд на лампу - то есть "сразу".

Если это не то "что надо", то требуется доработка алгоритма, а именно: изменение режима на "включать" должно отменять режим выключения в обратном направлении. И только.

Ну и чтобы не пыжится включать уже включенные лампы можно ввести переменные, отслеживающие их состояния. А можно просто читать выходные пины ламп.

"Тогда получится что если ходить туды-сюды, свет просто будет гореть, а пауза обнуляться и начинаться заного! Так?"

Угу. А если дойти до середины и встать, то после задержки все погаснет, но дойдя до датчика - снова включится, хотя там уже никого и нет. :)

Какие-то коллизии в такой схеме все равно неизбежны при любом алгоритме, ибо "данных недостаточно".

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

#define fadePin1 10 //пин управления MOSFET транзистором

#define fadePin2 9 //пин управления MOSFET транзистором

#define fadePin3 6 //пин управления MOSFET транзистором



int calibrationTime = 30; //Время калибровки датчика (10-60 сек. по даташиту)

int pirPin1 = 2; //пин подключения управляющего сигнала PIR датчика1

int pirPin2 = 4; //пин подключения управляющего сигнала PIR датчика2



int light; //переменная для хранения состояния света (вкл/выкл)

void setup(){

Serial.begin(9600);

pinMode(pirPin1, INPUT); //настариваем 2 пин как вход для сигналов с датчика

pinMode(pirPin2, INPUT); //настариваем 4 пин как вход для сигналов с датчика

pinMode(fadePin1, OUTPUT); // пины на выход, для управления транзисотором

pinMode(fadePin2, OUTPUT);

pinMode(fadePin3, OUTPUT);

light = 0; //устанаваливаем переменную для первого включения света



Serial.print("Calibrating"); //дадим датчику время на калибровку

for(int i = 0; i < calibrationTime; i++)

{

Serial.print(".");

delay(1000);

}

Serial.println(" done");

Serial.println("SENSOR ACTIVE");

delay(50);



}

void fadeLED(byte pin, boolean state)



{for(int i = 255*(1-state); state ? i<=255 : i>=0; state ? i++ : i--)

{

analogWrite(pin, i);

Serial.println(i); // передаем данные в порт

delay(10);

}



}





void loop()



{

if(digitalRead(pirPin1)) // если есть движение



{ if(!light) // и если свет не был включен

{ fadeLED(fadePin1, HIGH);

fadeLED(fadePin2, HIGH);

fadeLED(fadePin3, HIGH);

} // включаем по очереди

delay(5000); // пауза после полного открытия всех транзисторов

light = 1; // передаем значение переменной, что свет включен

}

else // иначе

{

if(light) // и если свет включен

{ 

fadeLED(fadePin1, LOW);

fadeLED(fadePin2, LOW);

fadeLED(fadePin3, LOW);

} // выключаем по очереди

light = 0; // передаем значение переменной, что свет выключен



}



} 

для этого пауза и будет) 

Да, включится, отработает цикл и LOW, что и надо!

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

Да ушли уже эти проходимцы(я их нагнал пока))))), дайте на "коленках" поморгать 3-я светодиодами от одного и от другого датчика, в одну и в другую сторону!)

Так не получится при явно прописанных задержках в скетче! Пока идет delay() проц просто тупит и ничегошеньки не делает .. как же вы "второй датчик" (да и первый) собираетесь опрашивать в период задержки?

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

Да пока ни как, просто туды сюды! я принцып хочу понять, куда и что писать то надо!

void loop()
{

if(digitalRead(pirPin1)) // если есть движение
 { if(!light) // и если свет не был включен

 { fadeLED(fadePin1, HIGH);

   fadeLED(fadePin2, HIGH);

   fadeLED(fadePin3, HIGH);

  } // включаем по очереди

  delay(5000); // пауза после полного открытия всех транзисторов
  light = 1; // передаем значение переменной, что свет включен
}
if(digitalRead(pirPin2)) // если есть движение
 { if(!light) // и если свет не был включен

 { fadeLED(fadePin3, HIGH);

   fadeLED(fadePin2, HIGH);

   fadeLED(fadePin1, HIGH);

  } // включаем по очереди

  delay(5000); // пауза после полного открытия всех транзисторов
  light = 1; // передаем значение переменной, что свет включен
}

зажец, зажег, теперь бы потушить)))

я не против учиться, читаю, вникаю! то что вы пытаетесь понять что мне надо в конце, это пока только задумка! Сейчас хотя бы поморгать, не одним, а 3))))

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

Но у вас тут алгоритм такой:

Если сработал первый или второй датчик И свет выключен, то включаем лампы 1,2,3 (или 3,2,1) .. тупим 5 сек .. второй датчик пофиг, поскольку свет уже включен и выключаем лампы (5 сек уже прошло!). Далее повторяем все снова.

Первый или второй - потомучто проверка происходит ну очень быстро (16мгц!) и если не сработал первый, то мгновенно проверяется второй. А если сработал второй, то процесс одинаков.

Для 5сек задержек на прохождение коридора - пофиг. А если это улица и длинная .. то выставляя большую задержку получите и большое тупление .. без какой-либо реакции на датчики.

вот пока так и хочу, пусть пока тупит)

Ну тогда добавьте в конец блок выключения, как у вас было .. "Если свет горит .."

else // иначе
 {
   if(light) // и если свет включен
  { 
   fadeLED(fadePin1, LOW);

   fadeLED(fadePin2, LOW);

   fadeLED(fadePin3, LOW);

   } // выключаем по очереди

light = 0; // передаем значение переменной, что свет выключен
  }

как, если в 3 строке мы опрашиваем здесь только, включен ли свет?!

надо еще опросить датчики?

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

Паронджанов "Занимательная информатика" - очень поучительно, честное слово, даже в 32)))) , читаю дальше!

Добавьте без else и его скобок. Только if(light){..} типа так:

void loop()
{
  if(digitalRead(pirPin1)) // если есть движение
  {
    if(!light) // и если свет не был включен
    {
      fadeLED(fadePin1, HIGH); // включаем по очереди
      fadeLED(fadePin2, HIGH);
      fadeLED(fadePin3, HIGH);
    }
    delay(5000); // пауза после полного открытия всех транзисторов
    light = 1; // передаем значение переменной, что свет включен
  }

  if(digitalRead(pirPin2)) // если есть движение
  {
    if(!light) // и если свет не был включен
    {
      fadeLED(fadePin3, HIGH); // включаем по очереди
      fadeLED(fadePin2, HIGH);
      fadeLED(fadePin1, HIGH);
    }
    delay(5000); // пауза после полного открытия всех транзисторов
    light = 1; // передаем значение переменной, что свет включен
  }

  if(light) // и если свет включен
  { 
    fadeLED(fadePin1, LOW);
    fadeLED(fadePin2, LOW);
    fadeLED(fadePin3, LOW);
  } // выключаем по очереди
}

И не ленитесь оформлять текст отступами. Так куда как понятней и читабельней, верно? Ну и сразу. Тут у вас 2 раза проверяется и делается по сути одно и тоже. Можно улучшить, типа так:

// предварительно: int fadePinX = Y; заменить на #define fadePinX Y !!!

uint8_t fades[] = {fadePin1, fadePin2, fadePin3};

int       isGo = 0; // порядок включения ламп

void loop()
{
  int       num=0, max=0;

  if( ! light ) // сначала проверяем это!
  {
    if( digitalRead(pirPin1) ){ isGo = 1; num=0; max=3; }
    if( digitalRead(pirPin2) ){ isGo = -1; num=2; max=-1; }

    while( num != max ){
      fadeLED( fades[num], HIGH ); // включаем лампу num
      num += isGo;
    }

    delay(5000);
    light = 1;
//    isGo = -isGo; // это если надо выключать в обратном порядке.

  } else {

    if( isGo ){ num=0; max=3; }
    else      { num=2; max=-1; }

    while( num != max ){
      fadeLED( fades[num], LOW );
      num += isGo;
    }
    light = 0;
    isGo = 0;
  }
}

Так получается что выключение, 1-2-3, это первый датчик, а второй где 3-2-1?

 if(light) // и если свет включен
  { 
    fadeLED(fadePin1, LOW);
    fadeLED(fadePin2, LOW);
    fadeLED(fadePin3, LOW);
  } // выключаем по очереди

Ну и поскольку цикл "практически одинаков" его можно втянуть внутрь фукнции включения/выключения ламп, типа так:

// или какие там надо чиселки..
#define fadePin1 3
#define fadePin2 6
#define fadePin3 9

uint8_t fades[] = {fadePin1, fadePin2, fadePin3};

int       isGo = 0; // порядок включения ламп

void fadeLED(byte pin, boolean state, int is_go)
{
  int       num=0, max=0;

  if( is_go == 1 ){ num=0; max=3; }
  if( is_go == -1){ num=2; max=-1; }

  while( num != max ){
    for(int i = 255*(1-state); state ? i<=255 : i>=0; state ? i++ : i--)
    {
      analogWrite(pin, i);
      Serial.println(i); // передаем данные в порт
      delay(10);
    }
    num += is_go;
  }
}

void loop()
{
  if( ! light ) // сначала проверяем это!
  {
    if( digitalRead(pirPin1) ){ isGo = 1; }
    if( digitalRead(pirPin2) ){ isGo = -1; }

    fadeLED( fades[num], HIGH, isGo ); // включаем лампЫ

    delay(5000);
    light = 1;
//    isGo = -isGo; // это если надо выключать в обратном порядке.

  } else {

    fadeLED( fades[num], LOW, isGo );

    light = 0;
    isGo = 0;
  }
}

Так "ишо красявей" .. можно ещё int на знаковый байтик кое-где поменять для полной кузявости .. но! Это "не тот алгоритм". :)

Все, голова квадратная)))))))

для эстетики строки 18-23 по предложению Andy заменить на:

for(int i = 0; i <= 255; delay(10), i++) analogWrite(pin, state ? i : 255-i);

Правда, delay(10) внутри определения цикла я вижу впервые, но компилятор это переварил и не поперхнулся.

а мой поперхнулся, вот эток строчкой )

fadeLED( fades[num], HIGH, isGo );

разбираюсь...!))

Ой, я там накосячил..

// или какие там надо чиселки..
#define fadePin1 3
#define fadePin2 6
#define fadePin3 9

uint8_t fades[] = {fadePin1, fadePin2, fadePin3};

int       isGo = 0; // порядок включения ламп

void fadeLED(boolean state, int is_go)
{
  int       num=0, max=0;

  if( is_go == 1 ){ num=0; max=3; }
  if( is_go == -1){ num=2; max=-1; }

  while( num != max ){
    for(int i = 255*(1-state); state ? i<=255 : i>=0; state ? i++ : i--)
    {
      analogWrite(fades[num], i);
      Serial.println(i); // передаем данные в порт
      delay(10);
    }
    num += is_go;
  }
}

void loop()
{
  if( ! light ) // сначала проверяем это!
  {
    if( digitalRead(pirPin1) ){ isGo = 1; }
    if( digitalRead(pirPin2) ){ isGo = -1; }

    fadeLED( HIGH, isGo ); // включаем лампЫ

    delay(5000);
    light = 1;
//    isGo = -isGo; // это если надо выключать в обратном порядке.

  } else {

    fadeLED( LOW, isGo );

    light = 0;
    isGo = 0;
  }
}

Номер пина теперь в массиве и он вычисляется в цикле while внутри функции. Его и вовсе не надо в параметры передавать.

Остальное давайте уже завтра, а то у нас тут утро уже скоро.. :)

00:10 по Москве)

#define fadePin1 10 //пин управления MOSFET транзистором

#define fadePin2 9 //пин управления MOSFET транзистором

#define fadePin3 6 //пин управления MOSFET транзистором



int calibrationTime = 30; //Время калибровки датчика (10-60 сек. по даташиту)

int pirPin1 = 2; //пин подключения управляющего сигнала PIR датчика1

int pirPin2 = 4; //пин подключения управляющего сигнала PIR датчика2



int light; //переменная для хранения состояния света (вкл/выкл)

void setup(){

Serial.begin(9600);

pinMode(pirPin1, INPUT); //настариваем 2 пин как вход для сигналов с датчика

pinMode(pirPin2, INPUT); //настариваем 4 пин как вход для сигналов с датчика

pinMode(fadePin1, OUTPUT); // пины на выход, для управления транзисотором

pinMode(fadePin2, OUTPUT);

pinMode(fadePin3, OUTPUT);

light = 0; //устанаваливаем переменную для первого включения света



 Serial.print("Calibrating"); //дадим датчику время на калибровку

 for(int i = 0; i < calibrationTime; i++)

{

 Serial.print(".");
 delay(1000);

}

 Serial.println(" done");
 Serial.println("SENSOR ACTIVE");
 delay(50);

}
uint8_t fades[] = {fadePin1, fadePin2, fadePin3};

int       isGo = 0; // порядок включения ламп

void fadeLED(boolean state, int is_go)
{
  int       num=0, max=0;

  if( is_go == 1 ){ num=0; max=3; }
  if( is_go == -1){ num=2; max=-1; }

  while( num != max ){
    for(int i = 255*(1-state); state ? i<=255 : i>=0; state ? i++ : i--)
    {
      analogWrite(fades[num], i);
      Serial.println(i); // передаем данные в порт
      delay(10);
    }
    num += is_go;
  }
}

void loop()
{
  if( ! light ) // сначала проверяем это!
  {
    if( digitalRead(pirPin1) ){ isGo = 1; }
    if( digitalRead(pirPin2) ){ isGo = -1; }

    fadeLED( HIGH, isGo ); // включаем лампЫ

    delay(5000);
    light = 1;
//    isGo = -isGo; // это если надо выключать в обратном порядке.

  } else {

    fadeLED( LOW, isGo );

    light = 0;
    isGo = 0;
  }
}

работает, как и хотел! Спасибо! Вот только одно НО, после выключения, какая то задержка что ли, датчики не реагируют вообще секунд 5-7( почему?

Все, с задержкой разобрался, датчики движения виноваты! Вот почему я не люблю pir сенсоры, не надежные, не всегда срабатывают( а чем заменить незнаю!

Вот как раз вопрос, такой датчик на ардуино есть?

http://ru.aliexpress.com/item/High-Quality-Single-Beam-Alarm-Photoelectr...

я что то не нашел!(

на датчиках есть одна-две оранжевые крутилки, регулируют длительность включения и уровень освещенности.

Вообщем не спал всю ночь, все в голову лезет; а если...? а вдруг...? а если так но не эдак?)))

Вот как я вижу ТЗ и меня здесь все устраивает!

1. а)Светло - спим

    б) темно - подъем

    в) проверка датчиков.

2. а) Нет движения - ждем

    б) движение датчик 1 - включаем с лево на право

       (если вдруг движение на 2 датчике и если свет не включен весь, включаем дальше, но как в п.2(г) если все            уже включено то п.3(б)  )

    в) движение датчик 2 - включаем с право на лево 

       (если вдруг движение на 1 датчике и если свет не включен весь, включаем дальше, но как в п.2(г) если все             уже включено то п.3(б)  )

    г) движение на датчиках 1+2 - включаем от краев в центр.

3. а) Запускаем отсчет паузы

    б) если вдруг движение - ДОБАВЛЯЕМ к паузе еще какое-то значение (при каждом движении ++i(это уже     опытным путем, тут не попасть сразу))

    в) Движения нет - пауза, пауза прошла,

4. Выключаем - как п.2, только в обратном порядке.  Движение!!! - стоп! все как есть на данном моменте и переход в п.2 (п.2 начинаем не сначала, а с момента на котором остановился п.4)

Да, все именно так!)

Щас мы опять все перевернем...

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

В итоге все придет к выбросу ардуино и установке датчика движения на каждый фонарь - при этом "аппаратная" логика будет работать стабильно, вне зависимости от количества объектов, их скорости и направления :)

Кстати, вы в курсе, что стоимость эксплуатации (более частая покупка и замена ламп из-за их постоянного включения, не любят ни этого) может превысить экономию электричества?

Это моя дорога, и только моя) по участку, 80м)

лампы да, а диодам "пофиг" будут стоять "кукурузы" только пределанные на 12 в) питание все от 12 в

это не касается LED светильников, им пофиг на включение выключение...

Ждем уважаемого Arhat109-2, он точно все раскритикует!) но это же и хорошо!)

Я только ЗА! Может увижу что то, что не заметил!

Дело не в экономии, это для красоты!)

1. а)Светло - спим(выход из loop)

    б) темно (не светло, иначе) - подъем (просто продолжаем далее)

    в) проверка датчиков. Угу, обоих и сразу в п.2. :)

2. а) Нет движения - ждем (выход из loop)

    б) сработал датчик 1: тут - ничего не включаем. Только фиксируем изменение его состояния (isGo1=1) на "включить слева-направо". Далее к "2.в"

       (реальное включение мы будем делать "постепенно" дальше .. по 1 лампе, каждый раз завершая loop, дабы не потерять срабатывание датчиков)

    в) сработал датчик 2: аналогично, просто фиксируем состояние "справа-налево" (isGo2=1). И далее к п.3.

 --   г) движение на датчиках 1+2 - включаем от краев в центр. (незачем, само так получится)

3. А вот тут как раз проверяем признаки состояния isGo1, isGo2 и включаем лампы согласно правилам (по одной за 1 проход loop!):

3.а) isGo1=1: включаем лампу в порядке 1,2,3,.. предварительно проверяя не включены ли они уже.

3.б) isGo2=1: включаем лампу в порядке 6,5,4,.. также с проверкой.

** Если включения "встретились" (лампа оказалась включена), то фиксируем точку встречи в каждом направлении num1 = N. Потом, если потребуется выключать (нет никого), выключать будем от этой лампы, "каждый в свою сторону".

** Если включили последнюю лампу - Запускаем отсчет паузы. Пауза одна, и соответственно какое направление завершится последним, то и будет рулить паузой.

--    б) если вдруг движение - ДОБАВЛЯЕМ к паузе еще какое-то значение (при каждом движении ++i(это уже     опытным путем, тут не попасть сразу)) не требуется, само случится.

4. не так: Движения нет - пауза, пауза прошла,

4. Если лампы включены И прошла пауза (это и означает что нет движения, иначе пауза обновляется!), то: Выключаем - как п.2, только в обратном порядке. Точно также строго по 1 лампе за 1 проход loop.

 Движение!!! - стоп! все как есть на данном моменте и переход в п.2 (п.2 начинаем не сначала, а с момента на котором остановился п.4) -- не требуется. Само отловится началом loop, если из него выходить после изменения состояния КАЖДОГО действия с КАЖДОЙ лампой.

Получается что цикл loop не один, а как бы 8 что ли?

Один конечно. Просто на каждом проходе цикла он может делать "что-то" из этих пунктов. Ровно то, что в данном месте требуется делать. Или по-другому, исполнять действия ровно того состояния, в котором находится конечный автомат:

1. сработал датчик - изменил состояние на "включение".

2. состояние "включение" - зажгло лампу, переключилось на слудующую.

3. повтор состояния 2, пока не зажглись все лампы. Последняя изменяет состояние на включена пауза.

4. прохождение времени паузы - разрешает отработать состояние "выключение лампы".

5. выключение последней лампы меняет состояние на ожидание.

.. и так "по кругу", согласно правилам перехода между состояниями. И заметьте, что на каждом входе в loop мы имеем возможность опрашивать датчики и изменить ими состояние ещё раз.

был п.5, выключали третью лампу и тут, при заходе в loop, внезапно сработал датчик заново: он переводит автомат в состояние "включаем" .. и опять с первой лампы и снова новая пауза.

Это классическая схема "силуэт", в которой выбор текущей ветки исполнения определяется не иконой "выбор", а последовательной проверкой условий с заданным и возможно управляемым порядком прохождения веток. Узнаете? :)

)))) "Покраска забора")

Угу. Мои правки к вашему понимаю алгоритма - приняты? Там нет ничего "косячного", посмотрели? :)

Конечно! Так впринцыпе все так и осталось! Здесь вся фишка что у меня алгоритм это просто мысли и слова, а у Вас мысли слова и + программа(точнее знание как куда и что)))!

Вот здесь только вопрос; ** Если включили последнюю лампу - Запускаем отсчет паузы. Пауза одна, и соответственно какое направление завершится последним, то и будет рулить паузой.

а влиять на смену направления выключения ламп влиять не будет?

А давайте завтра проверим. А то после бессонной ночи .. да после пива .. по идее, каждое направление как-бы независимый набор состояний автомата, и если помните, я вам предлагал направления и вовсе оформить в виде массива. То есть, есть 2 направления (2 датчика как у вас) можно проверять их по очереди и их обработку чередовать в loop(), но если рассмотреть вопрос "ширшее", то можно (в будущем) заточить скетч под большее количество датчиков - направлений и тогда правильнее все данные по направлению оформить массивом от количества направлений и все состояния автомата тупо перебирать в цикле направлений. По сути как-бы "над loop()" возникает ещё перебор направлений вместо "двух" датчиков .. блин, сам не понял - понятно выразился или куда .. :)

Давайте до завтра.

А нужны ли они, енти датчики еще, вот учем вопрос))) 

А чё, прикольная задачка, как на олимпиаде в старших классах, держи мой вариант на 8 ламп.  Сколько нужно в реале из темы не понял, но все легко масштабировать до 32. Сетап не писал, это скучно. Обяснения в коментариях. Можна немного оптимизировать, но то пусть другой укажет (я его потом пошлю как всегда ;) Таймаут один и одинаков, надо разные - не проблема. Понятно на лампах не пробовал, но компилируется. 

byte LeftLED=0;
byte RigthLED=0;
int OldTime;
#define TIME_WAVE 5000  //5 sec
#define Fotodiod digitalRead(8)
#define PIR_left digitalRead(9)
#define PIR_rigth digitalRead(10)
#define OutLED(a) PORTD=a

void loop(void)
{
  int Time=millis(); //текущее время только здесь
  
  if(LeftLED || RigthLED) //чтото светит, датчик света не интересен
  {
    if(Time-OldTime>TIME_WAVE) //таймер сработал
    {
      OldTime=Time; //таймер дальше
      
      if(LeftLED==0xff) //светится все
        LeftLED=0x7f;
      else
        LeftLED=(LeftLED>>1) | (LeftLED & 0x80);
        
      if(RigthLED==0xff) //светится все
        RigthLED=0xfe;  // тушим первую
      else
        RigthLED=(RigthLED<<1) | (RigthLED & 1); //сдвигаем с заполнением нового разряда старым значением
    }
  }
  else //ничего не светится, проверяем датчик света
    if(Fotodiod) //светло
      return;
  
  if(!LeftLED)   //слева не стартовали
    if(PIR_left) //проверим левый датчик
    {
      LeftLED=0x80; //старт слева
      OldTime=Time; //таймер актуализируем
    }
    
  if(!RigthLED)
    if(PIR_rigth)
    {
      RigthLED=1;
      OldTime=Time;
    }
    
   OutLED(RigthLED | LeftLED);
}

ну вот, пришел Logik и все опошлил битовыми операциями. Теперь точно никто не сможет разобраться в скетче :)