Beispiel #1
0
    def __get_raw_data(self, force_update=False):
        starttime = int(time.time())
        if force_update or starttime - self.__cached_data[
                'last_update'] > terrariumOWFSSensor.__CACHE_TIMEOUT:
            if self.__port > 0:
                try:
                    proxy = protocol.proxy(self.__host, self.__port)
                    try:
                        self.__cached_data['temperature'] = float(
                            proxy.read('/{}/temperature'.format(
                                self.__sensor[:-2])))
                        self.__cached_data['last_update'] = starttime
                    except protocol.OwnetError:
                        pass

                    try:
                        self.__cached_data['humidity'] = float(
                            proxy.read('/{}/humidity'.format(
                                self.__sensor[:-2])))
                        self.__cached_data['last_update'] = starttime
                    except protocol.OwnetError:
                        pass

                except Exception as ex:
                    logger.warning(
                        'OWFS file system is not actve / installed on this device!'
                    )
Beispiel #2
0
def main():
    assert len(sys.argv) == 2
    urlc = urlsplit(sys.argv[1], scheme='owserver', allow_fragments=False)
    host = urlc.hostname or 'localhost'
    port = urlc.port or 4304
    assert not urlc.path or urlc.path == '/'

    p = protocol.proxy(host, port, persistent=False)
    pid = 'unknown'
    ver = 'unknown'
    try:
        pid = int(p.read('/system/process/pid'))
        ver = p.read('/system/configuration/version').decode()
    except protocol.OwnetError:
        pass
    print(pyownet.__name__, pyownet.__version__, pyownet.__file__)
    print('proxy_obj: {}'.format(p))
    print('server info: pid {}, ver. {}'.format(pid, ver))

    freq = 1 << 12

    for i in itertools.count():
        try:
            _ = p.dir()
        except protocol.Error as exc:
            print('Iteration {0} raised exception: {1}'.format(i, exc))
            break
        None if i % freq else print('Iteration {}'.format(i))
Beispiel #3
0
def main():

    print(platform.python_implementation(), platform.python_version())
    print(platform.system(), platform.release())
    print(pyownet.__name__, pyownet.__version__)

    owp = protocol.proxy(HOST, PORT, flags=protocol.FLG_UNCACHED)
    print(owp, 'vers.',
          protocol.bytes2str(owp.read(protocol.PTH_VERSION))
          if owp.present(protocol.PTH_VERSION) else 'unknown')

    signal.signal(signal.SIGALRM, dummy_handler)
    tic = time.time()
    signal.setitimer(signal.ITIMER_REAL, A, A)

    try:
        count = 0
        inter = 0
        while count < 10000:
            count += 1
            try:
                _ = owp.dir()
            except protocol.Error as exc:
                (_, val, tb) = sys.exc_info()
                assert val is exc
                inter += 1
                trs = traceback.extract_tb(tb)
                print(count, exc, trs[-1][0], trs[-1][1])
            time.sleep(random.uniform(0., B))  # can be interrupted
    except KeyboardInterrupt:
        print()
    signal.setitimer(signal.ITIMER_REAL, 0, A)
    elt = time.time() - tic
    print('{:d} errors / {:d} calls in {:.1f}s'.format(inter, count, elt))
Beispiel #4
0
def main():
    assert len(sys.argv) == 2
    urlc = urlsplit(sys.argv[1], scheme='owserver', allow_fragments=False)
    host = urlc.hostname or 'localhost'
    port = urlc.port or 4304
    assert not urlc.path or urlc.path == '/'

    p = protocol.proxy(host, port, persistent=False)
    pid = 'unknown'
    ver = 'unknown'
    try:
        pid = int(p.read('/system/process/pid'))
        ver = p.read('/system/configuration/version').decode()
    except protocol.OwnetError:
        pass
    print(pyownet.__name__, pyownet.__version__, pyownet.__file__)
    print('proxy_obj: {}'.format(p))
    print('server info: pid {}, ver. {}'.format(pid, ver))

    freq = 1 << 12

    for i in itertools.count():
        try:
            _ = p.dir()
        except protocol.Error as exc:
            print('Iteration {0} raised exception: {1}'.format(i, exc))
            break
        None if i % freq else print('Iteration {}'.format(i))
Beispiel #5
0
def main():
    assert len(sys.argv) == 2
    urlc = urlsplit(sys.argv[1], scheme='owserver', allow_fragments=False)
    host = urlc.hostname or 'localhost'
    port = urlc.port or 4304
    assert not urlc.path or urlc.path == '/'

    proxy = protocol.proxy(host, port, verbose=False)
    pid = -1
    ver = ''
    try:
        pid = int(proxy.read('/system/process/pid'))
        ver = proxy.read('/system/configuration/version').decode()
    except protocol.OwnetError:
        pass
    log("{0}, pid={1:d}, {2}".format(proxy, pid, ver))

    delta = 60
    assert threading.active_count() is 1
    started = 0
    while threading.active_count() == started + 1:
        th = threading.Thread(target=worker, args=(proxy, started, ), )
        th.start()
        started += 1
        try:
            sleep(delta)
        except KeyboardInterrupt:
            break
    log('started {0:d} worker threads'.format(started))
    log('still waiting for {0:d} worker threads'
        .format(threading.active_count()-1))
Beispiel #6
0
def main():

    print(platform.python_implementation(), platform.python_version())
    print(platform.system(), platform.release())
    print(pyownet.__name__, pyownet.__version__)

    owp = protocol.proxy(HOST, PORT, flags=protocol.FLG_UNCACHED)
    print(
        owp, 'vers.',
        protocol.bytes2str(owp.read(protocol.PTH_VERSION))
        if owp.present(protocol.PTH_VERSION) else 'unknown')

    signal.signal(signal.SIGALRM, dummy_handler)
    tic = time.time()
    signal.setitimer(signal.ITIMER_REAL, A, A)

    try:
        count = 0
        inter = 0
        while count < 10000:
            count += 1
            try:
                _ = owp.dir()
            except protocol.Error as exc:
                (_, val, tb) = sys.exc_info()
                assert val is exc
                inter += 1
                trs = traceback.extract_tb(tb)
                print(count, exc, trs[-1][0], trs[-1][1])
            time.sleep(random.uniform(0., B))  # can be interrupted
    except KeyboardInterrupt:
        print()
    signal.setitimer(signal.ITIMER_REAL, 0, A)
    elt = time.time() - tic
    print('{:d} errors / {:d} calls in {:.1f}s'.format(inter, count, elt))
Beispiel #7
0
    def load_data(self):
        data = None
        if self.__port > 0:
            data = {}
            try:
                proxy = protocol.proxy(self.__host, self.__port)
                try:
                    data['temperature'] = float(
                        proxy.read('/{}/temperature'.format(
                            self.get_address())))
                except protocol.OwnetError:
                    pass

                try:
                    data['humidity'] = float(
                        proxy.read('/{}/humidity'.format(self.get_address())))
                except protocol.OwnetError:
                    pass

            except Exception as ex:
                logger.warning(
                    'OWFS file system is not actve / installed on this device!'
                )

        if data is None:
            return None

        return data
