Home Automation with Self-learning 433 Power Switches

/*********************************************************************************************************
 * Based upon collective works by an unknown author, adapted for Cayenne (or Blynck) by Wouter-Jan       *
 * Info Flamingo: http://forum.arduino.cc/index.php?topic=201771.0                                       *
 * Info 433: a self-learning 433 libary in wording: https://forum.fhem.de/index.php/topic,36399.60.html  *
 * *******************************************************************************************************

******************************************************************************** 
** Flamingo_send                                                              **
**                                                                            **
**       Flamingo device commands (on/off)hard coded (not deciphered yet)     **
**       code is 28 byte long. To transfer it in 32 bit code 4 *0             **
**       is added to the left. For programming reason hex code representation **
**       of device code is used. E.g. Remote 0,C,On:                          **
**         code 28 bits: 0001100110111111110100100110                         **
**         code 32 bits: 00011001101111111101001001100000                     **
**         Hex:          19BFD260                                             **
**                                                                            **
**        "Sync" 1 pulse High, 15 pulse low                                   **
**        "1"    1 pulse High, 3 pulse low                                    **
**        "0"    3 pulse High, 1 pulse low                                    **
**        "end"  N/A                                                          **
**                                                                            **
**       For internal ref: Unit 0 = white remote , unit 1 = black remote      **
**                                                                            **
*******************************************************************************/

// Compiler only coding
#define FUNITS  12                                 /* Amount of units supported */
#define FCMDN   2                                  /* Amount of CMD 0 = On, 1 = Off */

// int rfPin = D7;                                 /* with ethernet shield D4 = SS (for SD card) (now in main sketch)*/

// define device codes:

uint32_t fdev[FUNITS][FCMDN] = {0xD9762A10, 0xDAA47850, /* Remote 0 */ 
                                0xDBDA22E0, 0xDBA27220, /* Remote 1 */
                                0x19BFD260, 0x195EEAA0, /* Remote 2 */
                                0x984CC650, 0x9A8C1050, /* Remote 3 */
                                0xDBFFFE90, 0xD91CEF10, /* Remote 4 */
                                0xDBC52FA0, 0xD9E35160, /* Remote 5 */
                                0x19B0FE60, 0x19682B20, /* Remote 6 */
                                0x9924E7D0, 0x9BA928D0, /* Remote 7 */                                        
                                0x25B25B60, 0x24DC2060, /* Remote 8  (not tested) */
                                0x2717B510, 0x275BADD0, /* Remote 9  (not tested) */
                                0xE56BF910, 0xE4D49F50, /* Remote 10 (not tested) */
                                0x65F1C2A0, 0x65B67B60  /* Remote 11 (not tested) */ 
           };                                         


// Define Flamingo_send variables / constants

int fpulse = 300;                              /* Pulse witdh in microseconds */
int fretrans = 5;                              /* Code retransmission         */
uint32_t fsendbuff;
uint32_t fdatabit;
uint32_t fdatamask = 0x80000000;

void Flamingo_Send(int funitc, int fcmd)
{

 // Test if used codes are valid

 if ((funitc < 0) || (funitc >  11)) {                  // check if unit code between 0-11 (Remote 0 to 11)
   Serial.print("Unit error: ");
   Serial.println(funitc);
   return;
 }

 if ((fcmd < 0) || (fcmd > 1)) {                       // check if command = 0 (off) or 1 (on)
   Serial.print("Command error: ");
   Serial.println(fcmd);
   return;
 }
 
 //End test used codes
 Serial.println("");
 Serial.println("Send Flamingo command: ");
 Serial.print("Flamingo Unit = :");
 Serial.println(funitc);
 Serial.print("command = :");
 Serial.println(fcmd);
 // Send Command

 for (int nRepeat = 0; nRepeat <= fretrans; nRepeat++) {

   fsendbuff = fdev[funitc][fcmd];

   // send SYNC 1P High, 15P low
   Serial.println("Send sync");

   digitalWrite(rfPin, HIGH);
   delayMicroseconds(fpulse * 1);
   digitalWrite(rfPin, LOW);
   delayMicroseconds(fpulse * 15);

   // end send SYNC

   // Send command

   for (int i = 0; i < 28; i++)                                 // Flamingo command is only 28 bits */
   {
     // read data bit
     fdatabit = fsendbuff & fdatamask;                         // Get most left bit
     fsendbuff = (fsendbuff << 1);                             // Shift left

     if (fdatabit != fdatamask)
     { // Write 0
       digitalWrite(rfPin, HIGH);
       delayMicroseconds(fpulse * 3);
       digitalWrite(rfPin, LOW);
       delayMicroseconds(fpulse * 1);
     }
     else
     { // Write 1
       digitalWrite(rfPin, HIGH);
       delayMicroseconds(fpulse * 1);
       digitalWrite(rfPin, LOW);
       delayMicroseconds(fpulse * 3);
     }
   }
 }
   //Serial.println("send code = :");
   //Serial.println(fsendbuff);
   Serial.println(rfPin);
}

