Automatic Chicken Coop Door (feat. takeout containers)

const char* ssid = "honeyIShrunkTheWiFi";     // your local Wi-Fi network
const char* password = "networkPassword";     // your Wi-Fi password

const char* sunRiseSetAPI = "https://api.sunrise-sunset.org/json?lat=40.014984&lng=-105.270546";       // these are coordinates to Boulder High School! Replace with your latitude and longitude.

const char* googleScript = ""; // If you want to integrate Google services like the calendar, or a spreadsheet to publish debugging data.

/* date/time API calling and parsing/printing data
 * - NTP and sunrise-sunset
 * - look at NTP documentation
 */
// helper functions for sunrise and sunset states w/ offsets
bool timeToOpen() {
  // if it is [offset_open] minutes til sunrise
  uint8_t openHour, openMin;
  if (offset_open > SUNRISE_MINUTE) { // eg 45 minutes before 6:20
    openMin = 60 - (offset_open - SUNRISE_MINUTE);
    openHour = SUNRISE_HOUR-1;
  } else {
    openMin = SUNRISE_MINUTE - offset_open;
    openHour = SUNRISE_HOUR;
  }
  if (CURRENT_HOUR >= openHour && CURRENT_MINUTE >= openMin) {
    return true;
  } else {
    return false;
  }
}

bool timeToClose() {
  // if it is [offset_close] minutes after sunset
  uint8_t closeHour, closeMin;
  closeMin = SUNSET_MINUTE + offset_close;
  if (closeMin > 59) { // eg 20 minutes before 6:45
    closeMin = closeMin % 60;
    closeHour = SUNSET_HOUR+1;
  } else {
    closeHour = SUNSET_HOUR;
  }
  if (CURRENT_HOUR >= closeHour && CURRENT_MINUTE >= closeMin) {
    return true;
  } else {
    return false;
  }
}

void updateLocalTime() {
  struct tm timeinfo;
  if (!getLocalTime(&timeinfo)) {
//    Serial.println(F("Failed to obtain time"));
    DATETIME_RDY = 0;
    return;
  }
  DATETIME_RDY = 1;
  CURRENT_YEAR = timeinfo.tm_year+1900;
  CURRENT_MONTH = timeinfo.tm_mon+1;
  CURRENT_DATE = timeinfo.tm_mday;
  CURRENT_HOUR = timeinfo.tm_hour;
  CURRENT_MINUTE = timeinfo.tm_min;
  DST_FLAG = timeinfo.tm_isdst;
  
  prevTime = currentTime;
  broadcastChange('t');
}

void getSunTimes() {
  // https://www.dfrobot.com/blog-917.html
  HTTPClient http;
  http.begin(sunRiseSetAPI);
  int httpCode = http.GET();
  if (httpCode > 0) {
    String payload = http.getString();
    http.end();
    StaticJsonDocument<520> doc;
    DeserializationError err = deserializeJson(doc, payload);

    if (err) {
//      Serial.println("Parsing failed");
//      Serial.println(err.c_str());
      return;
    }
    String sunrise = doc["results"]["sunrise"];
    String sunset = doc["results"]["sunset"];
    parseUTCString(sunrise, sunriseVals);
    parseUTCString(sunset, sunsetVals);
    broadcastChange('n');
  }
}

// unpack the string from sunrise-sunset API
// input format: "HH:MM:SS XM" in UTC or "H:MM:SS XM"
// output: [ready, hour, min] in 24-hour Mountain time
void parseUTCString(String UTCString, uint8_t (&buffArray)[3]) {
  uint8_t hour, minute;
  uint8_t firstColon = UTCString.indexOf(':');
  if (firstColon == 1 || firstColon == 2) {
    hour = UTCString.substring(0, firstColon).toInt();
    minute = UTCString.substring(firstColon+1, firstColon+3).toInt();
    char AMPM = (UTCString.charAt(firstColon+7));
    uint8_t DST;
    if (DST_FLAG > 0) { // if daylight savings
      DST = 1;} else {DST = 0;}
    if (AMPM == 'A') { // for AM, subtract GMT offset
      hour = ((hour % 12)+24+TZ+DST) % 24;
    } else if (AMPM == 'P') {
      hour = ((hour % 12)+12+TZ+DST) % 24;
    }
    buffArray[0] = 1;
    buffArray[1] = hour;
    buffArray[2] = minute;
    return;
  }
  buffArray[0] = 0;
  buffArray[1] = -1;
  buffArray[2] = -1; // error when hour/min is negative
}

void buildTimeString() {
  message = F("time: ");
  message += (CURRENT_HOUR > 12) ? CURRENT_HOUR - 12 : CURRENT_HOUR;
  message += ':';
  if (CURRENT_MINUTE < 10) {
    message += '0';
  }
  message += CURRENT_MINUTE;
  message += ' ';
  message += (CURRENT_HOUR > 12) ? F("PM") : F("AM");
}