Beispiel #8
0
def main():

    if len(sys.argv) >= 2:
        args = sys.argv[1:]
    else:
        args = ['localhost']
    for netloc in args:
        print('{0:=^33}'.format(netloc))
        try:
            host, port = netloc.split(':', 1)
        except ValueError:
            host, port = netloc, 4304
        try:
            proxy = protocol.proxy(host, port)
        except (protocol.ConnError, protocol.ProtocolError) as err:
            print(err)
            continue
        pid = None
        ver = None
        try:
            pid = int(proxy.read('/system/process/pid'))
            ver = proxy.read('/system/configuration/version').decode()
        except protocol.OwnetError:
            pass
        print('{0}, pid = {1:d}, ver = {2}'.format(proxy, pid, ver))
        print('{0:^17} {1:^7} {2:>7}'.format('id', 'type', 'temp.'))
        for sensor in proxy.dir(slash=False, bus=False):
            stype = proxy.read(sensor + '/type').decode()
            try:
                temp = float(proxy.read(sensor + '/temperature'))
                temp = "{0:.2f}".format(temp)
            except protocol.OwnetError:
                temp = ''
            print('{0:<17} {1:<7} {2:>7}'.format(sensor, stype, temp))
Beispiel #9
0
    def scan_sensors(callback=None):
        try:
            proxy = protocol.proxy('localhost', 4304)
            for sensor in proxy.dir(slash=False, bus=False):
                stype = proxy.read(sensor + '/type').decode()
                address = proxy.read(sensor + '/address').decode()
                try:
                    temp = float(proxy.read(sensor + '/temperature'))
                    yield terrariumOWFSSensor(None,
                                              'temperature',
                                              address,
                                              callback_indicator=callback)

                except protocol.OwnetError:
                    pass

                try:
                    humidity = float(proxy.read(sensor + '/humidity'))
                    yield terrariumOWFSSensor(None,
                                              'humidity',
                                              address,
                                              callback_indicator=callback)

                except protocol.OwnetError:
                    pass

        except Exception as ex:
            logger.warning(
                'OWFS file system is not actve / installed on this device! If this is not correct, try \'i2cdetect -y 1\' to see if device is connected.'
            )
Beispiel #10
0
def main_loop():
    logging.debug(("onewire server : %s") % (OW_HOST))
    logging.debug(("  port         : %s") % (str(OW_PORT)))
    logging.debug(("MQTT broker    : %s") % (MQTT_HOST))
    logging.debug(("  port         : %s") % (str(MQTT_PORT)))
    logging.debug(("pollinterval   : %s") % (str(POLLINTERVAL)))
    logging.debug(("statustopic    : %s") % (str(STATUSTOPIC)))
    logging.debug(("sensors        : %s") % (len(SENSORS)))
    for owid, owtopic in SENSORS.items():
        logging.debug(("  %s : %s") % (owid, owtopic))

    # Connect to the broker and enter the main loop
    mqtt_connect()

    # Connect to ow server
    owproxy = ow.proxy(OW_HOST, OW_PORT)

    while True:
        # simultaneous temperature conversion
        owproxy.write("/simultaneous/temperature", "1")

        # iterate over all sensors
        for owid, owtopic in SENSORS.items():
            logging.debug(("Querying %s : %s") % (owid, owtopic))
            try:
                owtemp = owproxy.read(("/%s/temperature") % (owid))
                logging.debug(("Sensor %s : %s") % (owid, owtemp.strip()))
                MQTTC.publish(owtopic, "{:.1f}".format(float(owtemp.strip())))
            except ow.Error:
                logging.info(
                    "Threw an unknown sensor exception for device %s - %s. Continuing",
                    owid, owname)
                continue

            time.sleep(float(POLLINTERVAL) / len(SENSORS))
Beispiel #11
0
	def __init__(self, owservers=['localhost:4304']):
		for owserver in owservers:
			(host, port) = owserver.split(':')
			owproxy = protocol.proxy(host=host, port=port, persistent=False)
			timeout = int( owproxy.read('/settings/timeout/volatile', timeout=5).decode('ascii') )
			self.owproxy.append(owproxy)
			if (self.timeout < timeout): self.timeout = timeout
Beispiel #12
0
def owbuslist(host='localhost'):
    from pyownet.protocol import proxy

    owProxy = proxy()
    buslist = []
    if host == 'localhost':
        dirs = owProxy.dir()
        for dir in dirs:
            buslist.append(str(dir))
    return owProxy, buslist
Beispiel #13
0
 def setUpClass(cls):
     try:
         cls.proxy = protocol.proxy(
             HOST,
             PORT,
             persistent=True,
         )
     except protocol.ConnError as exc:
         raise unittest.SkipTest('no owserver on %s:%s, got:%s' %
                                 (HOST, PORT, exc))
Beispiel #14
0
def owbuslist(host='localhost'):
    from pyownet.protocol import proxy

    owProxy = proxy()
    buslist = []
    if host == 'localhost':
        dirs = owProxy.dir()
        for dir in dirs:
            buslist.append(str(dir))
    return owProxy, buslist
Beispiel #15
0
def _connect(server):
    try:
        if ':' in server:
            server, port = server.split(':')
        else:
            port=4304
        log.info("Connecting to %s:%d", server, int(port))
        return protocol.proxy(server, int(port))
    except Exception as err:
        log.exception("Failed to retrieve devices from %s:%d: %r", server, int(port), err)
        raise
Beispiel #16
0
def list_sensors(host, port, dir_path):

    owproxy = protocol.proxy(host=host, port=port)

    if dir_path is not None:
        folders = owproxy.dir(dir_path)
    else:
        folders = owproxy.dir()
    
    for folder in folders:
        print folder
Beispiel #17
0
def main():
    assert len(sys.argv) == 2
    urlc = urlsplit(sys.argv[1], scheme='owserver', allow_fragments=False)
    host = urlc.hostname or 'localhost'
    port = urlc.port or 4304
    path = urlc.path or '/'

    p = proxy(host, port, verbose=True)

    while True:
        ret = p.read(path)
        assert ret, "'%s'" % ret
Beispiel #18
0
def main():
    assert len(sys.argv) == 2
    urlc = urlsplit(sys.argv[1], scheme='owserver', allow_fragments=False)
    host = urlc.hostname or 'localhost'
    port = urlc.port or 4304
    path = urlc.path or '/'

    p = proxy(host, port, verbose=True)

    while True:
        ret = p.read(path)
        assert ret, "'%s'" % ret
Beispiel #19
0
 def test_str(self):
     # check edge conditions in which _OwnetConnection.__str__ could fail
     try:
         p = protocol.proxy(HOST, PORT, persistent=True)
     except protocol.Error as exc:
         self.skipTest('no owserver on %s:%s, got:%s' % (HOST, PORT, exc))
     p.ping()
     if p.conn:
         p.conn.shutdown()
         str(p.conn)  # could fail if not able to determine socket peername
     else:
         self.skipTest('unable to create a persistent connection')
Beispiel #20
0
 def test_str(self):
     # check edge conditions in which _OwnetConnection.__str__ could fail
     try:
         p = protocol.proxy(HOST, PORT, persistent=True)
     except protocol.Error as exc:
         self.skipTest('no owserver on %s:%s, got:%s' % (HOST, PORT, exc))
     p.ping()
     if p.conn:
         p.conn.shutdown()
         str(p.conn)  # could fail if not able to determine socket peername
     else:
         self.skipTest('unable to create a persistent connection')
