I can't sync a physical button to a widget button

Costas · October 5, 2016, 4:29pm

@Castle maximum of 10 timers for each instance of SimpleTimer.

Castle · October 5, 2016, 4:38pm

@Costas may be possible to put additional timer like:

SimpleTimer timer1;
SimpleTimer timer2;

any idea?

Costas · October 5, 2016, 4:40pm

Yes, see my post at SyncPhysicalButton arduino mega 22pc button and 22pc physical button

I tested it on my Mega after making the post and it all works fine.

speed57 · October 5, 2016, 5:46pm

@Castle, a man of his word.

Castle · October 5, 2016, 8:45pm

@Sergey_Kuntsevich

#define BLYNK_PRINT Serial
#include <SPI.h>
#include <Ethernet.h>
#include <BlynkSimpleEthernet.h>
#include <SimpleTimer.h>
#define BLYNK_MSG_LIMIT 20

SimpleTimer timer0;
SimpleTimer timer1;
SimpleTimer timer2;
const int (duration) = 300;

char auth[] = "c4b698c712034338b2778cc1752196bb";

const int btnPin30 = A0; const int ledPin30 = 30; int ledState30 = LOW; int btnState30 = HIGH;
const int btnPin31 = A1; const int ledPin31 = 31; int ledState31 = LOW; int btnState31 = HIGH;
const int btnPin32 = A2; const int ledPin32 = 32; int ledState32 = LOW; int btnState32 = HIGH;
const int btnPin33 = A3; const int ledPin33 = 33; int ledState33 = LOW; int btnState33 = HIGH;
const int btnPin34 = A4; const int ledPin34 = 34; int ledState34 = LOW; int btnState34 = HIGH;
const int btnPin35 = A5; const int ledPin35 = 35; int ledState35 = LOW; int btnState35 = HIGH;
const int btnPin36 = A6; const int ledPin36 = 36; int ledState36 = LOW; int btnState36 = HIGH;
const int btnPin37 = A7; const int ledPin37 = 37; int ledState37 = LOW; int btnState37 = HIGH;
const int btnPin38 = A8; const int ledPin38 = 38; int ledState38 = LOW; int btnState38 = HIGH;
const int btnPin39 = A9; const int ledPin39 = 39; int ledState39 = LOW; int btnState39 = HIGH;
const int btnPin40 = A10; const int ledPin40 = 40; int ledState40 = LOW; int btnState40 = HIGH;
const int btnPin41 = A11; const int ledPin41 = 41; int ledState41 = LOW; int btnState41 = HIGH;
const int btnPin42 = A12; const int ledPin42 = 42; int ledState42 = LOW; int btnState42 = HIGH;
const int btnPin43 = A13; const int ledPin43 = 43; int ledState43 = LOW; int btnState43 = HIGH;
const int btnPin44 = A14; const int ledPin44 = 44; int ledState44 = LOW; int btnState44 = HIGH;
const int btnPin45 = A15; const int ledPin45 = 45; int ledState45 = LOW; int btnState45 = HIGH;
const int btnPin46 = 22; const int ledPin46 = 46; int ledState46 = LOW; int btnState46 = HIGH;
const int btnPin47 = 23; const int ledPin47 = 47; int ledState47 = LOW; int btnState47 = HIGH;
const int btnPin48 = 24; const int ledPin48 = 48; int ledState48 = LOW; int btnState48 = HIGH;
const int btnPin49 = 2;  const int ledPin49 = 49; int ledState49 = LOW; int btnState49 = HIGH;
const int btnPin50 = 3;  const int ledPin50 = 50; int ledState50 = LOW; int btnState50 = HIGH;
const int btnPin51 = 4;  const int ledPin51 = 51; int ledState51 = LOW; int btnState51 = HIGH;
const int btnPin25 = 5;  const int ledPin25 = 25; int ledState25 = LOW; int btnState25 = HIGH;
const int btnPin26 = 6;  const int ledPin26 = 26; int ledState26 = LOW; int btnState26 = HIGH;
const int btnPin27 = 7;  const int ledPin27 = 27; int ledState27 = LOW; int btnState27 = HIGH;
const int btnPin28 = 8;  const int ledPin28 = 28; int ledState28 = LOW; int btnState28 = HIGH;
const int btnPin29 = 9;  const int ledPin29 = 29; int ledState29 = LOW; int btnState29 = HIGH;

#define turn_ON   0
#define turn_OFF  1

//#define BLYNK_MSG_LIMIT 10
unsigned long currentTime; //millis
unsigned long loopTime; //millis
void checkPhysicalButton30(); void checkPhysicalButton31(); void checkPhysicalButton32(); void checkPhysicalButton33(); void checkPhysicalButton34(); void checkPhysicalButton35();
void checkPhysicalButton36(); void checkPhysicalButton37(); void checkPhysicalButton38(); void checkPhysicalButton39(); void checkPhysicalButton40(); void checkPhysicalButton41();
void checkPhysicalButton42(); void checkPhysicalButton43(); void checkPhysicalButton44(); void checkPhysicalButton45(); void checkPhysicalButton46(); void checkPhysicalButton47();
void checkPhysicalButton48(); void checkPhysicalButton49(); void checkPhysicalButton50(); void checkPhysicalButton51(); void checkPhysicalButton25(); void checkPhysicalButton26();
void checkPhysicalButton27(); void checkPhysicalButton28(); void checkPhysicalButton29();