/* File: doorControl.ino
 * Short desc: Handles auto/manual controls for the door motor.
 * IN AUTO MODE:
 *	- runs sunrise/sunset state machines
 *	- when opening/closing door, runs motor state machine 
 *	  with fixed motor interval
 *  - user can adjust motor interval in UI
 * IN MANUAL MODE:
 *	- lets user run motor up/down manually
 *		> web client buttons
 *		> physical press buttons
 *	- lets user manually set open/close status if hook was used
 */

void startDoor(bool dir, uint8_t interval) {
  motorInterval = interval;
  motorStartTime = currentTime;
  motorTime = 0;
  if (dir) {
    motorOn = openDoor();
  } else {
    motorOn = closeDoor();
  }
  updateDoorStatus();
}

// start running motor to open door
bool openDoor() {
  motorDir = true;
  motor.drive(OPEN_DR);
  return true;
}

// start closing door
bool closeDoor() {
  motorDir = false;
  motor.drive(CLOSE_DR); 
  return true;
}

bool stopDoor() {
	motor.brake();
	motorTime = 0; // reset motor time counter
	return false;
}

// when done running the motor, update door status
void updateDoorStatus() {
  if (!motorOn) {
    if (motorDir) { 
      doorStatus = true;
    } else {
      doorStatus = false;
    }
  }
  broadcastChange('d');
}

void updateAutoMode() {
  autoMode = !autoMode;
  motorOn = stopDoor();
  broadcastChange('c');
}

/* Callback function for websocket events. */
void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t length) {
  switch (type) {
    case WStype_DISCONNECTED: // if a client disconnects
//      Serial.printf("[%u] Client disconnected :(\n", num);
      if (webSocket.connectedClients() == 0) { // if no more clients
        clientConnected = false;
      }
      break;
    case WStype_CONNECTED: { // if a new websocket client connects
        if (!clientConnected) { // update clientConnected
          clientConnected = true;
        }
        IPAddress ip = webSocket.remoteIP(num);
//        Serial.printf("[%u] Connected from %d.%d.%d.%d\n", num, ip[0], ip[1], ip[2], ip[3]);
        updateWS('f');
        updateWS('d');
        updateWS('m');
        updateWS('e');
        updateWS('c');
        updateWS('g');
        updateWS('n');
        break;
      }
    case WStype_TEXT: { // if new text data is received
        //        Serial.printf("[%u] sent: %s\n", num, payload);
        if (payload[0] == 'o') {
          // clicked open button
          startDoor(true, 30);
        } else if (payload[0] == 'c') {
          // clicked close button
          startDoor(false, 30);
        } else if (payload[0] == 'h') {
          // released open/close button
          motorOn = stopDoor();
          updateDoorStatus();
        } else if (payload[0] == 's') {
          if (payload[1] == 'o') {
            // clicked manual set open button
            doorStatus = true;
          } else if (payload[1] == 'c') {
            // clicked manual set close button
            doorStatus = false;
          }
          broadcastChange('d');
        } else if (payload[0] == 'f') {
          flockStatus = payload[1];
          broadcastChange('f');
          if (googleEnabled) {
            String message = String((char*)payload);
            message += webSocket.remoteIP(num).toString();
            postToGoogle(message);
          }
        } else if (payload[0] == 'a') {
          // clicked manual button
          updateAutoMode();
        } else if (payload[0] == 'g') {
          // toggle Google POST requests
          googleEnabled = !googleEnabled;
          broadcastChange('g');
        } else if (payload[0] == 'm') {
          // user changed motorInterval thru client interface
          // client will send "m[o/c][seconds]"
          char* param = (char*) payload + 2;
          if (payload[1] == 'o') {
            motorInterval_open = String(param).toInt();
          } else {
            motorInterval_close = String(param).toInt();
          }
          broadcastChange('m');
        } else if (payload[0] == 'e') {
          // user adjusted open/close offsets
          char* param = (char*) payload + 2;
          if (payload[1] == 'o') {
            offset_open = String(param).toInt();
          } else {
            offset_close = String(param).toInt();
          }
          broadcastChange('e');
        } else if (googleEnabled) {
          message = F("client message [");
          message += webSocket.remoteIP(num).toString() + "]: ";
          message += String((char*)payload);
          postToGoogle(message);
        }
        break;
      }
      default:
        break;
  }
}

/* send a POST request to the Google cloud service
   src: https://github.com/arduino-libraries/ArduinoHttpClient/blob/master/src/HttpClient.cpp
*/
int postToGoogle(String data) {
  HTTPClient http;
  http.begin(googleScript);
  http.addHeader(F("Content-Type"), F("text/plain"), true);
  int httpResponseCode = http.POST(data);
  http.end();
  return httpResponseCode;
}