Beispiel #21
0
def main():
    """parse commandline arguments and print result"""

    #
    # setup command line parsing a la argpase
    #
    parser = argparse.ArgumentParser()

    # positional args
    parser.add_argument('uri', metavar='URI', nargs='?', default='/',
                        help='[owserver:]//hostname:port/path')

    #
    # parse command line args
    #
    args = parser.parse_args()

    #
    # parse args.uri and substitute defaults
    #
    urlc = urlsplit(args.uri, scheme='owserver', allow_fragments=False)
    assert urlc.fragment == ''
    if urlc.scheme != 'owserver':
        parser.error("Invalid URI scheme '{0}:'".format(urlc.scheme))
    if urlc.query:
        parser.error("Invalid URI, query component '?{0}' not allowed"
                     .format(urlc.query))
    try:
        host = urlc.hostname or 'localhost'
        port = urlc.port or 4304
    except ValueError as error:
        parser.error("Invalid URI: invalid net location '//{0}/'"
                     .format(urlc.netloc))

    #
    # create owserver proxy object
    #
    try:
        owproxy = protocol.proxy(host, port, persistent=True)
    except protocol.ConnError as error:
        print("Unable to open connection to '{0}:{1}'\n{2}"
              .format(host, port, error), file=sys.stderr)
        sys.exit(1)
    except protocol.ProtocolError as error:
        print("Protocol error, '{0}:{1}' not an owserver?\n{2}"
              .format(host, port, error), file=sys.stderr)
        sys.exit(1)

    stress(owproxy, urlc.path)
Beispiel #22
0
def sensors():
  sensorsdict = {}
  sensorsdict['/28.B22793050000'] = 'podloga'
  sensorsdict['/28.858D94050000'] = 'sciana'

  host, port = "localhost", 4304
  proxy = protocol.proxy(host, port)
  pid = int(proxy.read('/system/process/pid'))
  ver = proxy.read('/system/configuration/version').decode()
  for sensor in proxy.dir(slash=False, bus=False):
    stype = proxy.read(sensor + '/type').decode()
    if stype == "DS18B20":
      temp = float(proxy.read(sensor + '/temperature'))
      temp = "{0:.1f}".format(temp)
      print(sensorsdict[sensor], sensor, temp)
Beispiel #23
0
    def temp_connect(self, temp_all):

        temp_host = temp_all[0]
        temp_port = temp_all[1]

        try:
            self.ow_proxy = protocol.proxy(temp_host, temp_port)

        except IOError:
            print("PANIC - cannot connect to sensor's")
            print('Error class:', sys.exc_info()[0])
            print('Error code :', sys.exc_info()[1])
            print('host       :', temp_host)
            print('port       :', temp_port)
            sys.exit(2)

        return ()
Beispiel #24
0
def main():
    config = get_config()
    client = InfluxDBClient(config['influxdb']['host'],
                            config['influxdb']['port'],
                            config['influxdb']['user'],
                            config['influxdb']['password'],
                            config['influxdb']['db']
                            )

    while True:
        for owserver in config['owservers']:
            try:
                proxy = protocol.proxy(owserver['owserver_host'],
                                    owserver['owserver_port'])
            except (protocol.ConnError, protocol.ProtocolError) as err:
                print(err)
                continue

            data = []

            #for sensor in proxy.dir(slash=False, bus=False):
            for sensor in owserver['sensors']:
                stype = proxy.read(sensor['id'] + '/type').decode()
                try:
                    temp = float(proxy.read(sensor['id'] + '/temperature'))
                    measure = { "measurement": "temperature",
                                "tags": {
                                    "region": owserver['region'],
                                    "host": owserver['hostname'],
                                    "zone": sensor['zone'],
                                    "type": stype
                                },
                            "fields": {
                                "value": temp
                            }
                            }
                    print(measure)
                    temp = "{0:.2f}".format(temp)
                    data.append(measure)
                except protocol.OwnetError:
                    temp = ''
            client.write_points(data)
        time.sleep(300)
Beispiel #25
0
    def get_readings(self):

        reading = {}

        reading['timestamp'] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
        reading['sensor_id'] = self.sensor_id
        reading['sensor_name'] = self.sensor_name
        
        owproxy = protocol.proxy(host=self.host, port=self.port)

        # key is one of: 'temperature','humididty','pressure'
        for key in self.sensors.keys():
            try:
                reading[key] = float(owproxy.read(self.sensors[key]).strip())
            except protocol.OwnetError as e:
                print "Error reading sensor: %s" % (e)
                return None
        
        return reading
Beispiel #26
0
def get_RPI_owtemp(host, port):
    try:
        owproxy = protocol.proxy(host, port, verbose=DEBUG)
    except protocol.ConnError as error:
        print "Error: Unable to open connection to host:port"
        return null
    except protocol.ProtocolError as error:
        print "Protocol error",error
        return null
    
    try:
      owdir =  owproxy.dir(slash=False, bus=False, timeout=TIMEOUT)
      #print owdir
    except protocol.OwnetError as error:
      print "ownet error",error
      return null
    except protocol.ProtocolError as error:
      print "Protocol error getting owdir",error
      return null
    
    sensor_data = {}
    for sensor in owdir:
      try:
        stype = owproxy.read(sensor + '/type', timeout=TIMEOUT).decode()
       
        if stype in [ 'DS18S20' , 'DS18B20' ]:
          data = owproxy.read(sensor+'/temperature', timeout=TIMEOUT)
    
          #print "read: %s %.1f" %  ( sensor[1:], float(data) )
          
          sensor_data[ sensor[1:] ] = float(data)
    
      except protocol.OwnetError as error:
        print "ownet error",error
        next
      except protocol.ProtocolError as error:
        print "Protocol error",error
        next

    return sensor_data
Beispiel #27
0
def main():
    assert len(sys.argv) == 2
    urlc = urlsplit(sys.argv[1], scheme='owserver', allow_fragments=False)
    host = urlc.hostname or 'localhost'
    port = urlc.port or 4304
    assert not urlc.path or urlc.path == '/'

    proxy = protocol.proxy(host, port, verbose=False)
    pid = ver = ''
    try:
        pid = int(proxy.read('/system/process/pid'))
        ver = proxy.read('/system/configuration/version').decode()
    except protocol.OwnetError:
        pass
    log("{0}, pid={1:d}, {2}".format(proxy, pid, ver))

    delta = 1
    for i in range(MTHR):
        th = threading.Thread(target=worker, args=(proxy, i, ), )
        th.start()
        time.sleep(1.03*delta)
        delta *= 2
Beispiel #28
0
def main():
    assert len(sys.argv) == 2
    urlc = urlsplit(sys.argv[1], scheme='owserver', allow_fragments=False)
    host = urlc.hostname or 'localhost'
    port = urlc.port or 4304
    assert not urlc.path or urlc.path == '/'

    proxy = protocol.proxy(host, port, verbose=False)
    pid = -1
    ver = ''
    try:
        pid = int(proxy.read('/system/process/pid'))
        ver = proxy.read('/system/configuration/version').decode()
    except protocol.OwnetError:
        pass
    log("{0}, pid={1:d}, {2}".format(proxy, pid, ver))

    delta = 60
    assert threading.active_count() is 1
    started = 0
    while threading.active_count() == started + 1:
        th = threading.Thread(
            target=worker,
            args=(
                proxy,
                started,
            ),
        )
        th.start()
        started += 1
        try:
            sleep(delta)
        except KeyboardInterrupt:
            break
    log('started {0:d} worker threads'.format(started))
    log('still waiting for {0:d} worker threads'.format(
        threading.active_count() - 1))
