Светофор

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

Народ , нужна ваша помощь.
Встала задача сделать светофор и семафор для детского автодрома.

Два трехцветных светофора должны последовательно включать и выключать цвета .
Семафор должен 5 минут работать , 5 неработать , при том , в режиме работы
он должен мигать с частотой примерно 10Гц ,т.е. 5 минут мигает ,5 минут негорит.

Светофор и семафор должны быть независимыми друг от друга.
Вот в этом то вся проблема .
Мои попытки сделать на таймере ни к чему не привели.

Может у кого есть примеры подходящих таймеров ?

 

Железо:
фридуино
светодиодные кластеры
БП от компа
Микросхема ULN2003

...ну и мелочь 

26rus
26rus аватар
Offline
Зарегистрирован: 03.05.2011

со светофорами все просто...

fritzing.org/projects/digital-inputoutput-traffic-light/

fritzing.org/projects/arduino-variable-cycle-traffic-lights-wpush-button/

fritzing.org/projects/the-weirdest-traffic-light/

(скетчи и схемы по ссылкам)

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

ЗЫ: семафор лучше связать со светофорами, а то будет ситуация как в жизни, то все едут, то всё стоит...

ну это конечно зависит от развяски дороги :)

 

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

Спасибо буду пробовать.

Под семафором я имел в виду жедезнодорожный светофор. 

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

К сожалению не то .

Мне таймеры нужны. 

26rus
26rus аватар
Offline
Зарегистрирован: 03.05.2011

в скетче прописать временные интервалы и усё...

или таймеры - цифровые индикаторы с обратным отсчетом?

26rus
26rus аватар
Offline
Зарегистрирован: 03.05.2011

это www.youtube.com/watch видео, как моргает светофор собраный по схеме fritzing.org/projects/the-weirdest-traffic-light/

временные интервалы и амплитуду думаю исправить не проблема...

const int pinR = 13;
const int pinY = 12;
const int pinG = 11;

const int durationMs = 4000;

typedef enum EState {
  RED = 0,
  YELLOW = 1,
  GREEN = 2,
  REDYELLOW = 3
} State;

State light = RED;

void setup()
{
    pinMode(pinR, OUTPUT); 
    pinMode(pinY, OUTPUT);
    pinMode(pinG, OUTPUT);
    
    // blink yellow
    for(int i=0; i<5; ++i)
    {
        digitalWrite(pinY, HIGH);
        delay(1000);
        digitalWrite(pinY, LOW);
        delay(1000);
    }
    
    // switch to red and wait
    digitalWrite(pinR, HIGH);
    delay(2000);
}

void loop()
{ 
    switch(light)
    {
        case RED: 
            digitalWrite(pinR, HIGH);
            digitalWrite(pinY, LOW);
            light = REDYELLOW;
            break;
            
        case REDYELLOW: 
            digitalWrite(pinR, HIGH);
            digitalWrite(pinY, HIGH);
            digitalWrite(pinG, LOW);
            light = GREEN;
            break;            
            
        case GREEN: 
            digitalWrite(pinR, LOW);
            digitalWrite(pinY, LOW);
            digitalWrite(pinG, HIGH);
            light = YELLOW;
            break;

        case YELLOW: 
            digitalWrite(pinY, HIGH);
            digitalWrite(pinG, LOW);
            light = RED;
            break;
    }
    
    delay(durationMs);
}

на всякий случай скетч...

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

"Таймеры " это вместо delay.

Что бы программа не останавливалась в моменты задержек. 

Вэтой программе присутствует паразитный delay ,который помешает работе семафора .

Adessit
Adessit аватар
Offline
Зарегистрирован: 12.04.2011

есть на форуме пример, про мигающий светодиод без приостановки всей программы написан с использованием millis() . Сравниваются 2 числа таймера и если оно равно времени задержки то загорается/тухнет. Пины если задаёшь значение 1 то оно так и держиться единицей пока не задашь новое значение) 

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011








long previousMillis = 0;   
long interval = 1000;    

void setup()
{
  pinMode(13, OUTPUT); 
}

void loop()
{

 
 
  if (millis() - previousMillis > interval) 
{

    previousMillis = millis();   
    
   digitalWrite(13,!digitalRead(13));
  }
}

 Если вы это имели в виду , то с тремя цветами светофора оно не работает.

 

 

Adessit
Adessit аватар
Offline
Зарегистрирован: 12.04.2011

а почему нет? Сделайте 2 функции:

1я светофора

2я семафора

в loop()

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

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

Далее еще можно внедрить DigitalWriteFast для ускорения вывода, но сомневаюсь что в нём будет нужда.

Давайте схему подключений помогу с программой) Что к какому пину и схему переключений цветов по времени, событиям

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

Буду очень юлагодарен если поможете с программой.

 

Схема простейшая , к выходам МК подключена ULN2003 (транзисторная сборка) через нее запитываем нагрузку -

светодиодные кластеры.

Девять пинов на два светофора, три пина на семафор (два горят попеременно , один постоянно).

 

Алгоритм :

Зеленый первого светофора горит 25с  потом 5с моргает , в это время красный второго горит.

Зеленый гаснет , желтый включается , горит 10с , красный второго горит.

Желтый гаснет , включается красный  40с , красный второго гаснет включается зеленый второго.

Потом повторяется то же самое , только наоборот.

Вот программа для двух светофоров , которую я сделал на delay , а надо на таймерах  , что бы семафор 

работал независимо от двух светофоров.

void setup ()
{
  
  
   pinMode(13,OUTPUT);
   pinMode(14,OUTPUT);
   pinMode(12,OUTPUT);
   
   
    pinMode(15,OUTPUT);
   pinMode(16,OUTPUT);
   pinMode(17,OUTPUT);
   
   
}

void loop ()

{
  
   digitalWrite(13,HIGH);
 
  digitalWrite(14,HIGH);
  delay(25000);
  digitalWrite(14,LOW);
  delay(500);
  digitalWrite(14,HIGH);
  delay(500);
  digitalWrite(14,LOW);
  delay(500);
  digitalWrite(14,HIGH);
  delay(500);
  digitalWrite(14,LOW);
  delay(500);
  digitalWrite(14,HIGH);
  delay(500);
  digitalWrite(14,LOW);
  delay(500);
  digitalWrite(14,HIGH);
  delay(500);
  digitalWrite(14,LOW);
  delay(500);
  digitalWrite(14,HIGH);
  delay(500);
  digitalWrite(14,LOW);
 
  
  
   digitalWrite(15,HIGH);
  delay(10000);
  digitalWrite(15,LOW);
  
   digitalWrite(13,LOW);
   
   
    digitalWrite(16,HIGH);
    
    
    
   digitalWrite(17,HIGH);
  delay(25000);
  digitalWrite(17,LOW);
  delay(500);
  digitalWrite(17,HIGH);
  delay(500);
  digitalWrite(17,LOW);
  delay(500);
  digitalWrite(17,HIGH);
  delay(500);
  digitalWrite(17,LOW);
  delay(500);
  digitalWrite(17,HIGH);
  delay(500);
  digitalWrite(17,LOW);
  delay(500);
  digitalWrite(17,HIGH);
  delay(500);
  digitalWrite(17,LOW);
  delay(500);
  digitalWrite(17,HIGH);
  delay(500);
  digitalWrite(17,LOW);
  
  
  digitalWrite(12,HIGH);
  delay(10000);
   digitalWrite(12,LOW);
  
   digitalWrite(16,LOW);
  
 
  
 
 
  
}

 

 

 

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

