Ejemplo n.º 1
0
def valveJob(setting): #(valve, onDuration)
    print 'OPENING VALVE'
    tft.markActiveJob(setting['id'], True);
    durationLeft = int(setting['on_duration']) + 2
    #binaryValveList = map(int, list(format(setting['valve'], '08b')))
    #print binaryValveList
    pump = Relay()
    pump.on()
    time.sleep(1)
    #valves = Shiftregister()
    #shiftreg.outputList(binaryValveList)
    valves.outputDecimal(setting['valve'])
    #valves.enable()
    while durationLeft > 2:
        time.sleep(1)
        durationLeft -= 1
        print 'TIME LEFT: %i' % (durationLeft - 1)
    print 'CLOSING VALVE'
    pump.off()
    print 'reset shift register 1'
    #valves.disable()
    valves.reset()
    time.sleep(1)

    #valves.reset()
    tft.markActiveJob(setting['id'], False);
    db = DB()
    db.addLogLine(setting, datetime.now())
    return
Ejemplo n.º 2
0
async def test_async():
    relay = Relay(2)
    relay.on()
    print("on")
    asyncio.sleep(1)
    relay.off()
    print("off")
    asyncio.sleep(1)
    asyncio.create_task(relay.async_blink())
    for i in range(0,10):
        print(i)
        if i == 5:
            relay.stop_async_blink()
        await asyncio.sleep(1)
Ejemplo n.º 3
0
class Humidifier():
  """A Humidifier class."""

  def __init__(self, power_pin, button_pin, name, status=0):
    self.power_relay = Relay(power_pin, name + '_power_relay', 0)
    self.button = Button(button_pin, name + '_button', 0)
    self.status = 0
    # self.nominal_status = 0
    # 0 = Off - 1 = On - 2 = on for - 3 = pulse
    self.advanced_status = 0
    # active, pause time. It is valid only if self.status = 1
    self.status_interval = []
    # Interval used to activate the component after a certain time
    self.interval = None

  def get_status(self):
    # convert to boolean
    return not(not self.advanced_status)

  def set_status(self, status):
    if status == 0:
      self.power_relay.off()
    else:
      self.power_relay.on()
      self.button.switch_status()

  def on(self):
    # if self.status <> 1:
    self.set_status(1)
    self.status = 1
    self.advanced_status = 1

  def on_for(self, active_time):
    logging.debug('Humidifier on_for: %s', active_time)
    self.on()
    time.sleep(active_time)
    self.off()
    self.advanced_status = 1

  def pulse(self, active_time, sleep):
    set_interval(on_for)

  def off(self):
    self.set_status(0)
    self.status = 0
    self.advanced_status = 0
Ejemplo n.º 4
0
def demo():
    from relay import Relay
    import time
    relay = Relay(2)
    relay.off()
    data = b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
    frc = Mfrc522()
    print("Checking Tag")
    print(frc.read())
    relay.on()
    time.sleep(1)
    relay.flip()
    relay.blink()
    print("Writting data to tag")
    print(frc.write(data))
    relay.stop_blink()
    time.sleep(1)
    relay.on()
    print("Check again")
    print(frc.read())
    time.sleep(1)
    relay.off()
