Making a Dumb Garage Door Opener Smarter

#!/usr/bin/python3
# 
# Create a config.json file with your variables like below:
#   {
#     "notifyChannelMinutes": 15,
#     "notifyIntervalMinutes": 15,
#     "notifyQuietStart": "8:00",
#     "notifyQuietEnd": "17:30",
#     "particle.url": "https://api.particle.io/v1/devices/{0}/{1}?access_token={2}&format=raw",
#     "particle.device": "[DEVICEID]",
#     "particle.variable": "garageDoor",
#     "particle.token": "[DEVICETOKEN]",
#     "slack.url": "https://hooks.slack.com/services/[SLACKDETAILS]",
#     "slack.channel": "home-garagedoor",
#     "slack.user": "home-pi"
#   }

import datetime
import dateutil.parser    # pip install python-dateutil
import logging
import logging.handlers
import json
import os
import pytz
import requests
import sys
import time

from slack_sdk.webhook import WebhookClient

appDir = os.path.dirname(os.path.realpath(sys.argv[0]))
now = datetime.datetime.now()

# Logging
appDir = os.path.dirname(os.path.realpath(sys.argv[0]))
logFormat = logging.Formatter('%(asctime)s: %(message)s')
log = logging.getLogger('check-door')
log.setLevel(logging.DEBUG)
logFile = logging.handlers.RotatingFileHandler(appDir + '/logs/check-door.log', maxBytes=1000000, backupCount=5)
logFile.setFormatter(logFormat)
log.addHandler(logFile)

# Manage config info
class AppConfig:
    def __init__(self):
        self.notify_quiet = False
        self.configJson = {} 
        configFile = appDir + '/config.json'
        if os.path.isfile(configFile):
            self.configJson = json.loads(open(configFile).read())
            self.set_notify_quiet()

    def get(self, key):
        return self.configJson[key]

    def get_minutes_into_day(self, date):
        return (date.hour * 60) + date.minute

    def set_notify_quiet(self):
        now = self.get_minutes_into_day(datetime.datetime.now(pytz.timezone('US/Pacific')))
        start = self.get_minutes_into_day(datetime.datetime.strptime(self.get('notifyQuietStart'), "%H:%M"))
        end = self.get_minutes_into_day(datetime.datetime.strptime(self.get('notifyQuietEnd'), "%H:%M"))
        self.notify_quiet = (now >= start and now <= end)

# Load our previous door state from last time we ran
class AppState:
    def __init__(self):
        self.stateJson = {} 
        self.stateCacheFile = appDir + '/cache/state.json'
        if os.path.isfile(self.stateCacheFile):
            self.stateJson = json.loads(open(self.stateCacheFile).read())

    def get(self, key):
        return self.stateJson[key]

    def getDate(self, key):
        return dateutil.parser.parse(self.stateJson[key])

    def set(self, key, value):
        self.stateJson[key] = value

    def isSet(self, key):
        return key in self.stateJson and self.stateJson[key] != None

    def save(self):
        with open(self.stateCacheFile, 'w') as fp:
            json.dump(self.stateJson, fp)

# Load our garage door state from sensor info published to Particle cloud
class DoorState:
    def __init__(self, config):
        self.valid = False
        self.open = False
        try:
            url = config.get('particle.url').format(config.get('particle.device'), config.get('particle.variable'), config.get('particle.token'))
            r = requests.get(url)
            self.value = int(r.text)

            # Ignore values if too large or small - assume something is wrong with sensor data.
            # Value is very consistently in the 200 range when closed.
            if self.value > 0 and self.value < 10000:
                self.valid = True 
                if self.value > 800:
                    self.open = True
            log.debug('Value: {0}, Valid: {1}, Open: {2}'.format(self.value, self.valid, self.open))
        except Exception as e:
            log.exception("Error getting door value.")

        # When debugging it is useful to hard-code the value
        #self.open = True

# Logic to post to Slack API: https://api.slack.com/incoming-webhooks#sending_messages
class Slack:
    def __init__(self, config):
        self.config = config

    def send(self, msg):
        try:
            log.debug('Sending message: ' + msg)
            slack = WebhookClient(config.get('slack.url'))
            r = slack.send(text=msg)
            log.debug('Slack response: #{0} {1}'.format(r.status_code, r.body))
        except Exception as e:
            log.exception("Error sending message.")

# Load config and door state
config = AppConfig()
door = DoorState(config)
#door.open = True

if not door.valid:
    sys.exit() 

# Check previous state 
state = AppState()
openSince = None
if state.isSet('openSince'):
    openSince = state.getDate('openSince')
    openSinceDisplay = openSince.strftime('%Y-%m-%d %H:%M:%S')
    log.debug("Door has been open since " + openSinceDisplay)
        