void setup()
{
  Serial.begin(9600);
  Blynk.begin(auth);
  {
    pinMode(ledPin30, OUTPUT); pinMode(btnPin30, INPUT_PULLUP); digitalWrite(ledPin30, ledState30); timer1.setInterval(100L, checkPhysicalButton30);
    pinMode(ledPin31, OUTPUT); pinMode(btnPin31, INPUT_PULLUP); digitalWrite(ledPin31, ledState31); timer1.setInterval(100L, checkPhysicalButton31);
    pinMode(ledPin32, OUTPUT); pinMode(btnPin32, INPUT_PULLUP); digitalWrite(ledPin32, ledState32); timer1.setInterval(100L, checkPhysicalButton32);
    pinMode(ledPin33, OUTPUT); pinMode(btnPin33, INPUT_PULLUP); digitalWrite(ledPin33, ledState33); timer1.setInterval(100L, checkPhysicalButton33);
    pinMode(ledPin34, OUTPUT); pinMode(btnPin34, INPUT_PULLUP); digitalWrite(ledPin34, ledState34); timer1.setInterval(100L, checkPhysicalButton34);
    pinMode(ledPin35, OUTPUT); pinMode(btnPin35, INPUT_PULLUP); digitalWrite(ledPin35, ledState35); timer1.setInterval(100L, checkPhysicalButton35);
    pinMode(ledPin36, OUTPUT); pinMode(btnPin36, INPUT_PULLUP); digitalWrite(ledPin36, ledState36); timer1.setInterval(100L, checkPhysicalButton36);
    pinMode(ledPin37, OUTPUT); pinMode(btnPin37, INPUT_PULLUP); digitalWrite(ledPin37, ledState37); timer1.setInterval(100L, checkPhysicalButton37);
    pinMode(ledPin38, OUTPUT); pinMode(btnPin38, INPUT_PULLUP); digitalWrite(ledPin38, ledState38); timer1.setInterval(100L, checkPhysicalButton38);
    pinMode(ledPin39, OUTPUT); pinMode(btnPin39, INPUT_PULLUP); digitalWrite(ledPin39, ledState39); timer1.setInterval(100L, checkPhysicalButton39);
    pinMode(ledPin40, OUTPUT); pinMode(btnPin40, INPUT_PULLUP); digitalWrite(ledPin40, ledState40); timer0.setInterval(100L, checkPhysicalButton40);
    pinMode(ledPin41, OUTPUT); pinMode(btnPin41, INPUT_PULLUP); digitalWrite(ledPin41, ledState41); timer0.setInterval(100L, checkPhysicalButton41);
    pinMode(ledPin42, OUTPUT); pinMode(btnPin42, INPUT_PULLUP); digitalWrite(ledPin42, ledState42); timer0.setInterval(100L, checkPhysicalButton42);
    pinMode(ledPin43, OUTPUT); pinMode(btnPin43, INPUT_PULLUP); digitalWrite(ledPin43, ledState43); timer0.setInterval(100L, checkPhysicalButton43);
    pinMode(ledPin44, OUTPUT); pinMode(btnPin44, INPUT_PULLUP); digitalWrite(ledPin44, ledState44); timer0.setInterval(100L, checkPhysicalButton44);
    pinMode(ledPin45, OUTPUT); pinMode(btnPin45, INPUT_PULLUP); digitalWrite(ledPin45, ledState45); timer0.setInterval(100L, checkPhysicalButton45);
    pinMode(ledPin46, OUTPUT); pinMode(btnPin46, INPUT_PULLUP); digitalWrite(ledPin46, ledState46); timer0.setInterval(100L, checkPhysicalButton46);
    pinMode(ledPin47, OUTPUT); pinMode(btnPin47, INPUT_PULLUP); digitalWrite(ledPin47, ledState47); timer0.setInterval(100L, checkPhysicalButton47);
    pinMode(ledPin48, OUTPUT); pinMode(btnPin48, INPUT_PULLUP); digitalWrite(ledPin48, ledState48); timer0.setInterval(100L, checkPhysicalButton48);
    pinMode(ledPin49, OUTPUT); pinMode(btnPin49, INPUT_PULLUP); digitalWrite(ledPin49, ledState49); timer0.setInterval(100L, checkPhysicalButton49);
    pinMode(ledPin50, OUTPUT); pinMode(btnPin50, INPUT_PULLUP); digitalWrite(ledPin50, ledState50); timer2.setInterval(100L, checkPhysicalButton50);
    pinMode(ledPin51, OUTPUT); pinMode(btnPin51, INPUT_PULLUP); digitalWrite(ledPin51, ledState51); timer2.setInterval(100L, checkPhysicalButton51);
    pinMode(ledPin25, OUTPUT); pinMode(btnPin25, INPUT_PULLUP); digitalWrite(ledPin25, ledState25); timer2.setInterval(100L, checkPhysicalButton25);
    pinMode(ledPin26, OUTPUT); pinMode(btnPin26, INPUT_PULLUP); digitalWrite(ledPin26, ledState26); timer2.setInterval(100L, checkPhysicalButton26);
    pinMode(ledPin27, OUTPUT); pinMode(btnPin27, INPUT_PULLUP); digitalWrite(ledPin27, ledState27); timer2.setInterval(100L, checkPhysicalButton27);
    pinMode(ledPin28, OUTPUT); pinMode(btnPin28, INPUT_PULLUP); digitalWrite(ledPin28, ledState28); timer2.setInterval(100L, checkPhysicalButton28);
    pinMode(ledPin29, OUTPUT); pinMode(btnPin29, INPUT_PULLUP); digitalWrite(ledPin29, ledState29); timer2.setInterval(100L, checkPhysicalButton29);

    digitalWrite(ledPin30, turn_OFF); digitalWrite(ledPin45, turn_OFF);
    digitalWrite(ledPin31, turn_OFF); digitalWrite(ledPin46, turn_OFF);
    digitalWrite(ledPin32, turn_OFF); digitalWrite(ledPin47, turn_OFF);
    digitalWrite(ledPin33, turn_OFF); digitalWrite(ledPin48, turn_OFF);
    digitalWrite(ledPin34, turn_OFF); digitalWrite(ledPin49, turn_OFF);
    digitalWrite(ledPin35, turn_OFF); digitalWrite(ledPin50, turn_OFF);
    digitalWrite(ledPin36, turn_OFF); digitalWrite(ledPin50, turn_OFF);
    digitalWrite(ledPin37, turn_OFF); digitalWrite(ledPin51, turn_OFF);
    digitalWrite(ledPin38, turn_OFF); digitalWrite(ledPin25, turn_OFF);
    digitalWrite(ledPin39, turn_OFF); digitalWrite(ledPin26, turn_OFF);
    digitalWrite(ledPin40, turn_OFF); digitalWrite(ledPin27, turn_OFF);
    digitalWrite(ledPin41, turn_OFF); digitalWrite(ledPin28, turn_OFF);
    digitalWrite(ledPin42, turn_OFF); digitalWrite(ledPin29, turn_OFF);
    digitalWrite(ledPin43, turn_OFF);
    digitalWrite(ledPin44, turn_OFF);
  }
  while (Blynk.connect() == false) {
    // Wait until connected
  }
}
//bool isFirstConnect = true;