Семафор :

Два пина работают попеременно 5минут (один работает 1с гаснет включается второй 1с и т.д.)

В течении этих же пять минут горит третий пин ( не моргает) , потом все гаснет на 5минут.

 

Таймеры нужны мне также для того что бы "Онлайн" опрашивать АЦП  , для регулировки временной задержки

вкл/выкл семафора , с помощью переменных резисторов. 

Adessit
Adessit аватар
Offline
Зарегистрирован: 12.04.2011

ОК,я всё ваше понял, ничего сложного не вижу 

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

Adessit

Если честно , то я не умею работать с дополнительными функциями и прерываниями (просто не было необходимости в них),

но учиться нужно . Может дадите толковую ссылку (для чайников) , а то я что то не очень "впитал" статью про функции с этого сайта.

 

Adessit
Adessit аватар
Offline
Зарегистрирован: 12.04.2011
void svetoforOne(int g, int y, int r)
 {
  if(g==0)
  {
  digitalWrite(sv2green, LOW); //если подали на вход функции первый 0 - то зеленый тухнет
  }
  
  if(g==1){
  digitalWrite(sv2green, HIGH);//если подали на вход функции первую 1 - то зеленый загорается
  }
  
  if(y==0)
  {
  digitalWrite(sv2yellow, LOW);
  }
  
  if(y==1)
  {
  digitalWrite(sv2yellow, HIGH);
  }
  
   if(r==0)
  {
  digitalWrite(sv2red, LOW);
  }
  if(r==1)
  {
  digitalWrite(sv2red, HIGH);
  }
}


Кусок из программы которая будет у вас. Делаю это раз чтоб потом сто раз не писать эти значения. Тоесть если подать svetofor1(1,0,0)
то будет гореть только зеленый
Ссылку пока не нашел, много работы


 

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

А как вызвать эту функцию ?

Как , вообще , будет выглядеть программа ? 

Adessit
Adessit аватар
Offline
Зарегистрирован: 12.04.2011

константы

пины

переменные

 все дополнительные функции

setup()

loop()

миллион проверок "Если" масса промежуточных значений, думал будет проще, но уже самому интересно;) код большой будет но всё коментирую на русском

 

Вызвать новую фнкцию просто, в loop гдето в коде просто пишешь svetoforOne(x,y,z) где х,y,z могут принимать или 1 или 0, что включает или выключает соответствующий цвет.x-красный, y-желтый, z-красный.

 

Adessit
Adessit аватар
Offline
Зарегистрирован: 12.04.2011

Но код обещает быть быстрым;) 

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

Вот так оно даже компилироваться не хочет

 

int sv2green =11;
int sv2yellow=12;
int sv2red=13;

void setup()
{
pinMode(sv2yellow,OUTPUT);
pinMode(sv2red,OUTPUT);
pinMode(sv2green,OUTPUT);



}



void loop()
{
 
 svetoforOne( g,  y,  r)
  
  
  
  
  
}



void svetoforOne(int g, int y, int r)
	 {
	  if(g==0)
	  {
	  digitalWrite(sv2green, LOW); //если подали на вход функции первый 0 - то зеленый тухнет
	  }
	   
	  if(g==1){
	  digitalWrite(sv2green, HIGH);//если подали на вход функции первую 1 - то зеленый загорается
	  }
	   
	  if(y==0)
	  {
	  digitalWrite(sv2yellow, LOW);
	  }
	   
	  if(y==1)
	  {
	  digitalWrite(sv2yellow, HIGH);
	  }
	   
	   if(r==0)
	  {
	  digitalWrite(sv2red, LOW);
	  }
	  if(r==1)
	  {
	  digitalWrite(sv2red, HIGH);
	  }
	}






 

Adessit
Adessit аватар
Offline
Зарегистрирован: 12.04.2011

void loop()
 {
  
svetoforOne( g, y, r)
 } 

А напиши вместо  g, y, r - (1,0,1)
 

Так как написал ты можно если ты в Loop даш тип данным и запишешь каждой букве значение от нуля до единицы

int g=0;

in r=1;

int y=0;

 

 

Adessit
Adessit аватар
Offline
Зарегистрирован: 12.04.2011

и этот код лишь одной функции -  малая часть программы;) 

kikia99
Offline
Зарегистрирован: 22.03.2011

а не проще ввести одну переменную  и увеличивать ее на еденицу

всем сигналам присвоить константные значения и сравнивать с переменной

при достижение равенства (событие) плюс много связанных событий со сменой знака  

Adessit
Adessit аватар
Offline
Зарегистрирован: 12.04.2011

Ну задача одновременно чтоб работали 2 светофора и один семафор, чтоб переключения зависили только от времени, "паралельно" всё работало.

Ваш код? А то не много не понял вас. Если про секундный счетчик то я понял, я так и думаю сделать, учет вести не в милисекундах а в секундах

Adessit
Adessit аватар
Offline
Зарегистрирован: 12.04.2011

ААА я нашел)))))))))))))))))

Опечатка в программе!!!! Некоторые коментарии нужно перепроверить

Вот ниже будет полный код на 2 светофора:

//обьявляем все пины лампочек

#define sv1green 10 //зеленый первого светофора
#define sv1yellow 11 // желтый первого светофора
#define sv1red 12 // красный первого светофора
#define sv2green 7
#define sv2yellow 8
#define sv2red 9
#define semblink1 6 //мигающая первая лампа семафора
#define semblink2 5 //вторая
#define semlamp3 4 //третья постоянно горящая

//переменные хранящие предыдущее значение для сравнения с текущим, начальное значение нуль

long timerStateG1=0; 
long timerStateG2=0; 
//long timerStateSem=0;

//переменные значения интервалов для кождой лампочки семафора и светофоров
long intervalGreen = 25000; //25c свечения зеленого цвета
long intervalGrBlink = 5000; //5с моргание зеленого
long intervalYellow = 10000; //10с горит желтый
long intervalRed = 40000; // 40с горит красный
long intervalBlink = 1000; // 1с моргание семафора
long intervalSemafor = 300000; //5минут интервал работы семафора