Ejemplo n.º 5
0
class RunLoop:
    SLEEP_MS_DEFAULT = 20
    LED_TOGGLE_DEFAULT = 500

    def __init__(self, config, verbose=0):
        self.verbose = verbose
        # ------------------------------------------------------------------------------------------------------------ #
        self.exit = False
        self.config = config
        # ------------------------------------------------------------------------------------------------------------ #
        self.sleep_ms = self.SLEEP_MS_DEFAULT
        # ------------------------------------------------------------------------------------------------------------ #
        # Initialise required services
        # ------------------------------------------------------------------------------------------------------------ #
        if self.config['pinout']['led'] is None:
            from led import MockLed
            self.led = MockLed()
        else:
            from led import Led
            self.led = Led(self.config['pinout']['led']['pin'],
                           self.config['pinout']['led']['on_level'])
        # ------------------------------------------------------------------------------------------------------------ #
        if self.config['pinout']['button'] is None:
            from button import MockButton
            self.button = MockButton()
        else:
            from button import Button
            self.button = Button(self.config['pinout']['button']['pin'],
                                 self.config['pinout']['button']['on_level'])
        # ------------------------------------------------------------------------------------------------------------ #
        if self.config['pinout']['relay'] is None:
            from relay import MockRelay
            self.relay = MockRelay()
        else:
            from relay import Relay
            self.relay = Relay(self.config['pinout']['relay']['pin'],
                               self.config['pinout']['relay']['on_level'])
        # ------------------------------------------------------------------------------------------------------------ #
        self.wifi = WiFi(self.config)  # , verbose=self.verbose)
        self.device_id = self.wifi.device_id()
        self.messaging = Messaging(self.config, self.device_id)
        # ------------------------------------------------------------------------------------------------------------ #
        # Application ready feedback --------------------------------------------------------------------------------- #
        self.led.on(poll=True)
        sleep(2)
        self.led.off(poll=True)
        # ------------------------------------------------------------------------------------------------------------ #
        if self.wifi.connected():
            self.on_wifi_connected(be_verbose=False)
        # ------------------------------------------------------------------------------------------------------------ #
        if self.verbose:
            print('<{} with id {}>'.format(self.config['device']['type'],
                                           self.device_id))
            print(self.led)
            print(self.button)
            print(self.relay)
            print(self.wifi)
            print(self.messaging)

    def on_wifi_connected(self, be_verbose=True):
        if be_verbose and self.verbose:
            print(self.wifi)
        self.led.toggle(self.LED_TOGGLE_DEFAULT)
        if not self.messaging.connected():
            self.messaging.connect()

    def run(self):
        if self.verbose:
            print('Run loop ' 'started')
        while not self.exit:
            # ======================================================================================================== #
            self.led.poll()
            self.button.poll()
            # -------------------------------------------------------------------------------------------------------- #
            if self.relay.state(
            ) == self.relay.STATE_OFF and self.button.pressed(
            ) == self.button.SHORT_PRESS:
                if self.verbose:
                    print('<Button: SHORT_PRESS ' '0' '>')
                self.messaging.publish({
                    'state':
                    '<Button: SHORT_PRESS '
                    'relay state: '
                    'on'
                    '>'
                })
                self.relay.on()
                self.button.clear()
            elif self.relay.state(
            ) == self.relay.STATE_ON and self.button.pressed(
            ) > self.button.NOT_PRESSED:
                if self.verbose:
                    print('<Button: SHORT_PRESS ' '1' '>')
                self.messaging.publish({
                    'state':
                    '<Button: SHORT_PRESS '
                    'relay state: '
                    'off'
                    '>'
                })
                self.relay.off()
                self.button.clear()
            elif self.led.enabled() is True and self.button.pressed(
            ) == self.button.LONG_PRESS:
                if self.verbose:
                    print('<Button: LONG_PRESS ' '0' '>')
                self.messaging.publish({
                    'state':
                    '<Button: LONG_PRESS '
                    'led enabled: '
                    'off'
                    '>'
                })
                self.led.enable(False)
                self.led.off()
                self.button.clear()
            elif self.led.enabled() is False and self.button.pressed(
            ) > self.button.NOT_PRESSED:
                if self.verbose:
                    print('<Button: LONG_PRESS ' '2' '>')
                self.messaging.publish(
                    {'state': '<Button: LONG_PRESS '
                     'led enabled: '
                     'on'
                     '>'})
                self.led.enable(True)
                self.led.toggle(self.LED_TOGGLE_DEFAULT)
                self.button.clear()
            # -------------------------------------------------------------------------------------------------------- #
            if self.wifi.connected():
                if self.messaging.connected() is False:
                    self.on_wifi_connected()
                if self.messaging.poll():
                    if 'action' in self.messaging.msg:
                        if self.messaging.msg['action'] == 'on':
                            if self.verbose:
                                print('<Relay: ' 'on' '>')
                            self.relay.on()
                        elif self.messaging.msg['action'] == 'off':
                            if self.verbose:
                                print('<Relay: ' 'off' '>')
                            self.relay.off()
                        elif self.messaging.msg['action'] == 'exit':
                            if self.verbose:
                                print('<Application: ' 'exit' '>')
                            self.exit = True
                    self.messaging.completed()
            elif self.wifi.connected() is False:
                if self.wifi.connecting() is False:
                    self.led.toggle(250)
                    self.led.on(poll=True, save_state=True)
                if self.wifi.connect() is True:
                    self.led.off(poll=True, restore_state=True)
            # ======================================================================================================== #
            sleep_ms(self.sleep_ms)  # Reduce the tightness of the run loop
            # ======================================================================================================== #
        if self.verbose:
            print('Run loop ' 'exited')

    def close(self):
        self.exit = True
        if self.led:
            self.led.close()
        if self.button:
            self.button.close()
        if self.relay:
            self.relay.close()
        if self.messaging:
            self.messaging.disconnect()
        # if self.wifi:
        #     self.wifi.disconnect()            # Don't do this, you will loose connection to the REPL
        if self.verbose:
            print('Run loop ' 'closed')
