Arduino.ru

#2

http://arduino.ru/tutorials/BlinkWithoutDelay

http://arduino.ru/forum/programmirovanie/etyudy-dlya-nachinayushchikh-blink-i-bez-delay-i-bez-millis

И ещё - http://arduino.ru/forum/programmirovanie/blink-ne-dlya-devochek

Всем спасибо.

qwone. Я пробовал данный пример до создания поста, но брал из этого вашего поста http://arduino.ru/forum/programmirovanie/arduino-taimer-vklyucheniyaotklyucheniya?page=1#comment-243759 Тогда у меня  не получилось, с обоими значениями поставленными мной в 1 секунду   светодиод только горел, горел и с 2000 и 1000.

/*
#1
#2
#3
*/
//#1
//#2
//#3
void setup() {
  //#1
  //#2
  //#3
}
void loop() {
  static uint32_t MILLIS ;
  MILLIS = millis() ;
  //#1 1000 миллисекунд вычислит. поток 1
  static uint32_t past_1 = 0 ;
  if (MILLIS - past_1 >= 1000) { // если прошло 1000 миллисек
    past_1 = MILLIS ;
    // сам код
    MILLIS = millis() ;
  }
  //#2  200 миллисекунд вычислит. поток 2
  static uint32_t past_2 = 0 ;
  if (MILLIS - past_2 >= 200) { // если прошло 200 миллисек
    past_2 = MILLIS ;
    // сам код
    MILLIS = millis() ;
  }
  //#3  100 миллисекунд вычислит. поток 3
  static uint32_t past_3 = 0 ;
  if (MILLIS - past_3 >= 100) { // если прошло 100 миллисек
    past_3 = MILLIS ;
    // сам код
  }
}

подставил  зачения  1000 и 2000 заработал. Немного поиграв значениями  у меня получилось что

static uint32_t past_1 = 0 ;

во всех группах ставил past_1 //(:

     statistatic uint32_t past_5 = 0 ;

    }

если написать digitalWrite(10, HIGH);   работать не будет, хотя в 1,2,3,4 групах работает.

Вы скорее всего сами понаставляли ошибок. А где и как я же не вижу  ваш код, только обрывки. И опять же не знаю что вы хотите делать.

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

  
class BUTTON {
  public:
    //================================================================
    static const byte bounce_              =   50; // длительность отслеживания дребезга.
    static const byte doubleclick_         =  200; // длительность отслеживания двойного клика.
    static const unsigned long timer_      = 200000; // длительность отслеживания неактивности.
    static const unsigned int retention_   = 2000; // длительность отслеживания нажатия и удержания.
    //================================================================
    boolean click_down;
    boolean click_up;
    boolean doubleclick;
    boolean timer;
    boolean retention;
    //=================================
    unsigned long m;
    boolean  p;
    boolean  b;
    boolean dc;
    byte     c;
    boolean  t;
    boolean  r;
    //=================================
    byte _pb;
    //=================================
    BUTTON(byte pb) {
      _pb = pb;
      pinMode(_pb, INPUT);
      digitalWrite(_pb, 1);
      //====
      click_down      = 0;
      click_up        = 0;
      doubleclick     = 0;
      timer           = 0;
      retention       = 0;
      //====
      m  =      millis();
      p  = digitalRead(_pb);
      b  =                0;
      dc =                0;
      c  =                0;
      t  =                0;
      r  =                0;
      //====
    }