//глобальные переменные для состояний каждой лампочки

int red1=0;
int yellow1=0;
int green1=1;
int red2=1;
int yellow2=0;
int green2=0;
int blink1=1;
int blink2=0;
int semafor3=1;

//=======================
//функция первого светофора
//void svetoforOne(int g, int y, int r)
void svetoforOne(int g, int y, int r)
{
  digitalWrite(sv1green, g);
  digitalWrite(sv1yellow, y);
  digitalWrite(sv1red, r);
}
//========================
//функция второго светофора

void svetoforTwo(int g, int y, int r)
{
  digitalWrite(sv2green, g);
  digitalWrite(sv2yellow, y);
  digitalWrite(sv2red, r);
}
/*функция семафора semafor(мигающая лампа 1, мигающая лампа 2, пост.лампа 3), void semafor(1, 0, 1) - горят 2 из 3х ламп
void semafor(int b1, int b2, int L3)*/
void semafor(int g, int y, int r)
{
  digitalWrite(sv2green, g);
  digitalWrite(sv2yellow, y);
  digitalWrite(sv2red, r);
}

//==========================
int st1=1;
int st2=1;
int blink5=1;
int blink6=1;
void setup()
{
  //задаём все пины на вывод
pinMode(sv1green, OUTPUT);
pinMode(sv1yellow, OUTPUT);
pinMode(sv1red, OUTPUT);
pinMode(sv2green, OUTPUT);
pinMode(sv2yellow, OUTPUT);
pinMode(sv2red, OUTPUT);
//pinMode(semblink1, OUTPUT);
//pinMode(semblink2, OUTPUT);
//pinMode(semlamp3, OUTPUT);
//включаем светофоры и семафор при включении ардуины
svetoforOne(green1,yellow1,red1);
svetoforTwo(green2,yellow2,red2);
//semafor(blink1,blink2,semafor3);

}


void loop()
{
  svetoforOne(green1,yellow1,red1);
  svetoforTwo(green2,yellow2,red2);
  if (st1==1){
    //первый этап первого светофора - после 25с зеленый тухнет
    if((millis() - timerStateG1) >= intervalGreen){ // проверка 25с
      timerStateG1=millis(); //передаём следующей функции начальное время отсчета
      green1=0; //green off
      st1=2; //делаемс след.шаг
    }
  }
  if (st1==2){
    //моргаем зеленым
     if((millis() - timerStateG1) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
       timerStateG1=millis(); //передаём следующей функции начальное время отсчета
      green1=1;
      st1=3; //идём к следующему шагу светофора первого
      
     }
  }
 if (st1==3){
    //моргаем зеленым
     if((millis() - timerStateG1) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
      timerStateG1=millis(); //передаём следующей функции начальное время отсчета
      green1=0;
      st1=4; //идём к следующему шагу светофора первого
      
     }
  }
  if (st1==4){
    //моргаем зеленым
     if((millis() - timerStateG1) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
      timerStateG1=millis(); //передаём следующей функции начальное время отсчета 
      green1=1;
      st1=5; //идём к следующему шагу светофора первого
     
     }
  }
 if (st1==5){
   //моргаем зеленым
     if((millis() - timerStateG1) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
      timerStateG1=millis(); //передаём следующей функции начальное время отсчета
      green1=0;
      st1=6; //идём к следующему шагу светофора первого
     
     }
  }
  if (st1==6){
    //моргаем зеленым
     if((millis() - timerStateG1) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
      timerStateG1=millis(); //передаём следующей функции начальное время отсчета
      green1=1;
      st1=7; //идём к следующему шагу светофора первого
     }
  }
  if (st1==7){
    //тушим зеленый - включаем желтый
     if((millis() - timerStateG1) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
      timerStateG1=millis(); //передаём следующей функции начальное время отсчета
      green1=0;
      yellow1=1;//включаем желтый
      st1=8; //идём к следующему шагу светофора первого
       
     
   }
  }
 
   //желтый гаснет через 10с вкл.красный
       if (st1==8){
         
          if((millis() - timerStateG1) >= intervalYellow){
            timerStateG1=millis();//передаём следующей функции начальное время отсчета
            yellow1=0;//yellow 1 off
            red1=1;//красный вкл
            st1=9;//увел.счетчик этапов
             
       }
   }
   //красный гаснет через 40с вкл.зеленый - последний этап первого светофора
       if (st1==9){
         
          if((millis() - timerStateG1) >= intervalRed){
            timerStateG1=millis();//передаём следующей функции начальное время отсчета
            red1=0;//yellow 1 off
            green1=1;//красный вкл
            st1=1;//уменьшаем для возврата к первому этапу
              
       }
   }
  //----------------------------------------------------------------------------------------------------------
  //##########################################################################################################
  //##########################################################################################################
  //##########################################################################################################
  //второй светофор первый этап, начинается с красного
  //##########################################################################################################
  //##########################################################################################################
 
  if (st2==1){
    //первый этап первого светофора - после 25с зеленый тухнет
    if((millis() - timerStateG2) >= intervalRed){ // проверка 40с
     timerStateG2=millis(); //передаём следующей функции начальное время отсчета
      red2=0; //red2 off
      green2=1;//green2 on
      st2=2; //делаемс след.шаг
    }
  }
  if (st2==2){
    //первый этап первого светофора - после 25с зеленый тухнет
    if((millis() - timerStateG2) >= intervalGreen){ // проверка 25с
      timerStateG2=millis(); //передаём следующей функции начальное время отсчета
      green2=0; //red2 off
      st2=3; //делаемс след.шаг
    }
  }
  
  if (st2==3){
    //моргаем зеленым
     if((millis() - timerStateG2)>= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
       timerStateG2=millis(); //передаём следующей функции начальное время отсчета
      green2=1;
       st2=4; //идём к следующему шагу светофора первого
    }
  }
 if (st2==4){
    //моргаем зеленым
     if((millis() - timerStateG2) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
      timerStateG2=millis(); //передаём следующей функции начальное время отсчета
      green2=0;
      st2=5; //идём к следующему шагу светофора первого
       
     }
  }
  if (st2==5){
    //моргаем зеленым
     if((millis() - timerStateG2) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
      timerStateG2=millis(); //передаём следующей функции начальное время отсчета
      green2=1;
      st2=6; //идём к следующему шагу светофора первого
    }
  }
 if (st2==6){
   //моргаем зеленым
     if((millis() - timerStateG2) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
      green2=0;
      st2=7; //идём к следующему шагу светофора первого
      timerStateG2=millis(); //передаём следующей функции начальное время отсчета
     }
  }
  if (st2==7){
    //моргаем зеленым
     if((millis() - timerStateG2) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
      timerStateG2=millis(); //передаём следующей функции начальное время отсчета
      green2=1;
      st2=8; //идём к следующему шагу светофора первого
     }
  }
  if (st2==8){
    //тушим зеленый - включаем желтый
     if((millis() - timerStateG2) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
      timerStateG2=millis(); //передаём следующей функции начальное время отсчета
      green2=0;
      yellow2=1;//включаем желтый
      st2=9; //идём к следующему шагу светофора первого
         
   }
  }
 
   //желтый гаснет через 10с вкл.красный
       if (st2==9){
         
          if((millis() - timerStateG2) >= intervalYellow){
            timerStateG2=millis();//передаём следующей функции начальное время отсчета
            yellow2=0;//yellow 1 off
            red2=1;//красный вкл
            st2=1;//увел.счетчик этапов
              
       }
   }
   
svetoforOne(green1,yellow1,red1);
svetoforTwo(green2,yellow2,red2);  
  
  

}

 

 