void sunsetrise() {

/*  Calculate when sunrises and sunsets based upon GSP-coordinates and date of the year
 *  using TimeLord.h library.
 *  dates are stores as integer and float whereas float simulates a time-notation without semi-column. 
 */
  
  float const LONGITUDE = 4.26; //change this according to your own location
  float const LATITUDE = 52.08; //ditto 

  TimeLord tardis; 
  tardis.TimeZone((60) + check_DST * 60); // tell TimeLord what timezone your RTC / NTP-server is synchronized to. You can ignore DST
  // as long as the RTC never changes back and forth between DST and non-DST
  tardis.Position(LATITUDE, LONGITUDE); // tell TimeLord where in the world we are
  //byte today[] = {  0, 0, 12, 21, 8, 2017    }; // store manual date (at noon) in an array for TimeLord to use
  byte today[] = {  0, 0, 12, dateTime.day, dateTime.month, dateTime.year }; // store RTC date (at noon) in an array for TimeLord to use
  
  if (tardis.SunRise(today)) // if the sun will rise today (it might not, in the [ant]arctic)
     {
     time_sunrise = today[tl_hour] * 60 + today[tl_minute];
     time_sunrise_d = today[tl_hour] * 1.0 + today[tl_minute] / 100.0;
     }
  if (tardis.SunSet(today)) // if the sun will set today (it might not, in the [ant]arctic)
     {
     time_sunset = today[tl_hour] * 60 + today[tl_minute];
     time_sunset_d = today[tl_hour] * 1.0 + today[tl_minute] / 100.0;
     }
  }
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  
  void publishSystemUpTime(){ 
    //source: http://community.mydevices.com/t/system-uptime-millis-to-dd-hh-mm-code-optimization-question-esp8266/4434
    long millisecs = millis();
    //systemUpTimeMn = int((millisecs / (1000*60)) % 60);
    //systemUpTimeHr = int((millisecs / (1000*60*60)) % 24);
    //systemUpTimeDy = int((millisecs / (1000*60*60*24)) % 365);
    uptime = int((millisecs / (1000*60*60)) % 24) + int((millisecs / (1000*60)) % 60) / 100.0;
    //Serial.println(uptime);
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

void DHTroutine() {
    h = dht.readHumidity();
    t = dht.readTemperature();
    Serial.print("Humidity: ");
    Serial.print(h);
    Serial.println(" %\t");
    Serial.print("Temperature: ");
    Serial.print(t);
    Serial.println(" Celcius ");
    Cayenne.virtualWrite(30, t, "temp", "c");
    Cayenne.virtualWrite(31, h, "rel_hum", "p");
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

void flamingo_2actions(int tmp_switch, int tmp_switch_value){ //used to invert the flamingo switch

  Cayenne.virtualWrite(tmp_switch, tmp_switch_value);
  Flamingo_Send(tmp_switch, !tmp_switch_value); // ON/OFF

}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

void Timeroutine() {
     
    // first parameter: Time zone; second parameter: 1 for European summer time; 2 for US daylight saving time (not implemented yet)
    dateTime = NTPnl.getTime(1.0, 1); // get time from internal clock
    //NTPnl.printDateTime(dateTime);
    time_now = dateTime.hour * 60 + dateTime.minute;
    time_now_d = dateTime.hour * 1.0 + ( dateTime.minute / 100.0);
    
    if (time_now >= time_sunset || time_now <= time_sunrise) {
       Cayenne.virtualWrite(41, 1, "digital_sensor", "d");
       //Serial.println("Night time = 1");
       } else {
       Cayenne.virtualWrite(41, 0, "digital_sensor", "d");
       //Serial.println("Night time = 0");
  }
    if (time_now >= time_sunset + time_offset || time_now <= time_sunrise - time_offset) { //delay for twilight offset set by slider
       Cayenne.virtualWrite(42, 1, "digital_sensor", "d");
       //Cayenne.virtualWrite(42, 1);
       //Serial.println("Twilight = 1");
       } else {
       //Cayenne.virtualWrite(42, 0);
       Cayenne.virtualWrite(42, 0, "digital_sensor", "d");
       //Serial.println("Twilight = 0");
       }
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

void Time_DST_refresh(){ //monthly reset of time based upon NTP-servers

  Serial.println("inside Time_DST_refresh()");
  // NTP-server part
  Serial.println("Connecting to NTP-server NL");
  while (!NTPnl.setSNTPtime()) Serial.print("."); // set internal clock
  Serial.print("Time set : ");
  // first parameter: Time zone; second parameter: 1 for European summer time; 2 for US daylight saving time (not implemented yet)
  dateTime = NTPnl.getTime(1.0, 1); // get time from internal clock
  NTPnl.printDateTime(dateTime);
  byte actualHour = dateTime.hour;
  /*
  byte actualMinute = dateTime.minute;
  byte actualsecond = dateTime.second;
  int actualyear = dateTime.year;
  byte actualMonth = dateTime.month;
  byte actualday = dateTime.day;
  byte actualdayofWeek = dateTime.dayofWeek;
  */
  // DST-part
  dateTime_wo_DST = NTPnl.getTime(1.0, 0); // get time from internal clock with out DST correction
  byte Hour_wo_DST =  dateTime_wo_DST.hour;
  if (Hour_wo_DST == dateTime.hour) {
    check_DST = 0;
  } else {
    check_DST = 1;
  }
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

void obsolete_scheduling() {
Serial.println("inside obsolete_scheduling");

//setting switches on !!!!
  if(time_now == time_sunset + time_offset + 11) {
      Cayenne.virtualWrite(13, 1);
      transmitter.sendUnit(1, 1); // Flamingo SF-501PWD unit 1
      Cayenne.virtualWrite(14, 1);
      transmitter.sendUnit(2, 1); // Flamingo SF-501PWD unit 2
  }
  
  if(time_now == time_sunset + time_offset + 1) {
     flamingo_2actions(0, 1);
     flamingo_2actions(2, 1);
     flamingo_2actions(4, 1);
     flamingo_2actions(7, 1);
  }

  if(time_now == time_sunset + time_offset + 24) {
     flamingo_2actions(1, 1);
     flamingo_2actions(3, 1);
  }

  //kerstverlichting
  if(time_now == 8 * 60 ) {
     flamingo_2actions(5, 1);
     flamingo_2actions(6, 1);
  }
  if(time_now == 2 * 60 ) {
     flamingo_2actions(6, 0);
  }

  if(time_now == 22 * 60 + 30 ) {
     flamingo_2actions(3, 0);
  }
  
  if(time_now == 23 * 60 + 40 ) {
     flamingo_2actions(0, 0);
     flamingo_2actions(1, 0);
     flamingo_2actions(2, 0);
     flamingo_2actions(3, 0);
     flamingo_2actions(4, 0);
     flamingo_2actions(5, 0);
     flamingo_2actions(7, 0);
  }
  
  //turn light off by sleeping time
  if(time_now == 5) {
      //Serial.println("inside time_now == (24*60 - 5)");
      Cayenne.virtualWrite(13, 0);
      transmitter.sendUnit(1, 0); // Flamingo SF-501PWD unit 1
  }
  
  // turn lights off by sunrise
  if(time_now == time_sunrise - 30) { // half hour for actual sunrise light switches out
      Cayenne.virtualWrite(14, 0);
      transmitter.sendUnit(2, 0); // Flamingo SF-501PWD unit 2
  }

  if(time_now == 8 * 60 + 15 ) { // turning on some christmas lights by scheduling overide by remote only
    mySwitch.enableTransmit(rfPin);
    mySwitch.switchOn("11111", "10000");
    mySwitch.switchOn("11111", "01000");
    mySwitch.switchOn("11111", "00010");
    mySwitch.disableTransmit();
  }
  
  if(time_now ==  23 * 60 + 5 ) { // turning on some christmas lights by scheduling overide by remote only
  //Serial.println("Switch: woodpile");
    mySwitch.enableTransmit(rfPin);
    mySwitch.switchOff("11111", "10000");
    mySwitch.switchOff("11111", "00100");
    mySwitch.switchOff("11111", "00010");
    mySwitch.disableTransmit();
  }
}