Beispiel #29
0
    def _scan_sensors(unit_value_callback=None, trigger_callback=None):
        try:
            proxy = protocol.proxy(terrariumOWFSSensor.__HOST,
                                   terrariumOWFSSensor.__PORT)
            for sensor in proxy.dir(slash=False, bus=False):
                stype = proxy.read(sensor + '/type').decode()
                address = proxy.read(sensor + '/address').decode()
                try:
                    temp = float(proxy.read(sensor + '/temperature'))
                    yield terrariumSensor(
                        None,
                        terrariumOWFSSensor.HARDWARE,
                        'temperature',
                        address,
                        f'{terrariumOWFSSensor.NAME} measuring temperature',
                        unit_value_callback=unit_value_callback,
                        trigger_callback=trigger_callback)

                except protocol.OwnetError as ex:
                    pass

                try:
                    humidity = float(proxy.read(sensor + '/humidity'))
                    yield terrariumSensor(
                        None,
                        terrariumOWFSSensor.HARDWARE,
                        'humidity',
                        address,
                        f'{terrariumOWFSSensor.NAME} measuring humidity',
                        unit_value_callback=unit_value_callback,
                        trigger_callback=trigger_callback)

                except protocol.OwnetError:
                    pass

        except Exception as ex:
            pass
Beispiel #30
0
 def _load_hardware(self):
     # For now, we use/depend on the OWFS defaults
     device = protocol.proxy(self.__HOST, self.__PORT)
     return device
Beispiel #31
0
def main():
    """parse commandline arguments and print result"""

    #
    # setup command line parsing a la argpase
    #
    parser = argparse.ArgumentParser()

    # positional args
    parser.add_argument('uri', metavar='URI', nargs='?', default='/',
                        help='[owserver:]//server:port/entity')

    # optional args for temperature scale
    parser.set_defaults(t_flags=protocol.FLG_TEMP_C)
    tempg = parser.add_mutually_exclusive_group()
    tempg.add_argument('-C', '--Celsius', const=protocol.FLG_TEMP_C,
                       help='Celsius(default) temperature scale',
                       dest='t_flags', action='store_const', )
    tempg.add_argument('-F', '--Fahrenheit', const=protocol.FLG_TEMP_F,
                       help='Fahrenheit temperature scale',
                       dest='t_flags', action='store_const', )
    tempg.add_argument('-K', '--Kelvin', const=protocol.FLG_TEMP_K,
                       help='Kelvin temperature scale',
                       dest='t_flags', action='store_const', )
    tempg.add_argument('-R', '--Rankine', const=protocol.FLG_TEMP_R,
                       help='Rankine temperature scale',
                       dest='t_flags', action='store_const', )

    # optional arg for address format
    fcodes = collections.OrderedDict((
        ('f.i', protocol.FLG_FORMAT_FDI),
        ('fi', protocol.FLG_FORMAT_FI),
        ('f.i.c', protocol.FLG_FORMAT_FDIDC),
        ('f.ic', protocol.FLG_FORMAT_FDIC),
        ('fi.c', protocol.FLG_FORMAT_FIDC),
        ('fic', protocol.FLG_FORMAT_FIC), ))
    parser.set_defaults(format='f.i')
    parser.add_argument('-f', '--format', choices=fcodes,
                        help='format for 1-wire unique serial IDs display')

    parser.add_argument('--nosys', '--only-sensors',
                        action='store_false', dest='bus',
                        help='do not descend system directories')
    #
    # parse command line args
    #
    args = parser.parse_args()

    #
    # parse args.uri and substitute defaults
    #
    urlc = urlsplit(args.uri, scheme='owserver', allow_fragments=False)
    if urlc.scheme != 'owserver':
        parser.error("Invalid URI scheme '{}:'".format(urlc.scheme))
    assert not urlc.fragment
    if urlc.query:
        parser.error(
            "Invalid URI '{}', no query component allowed".format(args.uri))
    host = urlc.hostname or 'localhost'
    port = urlc.port or 4304

    #
    # create owserver proxy object
    #
    try:
        proxy = protocol.proxy(
            host, port, flags=args.t_flags | fcodes[args.format],
            persistent=True)
    except (protocol.ConnError, protocol.ProtocolError) as error:
        parser.exit(status=1, message=str(error)+'\n')

    def walk(path):
        try:
            if not path.endswith('/'):
                val = proxy.read(path)
                print("{:40} {!r}".format(path, val))
            else:
                for entity in proxy.dir(path, bus=args.bus):
                    walk(entity)
        except protocol.OwnetError as error:
            print('Unable to walk {}: server says {}'.format(path, error),
                  file=sys.stderr)
        except protocol.ConnError as error:
            print('Unable to walk {}: {}'.format(path, error), file=sys.stderr)

    with proxy:
        walk(urlc.path)
Beispiel #32
0
 def setUpClass(cls):
     try:
         cls.proxy = protocol.proxy(HOST, PORT, persistent=True, )
     except protocol.ConnError as exc:
         raise unittest.SkipTest('no owserver on %s:%s, got:%s' %
                                 (HOST, PORT, exc))