Adessit
Adessit аватар
Offline
Зарегистрирован: 12.04.2011

По удалял свои все сообщения которые были тут в процессе поиска бага 

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

Огромное вам спасибо.
 

 

А как сделать так чтобы задержки семафора регулировалис через потенциометры ?

Т.е.  куда вставить переменную значения полученую с АЦП ?

kikia99
Offline
Зарегистрирован: 22.03.2011

 

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

вы мне так для интереса скажите вот светофоры 2 штуки  они значения разные показывают или просто дублируют друг друга ?

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

А вы посмотрите на обычный перекресток и все поймете.

Перекресток - это пересечение двух дорог , два светофора регулируют движение на каждой из них.

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

Развести паралельно один светофор от другого нельзя т.к. не совпадут временные задержки. 

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

Если бы все цвета горели одинаковое время , скажем , минуту  то тогда можно было бы развести паралельно хоть 10 светофоров.

kikia99
Offline
Зарегистрирован: 22.03.2011

 

ну тоесть я прав это по сути один светофор только когда в одном зажигается красные диоды в другом зеленые  

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

если это перекресток то оба зелеными быть не могут ?  

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

Нет , не так.

 Время горения красного равно времени горения зеленого +желтого.

Если развести все от противоположных цветов то : когда на первом включается желтый на втором включиться зеленый ,

а должен  быть красный .

В общем пока на одном горит зеленый +желтый , на другом будет красный и наоборот.

Я сделал задержки зеленый 30с , желтый 10с , красный 40с.

Adessit
Adessit аватар
Offline
Зарегистрирован: 12.04.2011

Тут семафора еще нет, не успел дописать. По конкретнее какую величину в семафоре надо крутить? 

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

Обе величины .

От 0 до 10 минут. 

Adessit
Adessit аватар
Offline
Зарегистрирован: 12.04.2011

Тоесть время работы семафора от 0 до 10 и время когда весь семафор выключен от 0 до 10? Регулировать одновременно одним переменником сразу две величниы? или 2 переменника, по конкретнее 

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

Два переменника.

Одним регулируется время работы , другим время не работы. 

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

По хорошему , еще нужно сделать ИК управление , но это я сам (опыт есть).

Алгоритм такой : по  команде с пульта  производится инвертация ноги (скажем 13)

потом потом оператор if проверяет условие , если 13 нога HIGH то идет работа только с пультом (инвертация (вкл/выкл) цветов)

а если 13 нога LOW то идет автоматическая работа (ваша программа).

Можно ли так сделать ?

Можно ли просто заключить вашу программу в скобки оператора else , что бы она работала только когда включается  оператор 

else ?

Adessit
Adessit аватар
Offline
Зарегистрирован: 12.04.2011

 я добью семафор остальное вы уже сами) Всё можно, всю программу в одну проверку запихнуть,а можно и спрерываниями играться.

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

Зачем прерывания если можно так ? 

Adessit
Adessit аватар
Offline
Зарегистрирован: 12.04.2011

мы друг друга не понимаем. ИК пультом что собираетесь делать? По очереди включать каждый из 9ти цветов? И моргать тоже пультом? Понимаю пультом просто вкл/выкл всего и регулировать секунды переключений) Вот в последнем случае нужны прерывания

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

Пульт нужен для вкл/выкл 6 цветов (двух светофоров).

Например на пульте 7 кнопок , 1 отключает автоматическую программу и переходит в ожидание следующих команд с пульта.

Остальные инвертируют (вкл/выкл) шести цветов .

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

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

Сесафор не затрагивается (работает независимо от светофоров). 

 

Можно сделать и более сложный алгоритм .

Мне главное понять как включать и отключать автоматическую программу .

Мне кажется , идеальным решением будет конструкция if/else .

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

adessit  , я тут пытаюсь в ваш код вмонтировать управление с ИК пульта (два режима , ручной и автоматический)

Но что то не получается.

Сбиваются таймеры.

Может подскажете как лучше сделать.

 

#define sv1green 10 //зеленый первого светофора
	#define sv1yellow 11 // желтый первого светофора
	#define sv1red 12 // красный первого светофора
	#define sv2green 7
	#define sv2yellow 8
	#define sv2red 9
	#define semblink1 6 //мигающая первая лампа семафора
	#define semblink2 5 //вторая
	#define semlamp3 4 //третья постоянно горящая
	 
	//переменные хранящие предыдущее значение для сравнения с текущим, начальное значение нуль
	 