Ejemplo n.º 6
0
from flask import Flask, request, jsonify
from relay import Relay
from time import sleep
from gpiozero import LED

app = Flask(__name__)
provider = Relay(2)
provider.off()


@app.route("/")
def root():
    return "hello world"


@app.route("/transfer")
def transfer():
    energy = int(request.args['energy'])
    provider.on()
    sleep(energy)
    provider.off()
    return "did something"


if __name__ == '__main__':
    app.run(host='0.0.0.0')
Ejemplo n.º 7
0
class Poller():
    def __init__(self, settings_path):

        self.settings_path = settings_path
        # load settings
        self.settings = settings_handler.load_settings(settings_path)
        # arrange paths
        self.program_path = self.settings['paths']['program']
        self.examples_path = self.settings['paths']['examples']
        self.daily_log_path = self.settings['paths']['daily_log']
        # get intervals
        self.thermometer_poll = self.settings['poll_intervals']['temperature']
        self.time_to_wait = self.settings['poll_intervals']['settings']
        # parameters for UDP communication with thermometer
        self.UDP_IP = self.settings['configs']['UDP_IP']
        self.UDP_port = self.settings['configs']['UDP_port']
        self.thermometer = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.thermometer.settimeout(1)
        self.thermometer.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.temperature = self.settings['temperatures']['room']
        # handle day change
        if (self.settings['log']['last_day_on'] !=
                util.get_now()['formatted_date']):

            self.time_elapsed = 0
            util.write_log(
                self.daily_log_path, {
                    'date': self.settings['log']['last_day_on'],
                    'time_elapsed': util.format_seconds(self.time_elapsed)
                })
            self.time_elapsed = 0

        else:

            time_elapsed_restore = datetime.datetime.strptime(
                self.settings['log'].get('time_elapsed', '0:00:00'),
                '%H:%M:%S')

            self.time_elapsed = round(
                datetime.timedelta(
                    hours=time_elapsed_restore.hour,
                    minutes=time_elapsed_restore.minute,
                    seconds=time_elapsed_restore.second).total_seconds())

        self.program_number = self.settings['mode']['program']

        relay_settings = self.settings['relay']
        self.heater_switch = Relay(relay_settings, self.settings_path)

        self.last_current = None

        self.loop_count = 0

        self.count_start = time.perf_counter()

    def poll(self, current):
        '''
        Poll the settings.json file and behaves accordingly:
         - First sends a request for room temperature if self.loop_count is 0
           or a multiple of self.thermometer_poll (from settings file)
         - If room temperature is lower than desired_temp:
            - First checks if manual is ON
            - Then checks for auto mode

        Returns self.time_to_wait when heater is turned ON, 0 when OFF
        '''

        self.count_start = time.perf_counter()

        self.settings = settings_handler.handler(
            settings_path=self.settings_path,
            settings_changes={
                'log': {
                    'time_elapsed': util.format_seconds(self.time_elapsed),
                    'last_day_on': current['formatted_date']
                }
            })

        logger.debug('Settings handler in poller: {}'.format(self.settings))

        manual = self.settings['mode']['manual']
        auto = self.settings['mode']['auto']
        desired_temperature = self.settings['mode']['desired_temp']
        logger.debug('time to wait: {}'.format(self.time_to_wait))

        return self._handle_on_and_off(current, **self.settings['mode'])

    def _handle_on_and_off(self, current, manual, auto, program, desired_temp):
        '''
        Handles all there is to turning the heater on or off:
        modes, programs, temperature.
        '''

        # Get room temperature
        self.temperature = self.request_temperatures()

        # MANUAL MODE
        if manual:
            return self._manual_mode(desired_temp)

        # AUTO MODE
        elif auto:
            return self._auto_mode(desired_temp, current)

        # BOTH MANUAL AND AUTO ARE OFF
        else:
            return self.turn_off()

    def _manual_mode(self, desired_temperature):
        '''
        Action to take when MANUAL mode is True

        Manual mode prevails over auto mode and so does desired_temperature
        over possible numbers in program.json
        '''

        # Room temperature is lower than desired temperature
        if self.temperature < desired_temperature:
            return self.turn_on()
        # Room temperature satisfies desired temperature
        else:
            return self.turn_off()

    def _auto_mode(self, desired_temperature, current):
        '''
        Action to take when AUTO mode is True
        '''

        # Load program
        p = self._load_program(current)

        # Load program setting at current day and time
        program_now = p.program[current['weekday']][str(current['hours'])]
        logger.debug('Program is now: {}'.format(program_now))

        ### TURN ON CASE
        if (  # Value in program is bool, True, and room temp is
                # lower than desired temperature
            (program_now is True and self.temperature < desired_temperature) or
            (util.is_number(program_now) and self.temperature < program_now)):
            return self.turn_on()

        ### TURN OFF CASE
        elif (  # Value in program is bool, True and room temp is
                # greater than desired temperature
            (program_now is True and self.temperature >= desired_temperature)
                or
            (util.is_number(program_now) and self.temperature >= program_now)):
            return self.turn_off()

        ### ANYTHING ELSE GOES TO OFF, JUST IN CASE
        else:
            return self.turn_off()

    def _load_program(self, current):

        program = Program(program_number=self.program_number,
                          program_path=self.program_path,
                          examples_path=self.examples_path)

        logger.debug('Loaded program {}.'.format(program.program_number))
        logger.debug("It is {} on {}.".format(current['formatted_time'],
                                              current['weekday'].title()))

        return program

    def turn_on(self):

        seconds = self.time_to_wait

        # only when heater was off at previous loop
        if not self.heater_switch.stats:
            # set seconds to 60 so it doesn't immediately turn back off
            # when temperatures are fluctuating
            seconds = 60
            # reset loop_count so it will read temperatures
            # right away on next loop
            self.loop_count = -1
            logger.info('Room temperature lower than set desired temperature!'
                        ' Turning ON heater.')
            logger.debug('Heater switch stats: {}'.format(
                self.heater_switch.stats))
            logger.debug('Received signal to turn heater ON.')
            # start it
            self.heater_switch.on()

        self.heater_switch.catch_sleep(seconds, self.temperature)

        return time.perf_counter() - self.count_start

    def turn_off(self):

        seconds = self.time_to_wait

        # only when heater was on at previous loop
        if self.heater_switch.stats:
            # set seconds to 170 so it doesn't immediately turn back on
            # when temperatures are fluctuating
            seconds = 170
            # reset loop_count so it will read temperatures
            # right away on next loop
            self.loop_count = -1
            logger.info('Reached desired temperature.'
                        ' Turning OFF heater and waiting'
                        ' {} seconds before next poll.'.format(seconds))
            logger.debug('Received signal to turn heater OFF.')
            # stop it
            self.heater_switch.off()

        self.heater_switch.catch_sleep(seconds, self.temperature)

        return 0

    def request_temperatures(self):
        '''
        Send a request for temperatures to ESP8266.
        Response should be a JSON of the type:

        {
          "celsius": float
        }

        If request goes into timeout: request is skipped,
        self.temperature is set to None, request is repeated on next loop.
        If request is succesful and new temperature is different than what's
        reported in settings.json file: update the file and self.temperature.
        '''

        logger.debug('Loop count: {}; thermometer poll: {}; read: {}.'.format(
            self.loop_count, self.thermometer_poll,
            not self.loop_count % self.thermometer_poll))

        if not self.loop_count or not self.loop_count % self.thermometer_poll:

            self.thermometer.sendto(b'temps_req', (self.UDP_IP, self.UDP_port))

            try:
                self.temperature = json.loads(
                    self.thermometer.recv(4096).decode())['celsius']

                self.loop_count = 0

            except socket.timeout:

                self.loop_count = -1

            if self.temperature != self.settings['temperatures']['room']:

                self.settings = settings_handler.handler(
                    settings_path=self.settings_path,
                    settings_changes={
                        'temperatures': {
                            'room': self.temperature
                        }
                    })

        logger.debug('Temperature from thermometer is: {}° celsius.'.format(
            self.temperature))

        return self.temperature