Beispiel #33
0
def main():
    """parse commandline arguments and print result"""

    #
    # setup command line parsing a la argpase
    #
    parser = argparse.ArgumentParser()

    # positional args
    parser.add_argument('uri',
                        metavar='URI',
                        nargs='?',
                        default='/',
                        help='[owserver:]//hostname:port/path')

    # optional args for temperature scale
    parser.set_defaults(t_flags=protocol.FLG_TEMP_C)
    tempg = parser.add_mutually_exclusive_group()
    tempg.add_argument(
        '-C',
        '--Celsius',
        const=protocol.FLG_TEMP_C,
        help='Celsius(default) temperature scale',
        dest='t_flags',
        action='store_const',
    )
    tempg.add_argument(
        '-F',
        '--Fahrenheit',
        const=protocol.FLG_TEMP_F,
        help='Fahrenheit temperature scale',
        dest='t_flags',
        action='store_const',
    )
    tempg.add_argument(
        '-K',
        '--Kelvin',
        const=protocol.FLG_TEMP_K,
        help='Kelvin temperature scale',
        dest='t_flags',
        action='store_const',
    )
    tempg.add_argument(
        '-R',
        '--Rankine',
        const=protocol.FLG_TEMP_R,
        help='Rankine temperature scale',
        dest='t_flags',
        action='store_const',
    )

    # optional arg for address format
    fcodes = collections.OrderedDict((
        ('f.i', protocol.FLG_FORMAT_FDI),
        ('fi', protocol.FLG_FORMAT_FI),
        ('f.i.c', protocol.FLG_FORMAT_FDIDC),
        ('f.ic', protocol.FLG_FORMAT_FDIC),
        ('fi.c', protocol.FLG_FORMAT_FIDC),
        ('fic', protocol.FLG_FORMAT_FIC),
    ))
    parser.set_defaults(format='f.i')
    parser.add_argument('-f',
                        '--format',
                        choices=fcodes,
                        help='format for 1-wire unique serial IDs display')

    # optional arg for output format
    tempg = parser.add_mutually_exclusive_group()
    tempg.add_argument('--hex',
                       action='store_true',
                       help='write data in hex format')
    tempg.add_argument('-b',
                       '--binary',
                       action='store_true',
                       help='output binary data')

    #
    # parse command line args
    #
    args = parser.parse_args()

    #
    # parse args.uri and substitute defaults
    #
    urlc = urlsplit(args.uri, scheme='owserver', allow_fragments=False)
    assert urlc.fragment == ''
    if urlc.scheme != 'owserver':
        parser.error("Invalid URI scheme '{0}:'".format(urlc.scheme))
    if urlc.query:
        parser.error("Invalid URI, query component '?{0}' not allowed".format(
            urlc.query))
    try:
        host = urlc.hostname or 'localhost'
        port = urlc.port or 4304
    except ValueError as error:
        parser.error("Invalid URI: invalid net location '//{0}/'".format(
            urlc.netloc))

    #
    # create owserver proxy object
    #
    try:
        owproxy = protocol.proxy(
            host,
            port,
            flags=args.t_flags | fcodes[args.format],
        )
    except protocol.ConnError as error:
        print("Unable to open connection to '{0}:{1}'\n{2}".format(
            host, port, error),
              file=sys.stderr)
        sys.exit(1)
    except protocol.ProtocolError as error:
        print("Protocol error, '{0}:{1}' not an owserver?\n{2}".format(
            host, port, error),
              file=sys.stderr)
        sys.exit(1)

    try:
        if urlc.path.endswith('/'):
            for path in owproxy.dir(urlc.path, bus=True):
                print(path)
        else:
            data = owproxy.read(urlc.path)
            if args.binary:
                if sys.version_info < (3, ):
                    sys.stdout.write(data)
                else:
                    sys.stdout.buffer.write(data)
            else:
                if args.hex:
                    data = hexlify(data)
                print(data.decode('ascii', errors='backslashreplace'))
    except protocol.OwnetError as error:
        print("Ownet error\n{2}".format(host, port, error), file=sys.stderr)
        sys.exit(1)
    except protocol.ProtocolError as error:
        print("Protocol error, '{0}:{1}' buggy?\n{2}".format(
            host, port, error),
              file=sys.stderr)
        sys.exit(1)
Beispiel #34
0
def main():

    def report(name, res):
        scale = 1e3  # report times in ms
        print('  * {:17}'.format(name), end=':')
        for t in (sorted(res)):
            print(' {:6.3f} ms'.format(t / number * scale), end=',')
        print()

    parser = argparse.ArgumentParser()
    parser.add_argument('uri', metavar='URI', nargs='?', default='/',
                        help='[owserver:]//server:port/entity')
    parser.add_argument('-n', '--number', type=int, default=20,
                        metavar='N',
                        help='number of executions (default: %(default)s)')
    parser.add_argument('-r', '--repeat', type=int, default=5,
                        metavar='R',
                        help='repeat count (default: %(default)s)')

    args = parser.parse_args()
    urlc = urlsplit(args.uri, scheme='owserver', allow_fragments=False)
    if urlc.scheme != 'owserver':
        parser.error("Invalid URI scheme '{}:'".format(urlc.scheme))
    assert not urlc.fragment
    if urlc.query:
        parser.error(
            "Invalid URI '{}', no query component allowed".format(args.uri))
    host = urlc.hostname or 'localhost'
    port = urlc.port or 4304
    path = urlc.path or '/'

    try:
        base = protocol.proxy(host, port, persistent=False)
    except protocol.ConnError as exc:
        sys.exit('Error connecting to {}:{} {}'.format(host, port, exc))
    pid = 'unknown'
    ver = 'unknown'
    try:
        pid = int(base.read(protocol.PTH_PID))
        ver = base.read(protocol.PTH_VERSION).decode()
    except protocol.OwnetError:
        pass

    number = args.number
    repeat = args.repeat

    print('python  : {} {} on {}'.format(platform.python_implementation(),
                                         platform.python_version(),
                                         platform.platform(terse=True),))
    print('{:8s}: {}'.format(pyownet.__name__, pyownet.__version__))
    print('owproxy : {}'.format(base))
    print('owserver: pid {}, ver. {}'.format(pid, ver))
    print('url     : {}'.format(urlunsplit(urlc), ))
    print('samples : {} * {} repetitions'.format(number, repeat))
    print()

    global data, owproxy, hargs
    data = (b'\x00\x00\x00\x00\x00\x000:\xff\xff\xff\xfe\x00\x00\x00\x00\x00'
            b'\x00\x04\xd2\x00\x00\x00\xea')
    hargs = {'payload': 745, 'type': protocol.MSG_READ,
             'flags': protocol.FLG_UNCACHED | protocol.FLG_TEMP_C,
             'size': 234, 'offset': 52}

    print('{} core objects'.format(pyownet.__name__))

    setup = """
from pyownet.protocol import _FromServerHeader, _ToServerHeader, proxy
from __main__ import data, hargs
"""
    stmt = "_FromServerHeader(data)"

    timer = timeit.Timer(stmt=stmt, setup=setup)
    res = timer.repeat(number=number, repeat=repeat)
    report('_FromServerHeader', res)

    stmt = "_ToServerHeader(**hargs)"

    timer = timeit.Timer(stmt=stmt, setup=setup)
    res = timer.repeat(number=number, repeat=repeat)
    report('_ToServerHeader', res)

    stmt = "proxy(host='{}', port={})".format(host, port)

    timer = timeit.Timer(stmt=stmt, setup=setup)
    res = timer.repeat(number=number, repeat=repeat)
    report('proxy()', res)

    setup = "from __main__ import owproxy"
    stmt = "owproxy.ping()"

    print(stmt)

    owproxy = protocol.clone(base, persistent=False)
    timer = timeit.Timer(stmt=stmt, setup=setup)
    res = timer.repeat(number=number, repeat=repeat)
    report('non persistent', res)

    owproxy = protocol.clone(base, persistent=True)
    res = timer.repeat(number=number, repeat=repeat)
    report('persistent', res)

    setup = "from __main__ import owproxy"
    if path.endswith('/'):
        stmt = 'owproxy.dir("{}")'.format(path)
    else:
        stmt = 'owproxy.read("{}")'.format(path)

    owproxy = base
    assert 'owproxy' in globals()
    try:
        eval(stmt, globals(), )
    except protocol.OwnetError as err:
        print(err)
        sys.exit(1)

    print(stmt)
    owproxy = protocol.clone(base, persistent=False)
    timer = timeit.Timer(stmt=stmt, setup=setup)
    res = timer.repeat(number=number, repeat=repeat)
    report('non persistent', res)

    owproxy = protocol.clone(base, persistent=True)
    res = timer.repeat(number=number, repeat=repeat)
    report('persistent', res)