unsigned long val=0;
unsigned long val1=0;
unsigned long val2=0;
unsigned long val3=0;//Переменные для 
unsigned long val4=0;//записи и чтения
unsigned long val5=0;//EEPROM
unsigned long val6=0;
unsigned long val7=0;
unsigned long val8=0;
unsigned long val9=0;
unsigned long val10=0;









	long timerStateG1=0; 
	long timerStateG2=0; 
	//long timerStateSem=0;
	 
	//переменные значения интервалов для кождой лампочки семафора и светофоров
	long intervalGreen = 25000; //25c свечения зеленого цвета
	long intervalGrBlink = 5000; //5с моргание зеленого
	long intervalYellow = 8000; //10с горит желтый
	long intervalRed = 40000; // 40с горит красный
	long intervalBlink = 1000; // 1с моргание семафора
	long intervalSemafor = 300000; //5минут интервал работы семафора
	 
	//глобальные переменные для состояний каждой лампочки
	 
	int red1=0;
	int yellow1=0;
	int green1=1;
	int red2=1;
	int yellow2=0;
	int green2=0;
	int blink1=1;
	int blink2=0;
	int semafor3=1;
	 
	//=======================
	//функция первого светофора
	//void svetoforOne(int g, int y, int r)
	void svetoforOne(int g, int y, int r)
	{
	  digitalWrite(sv1green, g);
	  digitalWrite(sv1yellow, y);
	  digitalWrite(sv1red, r);
	}
	//========================
	//функция второго светофора
	 
	void svetoforTwo(int g, int y, int r)
	{
	  digitalWrite(sv2green, g);
	  digitalWrite(sv2yellow, y);
	  digitalWrite(sv2red, r);
	}
	/*функция семафора semafor(мигающая лампа 1, мигающая лампа 2, пост.лампа 3), void semafor(1, 0, 1) - горят 2 из 3х ламп
	void semafor(int b1, int b2, int L3)*/
	void semafor(int g, int y, int r)
	{
	  digitalWrite(sv2green, g);
	  digitalWrite(sv2yellow, y);
	  digitalWrite(sv2red, r);
	}
	 
	//==========================
	int st1=1;
	int st2=1;
	int blink5=1;
	int blink6=1;
	void setup()
	{
	  //задаём все пины на вывод
	pinMode(sv1green, OUTPUT);
	pinMode(sv1yellow, OUTPUT);
	pinMode(sv1red, OUTPUT);
	pinMode(sv2green, OUTPUT);
	pinMode(sv2yellow, OUTPUT);
	pinMode(sv2red, OUTPUT);
 pinMode(13, OUTPUT);

	//pinMode(semblink1, OUTPUT);
	//pinMode(semblink2, OUTPUT);
	//pinMode(semlamp3, OUTPUT);
	//включаем светофоры и семафор при включении ардуины
	svetoforOne(green1,yellow1,red1);
	svetoforTwo(green2,yellow2,red2);
	//semafor(blink1,blink2,semafor3);
	 
	}
	 
	 
	void loop()
	{
  
  val1=pulseIn(6,LOW);
   val1=val1/1000;
 if(val1==2)
{ 
 val2=pulseIn(6,LOW); 
 val3=pulseIn(6,LOW); 
 val4=pulseIn(6,LOW);//считываем 10 
 val5=pulseIn(6,LOW);//импульсов
 val6=pulseIn(6,LOW);//с pin7
 val7=pulseIn(6,LOW); 
 val8=pulseIn(6,LOW); 
 val9=pulseIn(6,LOW); 

 

 val2=val2/1000;
 val3=val3/1000;
 val4=val4/1000;
 val5=val5/1000;//конвертируем микросекунды в милисекунды
 val6=val6/1000;
 val7=val7/1000;
 val8=val8/1000;
 val9=val9/1000;
 
   
 if(val2==1&&val3==0&&val4==1&&val5==0&&val6==1&&val7==0&&
  val8==0&&val9==1)
  {
    digitalWrite(13,!digitalRead(13));
    delay(500);
  } 
}
  

if(digitalRead(13)==HIGH)
{
         digitalWrite(7,LOW);
         digitalWrite(8,LOW);
         digitalWrite(9,LOW);
         digitalWrite(10,LOW);
         digitalWrite(11,LOW);
         digitalWrite(12,LOW);
         
     
}
  else
  {
  
  
  
  
  
  
  
  
  
  
  
  
	  svetoforOne(green1,yellow1,red1);
	  svetoforTwo(green2,yellow2,red2);
	  if (st1==1){
	    //первый этап первого светофора - после 25с зеленый тухнет
	    if((millis() - timerStateG1) >= intervalGreen){ // проверка 25с
	      timerStateG1=millis(); //передаём следующей функции начальное время отсчета
	      green1=0; //green off
	      st1=2; //делаемс след.шаг
	    }
	  }
	  if (st1==2){
	    //моргаем зеленым
	     if((millis() - timerStateG1) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	       timerStateG1=millis(); //передаём следующей функции начальное время отсчета
	      green1=1;
	      st1=3; //идём к следующему шагу светофора первого
	       
	     }
	  }
	 if (st1==3){
	    //моргаем зеленым
	     if((millis() - timerStateG1) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	      timerStateG1=millis(); //передаём следующей функции начальное время отсчета
	      green1=0;
	      st1=4; //идём к следующему шагу светофора первого
	       
	     }
	  }
	  if (st1==4){
	    //моргаем зеленым
	     if((millis() - timerStateG1) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	      timerStateG1=millis(); //передаём следующей функции начальное время отсчета 
	      green1=1;
	      st1=5; //идём к следующему шагу светофора первого
	      
	     }
	  }
	 if (st1==5){
	   //моргаем зеленым
	     if((millis() - timerStateG1) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	      timerStateG1=millis(); //передаём следующей функции начальное время отсчета
	      green1=0;
	      st1=6; //идём к следующему шагу светофора первого
	     	     }
	  }
	  if (st1==6){
	    //моргаем зеленым
	     if((millis() - timerStateG1) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	      timerStateG1=millis(); //передаём следующей функции начальное время отсчета
	      green1=1;
	      st1=7; //идём к следующему шагу светофора первого
	     }
	  }
	  if (st1==7){
	    //тушим зеленый - включаем желтый
	     if((millis() - timerStateG1) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	      timerStateG1=millis(); //передаём следующей функции начальное время отсчета
	      green1=0;
	      yellow1=1;//включаем желтый
	      st1=8; //идём к следующему шагу светофора первого
	        
	      
	   }
	  }
	  
	   //желтый гаснет через 10с вкл.красный
	       if (st1==8){
	          
	          if((millis() - timerStateG1) >= intervalYellow){
	            timerStateG1=millis();//передаём следующей функции начальное время отсчета
	            yellow1=0;//yellow 1 off
	            red1=1;//красный вкл
	            st1=9;//увел.счетчик этапов
	              
	       }
	   }
	   //красный гаснет через 40с вкл.зеленый - последний этап первого светофора
	       if (st1==9){
	          
	          if((millis() - timerStateG1) >= intervalRed){
	            timerStateG1=millis();//передаём следующей функции начальное время отсчета
	            red1=0;//yellow 1 off
	            green1=1;//красный вкл
	            st1=1;//уменьшаем для возврата к первому этапу
	               
	       }
	   }
	  //----------------------------------------------------------------------------------------------------------
	  //##########################################################################################################
	  //##########################################################################################################
	  //##########################################################################################################
	  //второй светофор первый этап, начинается с красного
	  //##########################################################################################################
	  //##########################################################################################################
	  
	  if (st2==1){
	    //первый этап первого светофора - после 25с зеленый тухнет
	    if((millis() - timerStateG2) >= intervalRed){ // проверка 40с
	     timerStateG2=millis(); //передаём следующей функции начальное время отсчета
	      red2=0; //red2 off
	      green2=1;//green2 on
	      st2=2; //делаемс след.шаг
	    }
	  }
	  if (st2==2){
	    //первый этап первого светофора - после 25с зеленый тухнет
	    if((millis() - timerStateG2) >= intervalGreen){ // проверка 25с
	      timerStateG2=millis(); //передаём следующей функции начальное время отсчета
	      green2=0; //red2 off
	      st2=3; //делаемс след.шаг
	    }
	  }
	   
	  if (st2==3){
	    //моргаем зеленым
	     if((millis() - timerStateG2)>= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	       timerStateG2=millis(); //передаём следующей функции начальное время отсчета
	      green2=1;
	       st2=4; //идём к следующему шагу светофора первого
	    }
	  }
	 if (st2==4){
	    //моргаем зеленым
	     if((millis() - timerStateG2) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	      timerStateG2=millis(); //передаём следующей функции начальное время отсчета
	      green2=0;
	      st2=5; //идём к следующему шагу светофора первого
	        
	     }
	  }
	  if (st2==5){
	    //моргаем зеленым
	     if((millis() - timerStateG2) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	      timerStateG2=millis(); //передаём следующей функции начальное время отсчета
	      green2=1;
	      st2=6; //идём к следующему шагу светофора первого
	    }
	  }
	 if (st2==6){
	   //моргаем зеленым
	     if((millis() - timerStateG2) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	      green2=0;
	      st2=7; //идём к следующему шагу светофора первого
	      timerStateG2=millis(); //передаём следующей функции начальное время отсчета
	     }
	  }
	  if (st2==7){
	    //моргаем зеленым
	     if((millis() - timerStateG2) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	      timerStateG2=millis(); //передаём следующей функции начальное время отсчета
	      green2=1;
	      st2=8; //идём к следующему шагу светофора первого
	     }
	  }
	  if (st2==8){
	    //тушим зеленый - включаем желтый
	     if((millis() - timerStateG2) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	      timerStateG2=millis(); //передаём следующей функции начальное время отсчета
	      green2=0;
	      yellow2=1;//включаем желтый
	      st2=9; //идём к следующему шагу светофора первого
	          
	   }
	  }
	  
	   //желтый гаснет через 10с вкл.красный
	       if (st2==9){
	          
	          if((millis() - timerStateG2) >= intervalYellow){
	            timerStateG2=millis();//передаём следующей функции начальное время отсчета
	            yellow2=0;//yellow 1 off
	            red2=1;//красный вкл
	            st2=1;//увел.счетчик этапов
	               
	       }
	   }
	    
	svetoforOne(green1,yellow1,red1);
	svetoforTwo(green2,yellow2,red2);  
	   
	   
	 }
	}

 

 