void broadcastChange(char code) {
  static const bool debug = true;
  switch(code) {
    case 'g': // googleEnabled
        if (!googleEnabled) {
          updateGoogle(code);
        }
    case 'c': // autoMode
    case 'm': // motorInterval
    case 'f': // flockStatus
    case 'd': // doorStatus, motorOn, or motorDir
    case 'e': // offset adjustment
    case 'n': // sun times / date-time
        if (clientConnected) {
          updateWS(code);
        }
        if (googleEnabled) {
          updateGoogle(code);
        }
      break;    
    case 't': // time only
      if (clientConnected) {
        updateWS(code);
      }
      if (debug && googleEnabled) {
        updateGoogle(code);
      }
      break;
    case 's': // state
      if (debug && googleEnabled) {
        updateGoogle(code);
      }
      break;
    default:
      break;  
  }
}

void updateWS(char code) {
//  String message;
  switch(code) {
    case 'd': // doorStatus, motorOn, or motorDir
      if (motorOn) {
        if (motorDir) {
          message = F("opening ");
        } else {
          message = F("closing ");
        }
        message += int(motorTime);
      } else if (doorStatus) {
        message = F("open");
      } else {
        message = F("closed");
      }
      webSocket.broadcastTXT(message);
      break;
    case 'f': // flockStatus
      message = F("flock ");
      message += flockStatus;
      webSocket.broadcastTXT(message);
      break; 
    case 't': // update time only
      if (DATETIME_RDY) {
        buildTimeString();
        webSocket.broadcastTXT(message);
      }
      break;
    case 'n': // sun times / date (only sent once per client session)
    /* if there are any new date/time or sunrise/sunset time 
     *  data ready, send to connected clients
     */
      if (DATETIME_RDY) {
        message = F("date: ");
        message += String(CURRENT_MONTH) + '/' + String(CURRENT_DATE) + '/' + CURRENT_YEAR;
        webSocket.broadcastTXT(message);
        buildTimeString();
        webSocket.broadcastTXT(message);
      }    
      if (SUNRISE_RDY && SUNSET_RDY) {
        message = F("sunrise/sunset: ");
        message += String(SUNRISE_HOUR) + ':';// + minute_R + F(" AM");
        if (SUNRISE_MINUTE < 10) {
          message += '0';
        }
        message += String(SUNRISE_MINUTE) + F(" AM/");
        message += String(SUNSET_HOUR - 12) + ':';
        if (SUNSET_MINUTE < 10) {
          message += '0';
        }
        message += String(SUNSET_MINUTE) + F(" PM");
        webSocket.broadcastTXT(message);
      }
      break;
    case 'c': // autoMode
      if (autoMode) {
        message = F("control AUTO");
      } else {
        message = F("control MANUAL");
      }
      webSocket.broadcastTXT(message);
      break;
    case 'm': // motorInterval
      message = F("mo ");
      message += motorInterval_open;
      webSocket.broadcastTXT(message);
      message = F("mc ");
      message += motorInterval_close;
      webSocket.broadcastTXT(message);
      break;
    case 'e': // offsets
      message = F("eo ");
      message += offset_open;
      webSocket.broadcastTXT(message);
      message = F("ec ");
      message += String(offset_close);
      webSocket.broadcastTXT(message);
      break;
    case 'g': // googleEnabled
      if (googleEnabled) {
        message = F("google ON");
      } else {
        message = F("google OFF");
      }
      webSocket.broadcastTXT(message);
      break;
    case 's': // state
      message = F("state ");
      message += int(state);
      webSocket.broadcastTXT(message);
      break;
    default:
      break;  
  }
}

void updateGoogle(char code) {
  switch(code) {
    case 'd': // doorStatus, motorOn, or motorDir
      if (!motorOn) {
        if (doorStatus) {
          message = F("do");
        } else {
          message = F("dc");
        }      
        postToGoogle(message);
      }
      break;
    case 't': // sun times / date-time
    case 'n':
      break;
    case 'c': // autoMode
      if (autoMode) {
        message = F("ca");
      } else {
        message = F("cm");
      }
      postToGoogle(message);
      if (autoMode) {
        updateGoogle('e');
        updateGoogle('m');
      }
      break;
    case 'm': // motorInterval
      message = F("mo: ");
      message += String(motorInterval_open);
      message += F("  mc: ");
      message += String(motorInterval_close);
      postToGoogle(message);
      break;
    case 'e': // offsets
      message = F("eo: ");
      message += String(offset_open);
      message += F("  ec: ");
      message += String(offset_close);
      postToGoogle(message);
      break;
    case 'f': // flockStatus
      message = F("flock: ");
      message += String(flockStatus);
      postToGoogle(message);
      break; 
    case 'g': // googleEnabled
      if (googleEnabled) {
        message = F("Hello from the ESP");
      } else {
        message = F("Go away Google");
      }
      postToGoogle(message);
      break;
    case 's': // state
      message = F("state ");
      message += int(state);  
      postToGoogle(message);
      break;
    default:
      break;  
  }
}