Beispiel #35
0
def get_entities(config):
    """Get a list of entities."""
    base_dir = config[CONF_MOUNT_DIR]
    owhost = config.get(CONF_HOST)
    owport = config[CONF_PORT]

    # Ensure type is configured
    if owhost:
        conf_type = CONF_TYPE_OWSERVER
    elif base_dir == DEFAULT_SYSBUS_MOUNT_DIR:
        conf_type = CONF_TYPE_SYSBUS
    else:
        conf_type = CONF_TYPE_OWFS

    entities = []
    device_names = {}
    if CONF_NAMES in config:
        if isinstance(config[CONF_NAMES], dict):
            device_names = config[CONF_NAMES]

    # We have an owserver on a remote(or local) host/port
    if conf_type == CONF_TYPE_OWSERVER:
        _LOGGER.debug("Initializing using %s:%s", owhost, owport)
        try:
            owproxy = protocol.proxy(host=owhost, port=owport)
            devices = owproxy.dir()
        except protocol.Error as exc:
            _LOGGER.error("Cannot connect to owserver on %s:%d, got: %s",
                          owhost, owport, exc)
            devices = []
        for device in devices:
            _LOGGER.debug("Found device: %s", device)
            family = owproxy.read(f"{device}family").decode()
            dev_type = "std"
            if "EF" in family:
                dev_type = "HobbyBoard"
                family = owproxy.read(f"{device}type").decode()

            if family not in hb_info_from_type(dev_type):
                _LOGGER.warning(
                    "Ignoring unknown family (%s) of sensor found for device: %s",
                    family,
                    device,
                )
                continue
            for sensor_key, sensor_value in hb_info_from_type(
                    dev_type)[family].items():
                if "moisture" in sensor_key:
                    s_id = sensor_key.split("_")[1]
                    is_leaf = int(
                        owproxy.read(
                            f"{device}moisture/is_leaf.{s_id}").decode())
                    if is_leaf:
                        sensor_key = f"wetness_{s_id}"
                sensor_id = os.path.split(os.path.split(device)[0])[1]
                device_file = os.path.join(
                    os.path.split(device)[0], sensor_value)
                entities.append(
                    OneWireProxy(
                        device_names.get(sensor_id, sensor_id),
                        device_file,
                        sensor_key,
                        owproxy,
                    ))

    # We have a raw GPIO ow sensor on a Pi
    elif conf_type == CONF_TYPE_SYSBUS:
        _LOGGER.debug("Initializing using SysBus")
        for p1sensor in Pi1Wire().find_all_sensors():
            family = p1sensor.mac_address[:2]
            sensor_id = f"{family}-{p1sensor.mac_address[2:]}"
            if family not in DEVICE_SUPPORT_SYSBUS:
                _LOGGER.warning(
                    "Ignoring unknown family (%s) of sensor found for device: %s",
                    family,
                    sensor_id,
                )
                continue

            device_file = f"/sys/bus/w1/devices/{sensor_id}/w1_slave"
            entities.append(
                OneWireDirect(
                    device_names.get(sensor_id, sensor_id),
                    device_file,
                    "temperature",
                    p1sensor,
                ))
        if not entities:
            _LOGGER.error(
                "No onewire sensor found. Check if dtoverlay=w1-gpio "
                "is in your /boot/config.txt. "
                "Check the mount_dir parameter if it's defined")

    # We have an owfs mounted
    else:
        _LOGGER.debug("Initializing using OWFS %s", base_dir)
        for family_file_path in glob(os.path.join(base_dir, "*", "family")):
            with open(family_file_path) as family_file:
                family = family_file.read()
            if "EF" in family:
                continue
            if family in DEVICE_SENSORS:
                for sensor_key, sensor_value in DEVICE_SENSORS[family].items():
                    sensor_id = os.path.split(
                        os.path.split(family_file_path)[0])[1]
                    device_file = os.path.join(
                        os.path.split(family_file_path)[0], sensor_value)
                    entities.append(
                        OneWireOWFS(
                            device_names.get(sensor_id, sensor_id),
                            device_file,
                            sensor_key,
                        ))

    return entities
Beispiel #36
0
    my_logger.addHandler(handler)
    count = 2
    while count > 1:
        count = 0
        for p in psutil.process_iter(["name"]):
            if "oneWireBus" in p.name():
                count += 1
                if count > 2:
                    my_logger.critical(
                        "dziala wiecej niz dwa procesy odczytu temperatury")
                    panic()
    time.sleep(5)

    try:
        owproxy = protocol.proxy(host="127.0.0.1", port=4304)
        for sensor in sensors:
            if owproxy.present(sensor[0]):
                if sensor[1] == 'lazienka_gora' or sensor[1] == 'lazienka_dol':
                    value = (owproxy.read('%stemperature' %
                                          sensor[0]).decode('utf-8').strip())
                    humidity = (owproxy.read(
                        '%shumidity' % sensor[0]).decode('utf-8').strip())
                    time.sleep(1)
                    sock.sendto(bytes(value, 'utf-8'), (UDP_IP, sensor[2]))
                    time.sleep(1)
                    sock.sendto(bytes(humidity, 'utf-8'), (UDP_IP, sensor[3]))
                else:
                    value = (owproxy.read('%stemperature10' %
                                          sensor[0]).decode('utf-8').strip())
                    time.sleep(1)
Beispiel #37
0
def main():
    """parse commandline arguments and print result"""

    #
    # setup command line parsing a la argpase
    #
    parser = argparse.ArgumentParser()

    # positional args
    parser.add_argument("uri", metavar="URI", nargs="?", default="/", help="[owserver:]//hostname:port/path")

    # optional args for temperature scale
    parser.set_defaults(t_flags=protocol.FLG_TEMP_C)
    tempg = parser.add_mutually_exclusive_group()
    tempg.add_argument(
        "-C",
        "--Celsius",
        const=protocol.FLG_TEMP_C,
        help="Celsius(default) temperature scale",
        dest="t_flags",
        action="store_const",
    )
    tempg.add_argument(
        "-F",
        "--Fahrenheit",
        const=protocol.FLG_TEMP_F,
        help="Fahrenheit temperature scale",
        dest="t_flags",
        action="store_const",
    )
    tempg.add_argument(
        "-K",
        "--Kelvin",
        const=protocol.FLG_TEMP_K,
        help="Kelvin temperature scale",
        dest="t_flags",
        action="store_const",
    )
    tempg.add_argument(
        "-R",
        "--Rankine",
        const=protocol.FLG_TEMP_R,
        help="Rankine temperature scale",
        dest="t_flags",
        action="store_const",
    )

    # optional arg for address format
    fcodes = collections.OrderedDict(
        (
            ("f.i", protocol.FLG_FORMAT_FDI),
            ("fi", protocol.FLG_FORMAT_FI),
            ("f.i.c", protocol.FLG_FORMAT_FDIDC),
            ("f.ic", protocol.FLG_FORMAT_FDIC),
            ("fi.c", protocol.FLG_FORMAT_FIDC),
            ("fic", protocol.FLG_FORMAT_FIC),
        )
    )
    parser.set_defaults(format="f.i")
    parser.add_argument("-f", "--format", choices=fcodes, help="format for 1-wire unique serial IDs display")

    # optional arg for output format
    tempg = parser.add_mutually_exclusive_group()
    tempg.add_argument("--hex", action="store_true", help="write data in hex format")
    tempg.add_argument("-b", "--binary", action="store_true", help="output binary data")

    #
    # parse command line args
    #
    args = parser.parse_args()

    #
    # parse args.uri and substitute defaults
    #
    urlc = urlsplit(args.uri, scheme="owserver", allow_fragments=False)
    assert urlc.fragment == ""
    if urlc.scheme != "owserver":
        parser.error("Invalid URI scheme '{0}:'".format(urlc.scheme))
    if urlc.query:
        parser.error("Invalid URI, query component '?{0}' not allowed".format(urlc.query))
    try:
        host = urlc.hostname or "localhost"
        port = urlc.port or 4304
    except ValueError as error:
        parser.error("Invalid URI: invalid net location '//{0}/'".format(urlc.netloc))

    #
    # create owserver proxy object
    #
    try:
        owproxy = protocol.proxy(host, port, flags=args.t_flags | fcodes[args.format])
    except protocol.ConnError as error:
        print("Unable to open connection to '{0}:{1}'\n{2}".format(host, port, error), file=sys.stderr)
        sys.exit(1)
    except protocol.ProtocolError as error:
        print("Protocol error, '{0}:{1}' not an owserver?\n{2}".format(host, port, error), file=sys.stderr)
        sys.exit(1)

    try:
        if urlc.path.endswith("/"):
            for path in owproxy.dir(urlc.path, bus=True):
                print(path)
        else:
            data = owproxy.read(urlc.path)
            if args.binary:
                if sys.version_info < (3,):
                    sys.stdout.write(data)
                else:
                    sys.stdout.buffer.write(data)
            else:
                if args.hex:
                    data = hexlify(data)
                print(data.decode("ascii", errors="backslashreplace"))
    except protocol.OwnetError as error:
        print("Ownet error\n{2}".format(host, port, error), file=sys.stderr)
        sys.exit(1)
    except protocol.ProtocolError as error:
        print("Protocol error, '{0}:{1}' buggy?\n{2}".format(host, port, error), file=sys.stderr)
        sys.exit(1)