Adessit
Adessit аватар
Offline
Зарегистрирован: 12.04.2011

delay(500); - вот где ваша ошибка. Вы от них отказывались, а тут вставили, это пол-секунды, а если постоянно - то выйдет много задержки. 

Прошу прощения что не могу закончить ваш код. Нереально много работы на работе. 

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

Спасибо за подсказку.

Но делай там нужен для фильтрации  "дребезга".

Значит буду искать другой фильтр. 

Adessit
Adessit аватар
Offline
Зарегистрирован: 12.04.2011

ну попробуйте опять же через таймера чтение, через millis

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

Попробовал без delay. То же самое. 

Adessit
Adessit аватар
Offline
Зарегистрирован: 12.04.2011

Выложите код без delay()

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

Абсолютно то же самое только без delay.

Там некоторые коменты не соответствуют действительности.

#define sv1green 10 //зеленый первого светофора
	#define sv1yellow 11 // желтый первого светофора
	#define sv1red 12 // красный первого светофора
	#define sv2green 7
	#define sv2yellow 8
	#define sv2red 9
	#define semblink1 6 //мигающая первая лампа семафора
	#define semblink2 5 //вторая
	#define semlamp3 4 //третья постоянно горящая
	 
	//переменные хранящие предыдущее значение для сравнения с текущим, начальное значение нуль
	 