BLYNK_CONNECTED() {
  // if (isFirstConnect) {
  Blynk.syncVirtual(V30); Blynk.syncVirtual(V31); Blynk.syncVirtual(V32); Blynk.syncVirtual(V33); Blynk.syncVirtual(V34); Blynk.syncVirtual(V35); Blynk.syncVirtual(V36); Blynk.syncVirtual(V37);
  Blynk.syncVirtual(V38); Blynk.syncVirtual(V39); Blynk.syncVirtual(V40); Blynk.syncVirtual(V41); Blynk.syncVirtual(V42); Blynk.syncVirtual(V43); Blynk.syncVirtual(V44); Blynk.syncVirtual(V45);
  Blynk.syncVirtual(V43); Blynk.syncVirtual(V44); Blynk.syncVirtual(V45); Blynk.syncVirtual(V46); Blynk.syncVirtual(V47); Blynk.syncVirtual(V48); Blynk.syncVirtual(V49); Blynk.syncVirtual(V50);
  Blynk.syncVirtual(V51); Blynk.syncVirtual(V25); Blynk.syncVirtual(V26); Blynk.syncVirtual(V27); Blynk.syncVirtual(V28); Blynk.syncVirtual(V29);
  //Blynk.syncVirtual(V52);Blynk.syncVirtual(V53);
  //isFirstConnect = false;
  //}
}