Beispiel #38
0
def main():

    def report(name, res):
        scale = 1e3  # report times in ms
        print('** {:15}'.format(name), end=':')
        for t in (sorted(res)):
            print(' {:6.3f} ms'.format(t / number * scale), end=',')
        print()

    parser = argparse.ArgumentParser()
    parser.add_argument('uri', metavar='URI', nargs='?', default='/',
                        help='[owserver:]//server:port/entity')
    parser.add_argument('-n', '--number', type=int, default=20,
                        metavar='N',
                        help='number of executions (default: %(default)s)')
    parser.add_argument('-r', '--repeat', type=int, default=5,
                        metavar='R',
                        help='repeat count (default: %(default)s)')

    args = parser.parse_args()
    urlc = urlsplit(args.uri, scheme='owserver', allow_fragments=False)
    if urlc.scheme != 'owserver':
        parser.error("Invalid URI scheme '{}:'".format(urlc.scheme))
    assert not urlc.fragment
    if urlc.query:
        parser.error(
            "Invalid URI '{}', no query component allowed".format(args.uri))
    host = urlc.hostname or 'localhost'
    port = urlc.port or 4304
    path = urlc.path or '/'

    print(pyownet.__name__, pyownet.__version__, pyownet.__file__)

    try:
        base = protocol.proxy(host, port, persistent=False)
    except protocol.ConnError as exc:
        sys.exit('Error connecting to {}:{} {}'.format(host, port, exc))
    pid = 'unknown'
    ver = 'unknown'
    try:
        pid = int(base.read('/system/process/pid'))
        ver = base.read('/system/configuration/version').decode()
    except protocol.OwnetError:
        pass

    print('proxy_obj: {}'.format(base))
    print('server info: pid {}, ver. {}'.format(pid, ver))
    print()

    number = args.number
    repeat = args.repeat

    setup = "from __main__ import proxy_obj"
    if path.endswith('/'):
        stmt = 'proxy_obj.dir("{}")'.format(path)
    else:
        stmt = 'proxy_obj.read("{}")'.format(path)

    print('timeit:\n statement: {}\n number: {}\n repetitions: {}'.format(
        stmt, number, repeat))
    print()

    global proxy_obj

    proxy_obj = base
    assert 'proxy_obj' in globals()
    try:
        eval(stmt, globals(), )
    except protocol.OwnetError as err:
        print(err)
        sys.exit(1)

    timer = timeit.Timer(stmt=stmt, setup=setup)

    proxy_obj = protocol.clone(base, persistent=False)
    res = timer.repeat(number=number, repeat=repeat)
    report('non persistent', res)

    proxy_obj = protocol.clone(base, persistent=True)
    res = timer.repeat(number=number, repeat=repeat)
    report('persistent', res)
Beispiel #39
0
def get_entities(config):
    """Get a list of entities."""
    base_dir = config[CONF_MOUNT_DIR]
    owhost = config.get(CONF_HOST)
    owport = config[CONF_PORT]

    # Ensure type is configured
    if owhost:
        conf_type = CONF_TYPE_OWSERVER
    elif base_dir == DEFAULT_SYSBUS_MOUNT_DIR:
        conf_type = CONF_TYPE_SYSBUS
    else:  # pragma: no cover
        # This part of the implementation does not conform to policy regarding 3rd-party libraries, and will not longer be updated.
        # https://developers.home-assistant.io/docs/creating_platform_code_review/#5-communication-with-devicesservices
        conf_type = CONF_TYPE_OWFS

    entities = []
    device_names = {}
    if CONF_NAMES in config:
        if isinstance(config[CONF_NAMES], dict):
            device_names = config[CONF_NAMES]

    # We have an owserver on a remote(or local) host/port
    if conf_type == CONF_TYPE_OWSERVER:
        _LOGGER.debug("Initializing using %s:%s", owhost, owport)
        try:
            owproxy = protocol.proxy(host=owhost, port=owport)
            devices = owproxy.dir()
        except protocol.Error as exc:
            _LOGGER.error("Cannot connect to owserver on %s:%d, got: %s",
                          owhost, owport, exc)
            devices = []
        for device in devices:
            _LOGGER.debug("Found device: %s", device)
            family = owproxy.read(f"{device}family").decode()
            dev_type = "std"
            if "EF" in family:
                dev_type = "HobbyBoard"
                family = owproxy.read(f"{device}type").decode()

            if family not in hb_info_from_type(dev_type):
                _LOGGER.warning(
                    "Ignoring unknown family (%s) of sensor found for device: %s",
                    family,
                    device,
                )
                continue
            for sensor_key, sensor_value in hb_info_from_type(
                    dev_type)[family].items():
                if "moisture" in sensor_key:
                    s_id = sensor_key.split("_")[1]
                    is_leaf = int(
                        owproxy.read(
                            f"{device}moisture/is_leaf.{s_id}").decode())
                    if is_leaf:
                        sensor_key = f"wetness_{s_id}"
                sensor_id = os.path.split(os.path.split(device)[0])[1]
                device_file = os.path.join(
                    os.path.split(device)[0], sensor_value)
                entities.append(
                    OneWireProxy(
                        device_names.get(sensor_id, sensor_id),
                        device_file,
                        sensor_key,
                        owproxy,
                    ))

    # We have a raw GPIO ow sensor on a Pi
    elif conf_type == CONF_TYPE_SYSBUS:
        _LOGGER.debug("Initializing using SysBus")
        for p1sensor in Pi1Wire().find_all_sensors():
            family = p1sensor.mac_address[:2]
            sensor_id = f"{family}-{p1sensor.mac_address[2:]}"
            if family not in DEVICE_SUPPORT_SYSBUS:
                _LOGGER.warning(
                    "Ignoring unknown family (%s) of sensor found for device: %s",
                    family,
                    sensor_id,
                )
                continue

            device_file = f"/sys/bus/w1/devices/{sensor_id}/w1_slave"
            entities.append(
                OneWireDirect(
                    device_names.get(sensor_id, sensor_id),
                    device_file,
                    "temperature",
                    p1sensor,
                ))
        if not entities:
            _LOGGER.error(
                "No onewire sensor found. Check if dtoverlay=w1-gpio "
                "is in your /boot/config.txt. "
                "Check the mount_dir parameter if it's defined")

    # We have an owfs mounted
    else:  # pragma: no cover
        # This part of the implementation does not conform to policy regarding 3rd-party libraries, and will not longer be updated.
        # https://developers.home-assistant.io/docs/creating_platform_code_review/#5-communication-with-devicesservices
        _LOGGER.debug("Initializing using OWFS %s", base_dir)
        _LOGGER.warning(
            "The OWFS implementation of 1-Wire sensors is deprecated, "
            "and should be migrated to OWServer (on localhost:4304). "
            "If migration to OWServer is not feasible on your installation, "
            "please raise an issue at https://github.com/home-assistant/core/issues/new"
            "?title=Unable%20to%20migrate%20onewire%20from%20OWFS%20to%20OWServer",
        )
        for family_file_path in glob(os.path.join(base_dir, "*", "family")):
            with open(family_file_path) as family_file:
                family = family_file.read()
            if "EF" in family:
                continue
            if family in DEVICE_SENSORS:
                for sensor_key, sensor_value in DEVICE_SENSORS[family].items():
                    sensor_id = os.path.split(
                        os.path.split(family_file_path)[0])[1]
                    device_file = os.path.join(
                        os.path.split(family_file_path)[0], sensor_value)
                    entities.append(
                        OneWireOWFS(
                            device_names.get(sensor_id, sensor_id),
                            device_file,
                            sensor_key,
                        ))

    return entities