unsigned long val=0;
unsigned long val1=0;
unsigned long val2=0;
unsigned long val3=0;//Переменные для 
unsigned long val4=0;//записи и чтения
unsigned long val5=0;//EEPROM
unsigned long val6=0;
unsigned long val7=0;
unsigned long val8=0;
unsigned long val9=0;
unsigned long val10=0;









	long timerStateG1=0; 
	long timerStateG2=0; 
	//long timerStateSem=0;
	 
	//переменные значения интервалов для кождой лампочки семафора и светофоров
	long intervalGreen = 25000; //25c свечения зеленого цвета
	long intervalGrBlink = 5000; //5с моргание зеленого
	long intervalYellow = 8000; //10с горит желтый
	long intervalRed = 40000; // 40с горит красный
	long intervalBlink = 1000; // 1с моргание семафора
	long intervalSemafor = 300000; //5минут интервал работы семафора
	 
	//глобальные переменные для состояний каждой лампочки
	 
	int red1=0;
	int yellow1=0;
	int green1=1;
	int red2=1;
	int yellow2=0;
	int green2=0;
	int blink1=1;
	int blink2=0;
	int semafor3=1;
	 
	//=======================
	//функция первого светофора
	//void svetoforOne(int g, int y, int r)
	void svetoforOne(int g, int y, int r)
	{
	  digitalWrite(sv1green, g);
	  digitalWrite(sv1yellow, y);
	  digitalWrite(sv1red, r);
	}
	//========================
	//функция второго светофора
	 
	void svetoforTwo(int g, int y, int r)
	{
	  digitalWrite(sv2green, g);
	  digitalWrite(sv2yellow, y);
	  digitalWrite(sv2red, r);
	}
	/*функция семафора semafor(мигающая лампа 1, мигающая лампа 2, пост.лампа 3), void semafor(1, 0, 1) - горят 2 из 3х ламп
	void semafor(int b1, int b2, int L3)*/
	void semafor(int g, int y, int r)
	{
	  digitalWrite(sv2green, g);
	  digitalWrite(sv2yellow, y);
	  digitalWrite(sv2red, r);
	}
	 
	//==========================
	int st1=1;
	int st2=1;
	int blink5=1;
	int blink6=1;
	void setup()
	{
	  //задаём все пины на вывод
	pinMode(sv1green, OUTPUT);
	pinMode(sv1yellow, OUTPUT);
	pinMode(sv1red, OUTPUT);
	pinMode(sv2green, OUTPUT);
	pinMode(sv2yellow, OUTPUT);
	pinMode(sv2red, OUTPUT);
 pinMode(13, OUTPUT);

	//pinMode(semblink1, OUTPUT);
	//pinMode(semblink2, OUTPUT);
	//pinMode(semlamp3, OUTPUT);
	//включаем светофоры и семафор при включении ардуины
	svetoforOne(green1,yellow1,red1);
	svetoforTwo(green2,yellow2,red2);
	//semafor(blink1,blink2,semafor3);
	 
	}
	 
	 
	void loop()
	{
  
  val1=pulseIn(6,LOW);
   val1=val1/1000;
 if(val1==2)
{ 
 val2=pulseIn(6,LOW); 
 val3=pulseIn(6,LOW); 
 val4=pulseIn(6,LOW);//считываем 10 
 val5=pulseIn(6,LOW);//импульсов
 val6=pulseIn(6,LOW);//с pin7
 val7=pulseIn(6,LOW); 
 val8=pulseIn(6,LOW); 
 val9=pulseIn(6,LOW); 

 

 val2=val2/1000;
 val3=val3/1000;
 val4=val4/1000;
 val5=val5/1000;//конвертируем микросекунды в милисекунды
 val6=val6/1000;
 val7=val7/1000;
 val8=val8/1000;
 val9=val9/1000;
 
   
 if(val2==1&&val3==0&&val4==1&&val5==0&&val6==1&&val7==0&&
  val8==0&&val9==1)
  {
    digitalWrite(13,!digitalRead(13));
    
  } 
}
  

if(digitalRead(13)==HIGH)
{
         digitalWrite(7,LOW);
         digitalWrite(8,LOW);
         digitalWrite(9,LOW);
         digitalWrite(10,LOW);
         digitalWrite(11,LOW);
         digitalWrite(12,LOW);
         
     
}
  else
  {
  
  
  
  
  
  
  
  
  
  
  
  
	  svetoforOne(green1,yellow1,red1);
	  svetoforTwo(green2,yellow2,red2);
	  if (st1==1){
	    //первый этап первого светофора - после 25с зеленый тухнет
	    if((millis() - timerStateG1) >= intervalGreen){ // проверка 25с
	      timerStateG1=millis(); //передаём следующей функции начальное время отсчета
	      green1=0; //green off
	      st1=2; //делаемс след.шаг
	    }
	  }
	  if (st1==2){
	    //моргаем зеленым
	     if((millis() - timerStateG1) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	       timerStateG1=millis(); //передаём следующей функции начальное время отсчета
	      green1=1;
	      st1=3; //идём к следующему шагу светофора первого
	       
	     }
	  }
	 if (st1==3){
	    //моргаем зеленым
	     if((millis() - timerStateG1) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	      timerStateG1=millis(); //передаём следующей функции начальное время отсчета
	      green1=0;
	      st1=4; //идём к следующему шагу светофора первого
	       
	     }
	  }
	  if (st1==4){
	    //моргаем зеленым
	     if((millis() - timerStateG1) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	      timerStateG1=millis(); //передаём следующей функции начальное время отсчета 
	      green1=1;
	      st1=5; //идём к следующему шагу светофора первого
	      
	     }
	  }
	 if (st1==5){
	   //моргаем зеленым
	     if((millis() - timerStateG1) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	      timerStateG1=millis(); //передаём следующей функции начальное время отсчета
	      green1=0;
	      st1=6; //идём к следующему шагу светофора первого
	     	     }
	  }
	  if (st1==6){
	    //моргаем зеленым
	     if((millis() - timerStateG1) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	      timerStateG1=millis(); //передаём следующей функции начальное время отсчета
	      green1=1;
	      st1=7; //идём к следующему шагу светофора первого
	     }
	  }
	  if (st1==7){
	    //тушим зеленый - включаем желтый
	     if((millis() - timerStateG1) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	      timerStateG1=millis(); //передаём следующей функции начальное время отсчета
	      green1=0;
	      yellow1=1;//включаем желтый
	      st1=8; //идём к следующему шагу светофора первого
	        
	      
	   }
	  }
	  
	   //желтый гаснет через 10с вкл.красный
	       if (st1==8){
	          
	          if((millis() - timerStateG1) >= intervalYellow){
	            timerStateG1=millis();//передаём следующей функции начальное время отсчета
	            yellow1=0;//yellow 1 off
	            red1=1;//красный вкл
	            st1=9;//увел.счетчик этапов
	              
	       }
	   }
	   //красный гаснет через 40с вкл.зеленый - последний этап первого светофора
	       if (st1==9){
	          
	          if((millis() - timerStateG1) >= intervalRed){
	            timerStateG1=millis();//передаём следующей функции начальное время отсчета
	            red1=0;//yellow 1 off
	            green1=1;//красный вкл
	            st1=1;//уменьшаем для возврата к первому этапу
	               
	       }
	   }
	  //----------------------------------------------------------------------------------------------------------
	  //##########################################################################################################
	  //##########################################################################################################
	  //##########################################################################################################
	  //второй светофор первый этап, начинается с красного
	  //##########################################################################################################
	  //##########################################################################################################
	  
	  if (st2==1){
	    //первый этап первого светофора - после 25с зеленый тухнет
	    if((millis() - timerStateG2) >= intervalRed){ // проверка 40с
	     timerStateG2=millis(); //передаём следующей функции начальное время отсчета
	      red2=0; //red2 off
	      green2=1;//green2 on
	      st2=2; //делаемс след.шаг
	    }
	  }
	  if (st2==2){
	    //первый этап первого светофора - после 25с зеленый тухнет
	    if((millis() - timerStateG2) >= intervalGreen){ // проверка 25с
	      timerStateG2=millis(); //передаём следующей функции начальное время отсчета
	      green2=0; //red2 off
	      st2=3; //делаемс след.шаг
	    }
	  }
	   
	  if (st2==3){
	    //моргаем зеленым
	     if((millis() - timerStateG2)>= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	       timerStateG2=millis(); //передаём следующей функции начальное время отсчета
	      green2=1;
	       st2=4; //идём к следующему шагу светофора первого
	    }
	  }
	 if (st2==4){
	    //моргаем зеленым
	     if((millis() - timerStateG2) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	      timerStateG2=millis(); //передаём следующей функции начальное время отсчета
	      green2=0;
	      st2=5; //идём к следующему шагу светофора первого
	        
	     }
	  }
	  if (st2==5){
	    //моргаем зеленым
	     if((millis() - timerStateG2) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	      timerStateG2=millis(); //передаём следующей функции начальное время отсчета
	      green2=1;
	      st2=6; //идём к следующему шагу светофора первого
	    }
	  }
	 if (st2==6){
	   //моргаем зеленым
	     if((millis() - timerStateG2) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	      green2=0;
	      st2=7; //идём к следующему шагу светофора первого
	      timerStateG2=millis(); //передаём следующей функции начальное время отсчета
	     }
	  }
	  if (st2==7){
	    //моргаем зеленым
	     if((millis() - timerStateG2) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	      timerStateG2=millis(); //передаём следующей функции начальное время отсчета
	      green2=1;
	      st2=8; //идём к следующему шагу светофора первого
	     }
	  }
	  if (st2==8){
	    //тушим зеленый - включаем желтый
	     if((millis() - timerStateG2) >= intervalBlink){//проверка с ходом в одну секунду для вкл.выкл.
	      timerStateG2=millis(); //передаём следующей функции начальное время отсчета
	      green2=0;
	      yellow2=1;//включаем желтый
	      st2=9; //идём к следующему шагу светофора первого
	          
	   }
	  }
	  
	   //желтый гаснет через 10с вкл.красный
	       if (st2==9){
	          
	          if((millis() - timerStateG2) >= intervalYellow){
	            timerStateG2=millis();//передаём следующей функции начальное время отсчета
	            yellow2=0;//yellow 1 off
	            red2=1;//красный вкл
	            st2=1;//увел.счетчик этапов
	               
	       }
	   }
	    
	svetoforOne(green1,yellow1,red1);
	svetoforTwo(green2,yellow2,red2);  
	   
	   
	 }
	}

 

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