BLYNK_WRITE(V30) {
  ledState30 = param.asInt();
  digitalWrite(ledPin30, ledState30);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin30, HIGH);       // turn OFF ledPin 30
      Serial.println("ledPin30 = OFF");   // Serial Print Relay status optional only if you want to see from serial monitor
    }
    if (i == 1) {
      digitalWrite(ledPin30, LOW);       // turn ON ledPin 30
      Serial.println("ledPin30 = ON");   // Serial Print Relay status you can delete this line if you dont want.
      delay (duration);
    }
  }
}
void checkPhysicalButton30() {
  if (digitalRead(btnPin30) == LOW) {
    if (btnState30 != LOW) {
      ledState30 = !ledState30;
      digitalWrite(ledPin30, ledState30);
      Blynk.virtualWrite(V30, ledState30);
    }
    btnState30 = LOW;
  } else {
    btnState30 = HIGH;
  }
}
BLYNK_WRITE(V31) {
  ledState31 = param.asInt();
  digitalWrite(ledPin31, ledState31);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin31, HIGH);       // turn OFF ledPin 31
      Serial.println("ledPin31 = OFF");   // Serial Print Relay status optional you can thesame line too to others outputs if you want.
    }
    if (i == 1) {
      digitalWrite(ledPin31, LOW);        // turn ON ledPin 31
      Serial.println("ledPin31 = ON");    // Serial Print Relay status
      delay (duration);
    }
  }
}
void checkPhysicalButton31() {
  if (digitalRead(btnPin31) == LOW) {
    if (btnState31 != LOW) {
      ledState31 = !ledState31;
      digitalWrite(ledPin31, ledState31);
      Blynk.virtualWrite(V31, ledState31);
    } btnState31 = LOW;
  } else {
    btnState31 = HIGH;
  }
}
BLYNK_WRITE(V32) {
  ledState32 = param.asInt();
  digitalWrite(ledPin32, ledState32);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin32, HIGH);
      //Serial.println("ledPin32 = OFF");   // un comment this line if you want to display this message in ser' mon'.
    }
    if (i == 1) {
      digitalWrite(ledPin32, LOW);
      //Serial.println("ledPin32 = ON");   // un comment if you want to display this message in ser mon.
      delay (duration);
    }
  }
}
void checkPhysicalButton32() {
  if (digitalRead(btnPin32) == LOW) {
    if (btnState32 != LOW) {
      ledState32 = !ledState32;
      digitalWrite(ledPin32, ledState32);
      Blynk.virtualWrite(V32, ledState32);
    } btnState32 = LOW;
  } else {
    btnState32 = HIGH;
  }
}
BLYNK_WRITE(V33) {
  ledState33 = param.asInt();
  digitalWrite(ledPin33, ledState33);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin33, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin33, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton33() {
  if (digitalRead(btnPin33) == LOW) {
    if (btnState33 != LOW) {
      ledState33 = !ledState33;
      digitalWrite(ledPin33, ledState33);
      Blynk.virtualWrite(V33, ledState33);
    } btnState33 = LOW;
  } else {
    btnState33 = HIGH;
  }
}
BLYNK_WRITE(V34) {
  ledState34 = param.asInt();
  digitalWrite(ledPin34, ledState34);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin34, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin34, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton34() {
  if (digitalRead(btnPin34) == LOW) {
    if (btnState34 != LOW) {
      ledState34 = !ledState34;
      digitalWrite(ledPin34, ledState34);
      Blynk.virtualWrite(V34, ledState34);
    } btnState34 = LOW;
  } else {
    btnState34 = HIGH;
  }
}
BLYNK_WRITE(V35) {
  ledState35 = param.asInt();
  digitalWrite(ledPin35, ledState35);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin35, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin35, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton35() {
  if (digitalRead(btnPin35) == LOW) {
    if (btnState35 != LOW) {
      ledState35 = !ledState35;
      digitalWrite(ledPin35, ledState35);
      Blynk.virtualWrite(V35, ledState35);
    } btnState35 = LOW;
  } else {
    btnState35 = HIGH;
  }
}
BLYNK_WRITE(V36) {
  ledState36 = param.asInt();
  digitalWrite(ledPin36, ledState36);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin36, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin36, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton36() {
  if (digitalRead(btnPin36) == LOW) {
    if (btnState36 != LOW) {
      ledState36 = !ledState36;
      digitalWrite(ledPin36, ledState36);
      Blynk.virtualWrite(V36, ledState36);
    } btnState36 = LOW;
  } else {
    btnState36 = HIGH;
  }
}
BLYNK_WRITE(V37) {
  ledState37 = param.asInt();
  digitalWrite(ledPin37, ledState37);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin37, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin37, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton37() {
  if (digitalRead(btnPin37) == LOW) {
    if (btnState37 != LOW) {
      ledState37 = !ledState37;
      digitalWrite(ledPin37, ledState37);
      Blynk.virtualWrite(V37, ledState37);
    } btnState37 = LOW;
  } else {
    btnState37 = HIGH;
  }
}
BLYNK_WRITE(V38) {
  ledState38 = param.asInt();
  digitalWrite(ledPin38, ledState38);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin38, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin38, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton38() {
  if (digitalRead(btnPin38) == LOW) {
    if (btnState38 != LOW) {
      ledState38 = !ledState38;
      digitalWrite(ledPin38, ledState38);
      Blynk.virtualWrite(V38, ledState38);
    } btnState38 = LOW;
  } else {
    btnState38 = HIGH;
  }
}
BLYNK_WRITE(V39) {
  ledState39 = param.asInt();
  digitalWrite(ledPin39, ledState39);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin39, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin39, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton39() {
  if (digitalRead(btnPin39) == LOW) {
    if (btnState39 != LOW) {
      ledState39 = !ledState39;
      digitalWrite(ledPin39, ledState39);
      Blynk.virtualWrite(V39, ledState39);
    } btnState39 = LOW;
  } else {
    btnState39 = HIGH;
  }
}
BLYNK_WRITE(V40) {
  ledState40 = param.asInt();
  digitalWrite(ledPin40, ledState40);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin40, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin40, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton40() {
  if (digitalRead(btnPin40) == LOW) {
    if (btnState40 != LOW) {
      ledState40 = !ledState40;
      digitalWrite(ledPin40, ledState40);
      Blynk.virtualWrite(V40, ledState40);
    } btnState40 = LOW;
  } else {
    btnState40 = HIGH;
  }
}
BLYNK_WRITE(V41) {
  ledState41 = param.asInt();
  digitalWrite(ledPin41, ledState41);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin41, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin41, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton41() {
  if (digitalRead(btnPin41) == LOW) {
    if (btnState41 != LOW) {
      ledState41 = !ledState41;
      digitalWrite(ledPin41, ledState41);
      Blynk.virtualWrite(V41, ledState41);
    } btnState41 = LOW;
  } else {
    btnState41 = HIGH;
  }
}
BLYNK_WRITE(V42) {
  ledState42 = param.asInt();
  digitalWrite(ledPin42, ledState42);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin42, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin42, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton42() {
  if (digitalRead(btnPin42) == LOW) {
    if (btnState42 != LOW) {
      ledState42 = !ledState42;
      digitalWrite(ledPin42, ledState42);
      Blynk.virtualWrite(V42, ledState42);
    } btnState42 = LOW;
  } else {
    btnState42 = HIGH;
  }
}
BLYNK_WRITE(V43) {
  ledState43 = param.asInt();
  digitalWrite(ledPin43, ledState43);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin43, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin43, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton43() {
  if (digitalRead(btnPin43) == LOW) {
    if (btnState43 != LOW) {
      ledState43 = !ledState43;
      digitalWrite(ledPin43, ledState43);
      Blynk.virtualWrite(V43, ledState43);
    } btnState43 = LOW;
  } else {
    btnState43 = HIGH;
  }
}
BLYNK_WRITE(V44) {
  ledState44 = param.asInt();
  digitalWrite(ledPin44, ledState44);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin44, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin44, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton44() {
  if (digitalRead(btnPin44) == LOW) {
    if (btnState44 != LOW) {
      ledState44 = !ledState44;
      digitalWrite(ledPin44, ledState44);
      Blynk.virtualWrite(V44, ledState44);
    } btnState44 = LOW;
  } else {
    btnState44 = HIGH;
  }
}
BLYNK_WRITE(V45) {
  ledState45 = param.asInt();
  digitalWrite(ledPin45, ledState45);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin45, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin45, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton45() {
  if (digitalRead(btnPin45) == LOW) {
    if (btnState45 != LOW) {
      ledState45 = !ledState45;
      digitalWrite(ledPin45, ledState45);
      Blynk.virtualWrite(V45, ledState45);
    } btnState45 = LOW;
  } else {
    btnState45 = HIGH;
  }
}
BLYNK_WRITE(V46) {
  ledState46 = param.asInt();
  digitalWrite(ledPin46, ledState46);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin46, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin46, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton46() {
  if (digitalRead(btnPin46) == LOW) {
    if (btnState46 != LOW) {
      ledState46 = !ledState46;
      digitalWrite(ledPin46, ledState46);
      Blynk.virtualWrite(V46, ledState46);
    } btnState46 = LOW;
  } else {
    btnState46 = HIGH;
  }
}
BLYNK_WRITE(V47) {
  ledState47 = param.asInt();
  digitalWrite(ledPin47, ledState47);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin47, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin47, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton47() {
  if (digitalRead(btnPin47) == LOW) {
    if (btnState47 != LOW) {
      ledState47 = !ledState47;
      digitalWrite(ledPin47, ledState47);
      Blynk.virtualWrite(V47, ledState47);
    } btnState47 = LOW;
  } else {
    btnState47 = HIGH;
  }
}
BLYNK_WRITE(V48) {
  ledState48 = param.asInt();
  digitalWrite(ledPin48, ledState48);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin48, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin48, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton48() {
  if (digitalRead(btnPin48) == LOW) {
    if (btnState48 != LOW) {
      ledState48 = !ledState48;
      digitalWrite(ledPin48, ledState48);
      Blynk.virtualWrite(V48, ledState48);
    } btnState48 = LOW;
  } else {
    btnState48 = HIGH;
  }
}
BLYNK_WRITE(V49) {
  ledState49 = param.asInt();
  digitalWrite(ledPin49, ledState49);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin49, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin49, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton49() {
  if (digitalRead(btnPin49) == LOW) {
    if (btnState49 != LOW) {
      ledState49 = !ledState49;
      digitalWrite(ledPin49, ledState49);
      Blynk.virtualWrite(V49, ledState49);
    } btnState49 = LOW;
  } else {
    btnState49 = HIGH;
  }
}
BLYNK_WRITE(V50) {
  ledState50 = param.asInt();
  digitalWrite(ledPin50, ledState50);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin50, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin50, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton50() {
  if (digitalRead(btnPin50) == LOW) {
    if (btnState50 != LOW) {
      ledState50 = !ledState50;
      digitalWrite(ledPin50, ledState50);
      Blynk.virtualWrite(V50, ledState50);
    } btnState50 = LOW;
  } else {
    btnState50 = HIGH;
  }
}

BLYNK_WRITE(V51) {
  ledState51 = param.asInt();
  digitalWrite(ledPin51, ledState51);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin51, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin51, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton51() {
  if (digitalRead(btnPin51) == LOW) {
    if (btnState51 != LOW) {
      ledState51 = !ledState51;
      digitalWrite(ledPin51, ledState51);
      Blynk.virtualWrite(V51, ledState51);
    } btnState51 = LOW;
  } else {
    btnState51 = HIGH;
  }
}
BLYNK_WRITE(V25) {
  ledState25 = param.asInt();
  digitalWrite(ledPin25, ledState25);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin25, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin25, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton25() {
  if (digitalRead(btnPin25) == LOW) {
    if (btnState25 != LOW) {
      ledState25 = !ledState25;
      digitalWrite(ledPin25, ledState25);
      Blynk.virtualWrite(V25, ledState25);
    } btnState25 = LOW;
  } else {
    btnState25 = HIGH;
  }
}
BLYNK_WRITE(V26) {
  ledState26 = param.asInt();
  digitalWrite(ledPin26, ledState26);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin26, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin26, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton26() {
  if (digitalRead(btnPin26) == LOW) {
    if (btnState26 != LOW) {
      ledState26 = !ledState26;
      digitalWrite(ledPin26, ledState26);
      Blynk.virtualWrite(V26, ledState26);
    } btnState26 = LOW;
  } else {
    btnState26 = HIGH;
  }
}
BLYNK_WRITE(V27) {
  ledState27 = param.asInt();
  digitalWrite(ledPin27, ledState27);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin27, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin27, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton27() {
  if (digitalRead(btnPin27) == LOW) {
    if (btnState27 != LOW) {
      ledState27 = !ledState27;
      digitalWrite(ledPin27, ledState27);
      Blynk.virtualWrite(V27, ledState27);
    } btnState27 = LOW;
  } else {
    btnState27 = HIGH;
  }
}
BLYNK_WRITE(V28) {
  ledState28 = param.asInt();
  digitalWrite(ledPin28, ledState28);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin28, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin28, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton28() {
  if (digitalRead(btnPin28) == LOW) {
    if (btnState28 != LOW) {
      ledState28 = !ledState28;
      digitalWrite(ledPin28, ledState28);
      Blynk.virtualWrite(V28, ledState28);
    } btnState28 = LOW;
  } else {
    btnState28 = HIGH;
  }
}
BLYNK_WRITE(V29) {
  ledState29 = param.asInt();
  digitalWrite(ledPin29, ledState29);
  {
    int i = param.asInt();
    int state;
    if (i == 0) {
      digitalWrite(ledPin29, HIGH);
    }
    if (i == 1) {
      digitalWrite(ledPin29, LOW);
      delay (duration);
    }
  }
}
void checkPhysicalButton29() {
  if (digitalRead(btnPin29) == LOW) {
    if (btnState29 != LOW) {
      ledState29 = !ledState29;
      digitalWrite(ledPin29, ledState29);
      Blynk.virtualWrite(V29, ledState29);
    } btnState29 = LOW;
  } else {
    btnState29 = HIGH;
  }
}

void loop()
{
  Blynk.run();
  timer0.run();
  timer1.run();
  timer2.run();
}

Jamin · October 5, 2016, 10:23pm

You only need to declare SimpleTimer timer; once.

Then just declare timers like so

timer2 = timer.setInterval(100L, checkPhysicalButton29);

Costas · October 5, 2016, 11:00pm

@Jamin are you sure that works because the docs are clear that each “timer” is limited to a count of 10, the OP requires 20+.

Jamin · October 5, 2016, 11:12pm

Still best practice to use only 2 declarations than to declare 10 different timers.

timer1 = timer.setInterval(100L, checkPhysicalButton29);
timer2 = timer.setInterval(100L, checkPhysicalButton29);
timer3 = timer.setInterval(100L, checkPhysicalButton29);
timer4 = timer.setInterval(100L, checkPhysicalButton29);
...
timer11 = timer2.setInterval(100L, checkPhysicalButton29);
timer12 = timer2.setInterval(100L, checkPhysicalButton29);
timer13 = timer2.setInterval(100L, checkPhysicalButton29);
timer14 = timer2.setInterval(100L, checkPhysicalButton29);

hjroh0315 · October 6, 2016, 2:02pm

Pullup
VirtualWrite
Profit

speed57 · October 6, 2016, 6:03pm

@Castle those mega code won’t work on nodemcu, do you know why?

Sergey_Kuntsevich · October 9, 2016, 4:00pm

no.?

Costas · October 9, 2016, 4:05pm

@speed57 perhaps because pinout of a nodemcu is very different to a Mega.

conkerkh · October 9, 2016, 5:20pm

Just set up interupt on the pin that monitors the state, then inside interupt callback set flag to sync physical button with widget, please keep your interupt call as short as possible so your code can exit interupt function before next interupt may occur (to be precise only set flag to send something don’t actually send anything inside the callback). That’s to be honest the only way it should be done. Interupt should be triggered on rising and falling edge if it is switch.

speed57 · October 10, 2016, 7:30pm

@conkerkh Actually I can’t write codes but more like copy and alternate them kinda newbe in this field. Mostly I ask community for code examples so understand concept.
Thank you for your replay

hgomez809 · March 5, 2017, 7:41am

Hello, I am trying to accomplish this same project on a NodeMCU, I have tried the code provided by Castle and modified a few lines to make it work with the esp8266 but it is not fully functional. Right now I am able to turn on/off the switch through the blynk app but not through the actual physical button. @Castle

#define BLYNK_PRINT Serial    // Comment this out to disable prints and save space
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
#include <SPI.h>
#include <TimeLib.h>
#include <SimpleTimer.h>

// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = "token";

// Your WiFi credentials.
// Set password to "" for open networks.
char ssid[] = "Wifi Name";
char pass[] = "Password";

const int btnPin1 = 1;             // pin for your physical push btn switch or toggle switch. just for example
const int RelayPin1 = 3;         // pin for your relay outputs or any trigger output. etc.
//declaire your other pins here for your next buttons

SimpleTimer timer;              // add simple timer for the time interval scanning period of physical button input switch.
WidgetLED led1(V0);

void checkPhysicalButton();
int btnPin1State = LOW;           // ON
int RelayPin1State = HIGH;        // OFF

//*******Sets Relays to Off Position*****************
#define TURN_ON 0                 // TURN_ON and TURN_OFF are defined to account for Active High relays
#define TURN_OFF 1                // Used to switch relay states

void setup()
{
  Serial.begin (9600);
  Blynk.begin(auth, ssid, pass);
  {
pinMode(RelayPin1, OUTPUT);            //  initialize your pin as output.
pinMode(btnPin1, INPUT_PULLUP);        //  initialize your pin as input with enable internal pull-up resistor "input_pullup"
digitalWrite(RelayPin1, RelayPin1State);
digitalWrite(RelayPin1, TURN_OFF);     // remain off till command is receive

// Setup a function to be called every 100 ms
timer.setInterval(100L, checkPhysicalButton);
  }
  while (Blynk.connect() == false) {
// Wait until connected
  }
}
void checkPin()
{
  // Invert state, since button is "Active LOW"
  if (digitalRead(btnPin1)) {
led1.on();
  } else {
led1.off();
  }
}
// Every time we connect to the cloud...
BLYNK_CONNECTED() {
  // Request the latest state from the server
  Blynk.syncVirtual(V1);
  // Alternatively, you could override server state using:
  //Blynk.virtualWrite(V1, RelayPin1State);
}
// When App button is pushed - switch the state
BLYNK_WRITE(V1) {                           // Map this Virtual Pin to your  Mobile Blynk apps widget.
  RelayPin1State = param.asInt();
  digitalWrite(RelayPin1, RelayPin1State);
  {
//BLYNK_LOG("Got a value: %s", param.asStr());
// You can also use:
int i = param.asInt();
int state;
// Switch mode inverse//
if (i == 0) {
  digitalWrite(RelayPin1, HIGH);
  Serial.println("Relay 1 = OFF");       // turn OFF your relay outputs
}
if (i == 1) {
  digitalWrite(RelayPin1, LOW);         // turn ON your relay outputs
  Serial.println("Relay 1 = ON");
  delay (300);                          // Delay response of your button switch (change it for you experimental but for me 300 is ok)
}
  }
}

void checkPhysicalButton()
{
  if (digitalRead(btnPin1) == LOW) {
// btnPin1State is used to avoid sequential toggles
if (btnPin1State != LOW) {
  // Toggle LED state
  RelayPin1State = !RelayPin1State;
  digitalWrite(RelayPin1, RelayPin1State);
  // Update Button Widget
  Blynk.virtualWrite(V1, RelayPin1State);
}
btnPin1State = LOW;
  } else {
btnPin1State = HIGH;
  }
}
void loop()
{
  Blynk.run();                               // Run Blynk
  timer.run();                               // Run SimpleTimer
}

Thank you for your help, i am new at this.

speed57 · March 5, 2017, 7:12pm

@hgomez809 I think all you need is this

#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
#include <SimpleTimer.h>

#define VPIN V1

char auth[] = "xxxxxxx";

void lightOn();
void lightOff();

boolean LampState = 0;
boolean SwitchReset = true;

const int TacSwitch = D5; 
const int RelayPin = D6; 

SimpleTimer timer;
WidgetLED VLED(V11);

void setup()      
{
  Serial.begin(115200);
  pinMode(RelayPin, OUTPUT);
  pinMode(TacSwitch, INPUT_PULLUP);
  delay(10);
  digitalWrite(RelayPin, LOW);
  Blynk.config(auth);
  timer.setInterval(100, ButtonCheck);
}
void loop()
{
  Blynk.run();
  timer.run();
}
void ButtonCheck() {
  boolean SwitchState = (digitalRead(TacSwitch));
  if (!SwitchState && SwitchReset == true) {
    if (LampState) {
      lightOff();
    } else {
      lightOn();
    }
    SwitchReset = false;
    delay(50);
  }
  else if (SwitchState) {
    SwitchReset = true;
  }
}
void ToggleRelay() {
  LampState = !LampState;
  if (LampState) {
       lightOn();
  }
  else lightOff();
}
void lightOn() {
    digitalWrite(RelayPin, LOW);
    LampState = 1;
    Blynk.virtualWrite(VPIN, HIGH); 
    VLED.off();
}
void lightOff() {
    digitalWrite(RelayPin, HIGH);
    LampState = 0;
    Blynk.virtualWrite(VPIN, LOW); 
    VLED.on();
}
BLYNK_WRITE(VPIN) {
  int SwitchStatus = param.asInt();
    if (SwitchStatus == 2){
    ToggleRelay();
  }
  else if (SwitchStatus){
    lightOn();
  }
  else lightOff();
}

code by @chrome1000
you can also get status update of button and LED widget.

gagansite · April 27, 2018, 1:11pm

@speed57

sir I am trying to convert your cod ein 4 channel could you help please.

#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
#include <SimpleTimer.h>

#define VPIN1 V1
#define VPIN2 V2
#define VPIN3 V3
#define VPIN3 V3
char auth[] = “b3b58a38a08a42d0bb059cb3e1f9c59b”;//“5b2e889b1b6f49a4bf9b2d1119cb91d8”;
char ssid[] = “Tenda_1BCB98”;
char pass[] = “gagangoel”;

void lightOn();
void lightOff();

boolean LampState = 0;
boolean SwitchReset = true;

const int TacSwitch1 = D5;
const int RelayPin1 = D6;

const int TacSwitch2 = D7;
const int RelayPin2 = D8;

const int TacSwitch3 = D0;
const int RelayPin3 = D1;

const int TacSwitch4 = D2;
const int RelayPin4 = D3;

SimpleTimer timer;
WidgetLED VLED(V11);

void setup()
{
Serial.begin(115200);
pinMode(RelayPin1, OUTPUT);
pinMode(TacSwitch1, INPUT_PULLUP);
pinMode(RelayPin2, OUTPUT);
pinMode(TacSwitch2, INPUT_PULLUP);
delay(10);
digitalWrite(RelayPin1, LOW);
digitalWrite(RelayPin2, LOW);
Blynk.config(auth);
timer.setInterval(100, ButtonCheck);
}
void loop()
{
Blynk.run();
timer.run();
}
void ButtonCheck() {
{ boolean SwitchState = (digitalRead(TacSwitch1));
if (!SwitchState && SwitchReset == true) {
if (LampState) {
lightOff();
} else {
lightOn();
}
SwitchReset = false;
delay(50);
}
else if (SwitchState) {
SwitchReset = true;
}

// 2
{ boolean SwitchState = (digitalRead(TacSwitch2));
if (!SwitchState && SwitchReset == true) {
if (LampState) {
lightOff();
} else {
lightOn();
}
SwitchReset = false;
delay(50);
}
else if (SwitchState) {
SwitchReset = true;
}
}

void ToggleRelay() {
}
LampState = !LampState;
if (LampState) {
lightOn();
}
else lightOff();
}

void lightOn()

{

digitalWrite(RelayPin1, LOW);
LampState = 1;
Blynk.virtualWrite(VPIN1, HIGH); 
VLED.off();

}
{
digitalWrite(RelayPin2, LOW);
LampState = 1;
Blynk.virtualWrite(VPIN2, HIGH);
VLED.off();
}}

void lightOff() {{
digitalWrite(RelayPin1, HIGH);
LampState = 0;
Blynk.virtualWrite(VPIN1, LOW);
VLED.on();
}
BLYNK_WRITE(VPIN1) {
int SwitchStatus = param.asInt();
if (SwitchStatus == 2){
ToggleRelay();
}
else if (SwitchStatus){
lightOn();
}
else lightOff();
}
{
digitalWrite(RelayPin2, HIGH);
LampState = 0;
Blynk.virtualWrite(VPIN2, LOW);
VLED.on();
}
BLYNK_WRITE(VPIN2) {
int SwitchStatus = param.asInt();
if (SwitchStatus == 2){
ToggleRelay();
}
else if (SwitchStatus){
lightOn();
}
else lightOff();
}}