Beispiel #40
0
    logger.addHandler(fh)

    logger.info(
        '## Starting 1Wire-Server ####################################################################'
    )

    while True:

        # read device list
        with open(path_to_devices + 'devices.json') as json_file:
            devicelist = json.load(json_file)
        # outputlist as dict
        outputlist = {}

        # connect to owfs
        owproxy = protocol.proxy(host='192.168.0.17', port=4304)

        # Enable simultaneous temperature conversation
        owproxy.write("/simultaneous/temperature", b'1')
        #ow._put("simultaneous/voltage","1")

        # read in connected sensor
        try:
            sensorlist = owproxy.dir(path='/', slash=False, timeout=0)

            # loop through sensors and read values
            for sensor in sensorlist:
                try:
                    sensorvalues = {}
                    # print('Sensor: ' + sensor)
                    # print('ID: ' + sensor.id)
Beispiel #41
0
def setup_platform(hass, config, add_entities, discovery_info=None):
    """Set up the one wire Sensors."""
    base_dir = config[CONF_MOUNT_DIR]
    owport = config[CONF_PORT]
    owhost = config.get(CONF_HOST)
    if owhost:
        _LOGGER.debug("Initializing using %s:%s", owhost, owport)
    else:
        _LOGGER.debug("Initializing using %s", base_dir)

    devs = []
    device_names = {}
    if CONF_NAMES in config:
        if isinstance(config[CONF_NAMES], dict):
            device_names = config[CONF_NAMES]

    # We have an owserver on a remote(or local) host/port
    if owhost:
        try:
            owproxy = protocol.proxy(host=owhost, port=owport)
            devices = owproxy.dir()
        except protocol.Error as exc:
            _LOGGER.error("Cannot connect to owserver on %s:%d, got: %s",
                          owhost, owport, exc)
            devices = []
        for device in devices:
            _LOGGER.debug("Found device: %s", device)
            family = owproxy.read(f"{device}family").decode()
            dev_type = "std"
            if "EF" in family:
                dev_type = "HobbyBoard"
                family = owproxy.read(f"{device}type").decode()

            if family not in hb_info_from_type(dev_type):
                _LOGGER.warning(
                    "Ignoring unknown family (%s) of sensor found for device: %s",
                    family,
                    device,
                )
                continue
            for sensor_key, sensor_value in hb_info_from_type(
                    dev_type)[family].items():
                if "moisture" in sensor_key:
                    s_id = sensor_key.split("_")[1]
                    is_leaf = int(
                        owproxy.read(
                            f"{device}moisture/is_leaf.{s_id}").decode())
                    if is_leaf:
                        sensor_key = f"wetness_{id}"
                sensor_id = os.path.split(os.path.split(device)[0])[1]
                device_file = os.path.join(
                    os.path.split(device)[0], sensor_value)
                devs.append(
                    OneWireProxy(
                        device_names.get(sensor_id, sensor_id),
                        device_file,
                        sensor_key,
                        owproxy,
                    ))

    # We have a raw GPIO ow sensor on a Pi
    elif base_dir == DEFAULT_MOUNT_DIR:
        for device_family in DEVICE_SENSORS:
            for device_folder in glob(
                    os.path.join(base_dir, f"{device_family}[.-]*")):
                sensor_id = os.path.split(device_folder)[1]
                device_file = os.path.join(device_folder, "w1_slave")
                devs.append(
                    OneWireDirect(
                        device_names.get(sensor_id, sensor_id),
                        device_file,
                        "temperature",
                    ))

    # We have an owfs mounted
    else:
        for family_file_path in glob(os.path.join(base_dir, "*", "family")):
            with open(family_file_path) as family_file:
                family = family_file.read()
            if "EF" in family:
                continue
            if family in DEVICE_SENSORS:
                for sensor_key, sensor_value in DEVICE_SENSORS[family].items():
                    sensor_id = os.path.split(
                        os.path.split(family_file_path)[0])[1]
                    device_file = os.path.join(
                        os.path.split(family_file_path)[0], sensor_value)
                    devs.append(
                        OneWireOWFS(
                            device_names.get(sensor_id, sensor_id),
                            device_file,
                            sensor_key,
                        ))

    if devs == []:
        _LOGGER.error("No onewire sensor found. Check if dtoverlay=w1-gpio "
                      "is in your /boot/config.txt. "
                      "Check the mount_dir parameter if it's defined")
        return

    add_entities(devs, True)
Beispiel #42
0
# logs temperature from OWFS into postgres database
# (c) Tomasz Torcz, ISC License

import os
import psycopg2
import systemd.daemon
import time
from timeit import default_timer

from pyownet.protocol import proxy

sleep_seconds = int(os.getenv("WATCHDOG_USEC")) / (2 * (10**6)) + 1

systemd.daemon.notify("STATUS=Opening owserver & DB connection...")
try:
    owproxy = proxy()
except Exception as err:
    print("Error connecting to owserver, sorry: {0}".format(err))
    exit(1)

try:
    dbconn = psycopg2.connect("dbname=house_metrics")
except Exception as err:
    print("Error connecting to DB, sorry: {0}".format(err))
    exit(2)

cur = dbconn.cursor()
cur.execute(
    "PREPARE put_temperature AS INSERT INTO temperatures (datetime, sensor_id, value) VALUES (NOW(), (SELECT id FROM sensors WHERE SN=$1), $2);"
)