Фильтровать "дребезг "я буду позже.

Сначала нужно сделать нормальный переход между ручным и автоматическим режимами. 

nestandart
nestandart аватар
Offline
Зарегистрирован: 15.06.2011

Эврика , господа !!!

Делал часы , получился светофор.

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

Принцип простой как табуретка , но к этой табуретке я шел месяц (или больше ?).

Программа довольно "сырая" (главное донести принцип) , но если "причесать" - будет вообще хорошо.

 

 

long previousMillis = 0;    

int sek=0;



void setup()
{
  pinMode(13,OUTPUT); 
  pinMode(12,OUTPUT); 
  pinMode(11,OUTPUT); 
  pinMode(10,OUTPUT); 
  pinMode(9,OUTPUT); 
  pinMode(8,OUTPUT); 
  pinMode(7,OUTPUT); 
  
}
void loop ()
{
  //************включаем таймер********************************//
   if (millis() - previousMillis > 500) 
 {
     previousMillis = millis(); 
    
     digitalWrite(13,!digitalRead(13));//вкл 13 в начале
                                       // каждой секунды
      if(digitalRead(13)==HIGH)
      {
       sek++;  //если 13 вкл - переменная +1
       
 //*********************************************************//      
       if (sek==1)
       {
         digitalWrite(12,HIGH);//вкл зеленого светофора1
         digitalWrite(8,HIGH);//вкл красного светофора2
         digitalWrite(11,LOW);
          digitalWrite(9,LOW);
          digitalWrite(10,LOW);
          digitalWrite(7,LOW);
         
         
         
       }
  //****************************************************//     
       if (sek==25)
       {
         digitalWrite(12,LOW);
         digitalWrite(8,HIGH);
         digitalWrite(11,LOW);//мигаем зеленым светофора1
          digitalWrite(9,LOW);
          digitalWrite(10,LOW);
          digitalWrite(7,LOW);  
       }
       
       
       
       
       
       
         if (sek==26)
       {
         digitalWrite(12,HIGH);
         digitalWrite(8,HIGH);
         digitalWrite(11,LOW);
          digitalWrite(9,LOW);
          digitalWrite(10,LOW);
          digitalWrite(7,LOW);  
       }
       
       
       
       
        if (sek==27)
       {
         digitalWrite(12,LOW);
         digitalWrite(8,HIGH);
         digitalWrite(11,LOW);
          digitalWrite(9,LOW);
          digitalWrite(10,LOW);
          digitalWrite(7,LOW);  
       }
       
       
        if (sek==28)
       {
         digitalWrite(12,HIGH);
         digitalWrite(8,HIGH);
         digitalWrite(11,LOW);
          digitalWrite(9,LOW);
          digitalWrite(10,LOW);
          digitalWrite(7,LOW);  
       }
       
        if (sek==29)
       {
         digitalWrite(12,LOW);
         digitalWrite(8,HIGH);
         digitalWrite(11,LOW);
          digitalWrite(9,LOW);
          digitalWrite(10,LOW);
          digitalWrite(7,LOW);  
       }
       
       
//***********************************************************//      
       
       if (sek==30)
       {
         digitalWrite(12,LOW);//выкл зеленого светофора1
            digitalWrite(11,HIGH);//вкл желтого светофора1
            digitalWrite(8,HIGH);
          digitalWrite(9,LOW);
          digitalWrite(10,LOW);
          digitalWrite(7,LOW);
            
       }
       
       if (sek==40)
       {
         digitalWrite(10,HIGH);//вкл красного светофора1
          digitalWrite(9,HIGH);//вкл зеленого светофора2
          digitalWrite(11,LOW);//выкл желтого светофора1
          digitalWrite(8,LOW);//выкл красного светофора2
          digitalWrite(7,LOW);
          digitalWrite(12,LOW);
       }
       
//************************************************************//       
        if (sek==65)
       {
         digitalWrite(10,HIGH);
          digitalWrite(9,LOW);
          digitalWrite(11,LOW);//мигаем зеленым светофора2
          digitalWrite(8,LOW);
          digitalWrite(7,LOW);
          digitalWrite(12,LOW);
       }
       
        if (sek==66)
       {
         digitalWrite(10,HIGH);
          digitalWrite(9,HIGH);
          digitalWrite(11,LOW);
          digitalWrite(8,LOW);
          digitalWrite(7,LOW);
          digitalWrite(12,LOW);
       }
       
       if (sek==67)
       {
         digitalWrite(10,HIGH);
          digitalWrite(9,LOW);
          digitalWrite(11,LOW);
          digitalWrite(8,LOW);
          digitalWrite(7,LOW);
          digitalWrite(12,LOW);
       }
       
       
       
        if (sek==68)
       {
         digitalWrite(10,HIGH);
          digitalWrite(9,HIGH);
          digitalWrite(11,LOW);
          digitalWrite(8,LOW);
          digitalWrite(7,LOW);
          digitalWrite(12,LOW);
       }
       
        if (sek==69)
       {
         digitalWrite(10,HIGH);
          digitalWrite(9,LOW);
          digitalWrite(11,LOW);
          digitalWrite(8,LOW);
          digitalWrite(7,LOW);
          digitalWrite(12,LOW);
       }
       
       
//*************************************************************//       
       
        if (sek==70)
       {
         digitalWrite(10,HIGH);
          digitalWrite(9,LOW);//выкл зеленого светофора2
          digitalWrite(11,LOW);
          digitalWrite(8,LOW);
          digitalWrite(7,HIGH);//вкл желтого светофора1
          digitalWrite(12,LOW);
       }
      
       
       
       if (sek==80)
       {
         sek=0;     //обнуляем значение таймера
       }
       
  
      }
       
  }
 
 
 
  
}

Запускаем таймер , который отбивает секунды , и закладывает их кол-во в переменную.

Ну а дальше включаем/выключаем пины при определенных значениях этой переменной.

В конце цикла двух светофоров обнуляем переменную.