msg = None
if door.open:
    # Flip our state flag to open if it is not already set
    if openSince is None:
        state.set('openSince', now.isoformat())
        openMinutes = 0
    else:
        openMinutes = (now - openSince).seconds/60

    # Only notify based on our notify interval - this keeps us from sending a Slack message every
    # time the sript runs (lets assume once per minute). 
    sendNotification = True
    if state.isSet('lastOpenNotify'):
        lastOpenNotify = state.getDate('lastOpenNotify')
        sendNotification = ((now - lastOpenNotify).seconds/60) > config.get('notifyIntervalMinutes')
            
    if sendNotification:
        state.set('lastOpenNotify', now.isoformat())
        msg = 'Garage door is open.'
        if openMinutes > 0:
            msg = "Garage door has been open for " + str(round(openMinutes)) + " minute(s)."

            # If it has been open for more than specified minute threshold also specify @channel
            if openMinutes > config.get('notifyChannelMinutes') and not config.notify_quiet:
                msg = "<!channel>: " + msg
    else:
        log.debug("Skipping sending notification due to notification interval.")

else:
    # If door was previously open - clear open state and send a message it is now closed. We always
    # send this message - regardless of notify interval.
    if not openSince is None:
        state.set('openSince', None)
        state.set('lastOpenNotify', None)
        msg = 'Garage door is closed.'

# Send message if we have one to post
if not msg is None:
    slack = Slack(config)
    slack.send(msg)

# Save app state for next time
state.save()

esphome:
  name: iot-garage-door-controller
  friendly_name: iot-garage-door-controller
  on_boot:
    priority: -100
    then:
      - logger.log:
          level: INFO
          format: "The garage door booted with closed state %.1f and open state %.1f"
          args: [ 'id(door_closed).state', 'id(door_open).state' ]
      - if:
          condition:
            binary_sensor.is_on: door_closed
          then:
            - text_sensor.template.publish:
                id: door_state
                state: "Closed"
      - if:
          condition:
            binary_sensor.is_on: door_open
          then:
            - text_sensor.template.publish:
                id: door_state
                state: "Open"

esp32:
  board: seeed_xiao_esp32c3

# Enable logging
logger:
  # Uncomment to switch from DEBUG to INFO level output
  #level: INFO

# Enable Home Assistant API
api:
  encryption:
    key: !secret api_key

ota:
  - platform: esphome
    password: !secret ota_pwd

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password

web_server:
  port: 80
  ota: false

captive_portal:

# A text value we update as door opens and closes
text_sensor:
  - platform: template
    name: "Door State"
    id: door_state

binary_sensor:
  # Convert the analog sensor values into an ON/OFF binary sensor
  - platform: analog_threshold
    id: door_closed
    name: "door-closed"
    sensor_id: sensor_door_closed
    threshold: 0.5
    # Don't use "garage" class as these are sensors - a "closed == ON" shows state as "OPEN"
    # device_class: garage
    icon: "mdi:garage"
    filters:
      - invert:
      - delayed_on_off: 50ms
    on_state:
      if:
        condition:
          binary_sensor.is_on: door_closed
        then:
          - logger.log: "Garage door is closed"
          - text_sensor.template.publish:
              id: door_state
              state: "Closed"
        else:
          - logger.log: "Garage door is opening"
          - text_sensor.template.publish:
              id: door_state
              state: "Opening"

  - platform: analog_threshold
    id: door_open
    name: "door-open"
    sensor_id: sensor_door_open
    threshold: 0.5
    # Don't use "garage" class as these are sensors - a "closed == ON" shows state as "OPEN"
    # device_class: garage
    icon: "mdi:garage-open"
    filters:
      - invert:
      - delayed_on_off: 50ms
    on_state:
      if:
        condition:
          binary_sensor.is_on: door_open
        then:
          - logger.log: "Garage door is open"
          - text_sensor.template.publish:
              id: door_state
              state: "Open"
        else:
          - logger.log: "Garage door is closing"
          - text_sensor.template.publish:
              id: door_state
              state: "Closing"

switch:
  - platform: gpio
    pin: GPIO4
    name: "door-relay"
    id: door_relay
    internal: true
    on_turn_on:
      - delay: 250ms
      - switch.turn_off: door_relay

sensor:
  - platform: uptime
    name: "uptime"

  - platform: wifi_signal
    name: "wifi-strength"
    update_interval: 60s

  - platform: adc
    pin:
      number: GPIO2
    id: sensor_door_open
    name: "sensor-door-open"
    update_interval: 1s
    attenuation: 2.5db
    internal: true
  
  - platform: adc
    pin:
      number: GPIO3
    id: sensor_door_closed
    name: "sensor-door-closed"
    update_interval: 1s
    attenuation: 2.5db
    internal: true

cover:
  - platform: feedback
    name: "Door"
    device_class: garage

    has_built_in_endstop: true
    max_duration: 20s

    open_action:
      - switch.turn_on: door_relay
    open_duration: 8s
    open_endstop: door_open

    close_action:
      - switch.turn_on: door_relay
    close_duration: 14s
    close_endstop: door_closed

    stop_action:
      - switch.turn_on: door_relay