def mbus_probe_secondary_address(ser, mask):
# False -> Collison
# None -> No reply
# True -> Single reply
meterbus.send_select_frame(ser, mask)
try:
frame = meterbus.load(meterbus.recv_frame(ser, 1))
except meterbus.MBusFrameDecodeError as e:
frame = e.value
if isinstance(frame, meterbus.TelegramACK):
meterbus.send_request_frame(ser, meterbus.ADDRESS_NETWORK_LAYER)
time.sleep(0.5)
frame = None
try:
frame = meterbus.load(
meterbus.recv_frame(ser))
except meterbus.MBusFrameDecodeError:
pass
if isinstance(frame, meterbus.TelegramLong):
return True, frame.secondary_address, frame.manufacturer
return None, None, None
return frame, None, None
def mbus_probe_secondary_address(ser, mask):
# False -> Collison
# None -> No reply
# True -> Single reply
meterbus.send_select_frame(ser, mask)
try:
frame = meterbus.load(meterbus.recv_frame(ser, 1))
except meterbus.MBusFrameDecodeError as e:
frame = e.value
if isinstance(frame, meterbus.TelegramACK):
meterbus.send_request_frame(ser, meterbus.ADDRESS_NETWORK_LAYER)
time.sleep(0.5)
frame = None
try:
frame = meterbus.load(meterbus.recv_frame(ser))
except meterbus.MBusFrameDecodeError:
pass
if isinstance(frame, meterbus.TelegramLong):
return True, frame.secondary_address, frame.manufacturer
return None, None, None
return frame, None, None
def do_char_dev(self, **kwargs):
address = self.address
device = self.device
baudrate = self.baudrate
try:
address = int(address)
if not (0 <= address <= 254):
address = address
except ValueError:
address = address.upper()
try:
ibt = meterbus.inter_byte_timeout(baudrate)
with serial.serial_for_url(device,
baudrate,
8,
'E',
1,
inter_byte_timeout=ibt,
timeout=1) as ser:
frame = None
if meterbus.is_primary_address(address):
self.ping_address(ser, meterbus.ADDRESS_NETWORK_LAYER, 0)
meterbus.send_request_frame(ser, address)
frame = meterbus.load(
meterbus.recv_frame(ser, meterbus.FRAME_DATA_LENGTH))
elif meterbus.is_secondary_address(address):
meterbus.send_select_frame(ser, address)
try:
frame = meterbus.load(meterbus.recv_frame(ser, 1))
except meterbus.MBusFrameDecodeError as e:
frame = e.value
assert isinstance(frame, meterbus.TelegramACK)
frame = None
# ping_address(ser, meterbus.ADDRESS_NETWORK_LAYER, 0)
meterbus.send_request_frame(ser,
meterbus.ADDRESS_NETWORK_LAYER)
time.sleep(0.3)
frame = meterbus.load(
meterbus.recv_frame(ser, meterbus.FRAME_DATA_LENGTH))
if frame is not None:
#print(frame.to_JSON())
return frame.to_JSON()
except serial.serialutil.SerialException as e:
print(e)
def do_char_dev(args):
address = None
try:
address = int(args.address)
if not (0 <= address <= 254):
address = args.address
except ValueError:
address = args.address.upper()
try:
ibt = meterbus.inter_byte_timeout(args.baudrate)
with serial.serial_for_url(args.device,
args.baudrate, 8, 'E', 1,
inter_byte_timeout=ibt,
timeout=1) as ser:
frame = None
if meterbus.is_primary_address(address):
if ping_address(ser, address, args.retries, args.echofix):
meterbus.send_request_frame(ser, address, read_echo=args.echofix)
frame = meterbus.load(
meterbus.recv_frame(ser, meterbus.FRAME_DATA_LENGTH))
elif meterbus.is_secondary_address(address):
if ping_address(ser, meterbus.ADDRESS_NETWORK_LAYER, args.retries, args.echofix):
meterbus.send_select_frame(ser, address, args.echofix)
try:
frame = meterbus.load(meterbus.recv_frame(ser, 1))
except meterbus.MBusFrameDecodeError as e:
frame = e.value
# Ensure that the select frame request was handled by the slave
assert isinstance(frame, meterbus.TelegramACK)
frame = None
meterbus.send_request_frame(
ser, meterbus.ADDRESS_NETWORK_LAYER, read_echo=args.echofix)
time.sleep(0.3)
frame = meterbus.load(
meterbus.recv_frame(ser, meterbus.FRAME_DATA_LENGTH))
if frame is not None:
return frame
except serial.serialutil.SerialException as e:
print(e)
return None
def do_char_dev(args):
address = None
try:
address = int(args.address)
if not (0 <= address <= 254):
address = args.address
except ValueError:
address = args.address.upper()
try:
ibt = meterbus.inter_byte_timeout(args.baudrate)
with serial.serial_for_url(args.device,
args.baudrate, 8, 'E', 1,
inter_byte_timeout=ibt,
timeout=1) as ser:
frame = None
if meterbus.is_primary_address(address):
ping_address(ser, meterbus.ADDRESS_NETWORK_LAYER, 0)
meterbus.send_request_frame(ser, address)
frame = meterbus.load(
meterbus.recv_frame(ser, meterbus.FRAME_DATA_LENGTH))
elif meterbus.is_secondary_address(address):
meterbus.send_select_frame(ser, address)
try:
frame = meterbus.load(meterbus.recv_frame(ser, 1))
except meterbus.MBusFrameDecodeError as e:
frame = e.value
assert isinstance(frame, meterbus.TelegramACK)
frame = None
# ping_address(ser, meterbus.ADDRESS_NETWORK_LAYER, 0)
meterbus.send_request_frame(
ser, meterbus.ADDRESS_NETWORK_LAYER)
time.sleep(0.3)
frame = meterbus.load(
meterbus.recv_frame(ser, meterbus.FRAME_DATA_LENGTH))
if frame is not None:
print(frame.to_JSON())
except serial.serialutil.SerialException as e:
print(e)
def mbus_query():
ser = serial.Serial(serial_dev, baud_rate, 8, 'E', 1, 0.5)
try:
meterbus.send_ping_frame(ser, slave_address)
frame = meterbus.load(meterbus.recv_frame(ser, 1))
assert isinstance(frame, meterbus.TelegramACK)
meterbus.send_request_frame(ser, slave_address)
frame = meterbus.load(meterbus.recv_frame(ser, meterbus.FRAME_DATA_LENGTH))
assert isinstance(frame, meterbus.TelegramLong)
mbus_json = json.loads(frame.to_JSON())
manufacturer = mbus_json["body"]["header"]["manufacturer"]
client.publish(post_topic, "manufacturer " + manufacturer)
except:
log('Failed to read data from slave at address %d' % slave_address)
client.publish(post_topic, "failed")
def dvh5x_tarif(address, device, baudrate, tarif):
try:
ibt = meterbus.inter_byte_timeout(baudrate)
with serial.Serial(device,
baudrate,
parity=serial.PARITY_EVEN,
rtscts=False,
timeout=0.2) as ser:
frame = None
ping_address(ser, meterbus.ADDRESS_NETWORK_LAYER, 0)
if True:
ret = ping_address(ser, address, 5)
print("Ping status: %s " % ret)
time.sleep(0.1)
send_tarif_frame(ser, address, tarif)
frame = meterbus.load(meterbus.recv_frame(ser, 1))
assert isinstance(frame, meterbus.TelegramACK)
print("tarif set ok")
ser.close()
except serial.serialutil.SerialException as e:
ser.close()
print(e)
def dvh5x_read(address, device, baudrate):
try:
ibt = meterbus.inter_byte_timeout(baudrate)
with serial.Serial(device,
baudrate,
parity=serial.PARITY_EVEN,
rtscts=False,
timeout=0.2) as ser:
frame = None
ping_address(ser, meterbus.ADDRESS_NETWORK_LAYER, 0)
if True:
ret = ping_address(ser, address, 5)
print("Ping status: %s " % ret)
if ret:
check_reset(ret)
else:
ser.close()
check_reset(ret)
return
time.sleep(0.1)
send_mask_frame(ser, address)
frame = meterbus.load(meterbus.recv_frame(ser, 1))
assert isinstance(frame, meterbus.TelegramACK)
print("custom ok")
ping_address(ser, meterbus.ADDRESS_NETWORK_LAYER, 0)
meterbus.send_request_frame(ser, address)
recv = meterbus.recv_frame(ser, meterbus.FRAME_DATA_LENGTH)
# print("recv", recv)
frame = meterbus.load(recv)
ser.close()
return frame
if frame is not None:
print(frame.body.interpreted['records'][0]['value'])
ser.close()
except serial.serialutil.SerialException as e:
print("SerialException")
print(e)
def setG4modern(address):
meterbus.send_request_setLUG_G4_readout_control(ser, address, 0x00)
try:
frame = meterbus.load(meterbus.recv_frame(ser, 1))
if isinstance(frame, meterbus.TelegramACK):
return True
except meterbus.MBusFrameDecodeError:
pass
return False
def setG4fast(address, enable=True):
meterbus.send_request_setLUG_G4_fast_readout(ser, address, enable)
try:
frame = meterbus.load(meterbus.recv_frame(ser, 1))
if isinstance(frame, meterbus.TelegramACK):
return True
except meterbus.MBusFrameDecodeError:
pass
return False
def setPrimary(address, newAddress):
meterbus.send_request_setPrimary(ser, address, newAddress)
try:
frame = meterbus.load(meterbus.recv_frame(ser, 1))
if isinstance(frame, meterbus.TelegramACK):
return True
except meterbus.MBusFrameDecodeError:
pass
return False
def ping_address(ser, address, retries=5):
for i in range(0, retries + 1):
meterbus.send_ping_frame(ser, address)
try:
frame = meterbus.load(meterbus.recv_frame(ser, 1))
if isinstance(frame, meterbus.TelegramACK):
return True
except meterbus.MBusFrameDecodeError:
pass
return False
def ping_address(ser, address, retries=5):
for i in range(0, retries + 1):
meterbus.send_ping_frame(ser, address)
try:
frame = meterbus.load(meterbus.recv_frame(ser, 1))
if isinstance(frame, meterbus.TelegramACK):
return True
except meterbus.MBusFrameDecodeError:
pass
return False
def test_ping_frame(self):
self.reset()
meterbus.send_ping_frame(self.master, 0)
self.assertEqual(self.slave.read(5), b"\x10\x40\x00\x40\x16")
# Slave sends ACK reply
self.slave.write(b'\xE5')
frame_data = meterbus.recv_frame(self.master, 1)
frame = meterbus.load(frame_data)
self.assertIsInstance(frame, meterbus.TelegramACK)
def test_ping_frame(self):
self.reset()
meterbus.send_ping_frame(self.master, 0)
self.assertEqual(self.slave.read(5),
b"\x10\x40\x00\x40\x16")
# Slave sends ACK reply
self.slave.write(b'\xE5')
frame_data = meterbus.recv_frame(self.master, 1)
frame = meterbus.load(frame_data)
self.assertIsInstance(frame, meterbus.TelegramACK)
def ping_address(ser, address, retries=5, read_echo=False):
for i in range(0, retries + 1):
meterbus.send_ping_frame(ser, address, read_echo)
try:
frame = meterbus.load(meterbus.recv_frame(ser, 1))
if isinstance(frame, meterbus.TelegramACK):
return True
except meterbus.MBusFrameDecodeError as e:
pass
time.sleep(0.5)
return False
def test_empty_reply(self):
self.reset()
meterbus.send_ping_frame(self.master, 0)
self.assertEqual(self.slave.read(5), b"\x10\x40\x00\x40\x16")
# Slave does not send anything
frame_data = meterbus.recv_frame(self.master, 1)
try:
frame = meterbus.load(frame_data)
except MBusFrameDecodeError as e:
frame = e.value
self.assertEqual(frame, None)
def test_send_select_frame(self):
self.reset()
meterbus.send_select_frame(self.master, "00000001DADAFA1B")
reply = (b"\x68\x0b\x0b\x68\x73\xfd\x52\x01\x00"
b"\x00\x00\xda\xda\xfa\x1b\x8c\x16")
self.assertEqual(self.slave.read(len(reply)), reply)
# Slave sends ACK reply
self.slave.write(b'\xE5')
frame_data = meterbus.recv_frame(self.master, 1)
frame = meterbus.load(frame_data)
self.assertIsInstance(frame, meterbus.TelegramACK)
def test_send_select_frame(self):
self.reset()
meterbus.send_select_frame(self.master,
"00000001DADAFA1B")
reply = (b"\x68\x0b\x0b\x68\x73\xfd\x52\x01\x00"
b"\x00\x00\xda\xda\xfa\x1b\x8c\x16")
self.assertEqual(self.slave.read(len(reply)), reply)
# Slave sends ACK reply
self.slave.write(b'\xE5')
frame_data = meterbus.recv_frame(self.master, 1)
frame = meterbus.load(frame_data)
self.assertIsInstance(frame, meterbus.TelegramACK)
def test_empty_reply(self):
self.reset()
meterbus.send_ping_frame(self.master,
0)
self.assertEqual(self.slave.read(5),
b"\x10\x40\x00\x40\x16")
# Slave does not send anything
frame_data = meterbus.recv_frame(self.master, 1)
try:
frame = meterbus.load(frame_data)
except MBusFrameDecodeError as e:
frame = e.value
self.assertEqual(frame, None)
def test_crc_error_frame(self):
self.reset()
self.slave.write(self.crcerror_frame)
frame = meterbus.recv_frame(self.master)
self.assertEqual(frame, False)
def test_read_partial_frame(self):
self.reset()
self.slave.write(self.partial_frame)
frame = meterbus.recv_frame(self.master)
self.assertEqual(frame, False)
def serial_request_multi():
parser = argparse.ArgumentParser(
description='Request data over serial M-Bus for devices.')
parser.add_argument('-d', action='store_true',
help='Enable verbose debug')
parser.add_argument('-b', '--baudrate',
type=int, default=2400,
help='Serial bus baudrate')
parser.add_argument('-a', '--address',
type=str, default=meterbus.ADDRESS_BROADCAST_REPLY,
help='Primary or secondary address')
parser.add_argument('-r', '--retries',
type=int, default=5,
help='Number of ping retries for each address')
parser.add_argument('-o', '--output', default="json",
help='Output format')
parser.add_argument('--echofix', action='store_true',
help='Read and ignore echoed data from target')
parser.add_argument('device', type=str, help='Serial device or URI')
args = parser.parse_args()
meterbus.debug(args.d)
address = args.address
try:
if 0 <= int(args.address) <= 254:
address = int(args.address)
except ValueError:
pass
try:
ibt = meterbus.inter_byte_timeout(args.baudrate)
with serial.serial_for_url(args.device,
args.baudrate, 8, 'E', 1,
inter_byte_timeout=ibt,
timeout=1) as ser:
frame = None
if meterbus.is_primary_address(address):
if False is ping_address(ser, address, args.retries):
sys.exit(1)
meterbus.send_request_frame_multi(ser, address, read_echo=args.echofix)
frame = meterbus.load(
meterbus.recv_frame(ser))
elif meterbus.is_secondary_address(address):
if False is ping_address(ser,
meterbus.ADDRESS_NETWORK_LAYER, args.retries, args.echofix):
ping_address(ser, meterbus.ADDRESS_BROADCAST_NOREPLY, args.retries, args.echofix)
meterbus.send_select_frame(ser, address, read_echo=args.echofix)
frame = meterbus.load(meterbus.recv_frame(ser, 1))
# Ensure that the select frame request was handled by the slave
assert isinstance(frame, meterbus.TelegramACK)
req = meterbus.send_request_frame_multi(
ser, meterbus.ADDRESS_NETWORK_LAYER, read_echo=args.echofix)
try:
frame = meterbus.load(meterbus.recv_frame(ser))
except meterbus.MBusFrameDecodeError:
frame = None
while frame and frame.more_records_follow:
# toogle FCB on and off
req.header.cField.parts[0] ^= meterbus.CONTROL_MASK_FCB
req = meterbus.send_request_frame_multi(
ser, meterbus.ADDRESS_NETWORK_LAYER, req, read_echo=args.echofix)
next_frame = meterbus.load(meterbus.recv_frame(ser))
frame += next_frame
if frame is not None:
print(serialize_frame(frame, args.output))
except serial.serialutil.SerialException as e:
print(e)
def test_crc_error_frame(self):
self.reset()
self.slave.write(self.crcerror_frame)
frame = meterbus.recv_frame(self.master)
self.assertEqual(frame, False)
8,
'E',
1,
inter_byte_timeout=ibt,
timeout=1) as ser:
frame = None
if meterbus.is_primary_address(address):
if False == ping_address(ser, address, args.retries,
args.echofix):
sys.exit(1)
meterbus.send_request_frame_multi(ser,
address,
read_echo=args.echofix)
frame = meterbus.load(meterbus.recv_frame(ser))
elif meterbus.is_secondary_address(address):
if False == ping_address(ser, meterbus.ADDRESS_NETWORK_LAYER,
args.retries, args.echofix):
ping_address(ser, meterbus.ADDRESS_BROADCAST_NOREPLY,
args.retries, args.echofix)
meterbus.send_select_frame(ser, address, args.echofix)
frame = meterbus.load(meterbus.recv_frame(ser, 1))
assert isinstance(frame, meterbus.TelegramACK)
req = meterbus.send_request_frame_multi(
ser,
meterbus.ADDRESS_NETWORK_LAYER,
read_echo=args.echofix)
def do_char_dev(args):
address = None
try:
address = int(args.address)
if not (0 <= address <= 254):
address = args.address
except ValueError:
address = args.address.upper()
try:
ibt = meterbus.inter_byte_timeout(args.baudrate)
with serial.serial_for_url(args.device,
args.baudrate,
8,
'E',
1,
inter_byte_timeout=ibt,
timeout=1) as ser:
frame = None
result = None
if meterbus.is_primary_address(address):
if ping_address(ser, address, args.retries, args.echofix):
meterbus.send_request_frame(ser,
address,
read_echo=args.echofix)
frame = meterbus.load(
meterbus.recv_frame(ser, meterbus.FRAME_DATA_LENGTH))
else:
print("no reply")
elif meterbus.is_secondary_address(address):
if ping_address(ser, meterbus.ADDRESS_NETWORK_LAYER,
args.retries, args.echofix):
meterbus.send_select_frame(ser, address, args.echofix)
try:
frame = meterbus.load(meterbus.recv_frame(ser, 1))
except meterbus.MBusFrameDecodeError as e:
frame = e.value
# Ensure that the select frame request was handled by the slave
assert isinstance(frame, meterbus.TelegramACK)
frame = None
meterbus.send_request_frame(ser,
meterbus.ADDRESS_NETWORK_LAYER,
read_echo=args.echofix)
time.sleep(0.3)
frame = meterbus.load(
meterbus.recv_frame(ser, meterbus.FRAME_DATA_LENGTH))
else:
print("no reply")
if frame is not None and args.output != 'dump':
recs = []
for rec in frame.records:
recs.append({'value': rec.value, 'unit': rec.unit})
ydata = {
'manufacturer':
frame.body.bodyHeader.manufacturer_field.
decodeManufacturer,
'identification':
''.join(map('{:02x}'.format, frame.body.bodyHeader.id_nr)),
'access_no':
frame.body.bodyHeader.acc_nr_field.parts[0],
'medium':
frame.body.bodyHeader.measure_medium_field.parts[0],
'records':
recs
}
if args.output == 'json':
result = json.dumps(ydata, indent=4, sort_keys=True)
print(json.dumps(ydata, indent=4, sort_keys=True))
elif args.output == 'yaml':
def float_representer(dumper, value):
if int(value) == value:
text = '{0:.4f}'.format(value).rstrip('0').rstrip(
'.')
return dumper.represent_scalar(
u'tag:yaml.org,2002:int', text)
else:
text = '{0:.4f}'.format(value).rstrip('0').rstrip(
'.')
return dumper.represent_scalar(
u'tag:yaml.org,2002:float', text)
# Handle float and Decimal representation
yaml.add_representer(float, float_representer)
yaml.add_representer(Decimal, float_representer)
result = yaml.dump(ydata,
default_flow_style=False,
allow_unicode=True,
encoding=None)
print(
yaml.dump(ydata,
default_flow_style=False,
allow_unicode=True,
encoding=None))
elif frame is not None:
result = frame.to_JSON()
print(frame.to_JSON())
return result
except serial.serialutil.SerialException as e:
print(e)
def do_char_dev(args):
address = None
try:
address = int(args.address)
if not (0 <= address <= 254):
address = args.address
except ValueError:
address = args.address.upper()
try:
#vib_to_show = ['14:0','59:1','59:0','89:0', '93:0', '255.34:0']
#vib_to_show = ['14:0','59:0','89:0', '93:0']
filter = {
((14, ), 0, 0): "one",
#((14,), 0, 1): "one_b",
((59, ), 0, 0): "FLOW",
((62, ), 0, 0): "FLOW",
((89, ), 0, 0): "FLOW_TEMPERATURE",
((91, ), 0, 0): "FLOW_TEMPERATURE",
((93, ), 0, 0): "RETURN_TEMPERATURE",
((95, ), 0, 0): "RETURN_TEMPERATURE",
((255, 34), 0, 0): "five",
((90, ), 0, 0): "FLOW_TEMPERATURE",
((94, ), 0, 0): "RETURN_TEMPERATURE",
}
ibt = meterbus.inter_byte_timeout(args.baudrate)
parity = 'E'
if args.monitor: parity = 'N'
with serial.serial_for_url(args.device,
args.baudrate,
8,
parity,
1,
inter_byte_timeout=ibt,
timeout=1) as ser:
if meterbus.is_primary_address(address):
if not args.monitor:
ping_address(ser, address, 0)
#ping_address(ser, meterbus.ADDRESS_NETWORK_LAYER, 0)
#setG4modern(ser, address)
#print("Landis+Gyr needs time")
#time.sleep(4)
#print("done")
t_start = time.time() - 3
try:
#ser.read(1)
while True:
time.sleep(0.1)
if not args.monitor:
if (time.time() - t_start) <= int(args.sleep):
continue
t_start = time.time()
meterbus.send_request_frame(ser, address)
time.sleep(0.2)
frame = None
#print(ser.inWaiting(), end = ' ')
if ser.inWaiting(): # >= 205:
#ser.read()
framedata = meterbus.recv_frame(
ser, meterbus.FRAME_DATA_LENGTH)
print("frame: ", framedata)
if framedata:
frame = meterbus.load(framedata)
if not frame:
continue
records = frame.body.bodyPayload.records
filtered = {
"ts": '{:10.0f}'.format(time.time()),
"records": [],
"framedata": framedata.hex(),
}
for record in records:
vib = tuple(record.vib.parts)
func = record.dib.function_type.value
storage_number = record.dib.storage_number
key = (vib, func, storage_number)
if key in filter:
#name = filter.get(key,"value")
filtered['records'].append(record.interpreted)
# print(name)
#record = records[vib]
#print('{:10},{:30}:{}'.format(vib, record['type'], record['value']))
# value = record.value
# if type(value) is int:
# print(' {:8} '.format(value), end='')
# else:
# print(' {:10.8} '.format(value), end='')
#print()
import simplejson as json
print(
json.dumps(filtered,
sort_keys=True,
indent=4,
use_decimal=True))
except KeyboardInterrupt:
pass
elif meterbus.is_secondary_address(address):
meterbus.send_select_frame(ser, address)
try:
frame = meterbus.load(meterbus.recv_frame(ser, 1))
except meterbus.MBusFrameDecodeError as e:
frame = e.value
assert isinstance(frame, meterbus.TelegramACK)
frame = None
# ping_address(ser, meterbus.ADDRESS_NETWORK_LAYER, 0)
meterbus.send_request_frame(ser,
meterbus.ADDRESS_NETWORK_LAYER)
time.sleep(0.3)
frame = meterbus.load(
meterbus.recv_frame(ser, meterbus.FRAME_DATA_LENGTH))
if frame is not None:
print(frame.to_JSON())
except serial.serialutil.SerialException as e:
print(e)
try:
ibt = meterbus.inter_byte_timeout(args.baudrate)
with serial.serial_for_url(args.device,
args.baudrate, 8, 'E', 1,
inter_byte_timeout=ibt,
timeout=1) as ser:
frame = None
if meterbus.is_primary_address(address):
if False == ping_address(ser, address, 0):
sys.exit(1)
meterbus.send_request_frame_multi(ser, address)
frame = meterbus.load(
meterbus.recv_frame(ser))
elif meterbus.is_secondary_address(address):
if False == ping_address(ser, meterbus.ADDRESS_NETWORK_LAYER, 0):
ping_address(ser, meterbus.ADDRESS_BROADCAST_NOREPLY, 0)
meterbus.send_select_frame(ser, address)
frame = meterbus.load(meterbus.recv_frame(ser, 1))
assert isinstance(frame, meterbus.TelegramACK)
req = meterbus.send_request_frame_multi(
ser, meterbus.ADDRESS_NETWORK_LAYER)
try:
frame = meterbus.load(meterbus.recv_frame(ser))
except meterbus.MBusFrameDecodeError:
#sendlab.username_pw_set("server", password="******")
sendlab.username_pw_set("node", password="******")
sendlab.connect("sendlab.nl", 11884, 60)
print("Sending Init message")
sendlab.publish("node/init", json.dumps(sensorInit))
timestamp = datetime.now()
while(1):
sendlab.loop()
timediff = datetime.now() - timestamp
if (timediff.seconds > 10):
try:
meterbus.send_ping_frame(ser, slave_address)
frame = meterbus.load(meterbus.recv_frame(ser, 1))
assert isinstance(frame, meterbus.TelegramACK)
meterbus.send_request_frame(ser, slave_address)
frame = meterbus.load(meterbus.recv_frame(ser, meterbus.FRAME_DATA_LENGTH))
assert isinstance(frame, meterbus.TelegramLong)
obj = json.loads(frame.to_JSON())
records = obj["body"]["records"]
data = {
"id": sensorId,
"timestamp": get_time_stamp(records),
"measurements": [{
"timestamp": get_time_stamp(records),
"heat_energy": float(records[0]["value"]),
"cool_energy": float(records[1]["value"]),
"energy_E8": float(records[2]["value"]),
"vol_d1_t0": float(records[3]["value"]),
def test_read_partial_frame(self):
self.reset()
self.slave.write(self.partial_frame)
frame = meterbus.recv_frame(self.master)
self.assertEqual(frame, False)
