async def test_id(args):
try:
serial_port = args["port"]
if serial_port is None:
serial_port = '/dev/ttyUSB0'
baud_rate = args["baud"]
if baud_rate:
baud_rate = int(baud_rate)
else:
baud_rate = 115200
reader, writer = await asyncio.wait_for(
serial_asyncio.open_serial_connection(url=serial_port,
baudrate=baud_rate), 1)
test = avalon.Transport(reader=reader, writer=writer)
test.start_reader_task()
test.transaction_channel_read(
0x60,
channel_number=0,
burst_length=4,
transaction=avalon.AvalonBus.READ_NON_INCREMENTING)
await asyncio.sleep(1)
test.close()
writer.close()
test = None
return True, ""
except Exception as local_ex:
return False, str(local_ex)
async def start(args):
try:
serial_port = args["port"]
if serial_port is None:
serial_port = '/dev/ttyUSB0'
baud_rate = args["baud"]
if baud_rate:
baud_rate = int(baud_rate)
else:
baud_rate = 115200
reader, writer = await asyncio.wait_for(
serial_asyncio.open_serial_connection(url=serial_port,
baudrate=baud_rate), 1)
test = avalon.Transport(reader=reader, writer=writer)
test.start_reader_task()
led_value = 0xFFFFFF | (0x1F << 24)
data = bytearray()
x_bytes = led_value.to_bytes(int(math.ceil(led_value.bit_length() /
8)),
byteorder='little')
data.extend(x_bytes)
test.transaction_channel_write(0,
data,
transaction=avalon.AvalonBus.LOOP_BACK,
length=0x5A)
await asyncio.sleep(1)
test.close()
test = None
return True, ""
except Exception as local_ex:
return False, str(local_ex)
def serial_read(self, device, rate, **kwargs):
"""Read the data from the port."""
import serial_asyncio
_LOGGER.info('Opening Serial Port')
reader, _ = yield from serial_asyncio.open_serial_connection(url=device, baudrate=rate, **kwargs)
_LOGGER.info('Opened Serial Port')
while True:
line = yield from reader.readline()
_LOGGER.info('Data read: %s', line)
line = line.decode('utf-8').strip()
_LOGGER.debug('Decoded Data: %s', line)
try:
if line[1] == 'Z':
_LOGGER.debug('Zone Info Found')
zone = line[2:5]
zone = zone.lstrip('0')
state = line[5]
_LOGGER.info('Signalled Zone: %s', zone)
_LOGGER.info('Zone State: %s', state)
self._alarmState[zone] = state
callback_zone_state_change(self._alarmState)
except IndexError:
_LOGGER.error('Index error malformed string recived')
async def led_test(args):
try:
serial_port = args["port"]
if serial_port is None:
serial_port = '/dev/ttyUSB0'
baud_rate = 115200
reader, writer = await asyncio.wait_for(
serial_asyncio.open_serial_connection(url=serial_port,
baudrate=baud_rate), 1)
test = avalon.Transport(reader=reader, writer=writer)
test.start_reader_task()
led_value = 0x01
data = bytearray(4)
for i in range(0, 0x100):
data[0] = i
logging.debug("length of data {}".format(len(data)))
test.transaction_channel_write(
0x0,
channel_number=0,
data_buffer=data,
transaction=avalon.AvalonBus.WRITE_NON_INCREMENTING)
pkt = await test.rx_pktQueue.get()
test.close()
test = None
return True, ""
except Exception as local_ex:
return False, str(local_ex)
async def test_id(args):
try:
serial_port = args["port"]
if serial_port is None:
serial_port = '/dev/ttyUSB0'
baud_rate = 115200
reader, writer = await asyncio.wait_for(
serial_asyncio.open_serial_connection(url=serial_port,
baudrate=baud_rate), 1)
test = avalon.Transport(reader=reader, writer=writer)
test.start_reader_task()
test.transaction_channel_read(
0x10,
channel_number=0,
burst_length=4,
transaction=avalon.AvalonBus.READ_NON_INCREMENTING)
pkt = await test.rx_pktQueue.get()
if len(pkt) is 4:
print("Array length {} 0x{:04x}".format(
len(pkt), int.from_bytes(pkt, byteorder='little')))
else:
print("Error")
test.close()
writer.close()
test = None
return True, ""
except Exception as local_ex:
return False, str(local_ex)
def serial_setup(loop, args):
if args.device != 'fake':
return serial_asyncio.open_serial_connection(loop=loop,
url=args.device,
baudrate=9600)
else:
return fake_serial.open_serial_connection()
def start_tasks(args):
loop = asyncio.get_event_loop()
queue = asyncio.Queue()
try:
reader, writer = loop.run_until_complete(
serial_asyncio.open_serial_connection(url=args.device,
baudrate=args.baudrate))
except:
logging.error("No device connected to {}".format(args.device))
return
serial_task = asyncio.ensure_future(run_serial_task(reader, queue))
server_func = functools.partial(run_network_task, reader, writer, queue)
server_task = asyncio.start_server(server_func, '0.0.0.0', args.port)
loop.run_until_complete(server_task)
try:
loop.run_until_complete(serial_task)
except:
pass
finally:
loop.run_until_complete(exit_app())
loop.stop()
loop.close()
def _connect(self):
self._reader, self._writer = yield from serial_asyncio.open_serial_connection(
loop=self._loop, url=self._port, baudrate=self._baudrate)
# Spawn coroutine for handling protocol messages.
ensure_future(self._handle_messages(), loop=self._loop)
self.send_status_request()
def read(self, queue):
"""
Read complete DSMR telegram's from the serial interface and parse it
into CosemObject's and MbusObject's.
Instead of being a generator, values are pushed to provided queue for
asynchronous processing.
:rtype: None
"""
# create Serial StreamReader
conn = serial_asyncio.open_serial_connection(**self.serial_settings)
reader, _ = yield from conn
while True:
# Read line if available or give control back to loop until new
# data has arrived.
data = yield from reader.readline()
self.telegram_buffer.append(data.decode('ascii'))
for telegram in self.telegram_buffer.get_all():
try:
# Push new parsed telegram onto queue.
queue.put_nowait(self.telegram_parser.parse(telegram))
except ParseError as e:
logger.warning('Failed to parse telegram: %s', e)
async def test_pwm(args):
try:
serial_port = args["port"]
if serial_port is None:
serial_port = '/dev/ttyUSB0'
baud_rate = args["baud"]
if baud_rate:
baud_rate = int(baud_rate)
else:
baud_rate = 115200
reader, writer = await asyncio.wait_for(
serial_asyncio.open_serial_connection(url=serial_port,
baudrate=baud_rate), 1)
test = avalon.Transport(reader=reader, writer=writer)
test.start_reader_task()
for x in range(1, 10000):
await asyncio.sleep(.250)
test.close()
writer.close()
test = None
return True, ""
except Exception as local_ex:
return False, str(local_ex)
async def start(args):
try:
serial_port = args["port"]
if serial_port is None:
serial_port = '/dev/ttyUSB0'
baud_rate = args["baud"]
if baud_rate:
baud_rate = int(baud_rate)
else:
baud_rate = 115200
reader, writer = await asyncio.wait_for(
serial_asyncio.open_serial_connection(url=serial_port,
baudrate=baud_rate), 1)
test = avalon.Transport(reader=reader, writer=writer)
test.start_reader_task()
data = bytearray()
test.transaction_channel_write(0,
data,
transaction=avalon.AvalonBus.LOOP_BACK,
length=0x5A)
await asyncio.sleep(1)
test.close()
test = None
return True, ""
except Exception as local_ex:
return False, str(local_ex)
async def connect(self):
log.debug('Connecting to "%s" with baudrate "%s"', self.device,
self.baudrate)
serial_kwargs = {'baudrate': self.baudrate, 'url': self.device}
coro = serial_asyncio.open_serial_connection(loop=self.loop,
**serial_kwargs)
self.reader, self.writer = await coro
self.transport = self.writer.transport
return self.reader, self.writer, self.transport
def serial_read(self, device, **kwargs):
"""Read the data from the port."""
import serial_asyncio
reader, _ = yield from serial_asyncio.open_serial_connection(
url=device, **kwargs)
while True:
line = yield from reader.readline()
self._state = line.decode('utf-8').strip()
self.async_schedule_update_ha_state()
async def pwm_id(args):
try:
serial_port = args["port"]
if serial_port is None:
serial_port = '/dev/ttyUSB0'
baud_rate = 115200
reader, writer = await asyncio.wait_for(
serial_asyncio.open_serial_connection(url=serial_port,
baudrate=baud_rate), 1)
test = avalon.Transport(reader=reader, writer=writer)
test.start_reader_task()
for i in range(0, 10):
test.transaction_channel_read(
0x20,
channel_number=0,
burst_length=4 * 6,
transaction=avalon.AvalonBus.READ_INCREMENTING)
pkt = await test.rx_pktQueue.get()
pwm_1 = int.from_bytes(pkt[0:4], byteorder='little', signed=False)
pwm_2 = int.from_bytes(pkt[4:8], byteorder='little', signed=False)
pwm_3 = int.from_bytes(pkt[8:12], byteorder='little', signed=False)
pwm_4 = int.from_bytes(pkt[12:16],
byteorder='little',
signed=False)
pwm_5 = int.from_bytes(pkt[16:20],
byteorder='little',
signed=False)
pwm_6 = int.from_bytes(pkt[20:], byteorder='little', signed=False)
print(
"pwm_1 0x{:08x} 0x{:08x} 0x{:08x} 0x{:08x} 0x{:08x} 0x{:08x}"
.format(pwm_1, pwm_2, pwm_3, pwm_4, pwm_5, pwm_6),
end='\r',
flush=True)
await asyncio.sleep(.1)
test.close()
writer.close()
test = None
return True, ""
except Exception as local_ex:
return False, str(local_ex)
async def SerialReader(loop):
global _reader, _writer
_reader, _writer = serial_asyncio.open_serial_connection(url=PORT,
baudrate=BAUDRATE,
loop=loop)
print("_reader", _reader)
print("_writer", _writer)
print(b'>*>p0x0800')
_writer.write(b'>*>p0x0800')
while True:
line = await _reader.readline()
print(len(line))
#line = line.decode("utf-8").strip()
#print(bytes(line, 'utf-8'))
for x in GlobalAPP['websockets']:
await x.send_str(line)
async def open(self):
if self.mode == CONNECTION_MODE.TCP:
pin = self.connection_kwargs.pop('pin', None)
if isinstance(self.target, (list, tuple)):
# make target be compatible with socket.__init__
target, port = self.target
else:
target, *port = self.target.split(':')
port = port and int(port[0]) or 1515
self.connection_kwargs.setdefault('port', port)
self.reader, self.writer = \
await wait_for(
asyncio.open_connection(target, **self.connection_kwargs),
self.connect_timeout, 'Connect timeout')
if self.verbose:
self.verbose('Connected')
if pin is not None:
try:
await self.start_tls(pin)
except Exception:
await self.close()
raise
else:
# Make this package optional
from serial_asyncio import open_serial_connection
self.reader, self.writer = \
await wait_for(
open_serial_connection(
url=self.target,
**self.connection_kwargs),
self.connect_timeout, 'Connect timeout')
if self.verbose:
self.verbose('Connected')
def serial_read(self, device, rate, **kwargs):
"""Read the data from the port."""
import serial_asyncio
reader, _ = yield from serial_asyncio.open_serial_connection(
url=device, baudrate=rate, **kwargs)
while True:
line = yield from reader.readline()
line = line.decode('utf-8').strip()
try:
data = json.loads(line)
if isinstance(data, dict):
self._attributes = data
except ValueError:
pass
if self._template is not None:
line = self._template.async_render_with_possible_json_value(
line)
self._state = line
self.async_schedule_update_ha_state()
def serial_read(self, device, rate, **kwargs):
"""Read the data from the port."""
import serial_asyncio
reader, _ = yield from serial_asyncio.open_serial_connection(
url=device, baudrate=rate, **kwargs)
while True:
line = yield from reader.readline()
line = line.decode('utf-8').strip()
try:
data = json.loads(line)
if isinstance(data, dict):
self._attributes = data
except ValueError:
pass
if self._template is not None:
line = self._template.async_render_with_possible_json_value(
line)
self._state = line
self.async_schedule_update_ha_state()
def read(self, queue):
"""
Read complete DSMR telegram's from the serial interface and parse it
into CosemObject's and MbusObject's.
Instead of being a generator, values are pushed to provided queue for
asynchronous processing.
:rtype Generator/Async
"""
# create Serial StreamReader
conn = serial_asyncio.open_serial_connection(**self.serial_settings)
reader, _ = yield from conn
telegram = []
while True:
# read line if available or give control back to loop until
# new data has arrived
line = yield from reader.readline()
line = line.decode('ascii')
# Telegrams need to be complete because the values belong to a
# particular reading and can also be related to eachother.
if not telegram and not is_start_of_telegram(line):
continue
telegram.append(line)
if is_end_of_telegram(line):
try:
parsed_telegram = self.telegram_parser.parse(telegram)
# push new parsed telegram onto queue
queue.put_nowait(parsed_telegram)
except ParseError:
logger.exception("failed to parse telegram")
telegram = []
def __readPacket(self, serialPort, baudrate, **kwargs):
"""Read the data from the serial port."""
serialReader, self.__serialWriter = yield from open_serial_connection(
url = serialPort,
baudrate = baudrate,
**kwargs
)
serialInitializedIsSet = False
while True:
readLine = yield from serialReader.readline()
asbPacketString = readLine.decode('UTF-8').strip()
decodedAsbPacket = decodeAsbPacket(asbPacketString)
## If the serial connection is ready, notify event once
if (serialInitializedIsSet == False):
_LOGGER.info("__readPacket(): The serial connection is ready.")
self.__hass.bus.async_fire(
EVENT_HOMEASSISTANT_ASYSBUS_SERIAL_READY
)
serialInitializedIsSet = True
if (decodedAsbPacket is not None):
_LOGGER.info("__readPacket(): Received a packet: %s",
decodedAsbPacket
)
try:
for device in self.__devices:
device.onPacketReceived(decodedAsbPacket)
except Exception as e:
_LOGGER.exception("__readPacket(): An exception is " + \
"occurred while notifying observing devices!"
)
async def test_ap102(args):
try:
serial_port = args["port"]
if serial_port is None:
serial_port = '/dev/ttyUSB0'
baud_rate = args["baud"]
if baud_rate:
baud_rate = int(baud_rate)
else:
baud_rate = 115200
reader, writer = await asyncio.wait_for(
serial_asyncio.open_serial_connection(url=serial_port,
baudrate=baud_rate), 1)
test = avalon.Transport(reader=reader, writer=writer)
test.start_reader_task()
data = bytearray()
blue = 0xff
green = 0xff
red = 0xff
high_range = 1
for index in range(0, high_range):
for x in range(0, 8):
led_value = set_led(0xF, blue=blue, green=green, red=red)
x_bytes = led_value.to_bytes(4, byteorder='little')
data.extend(x_bytes)
test.transaction_channel_write(
index,
channel_number=0,
data_buffer=data,
transaction=avalon.AvalonBus.WRITE_INCREMENTING)
logging.debug("index: " + str(index) + " " + str(index / 4 - 1))
await asyncio.sleep(.1)
data = bytearray()
led_enable = 1
x_bytes = led_enable.to_bytes(4, byteorder='little')
data.extend(x_bytes)
test.transaction_channel_write(
0,
channel_number=0,
data_buffer=data,
transaction=avalon.AvalonBus.WRITE_NON_INCREMENTING)
await asyncio.sleep(.250)
if index % 2:
blue = 0
green = 0
red = 0xff
else:
blue = 0xff
green = 0xff
red = 0xff
test.close()
writer.close()
test = None
return True, ""
except Exception as local_ex:
return False, str(local_ex)
async def test_led(args, loop):
try:
serial_port = args["port"]
if serial_port is None:
serial_port = '/dev/ttyUSB0'
baud_rate = args["baud"]
if baud_rate:
baud_rate = int(baud_rate)
else:
baud_rate = 115200
reader, writer = await asyncio.wait_for(
serial_asyncio.open_serial_connection(url=serial_port,
baudrate=baud_rate), 1)
test = avalon.Transport(reader=reader, writer=writer)
test.start_reader_task()
"""
for z in range (0, 10):
for x in range (0, 8):
data = bytearray()
led_value = (1 << x)
x_bytes= led_value.to_bytes(4, byteorder='little')
data.extend(x_bytes)
test.transaction_channel_write(0, channel_number=0, data_buffer=data, transaction=avalon.AvalonBus.WRITE_NON_INCREMENTING)
await asyncio.sleep(.01)
"""
data = bytearray()
test.transaction_channel_read(
0x60,
channel_number=0,
transaction=avalon.AvalonBus.READ_INCREMENTING)
await asyncio.sleep(1)
led_value = 0x00
x_bytes = led_value.to_bytes(4, byteorder='little')
data.extend(x_bytes)
test.transaction_channel_write(
0x050,
channel_number=0,
data_buffer=data,
transaction=avalon.AvalonBus.WRITE_NON_INCREMENTING)
led_index = 0
for y in range(0, 10000):
led_index += 1
if led_index is 8:
led_index = 0
for x in range(0, 8):
data = bytearray()
if x == led_index:
led_value = 0xFF00FF00
else:
led_value = 0xFF000000
x_bytes = led_value.to_bytes(4, byteorder='little')
data.extend(x_bytes)
test.transaction_channel_write(
0x0 + (x * 4),
channel_number=0,
data_buffer=data,
transaction=avalon.AvalonBus.WRITE_NON_INCREMENTING)
await asyncio.sleep(.1)
data = bytearray()
led_value = 0x00000000
x_bytes = led_value.to_bytes(4, byteorder='little')
data.extend(x_bytes)
test.transaction_channel_write(
0x0 + (8 * 4),
channel_number=0,
data_buffer=data,
transaction=avalon.AvalonBus.WRITE_NON_INCREMENTING)
await asyncio.sleep(.01)
test.close()
writer.abort()
writer.close()
test = None
loop.stop()
return True, ""
except Exception as local_ex:
loop.stop()
return False, str(local_ex)