Ejemplo n.º 8
0
class Controller:
    def __init__(self, positionRepository):
        self.isAdjusting = False
        self.directionRelay = Relay(constants.PIN_DIRECTION_RELAY,
                                    "Directory Relay")
        self.powerRelay = Relay(constants.PIN_POWER_RELAY, "Power Relay")
        self.positionRepository = positionRepository

    def adjust(self, targetPosition, client):

        currentPosition = self.positionRepository.read()

        if self.isAdjusting:
            return  # Would be better to throw an error i suppose
        else:
            self.isAdjusting = True

        shouldOpen = self.__should_open(currentPosition, targetPosition)
        if (shouldOpen == False):
            self.directionRelay.on()

        duration = self.__calculate_movement_duration(currentPosition,
                                                      targetPosition)
        curPos = 0.0 + currentPosition

        self.powerRelay.on()

        while True:
            #  if we reached 0, quit the job. if not, push notif
            if duration <= 0:
                break
            else:
                if client != None:
                    client.adjustment_callback(round(curPos))

            # Determine a proper amount to sleep
            toSleep = 0.5
            if (duration < 0.5):
                toSleep = duration

            # wait to keep that relay high
            time.sleep(toSleep)

            # calculate remaining duration
            duration = duration - toSleep

            # calculate the new current position
            if (shouldOpen):
                curPos = curPos + (
                    100.0 / (constants.SHUTTING_DURATION_IN_SECONDS / 0.5))
            else:
                curPos = curPos - (
                    100.0 / (constants.SHUTTING_DURATION_IN_SECONDS / 0.5))

        # Turn all relays off
        self.powerRelay.off()
        self.directionRelay.off()

        # make sure the position repo has the last state
        print('writing new position {0}'.format(targetPosition))
        self.positionRepository.write(targetPosition)

        # invoke callback for the interested parties
        client.adjustment_callback(targetPosition)
        self.isAdjusting = False

    def currentPosition(self):
        return self.positionRepository.read()

    def __calculate_movement_duration(self, currentPosition, targetPosition):
        percentualDifference = abs(currentPosition - targetPosition)
        secondByPercent = (constants.SHUTTING_DURATION_IN_SECONDS / 100.0)
        return percentualDifference * secondByPercent

    def __should_open(self, currentPosition, targetPosition):
        return currentPosition < targetPosition