    void read() {
      //=======================================================
      unsigned long nm =      millis();
      boolean       np = digitalRead(_pb);
      //=================
      boolean nb  = 0;
      boolean ndc = 0;
      boolean nt  = 0;
      boolean nr  = 0;
      //================
      click_down  = 0;
      click_up    = 0;
      doubleclick = 0;
      timer       = 0;
      retention   = 0;
      //=================
      if (np != p) {
        p = np;
        m = nm;
      }
      //=======================================================
      if (nm - m > bounce_) {
        nb = 1;
      }
      if (nm - m > doubleclick_) {
        ndc = 1;
      }
      if (ndc != dc) {
        dc = ndc;
        if (dc == 1) {
          c = 0;
        }
      }
      if (nb != b) {
        b = nb;
        if (p == 0 && b == 0) {
          click_down = 1;
          ++c;      if (c == 2) {
            c = 0;
            doubleclick = 1;
          }
        }
        if (p == 1 && b == 1) {
          click_up = 1;
        }
      }
      //=======================================================
      if (nm - m > timer_) {
        nt = 1;
      }
      if (nt != t) {
        t = nt;
        if (p == 1 && t == 1) {
          timer = 1;
        }
      }
      //=======================================================
      if (nm - m > retention_) {
        nr = 1;
      }
      if (nr != r) {
        r = nr;
        if (p == 0 && r == 1) {
          retention = 1;
        }
      }
      //=======================================================
    }
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
int regim = 1;
int flag = 0;                  // флаг первого включения
int R_Led_pin = 13;           
bool R_Led;
int G_Led_pin = 12;            
bool G_Led;
int Y_Led_pin = 11;            
bool Y_Led;
BUTTON BUTTON_01(10);


void setup()
{
  static uint32_t MILLIS ;
  MILLIS = millis() ;
  pinMode(Y_Led, OUTPUT);
  pinMode(G_Led, OUTPUT);
  pinMode(R_Led, OUTPUT);
  pinMode(10, INPUT_PULLUP);  
}

void loop()

{
  BUTTON_01.read();
  if (BUTTON_01.click_down && flag == 0)
  {
    regim = 3;
    flag = 1;
  }

  if (BUTTON_01.click_down && flag == 1)
  { regim++;
    if (regim > 4)
    {
      regim = 3;
    }
  }

  if (BUTTON_01.doubleclick && flag == 1)
  {
    regim = 2;
  }

  if (BUTTON_01.retention && flag == 1)
  {
    regim = 1;
    flag = 0;
  }

  if (BUTTON_01.timer && flag == 1)
  {
    regim = 1;
    flag = 0;
  }
  // первый режим
  if (regim == 1)
  {
    digitalWrite(11, LOW); //выключаем

    digitalWrite(12, LOW); //выключаем

	
    static uint32_t past_0 = 0 ;

    if (R_Led && millis() - past_0 >= 200)
    {
      digitalWrite(13, R_Led = 0);
    }
    if (millis() - past_0 >= 500)
    {
      past_0 = millis() ;
      digitalWrite(13, R_Led = 1);
    }
  }

  // второй режим
  if (regim == 2)
  {
    digitalWrite(13, LOW);

    static uint32_t past_1 = 0 ;
    if (G_Led && millis() - past_1 >= 200)
    {
      digitalWrite(12, G_Led = 0);
    }
    if (millis() - past_1 >= 1000)
    {
      past_1 = millis() ;
      digitalWrite(12, G_Led = 1);
    }
	
    static uint32_t past_2 = 0 ;
    if (Y_Led && millis() - past_2 >= 200)
    {
      digitalWrite(11, Y_Led = 0);
    }
    if (millis() - past_2 >= 1500)
    {
      past_2 = millis() ;
      digitalWrite(11, Y_Led = 1);
    }
   }


  // третий режим
  if (regim == 3)
  {
    digitalWrite(13, LOW);

    digitalWrite(12, HIGH);

	
    static uint32_t past_4 = 0 ;
    if (Y_Led && millis() - past_4 >= 500)
    {
      digitalWrite(11, Y_Led = 0);
    }
    if (millis() - past_4 >= 1000)
    {
      past_4 = millis() ;
      digitalWrite(11, Y_Led = 1);
    }
  }


  //четвертый режим
  if (regim == 4)
  {
    digitalWrite(13, HIGH);

    digitalWrite(12, LOW);
      static uint32_t past_5 = 0 ;
      if (Y_Led && millis() - past_5 >= 10000000)
        {
       digitalWrite(11, Y_Led = 0);
         }
        if (millis() - past_5 >= 10)
       {
           past_5 = millis() ;
          digitalWrite(11, Y_Led = 1);

        //digitalWrite(10, HIGH);
      }
   }
  }

возможно нашел еще не проверял//digitalWrite(11, HIGH);

w1d. Это направление Клапауция. Так что мне в этот код лучше лазить. Концепции немного не те.