def get(self, port=None, cfg=None, timeout=0):
work_oids = {'t': 16, 'h': 17}
wo = work_oids.get(port)
if wo is None: return None
snmp_oid = 'iso.3.6.1.4.1.3854.1.2.2.1.%u.1.3.%u' % (
wo, self.sensor_port - 1)
_timeout = timeout / self.snmp_tries
if netsnmp:
try:
sess = netsnmp.Session(Version=1,
DestHost=self.snmp_host,
RemotePort=self.snmp_port,
Community=self.community,
Timeout=int(_timeout * 1000000),
Retries=self.snmp_tries - 1)
return sess.get(netsnmp.VarList(snmp_oid))[0].decode()
except:
log_traceback()
return None
else:
return snmp.get(snmp_oid,
self.snmp_host,
self.snmp_port,
self.community,
_timeout,
self.snmp_tries - 1,
rf=int,
snmp_ver=1)
def get(self, port=None, cfg=None, timeout=0):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(timeout)
try:
time_start = time()
s.connect((self.host, 55443))
if time_start + timeout < time():
raise Exception('operation timeout')
s.send(('{ "id": 1, "method": "get_prop", "params":' +
' ["power", "color_mode", "rgb", "ct", "bright"] }\r\n'
).encode())
result = json.loads(s.recv(1024).decode())['result']
status = 1 if result[0] == 'on' else 0
if int(result[1]) == 2:
red = round(int(result[4]) * 255 / 100)
blue = round((int(result[3]) - 1700) / 4800 * red)
value = red * 65792 + blue
else:
value = int(result[2])
return status, '#{:06x}'.format(value)
except:
log_traceback()
return None
finally:
try:
s.close()
except:
pass
def test(self, cmd=None):
if cmd == 'self':
mb = modbus.get_port(self.modbus_port)
if not mb: return 'FAILED'
mb.release()
return 'OK'
if cmd == 'info':
mb = modbus.get_port(self.modbus_port)
if not mb: return 'FAILED'
if mb.client_type in ['tcp', 'udp']:
reg = 22
else:
reg = 21
rr = mb.read_holding_registers(reg, 1, unit=self.addr)
mb.release()
if rr.isError(): return 'FAILED'
try:
return '{:.2f}'.format(float(rr.registers[0]) / 100.0)
except:
log_traceback()
return 'FAILED'
if cmd == 'get': return self.get(timeout=get_timeout() * 10)
return {
'info': 'returns relay firmware version',
'get': 'get current relay state'
}
def exec(self, cmd=None, args=None):
if cmd == 'id':
try:
new_id = int(args)
if new_id < 1 or new_id > 247:
raise Exception('id not in range 1..247')
mb = modbus.get_port(self.modbus_port)
if not mb:
raise Exception('unable to get modbus port {}'.format(
self.modbus_port))
try:
result = mb.write_register(18, new_id, unit=self.addr)
except:
log_traceback()
result = None
mb.release()
if not result or result.isError(): return 'FAILED'
self.addr = new_id
self.phi_cfg['addr'] = new_id
return 'OK'
except:
log_traceback()
return 'FAILED'
else:
return {
'id': 'change relay slave ID (1..247), relay reboot required'
}
def get(self, port=None, cfg=None, timeout=0):
try:
if not eva.uc.i2cbus.lock(self.bus):
raise Exception('Unable to lock I2C bus %s ' % self.bus)
b = self.smbus2.SMBus(self.bus)
time_start = time.time()
rd = False
while time_start + timeout >= time.time():
try:
t, p, h = self.readBME280All(bus=b, addr=self.addr)
if t is not None and p is not None and h is not None:
rd = True
break
except:
pass
time.sleep(bus_delay)
eva.uc.i2cbus.release(self.bus)
if not rd: raise Exception('data read error')
return {
't': int(t * 100) / 100.0,
'p': int(p * 100) / 100.0,
'h': int(h * 100) / 100.0
}
except:
log_traceback()
return None
def test(self, cmd=None):
if cmd == 'self':
try:
identity = self.proxy.operate('list_identity')
return 'OK'
except:
log_traceback()
return 'FAILED'
elif cmd == 'info':
identity = self.proxy.operate('list_identity')
return {
'product_name': str(identity.get('product_name')),
'serial_number': str(identity.get('serial_number'))
}
elif cmd == 'get':
if self.tags:
return self.get(timeout=get_timeout())
else:
return 'tag list not specified'
elif cmd == 'help':
return {
'info': 'get equpment identity',
'get': 'get all tags',
'<TAG>': 'get tag value'
}
else:
return self.get(port=cmd, timeout=get_timeout())
def get(self, port=None, cfg=None, timeout=0):
if cfg:
relay_host, relay_port = parse_host_port(cfg.get('host'), 6722)
else:
relay_host = None
if not relay_host:
relay_host = self.relay_host
relay_port = self.relay_port
if not relay_host:
self.log_error('no host specified')
return None
server = (relay_host, relay_port)
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(timeout)
try:
sock.connect(server)
sock.send('00'.encode())
res = sock.recv(8).decode()
sock.close()
except:
sock.close()
raise
if len(res) < 8: raise Exception('bad data received')
result = {}
for i in range(8):
result[str(i + 1)] = int(res[i])
return result
except:
log_traceback()
return None
def set(oid,
value,
host,
port=161,
community='private',
timeout=0,
retries=0,
snmp_ver=2):
try:
for (err_i, err_st, err_idx, vals) in snmp_engine.setCmd(
snmp_engine.SnmpEngine(),
snmp_engine.CommunityData(community, mpModel=snmp_ver - 1),
snmp_engine.UdpTransportTarget((host, port),
timeout=timeout,
retries=retries),
snmp_engine.ContextData(),
snmp_engine.ObjectType(snmp_engine.ObjectIdentity(oid),
value)):
if err_i or err_st:
logging.debug('snmp error: %s' % err_i)
return None
else:
return True
except:
log_traceback()
return False
def unload(self):
for p, d in self.devices.items():
try:
d.close()
except:
log_traceback()
self.devices = []
def stop(self):
for d in self.devices:
try:
d.off()
d.close()
except:
log_traceback()
self.devices = []
def unload(self):
try:
result = requests.delete(self.api_uri, timeout=get_timeout())
if not result.ok:
raise Exception
except:
self.log_warning('unable to delete token')
log_traceback()
def mqtt_state_handler(self, data, topic, qos, retain):
try:
state = json.loads(data)
if state.get('RfReceived', {}).get('Data') == self.sensor_id:
with self.state_lock:
self.current_state = 1
self.state_set_time = time.time()
handle_phi_event(self, 1, self.get())
except:
log_traceback()
def get(self, port=None, cfg=None, timeout=0):
try:
result = requests.get('{}/lights/{}'.format(self.api_uri, port),
timeout=timeout).json()
if 'state' in result:
return 1 if result['state'].get('on') else 0
except:
self.log_error('unable to get state, port {}'.format(port))
log_traceback()
return None
def unload(self):
try:
result = requests.delete('{}/config/whitelist/{}'.format(
self.api_uri, self.user),
timeout=get_timeout()).json()
if 'success' not in result[0]:
raise Exception
except:
self.log_warning('unable to delete user from the bridge')
log_traceback()
def get(self, port=None, cfg=None, timeout=0):
try:
if port:
tag, tp = self._parse_tag(port)
if not tp:
tp = cfg.get('type') if cfg else None
if tp == 'BOOL':
if tag.endswith(']'):
tag, bit = tag.rsplit('[', 1)
bit = bit[:-1]
else:
bit = '0'
args = self.bitman + [tag, bit, '--timeout', str(timeout)]
self.log_debug(f'executing {" ".join(args)}')
p = subprocess.run(args,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
if p.returncode != 0:
self.log_error(p.stderr)
else:
result = int(p.stdout)
if self._has_feature.value:
return 1, result
else:
return result
else:
ttg = [tag]
else:
ttg = self.tags
if not ttg:
return None
result = {}
data = self.proxy.operate('read', ttg)
for i, v in enumerate(data):
if v is not None:
values = []
for val in v if isinstance(v, list) else [v]:
try:
values.append(round(val, self.fp))
except:
values.append(val)
value = ','.join([str(val) for val in values])
result[ttg[i]] = str(value)
else:
self.log_error(f'Unable to read {ttg[i]}')
if not result:
return None
elif port:
return result[port]
else:
return result
except:
log_traceback()
return None
def test(self, cmd=None):
if cmd == 'self':
try:
if not os.path.isdir('/sys/bus/gpio'):
raise Exception('gpio bus not found')
else:
return 'OK'
except:
log_traceback()
return 'FAILED'
return {'-': 'only self test command available'}
def get(self, port=None, cfg=None, timeout=0):
data = self.get_cached_state()
if data is None:
try:
data = self.engine.get_current(timeout=timeout)
if not data: return None
self.set_cached_state(data)
except:
log_traceback()
return None
if port is None: return data
return data.get(port)
def test(self, cmd=None):
if cmd == 'module':
return 'default' if not netsnmp else 'netsnmp'
if cmd == 'self' and self.snmp_host is None: return 'OK'
if cmd == 'info' or cmd == 'self':
if netsnmp:
try:
sess = netsnmp.Session(
Version=2,
DestHost=self.snmp_host,
RemotePort=self.snmp_port,
Community=self.snmp_read_community,
Timeout=int(get_timeout() * 1000000),
Retries=self.snmp_tries - 1)
except:
log_traceback()
sess = None
if netsnmp:
try:
name = sess.get(netsnmp.VarList(self.oid_name))[0].decode()
except:
log_traceback()
name = None
else:
name = snmp.get(
self.oid_name,
self.snmp_host,
self.snmp_port,
self.snmp_read_community,
timeout=get_timeout(),
retries=self.snmp_tries - 1)
if not name: return 'FAILED'
if name and cmd == 'self': return 'OK'
if netsnmp:
try:
version = sess.get(netsnmp.VarList(
self.oid_version))[0].decode()
except:
version = None
else:
version = snmp.get(
self.oid_version,
self.snmp_host,
self.snmp_port,
self.snmp_read_community,
timeout=get_timeout())
if not version: return 'FAILED'
return '%s %s' % (name.strip(), version.strip())
return {
'info': 'returns relay ip module name and version',
'module': 'current SNMP module'
}
def push_state(self, payload):
try:
data = payload['data']
self.data['bat'] = int(data[4:8], 16) / 100
self.data['hum'] = int(data[12:14], 16) * 0.5
self.data['pres'] = int(data[18:22], 16) / 10
self.data['temp'] = int(data[26:30], 16) / 10
self.data['gas'] = int(data[34:38], 16) / 100
handle_phi_event(self, data=self.data)
return True
except:
log_traceback()
return False
def test(self, cmd=None):
if cmd in ['self', 'get']:
try:
u = self.api_uri
result = requests.get(u, timeout=get_timeout()).json()
if 'manufacturer' not in result:
raise Exception
return 'OK' if cmd == 'self' else result
except:
log_traceback()
return 'FAILED' if cmd == 'self' else None
else:
return {'get': 'get panel info'}
def start(self):
if self.ports:
ports = self.ports
if not isinstance(ports, list):
ports = [ports]
for p in ports:
try:
d = self.gpiozero.DigitalOutputDevice(int(p))
d.on()
self.devices.append(d)
except:
log_traceback()
self.log_error('can not power on gpio port %s' % p)
def get(self, port=None, cfg=None, timeout=0):
mb = modbus.get_port(self.modbus_port, timeout)
if not mb: return None
try:
rr = mb.read_input_registers(30014, 2, unit=self.addr)
mb.release()
if rr.isError():
self.log_debug(rr)
return None
return {'l': rr.registers[0] * 65536 + rr.registers[1]}
except:
log_traceback()
return None
def set(self, port=None, data=None, cfg=None, timeout=0):
time_start = time()
if cfg:
addr = cfg.get('addr')
if addr is None: addr = self.addr
else: addr = self.addr
if addr is None:
self.log_error('1-Wire addr not specified')
return False
if not lock('w1:' + addr):
self.log_error('can not acquire lock')
return False
try:
if isinstance(port, list):
_port = port
_data = data
else:
_port = [port]
_data = [data]
r = self.safe_read(addr)
if r is None:
raise Exception('1-Wire get error')
for i in range(0, len(_port)):
_p = int(_port[i])
_d = int(_data[i])
if _p < 1 or _p > 8:
raise Exception('port is not in range 1..8')
if _d < 0 or _d > 1:
raise Exception('data is not in range 0..1')
if _d: r = 1 << (_p - 1) ^ 0xFF & r
else: r = r | 1 << (_p - 1)
if time_start + timeout <= time():
raise Exception('1-Wire timeout')
for i in range(self.retries + 1):
try:
open('%s/%s/output' % (self.w1, addr), 'wb').write(
bytes([r]))
sleep(w1_delay)
rn = self.safe_read(addr)
except:
rn = None
if r == rn: break
if i == self.retries: raise Exception('1-Wire set error')
if time_start + timeout <= time():
raise Exception('1-Wire timeout')
unlock('w1:' + addr)
return True
except:
unlock('w1:' + addr)
log_traceback()
return False
def test(self, cmd=None):
if cmd == 'self':
try:
if os.path.isdir('/sys/bus/gpio'):
return 'OK'
else:
raise Exception('gpio bus not found')
except:
log_traceback()
return 'FAILED'
elif cmd == 'get':
return self.get(timeout=get_timeout())
else:
return {'get', 'Return current sensor state'}
def push_state(self, payload):
if payload == 'test':
return True
else:
for port, v in payload.items():
try:
if port in self.data:
self.data[port] = v
else:
raise LookupError(f'Port {port} not found')
except:
log_traceback()
return False
return True
def get(self, port=None, cfg=None, timeout=0):
mb = modbus.get_port(self.modbus_port, timeout)
if not mb: return None
try:
rr = mb.read_input_registers(30002, 2, unit=self.addr)
mb.release()
if rr.isError():
self.log_debug(rr)
return None
temp = rr.registers[0]
if temp > 32767: temp = temp - 65536
return {'t': temp / 100, 'h': rr.registers[1] / 100}
except:
log_traceback()
return None
def get(self, port=None, cfg=None, timeout=0):
if port is None: return None
for i in range(self.retries + 1):
try:
r = open('%s/%s/w1_slave' % (self.w1, port)).readlines()
if r[0].strip()[-3:] != 'YES': return None
d, val = r[1].strip().split('=')
val = float(val) / 1000
return val
except:
if i == self.retries:
log_traceback()
else:
sleep(w1_delay)
return None
def set(self, port=None, data=None, cfg=None, timeout=0):
try:
ops = []
bitman_ops = []
for p, v in zip(port if isinstance(port, list) else [port],
data if isinstance(data, list) else [data]):
tp = cfg.get('type') if cfg else None
if not tp:
tp = self.tag_types.get(p)
if tp == 'BOOL':
if p.endswith(']'):
tag, bit = p.rsplit('[', 1)
bit = bit[:-1]
else:
tag = p
bit = '0'
val = v[1] if isinstance(v, tuple) or isinstance(
v, list) else v
bitman_ops.append([tag, bit, str(val)])
else:
op = f'{port}='
if tp:
op += f'({tp.upper()})'
op += str(v[1]) if isinstance(v, tuple) or isinstance(
v, list) else str(v)
ops.append(op)
success = True
if ops:
self.log_debug(f'EnIP OP {" ".join(ops)}')
result = self.proxy.operate('write', ops)
for op, r in zip(ops, result):
if r is not True:
self.log_error(f'tag set {op} error')
success = False
if bitman_ops:
for op in bitman_ops:
args = self.bitman + op + ['--timeout', str(timeout)]
self.log_debug(f'executing {" ".join(args)}')
p = subprocess.run(args,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
if p.returncode != 0:
self.log_error(p.stderr)
success = False
return success
except:
log_traceback()
return False
def test(self, cmd=None):
if cmd in ['self', 'get', 'new']:
c = 'lights'
if cmd == 'new':
c = 'lights/new'
try:
result = requests.get('{}/{}'.format(self.api_uri, c),
timeout=get_timeout()).json()
if isinstance(result, list):
raise Exception
return 'OK' if cmd == 'self' else result
except:
log_traceback()
return 'FAILED' if cmd == 'self' else None
else:
return {'get': 'get state of all lights', 'new': 'get new lights'}
def get(self, port=None, cfg=None, timeout=0):
mb = modbus.get_port(self.modbus_port, timeout)
if not mb: return None
try:
rr = mb.read_holding_registers(3000, 2, unit=self.unit_id)
mb.release()
if rr.isError():
self.log_debug(rr)
return None
val = struct.unpack(
'f',
struct.pack('H', rr.registers[0]) +
struct.pack('H', rr.registers[1]))[0]
return (1, '{:.2f}'.format(val)) if val > 0 else 0
except:
log_traceback()
return None