Ejemplo n.º 9
0
class Wifi(ConfigOp):
    def __init__(self, hostname, pin=2):
        self.__wlan = None
        self.__timeout = DEFAULT_TMOUT
        self.__led = Relay(pin)
        self.is_ok = False
        self.gw = None
        self.ip = None
        self.dns = None
        ConfigOp.__init__(self, 'wifi', CONFIG_NAME)
        self.add_command(self.__get_info, GET)
        self.add_command(self.__reconnect, SET, 'reconnect')
        self.__hostname = hostname

    def is_connected(self):
        return self.__wlan != None and self.__wlan.isconnected()

    async def __get_info(self, _):
        v = self.get_info()
        await sleep(0)
        return result(200, None, v)

    async def __reconnect(self, _):
        delayed_task(5000, self.async_connect, (True), True)
        return result(200, None, RECONNECT_WIFI)

    async def __reload_config(self):  # NOSONAR
        return await self.__reconnect(None)

    def get_info(self):
        return {
            "mac": MAC,
            "connected": self.is_connected(),
            "connection tested": self.is_ok,
            "hostname": self.__hostname,
            "ip": self.ip,
            "gw": self.gw,
            "dns": self.dns
        }

    def check_wifi_config(self):
        self.load()
        return not (self.__config is None or is_str_empty(self.__config[SSID])
                    or is_str_empty(self.__config[PASSWORD]))

    def disconnect(self):
        if self.__wlan is not None and self.__wlan.isconnected():
            self.__wlan.disconnect()
            self.__wlan.active(False)

    async def async_connect(self, force_rec=False):
        if self.__wlan is not None and self.__wlan.isconnected():
            if force_rec:
                self.disconnect()
                return await self.__async_connect()
            return True
        return await self.__async_connect()

    async def __async_connect(self):
        self.__connect_init()
        return await self.__async_connect_finish()

    async def __async_connect_finish(self):
        start_time = time()  # Check time
        while not self.__wlan.isconnected():
            await sleep_ms(DEFAULT_300)
            self.__led.on()
            await sleep_ms(DEFAULT_300)
            self.__led.off()
            if time() - start_time > self.__timeout:
                log.error("Wifi connection timeout: %d", self.__timeout)
                break
        return self.__set_properties()

    def __connect_init(self):
        self.check_wifi_config()
        if self.__config is None:
            log.error("Wifi config is None")
            return
        log.info("Connect to wifi: %s", self.__config[SSID])
        self.__wlan = WLAN(STA_IF)  # 创建 station 接口
        if self.__wlan.isconnected():
            self.__wlan.disconnect()
        self.__wlan.active(True)  # Activate the interface
        self.__wlan.scan()  # Scan
        self.__led.off()
        self.__wlan.config(dhcp_hostname=self.__hostname)
        self.__wlan.connect(self.__config[SSID],
                            self.__config[PASSWORD])  # 连接到指定ESSID网络
        if TIMEOUT in self.__config:
            self.__timeout = self.__config[TIMEOUT]

    def __set_properties(self):
        if self.__wlan.isconnected():
            log.info('network information: %r', self.__wlan.ifconfig())
            (self.ip, _, self.gw, self.dns) = self.__wlan.ifconfig()
            self.is_ok = True
            self.__led.on()
        else:
            self.ip = None
            self.gw = None
            self.dns = None
            self.is_ok = False
            self.__wlan = None
            self.__led.off()
        return self.is_ok

    def check_connection(self):
        if hw.WIFI_CHECK_TYPE == 0:
            return True
        if not self.is_connected():
            return False
        if hw.WIFI_CHECK_TYPE == 1:
            return True
        dest = self.gw
        if hw.WIFI_CHECK_TYPE == 3:
            if WIFI_CHECK_HOST in self.__config != None:
                dest = self.__config[WIFI_CHECK_HOST]
            else:
                dest = hw.WIFI_CHECK_HOST
        return ping_check(dest)

    async def monitor(self):
        log.debug("Setup wifi monitor")
        while hw.WIFI:
            try:
                await sleep(hw.WIFI_CHECK_INTVAL)
                if not self.check_connection():
                    log.info("Wifi is not ready, reconnecting...")
                    await self.async_connect(True)
            except:  #NOSONAR # pylint: disable=W0702
                pass