def test_asyncio(self):
TEXT = b'hello world\n'
received = []
actions = []
class Output(asyncio.Protocol):
def connection_made(self, transport):
self.transport = transport
actions.append('open')
transport.serial.rts = False
transport.write(TEXT)
def data_received(self, data):
#~ print('data received', repr(data))
received.append(data)
if b'\n' in data:
self.transport.close()
def connection_lost(self, exc):
actions.append('close')
asyncio.get_event_loop().stop()
def pause_writing(self):
actions.append('pause')
print(self.transport.get_write_buffer_size())
def resume_writing(self):
actions.append('resume')
print(self.transport.get_write_buffer_size())
coro = serial_asyncio.create_serial_connection(self.loop, Output, PORT, baudrate=115200)
self.loop.run_until_complete(coro)
self.loop.run_forever()
self.assertEqual(b''.join(received), TEXT)
self.assertEqual(actions, ['open', 'close'])
def open(port):
global transport
loop = asyncio.get_event_loop()
reader = asyncio.StreamReader()
proto = asyncio.StreamReaderProtocol(reader)
transport, _ = yield from serial_asyncio.create_serial_connection(
loop, lambda: proto, url=port, baudrate=115200)
return transport
def test_asyncio(self):
TEXT = b'Hello, World!\n'
received = []
actions = []
class Input(asyncio.Protocol):
def __init__(self):
super().__init__()
self._transport = None
def connection_made(self, transport):
self._transport = transport
def data_received(self, data):
self._transport.write(data)
class Output(asyncio.Protocol):
def __init__(self):
super().__init__()
self._transport = None
def connection_made(self, transport):
self._transport = transport
actions.append('open')
transport.write(TEXT)
def data_received(self, data):
received.append(data)
if b'\n' in data:
self._transport.close()
def connection_lost(self, exc):
actions.append('close')
self._transport.loop.stop()
def pause_writing(self):
actions.append('pause')
print(self._transport.get_write_buffer_size())
def resume_writing(self):
actions.append('resume')
print(self._transport.get_write_buffer_size())
if PORT.startswith('socket://'):
coro = self.loop.create_server(Input, HOST, _PORT)
self.loop.run_until_complete(coro)
client = serial_asyncio.create_serial_connection(self.loop, Output, PORT)
self.loop.run_until_complete(client)
self.loop.run_forever()
self.assertEqual(b''.join(received), TEXT)
self.assertEqual(actions, ['open', 'close'])
def main():
application = tornado.web.Application([
(r'/ws', WSHandler),
(r"/static/(.*)", tornado.web.StaticFileHandler, dict(path=SCRIPT_PATH)),
(r'/(.*)', MainHandler),
])
tornado.platform.asyncio.AsyncIOMainLoop().install()
loop = asyncio.get_event_loop()
config = json.load(open(os.path.join(SCRIPT_PATH, 'server.json')))
if 'serial' in config:
# TODO: Ugly fugly, please fix
Denon.connected = asyncio.Event(loop=loop)
asyncio.ensure_future(
serial_asyncio.create_serial_connection(
loop, Denon, config['serial'], baudrate=9600))
loop.run_until_complete(Denon.connected.wait())
denon = Denon.instance
mqtt_client = MQTTClient(
denon, config['mqtt_host'], config['mqtt_user'], config['mqtt_pass'])
loop.run_until_complete(mqtt_client.start())
else:
denon = MQTTDenon(config['mqtt_host'], config['mqtt_user'], config['mqtt_pass'])
MainHandler.denon = denon
MainHandler.config = config
loop.run_until_complete(denon.start())
loop.run_until_complete(denon.request_status())
http_server = tornado.httpserver.HTTPServer(application)
if 'http_addr' in config:
http_server.listen(config['http_port'], address=config['http_addr'])
else:
http_server.listen(config['http_port'])
try:
loop.run_forever()
except KeyboardInterrupt:
pass
print("Stopping")
loop.run_until_complete(denon.stop())
if 'serial' in config:
loop.run_until_complete(mqtt_client.stop())
loop.stop()
def connect(self):
"""
Connect Async client
:return:
"""
_logger.debug('Connecting.')
try:
from serial_asyncio import create_serial_connection
yield from create_serial_connection(
self.loop, self._create_protocol, self.port, baudrate=self.baudrate,
bytesize=self.bytesize, stopbits=self.stopbits
)
yield from self._connected_event.wait()
_logger.info('Connected to %s', self.port)
except Exception as ex:
_logger.warning('Failed to connect: %s', ex)
for avatar_conf in conf['avatars']:
name = avatar_conf['name']
if name in avatars:
raise Error('Cannot have two Avatars with the same name: ' +
str(avatar_conf['name']))
callbacks = []
callbacks.append(
lambda x: log.debug("Status from[%s]: %s", name, repr(x)))
callbacks.append(
lambda x: datawriter.writerow(status_to_list(name, x)))
callbacks.append(functools.partial(fastrack_emitter.emit, name))
avatar_obj = avatar.AvatarProtocol(name, callbacks)
avatar_coro = serial_asyncio.create_serial_connection(
loop, lambda: avatar_obj, '/dev/ttyUSB0', baudrate=9600)
avatar_task = loop.run_until_complete(avatar_coro)
avatars[name] = avatar_obj
# Create web server.
web_handler = web.WabatarServer(avatars).new_handler()
web_task = loop.run_until_complete(
loop.create_server(web_handler, '0.0.0.0', 8080))
try:
loop.run_forever()
finally:
web_task.close()
loop.run_until_complete(fastrack_emitter.stop())
loop.run_until_complete(web_task.wait_closed())
def connection_lost(self, exc):
print('Writer closed')
async def send(self):
"""Send four newline-terminated messages, one byte at a time.
"""
message = b'foo\nbar\nbaz\nqux\n'
for b in message:
await asyncio.sleep(0.5)
self.transport.serial.write(bytes([b]))
print(f'Writer sent: {bytes([b])}')
self.transport.close()
loop = asyncio.get_event_loop()
reader = serial_asyncio.create_serial_connection(loop,
Reader,
'reader',
baudrate=115200)
writer = serial_asyncio.create_serial_connection(loop,
Writer,
'writer',
baudrate=115200)
asyncio.ensure_future(reader)
print('Reader scheduled')
asyncio.ensure_future(writer)
print('Writer scheduled')
loop.call_later(10, loop.stop)
loop.run_forever()
print('Done')
async def initLink(self, strconnection: str):
"""Try initialising a connection. returns True if connection
was successful, False otherwise"""
constr = strconnection.split(":")
newlink = None
try:
if constr[0] == "udpserver":
newlink = UDPConnection(rxcallback=self.incomingPacket,
clcallback=self.closelinkcallback,
dialect=self.dialect,
mavversion=self.mavversion,
server=True,
srcsystem=self.sourceSystem,
srccomp=self.sourceComponent,
name=strconnection)
trans = self.loop.create_datagram_endpoint(
lambda: newlink, local_addr=(constr[1], constr[2]))
await asyncio.wait_for(trans, timeout=0.2)
elif constr[0] == "udpclient":
newlink = UDPConnection(rxcallback=self.incomingPacket,
clcallback=self.closelinkcallback,
dialect=self.dialect,
mavversion=self.mavversion,
server=False,
srcsystem=self.sourceSystem,
srccomp=self.sourceComponent,
name=strconnection)
trans = self.loop.create_datagram_endpoint(
lambda: newlink, remote_addr=(constr[1], constr[2]))
await asyncio.wait_for(trans, timeout=0.2)
elif constr[0] == "serial":
newlink = SerialConnection(rxcallback=self.incomingPacket,
clcallback=self.closelinkcallback,
dialect=self.dialect,
mavversion=self.mavversion,
srcsystem=self.sourceSystem,
srccomp=self.sourceComponent,
name=strconnection)
trans = serial_asyncio.create_serial_connection(self.loop, lambda: newlink,
constr[1], int(constr[2]))
await asyncio.wait_for(trans, timeout=0.2)
elif constr[0] == "tcpclient":
newlink = TCPConnection(rxcallback=self.incomingPacket,
clcallback=self.closelinkcallback,
dialect=self.dialect,
mavversion=self.mavversion,
server=False,
srcsystem=self.sourceSystem,
srccomp=self.sourceComponent,
name=strconnection)
trans = self.loop.create_connection(
lambda: newlink, constr[1], int(constr[2]))
await asyncio.wait_for(trans, timeout=0.2)
elif constr[0] == "tcpserver":
newlink = TCPConnection(rxcallback=self.incomingPacket,
clcallback=self.closelinkcallback,
dialect=self.dialect,
mavversion=self.mavversion,
server=True,
srcsystem=self.sourceSystem,
srccomp=self.sourceComponent,
name=strconnection)
await self.loop.create_server(lambda: newlink, constr[1], int(constr[2]))
else:
logging.debug("Bad link type: %s", constr)
return False
# ok, we've got a link
self.linkdict[strconnection] = newlink
logging.debug("Added link - %s", strconnection)
return True
except(OSError, asyncio.TimeoutError):
logging.debug("Can't connect - %s", strconnection)
self.linkdict[strconnection] = None
return False
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
import asyncio
import logging
import serial_asyncio
from pyduofern.duofern_stick import DuofernStickAsync
logging.basicConfig(level=logging.DEBUG)
loop = asyncio.get_event_loop()
coro = serial_asyncio.create_serial_connection(loop,
lambda: DuofernStickAsync(loop),
'/dev/ttyUSB0',
baudrate=115200)
f, proto = loop.run_until_complete(coro)
# proto.handshake()
initialization = asyncio. async (proto.handshake())
asyncio.wait(initialization)
def cb(a):
logging.info(a)
asyncio. async (proto.command("409882", "position", 10))
proto.available.add_done_callback(cb)
print(self.transport.get_write_buffer_size())
print('resume writing')
# https://docs.python.org/3/library/asyncio-eventloop.html
# asyncio.get_event_loop() :
# Function: get the current event loop OR create a new event loop and set it as the current one
# IF there is no current event loop set in the current OS thread,
# AND set_event_loop() has not yet been called
# THEN asyncio will create a new event loop and set it as the current one
loop = asyncio.get_event_loop()
# serial_asyncio.create_serial_connection(loop, protocol_factory, *args, **kwargs)
# Function: Get a connection making coroutine
# Parameters:
# loop - The event handler
# protocol_factory - Factory function(asyncio.coroutine) for a asyncio.Protocol
# args, kwargs - Passed to the serial.Serial init function
coro = serial_asyncio.create_serial_connection(loop,
Output,
'/dev/ttyAMA0',
baudrate=2000000)
# loop.run_until_complete(future)
# Function: run until the future(an instance of Future) has completed
# If the argument is a coroutine object it is implicitly scheduled to run as a asyncio.Task
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
self._transport = transport
print('port opened', self._transport)
self._transport.serial.rts = False
self._transport.write(b'Hello, World!\n')
def data_received(self, data):
print('data received', repr(data))
if b'\n' in data:
self._transport.close()
def connection_lost(self, exc):
print('port closed')
self._transport.loop.stop()
def pause_writing(self):
print('pause writing')
print(self._transport.get_write_buffer_size())
def resume_writing(self):
print(self._transport.get_write_buffer_size())
print('resume writing')
loop = asyncio.get_event_loop()
coro = create_serial_connection(loop,
Output,
'/dev/tty.usbmodem1424421',
baudrate=115200)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
ports = ['COM%s' % (i + 1) for i in range(256)]
elif sys.platform.startswith('linux') or \
sys.platform.startswith('cygwin'):
# this excludes your current terminal "/dev/tty"
# ports = glob.glob('/dev/tty[A-Za-z]*')
# modification to show ONLY Arduinos
ports = glob.glob('/dev/tty[A-Z]*')
elif sys.platform.startswith('darwin'):
ports = glob.glob('/dev/tty.*')
else:
raise EnvironmentError('Unsupported platform')
result = []
for port in ports:
try:
s = serial.Serial(port)
s.close()
result.append(port)
except (OSError, serial.SerialException):
pass
return result
port = Output.list_serial_ports().pop()
loop = asyncio.get_event_loop()
coro = serial_asyncio.create_serial_connection(loop, Output, port,
baudrate=9600)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
async def connect(self):
if self.ev_connected.is_set():
log.warning("already connected")
return False
self.ack_queue = asyncio.Queue(self.firmware.max_buffer_lenght)
self.tx_queue = asyncio.Queue(1)
rx_queue = asyncio.Queue()
is_alive = asyncio.Event()
await self.store('idle', True)
self.ev_resume = asyncio.Event()
self.ev_resume.set()
self.panic_mode = False
port_spec = re.compile("^(.+)://(.+)[@:]([0-9]+)$")
port = self.cfg["port"].strip()
if not port_spec.match(port):
log.error("port property in configuration not parsable.")
return False
def connect_cb(ev_done, ev_connected, future):
try:
r = future.result()
except concurrent.futures._base.CancelledError:
log.debug('Connect task cancelled')
except FileNotFoundError as e:
log.error(str(e))
except serial.serialutil.SerialException as e:
log.error(str(e))
except OSError as e:
log.error(str(e))
except Exception as e:
log.critical("Unhandled exception: {}".format(str(e)))
log.critical(traceback.format_exc())
else:
ev_connected.set()
finally:
ev_done.set()
log.info("device '{}' trying to connect...".format(self.get_name()))
## the result must have three groups exactly"
proto, addr, param = port_spec.findall(port)[
0] ## we can only have one
ev_done = asyncio.Event()
loop = self.gctx['loop']
if proto == 'dummy':
DummySerialConnection(self, rx_queue)
ev_done.set()
self.ev_connected.set()
elif proto == 'serial':
coro = serial_asyncio.create_serial_connection(loop,
functools.partial(
CncConnection,
self, rx_queue),
addr,
baudrate=param)
self.tx_task = asyncio.ensure_future(coro)
self.tx_task.add_done_callback(
functools.partial(connect_cb, ev_done, self.ev_connected))
elif proto == 'tcp':
coro = loop.create_connection(
functools.partial(CncConnection, self, rx_queue), addr, param)
self.tx_task = asyncio.ensure_future(coro)
self.tx_task.add_done_callback(
functools.partial(connect_cb, ev_done, self.ev_connected))
else:
log.error("can't understand portspec")
return False
await ev_done.wait()
if not self.ev_connected.is_set():
log.error("Failed to connect.")
return False
await self.store('connected', True)
self.tx_task = asyncio.ensure_future(
self.sender(self.tx_queue, self.ack_queue, is_alive))
self.tx_task.add_done_callback(self.task_done)
self.rx_task = asyncio.ensure_future(
self.receiver(rx_queue, self.ack_queue, is_alive))
self.rx_task.add_done_callback(self.task_done)
return True
def start_message(self):
self.reply = bytearray()
def feed_message(self, byte):
self.reply.append(byte)
def end_message(self):
print('\n<- {}'.format(bytes(self.reply)), flush=True)
self.prompt()
def prompt(self):
print('?? ', end='', flush=True)
loop = asyncio.get_event_loop()
coro = serial_asyncio.create_serial_connection(
loop,
WJMx50,
'/dev/ttyUSB0', # or whatever yr comport is
bytesize=serial.EIGHTBITS, #.SEVENBITS, - EIGHTBITS for extron
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
'''
PARITY_NONE, PARITY_EVEN, PARITY_ODD, PARITY_MARK, PARITY_SPACE = 'N', 'E', 'O', 'M', 'S'
STOPBITS_ONE, STOPBITS_ONE_POINT_FIVE, STOPBITS_TWO = (1, 1.5, 2)
FIVEBITS, SIXBITS, SEVENBITS, EIGHTBITS = (5, 6, 7, 8)
'''
print("port opened", transport)
# transport.serial.rts = False # You can manipulate Serial object via transport
transport.write(b"Hello, World!\n") # Write serial data via transport
def data_received(self, data):
print("data received", repr(data))
if b"\n" in data:
self.transport.close()
def connection_lost(self, exc):
print("port closed")
self.transport.loop.stop()
def pause_writing(self):
print("pause writing")
print(self.transport.get_write_buffer_size())
def resume_writing(self):
print(self.transport.get_write_buffer_size())
print("resume writing")
loop = asyncio.get_event_loop()
coro = serial_asyncio.create_serial_connection(loop,
Output,
"/dev/ttyACM0",
baudrate=115200)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
def async_setup(hass, config):
""" Setup the ZiGate platform """
import serial_asyncio
from .zigate2hass import ZiGateProtocol, ZiGate2HASS
from pyzigate.interface import ZiGate
_LOGGER.debug('ZIGATE : Starting')
# device interpreter
zigate = ZiGate2HASS(hass)
# Go through config and find all addresses of zigate devices
_LOGGER.debug('ZIGATE : Finding zigate addresses')
for domain_config in config.keys():
if domain_config in COMPONENT_TYPES:
for platform_config in config[domain_config]:
if platform_config['platform'] == DOMAIN:
if 'address' in platform_config.keys():
zigate.add_known_device(
str(platform_config['address'])[:6])
_LOGGER.debug('ZIGATE : All known addresses added')
# Commands available as HASS services
def permit_join(call):
"""Put ZiGate in Permit Join mode and register new devices"""
zigate.permit_join()
def raw_command(call):
"""send a raw command to ZiGate"""
cmd = call.data.get('cmd', '')
data = call.data.get('data', '')
zigate.send_data(cmd, data)
def zigate_init(call):
channel = call.data.get('channel', DEFAULT_CHANNEL)
zigate.send_data('0021', '0000%02x00' % int(channel)) # Channel
zigate.send_data('0023', '00') # Coordinator
zigate.send_data('0024', '') # Start network
hass.services.async_register(DOMAIN, 'permit_join', permit_join)
hass.services.async_register(DOMAIN, 'raw_command', raw_command)
hass.services.async_register(DOMAIN, 'init', zigate_init)
# Asyncio serial connection to the device
# If HOST is configured, then connection is WiFi
if config[DOMAIN].get(CONF_HOST) is "":
# Serial
coro = serial_asyncio.create_serial_connection(
hass.loop,
ZiGateProtocol,
config[DOMAIN].get(CONF_SERIAL_PORT),
baudrate=config[DOMAIN].get(CONF_BAUDRATE))
else:
# WiFi
coro = hass.loop.create_connection(ZiGateProtocol,
host=config[DOMAIN].get(CONF_HOST),
port=config[DOMAIN].get(CONF_PORT))
future = hasync.run_coroutine_threadsafe(coro, hass.loop)
# bind connection to the device interpreter
future.add_done_callback(partial(bind_transport_to_device, zigate))
return True
#await asyncio.sleep(random.randint(0, 6))
await asyncio.sleep(3)
queue.task_done()
async def main():
loop = asyncio.get_event_loop()
queue = asyncio.Queue(loop=loop)
produce = partial(Reader, queue)
producer_coro = serial_asyncio.create_serial_connection(
loop, produce, com, baudrate)
consumer_coro = consume(queue)
await producer_coro
await consumer_coro
#await asyncio.gather(producer_coro, consumer_coro)
#asyncio.run(main()) # after 3.7.0
# before 3.7.0
loop = asyncio.get_event_loop()
queue = asyncio.Queue(loop=loop)
produce = partial(Reader, queue)
producer_coro = serial_asyncio.create_serial_connection(
loop, produce, com, baudrate)
print(producer_coro)
consumer_coro = consume(queue)
loop.run_until_complete(asyncio.gather(producer_coro, consumer_coro))
loop.close()
data = yield from self.send_queue.get()
self.transport.write(data)
except asyncio.CancelledError:
logger.info("Got CancelledError, stopping send loop")
break
logger.debug("sending {}".format(data))
def connection_lost(self, exc):
print('The server closed the connection')
print('Stop the event loop')
self.loop.stop()
loop = asyncio.get_event_loop()
coro = serial_asyncio.create_serial_connection(loop, lambda: Output(loop), '/dev/ttyUSB0', baudrate=115200)
running = True
def one_time_callback(protocol, _message, name, future):
logger.info("{} answer for {}".format(_message, name))
if not future.cancelled():
future.set_result(_message)
protocol.callback = None
@asyncio.coroutine
def send_and_await_reply(protocol, message, message_identifier):
future = asyncio.Future()
protocol.callback = lambda message: one_time_callback(protocol, message, message_identifier, future)
yield from protocol.send_message(message.encode("utf-8"))
client.on_message = on_message
lwtPublish = client.publish(mqtt_topicBase + "/LWT", 'ON')
await lwtPublish.wait_for_publish()
print("MQTT LWT published!")
while True:
msg = await mqttTxQueue.get()
try:
msgPublish = client.publish(mqtt_topicBase + msg[0], msg[1], retain=msg[2])
await msgPublish.wait_for_publish()
print("MQTT publish - Retain: " + str(msg[2]) + " Topic: " + mqtt_topicBase + msg[0] + " - Message: " + str(msg[1]))
except IndexError:
print("MQTT publish failed: ")
print(msg)
canRxQueue = asyncio.Queue()
canTxQueue = asyncio.Queue()
mqttTxQueue = asyncio.Queue()
canPartial = partial(canRxTx, canRxQueue, canTxQueue)
loop = asyncio.get_event_loop()
canAIO = serial_asyncio.create_serial_connection(loop, canPartial, port, baudrate=baud)
asyncio.ensure_future(canAIO)
asyncio.ensure_future(procCANRx(canRxQueue, mqttTxQueue))
asyncio.ensure_future(mqtt(mqttTxQueue, canTxQueue, mqtt_server, mqtt_port, mqtt_topicBase, mqtt_user, mqtt_pass, mqtt_ca))
loop.run_forever()
loop.close()
def get_async_blackbird2(port_url, loop):
"""
Return asynchronous version of Blackbird2 interface
:param port_url: serial port, i.e. '/dev/ttyUSB0'
:return: asynchronous implementation of blackbird2 interface
"""
lock = asyncio.Lock()
def locked_coro(coro):
@asyncio.coroutine
@wraps(coro)
def wrapper(*args, **kwargs):
with (yield from lock):
return (yield from coro(*args, **kwargs))
return wrapper
class blackbird2Async(blackbird2):
def __init__(self, blackbird2_protocol):
self._protocol = blackbird2_protocol
@locked_coro
@asyncio.coroutine
def zone_status(self, zone: int):
string = yield from self._protocol.send(
_format_zone_status_request(zone), skip=15)
return ZoneStatus.from_string(zone, string)
@locked_coro
@asyncio.coroutine
def set_zone_power(self, zone: int, power: bool):
yield from self._protocol.send(_format_set_zone_power(zone, power))
@locked_coro
@asyncio.coroutine
def set_zone_source(self, zone: int, source: int):
yield from self._protocol.send(
_format_set_zone_source(zone, source))
@locked_coro
@asyncio.coroutine
def set_zone_source_no_ir(self, zone: int, source: int):
yield from self._protocol.send(
_format_set_zone_source_no_ir(zone, source))
@locked_coro
@asyncio.coroutine
def set_all_zone_source(self, source: int):
yield from self._protocol.send(_format_set_all_zone_source(source))
@locked_coro
@asyncio.coroutine
def lock_front_buttons(self):
yield from self._protocol.send(_format_lock_front_buttons())
@locked_coro
@asyncio.coroutine
def unlock_front_buttons(self):
yield from self._protocol.send(_format_unlock_front_buttons())
@locked_coro
@asyncio.coroutine
def lock_status(self):
string = yield from self._protocol.send(_format_lock_status())
return LockStatus.from_string(string)
class blackbird2Protocol(asyncio.Protocol):
def __init__(self, loop):
super().__init__()
self._loop = loop
self._lock = asyncio.Lock()
self._transport = None
self._connected = asyncio.Event(loop=loop)
self.q = asyncio.Queue(loop=loop)
def connection_made(self, transport):
self._transport = transport
self._connected.set()
_LOGGER.debug('port opened %s', self._transport)
def data_received(self, data):
asyncio.ensure_future(self.q.put(data), loop=self._loop)
@asyncio.coroutine
def send(self, request: bytes, skip=0):
yield from self._connected.wait()
result = bytearray()
# Only one transaction at a time
with (yield from self._lock):
self._transport.serial.reset_output_buffer()
self._transport.serial.reset_input_buffer()
while not self.q.empty():
self.q.get_nowait()
self._transport.write(request)
try:
while True:
result += yield from asyncio.wait_for(self.q.get(),
TIMEOUT,
loop=self._loop)
if len(result) > skip and result[-LEN_EOL:] == EOL:
ret = bytes(result)
_LOGGER.debug('Received "%s"', ret)
return ret.decode('ascii')
except asyncio.TimeoutError:
_LOGGER.error(
"Timeout during receiving response for command '%s', received='%s'",
request, result)
raise
_, protocol = yield from create_serial_connection(loop,
functools.partial(
blackbird2Protocol,
loop),
port_url,
baudrate=9600)
return blackbird2Async(protocol)
}
async with session.post(config.endpoint, json=post_data) as resp:
print("hitting endpoint")
print(resp.status)
print(await resp.text())
class Output(asyncio.Protocol):
def connection_made(self, transport):
self.transport = transport
print("port opened", transport)
def data_received(self, data):
print("data received", repr(data))
loop.create_task(post_data(data))
if b"\n" in data:
self.transport.close()
def connection_lost(self, exc):
print("port closed")
self.transport.loop.stop()
serial_monitor = serial_asyncio.create_serial_connection(loop,
Output,
config.serial_port,
baudrate=config.baud)
loop.run_until_complete(serial_monitor)
loop.run_forever()
loop.close()
def get_async_monoprice(port_url, loop):
"""
Return asynchronous version of Monoprice interface
:param port_url: serial port, i.e. '/dev/ttyUSB0'
:return: asynchronous implementation of Monoprice interface
"""
lock = asyncio.Lock()
def locked_coro(coro):
@asyncio.coroutine
@wraps(coro)
def wrapper(*args, **kwargs):
with (yield from lock):
return (yield from coro(*args, **kwargs))
return wrapper
class MonopriceAsync(Monoprice):
def __init__(self, monoprice_protocol):
self._protocol = monoprice_protocol
@locked_coro
@asyncio.coroutine
def zone_status(self, zone: int):
# Ignore first 6 bytes as they will contain 3 byte command and 3 bytes of EOL
string = yield from self._protocol.send(
_format_zone_status_request(zone), skip=6)
return ZoneStatus.from_string(string)
@locked_coro
@asyncio.coroutine
def set_power(self, zone: int, power: bool):
yield from self._protocol.send(_format_set_power(zone, power))
@locked_coro
@asyncio.coroutine
def set_mute(self, zone: int, mute: bool):
yield from self._protocol.send(_format_set_mute(zone, mute))
@locked_coro
@asyncio.coroutine
def set_volume(self, zone: int, volume: int):
yield from self._protocol.send(_format_set_volume(zone, volume))
@locked_coro
@asyncio.coroutine
def set_treble(self, zone: int, treble: int):
yield from self._protocol.send(_format_set_treble(zone, treble))
@locked_coro
@asyncio.coroutine
def set_bass(self, zone: int, bass: int):
yield from self._protocol.send(_format_set_bass(zone, bass))
@locked_coro
@asyncio.coroutine
def set_balance(self, zone: int, balance: int):
yield from self._protocol.send(_format_set_balance(zone, balance))
@locked_coro
@asyncio.coroutine
def set_source(self, zone: int, source: int):
yield from self._protocol.send(_format_set_source(zone, source))
@locked_coro
@asyncio.coroutine
def restore_zone(self, status: ZoneStatus):
yield from self._protocol.send(
_format_set_power(status.zone, status.power))
yield from self._protocol.send(
_format_set_mute(status.zone, status.mute))
yield from self._protocol.send(
_format_set_volume(status.zone, status.volume))
yield from self._protocol.send(
_format_set_treble(status.zone, status.treble))
yield from self._protocol.send(
_format_set_bass(status.zone, status.bass))
yield from self._protocol.send(
_format_set_balance(status.zone, status.balance))
yield from self._protocol.send(
_format_set_source(status.zone, status.source))
class MonopriceProtocol(asyncio.Protocol):
def __init__(self, loop):
super().__init__()
self._loop = loop
self._lock = asyncio.Lock()
self._transport = None
self._connected = asyncio.Event(loop=loop)
self.q = asyncio.Queue(loop=loop)
def connection_made(self, transport):
self._transport = transport
self._connected.set()
_LOGGER.debug('port opened %s', self._transport)
def data_received(self, data):
asyncio.ensure_future(self.q.put(data), loop=self._loop)
@asyncio.coroutine
def send(self, request: bytes, skip=0):
yield from self._connected.wait()
result = bytearray()
# Only one transaction at a time
with (yield from self._lock):
self._transport.serial.reset_output_buffer()
self._transport.serial.reset_input_buffer()
while not self.q.empty():
self.q.get_nowait()
self._transport.write(request)
try:
while True:
result += yield from asyncio.wait_for(self.q.get(),
TIMEOUT,
loop=self._loop)
if len(result) > skip and result[-LEN_EOL:] == EOL:
ret = bytes(result)
_LOGGER.debug('Received "%s"', ret)
return ret.decode('ascii')
except asyncio.TimeoutError:
_LOGGER.error(
"Timeout during receiving response for command '%s', received='%s'",
request, result)
raise
_, protocol = yield from create_serial_connection(loop,
functools.partial(
MonopriceProtocol,
loop),
port_url,
baudrate=9600)
return MonopriceAsync(protocol)
metavar='WAMP_REALM',
default=os.getenv("NERDRAGE_WAMP_REALM"))
parser.add_argument('--port',
metavar='SERIAL_PORT',
default=os.getenv("NERDRAGE_SERIAL_PORT"))
args = parser.parse_args()
print(f'WAMP server address: {args.address}')
print(f'WAMP realm: {args.realm}')
print(f'Serial port: {args.port}')
loop = asyncio.get_event_loop()
serial_coro = serial_asyncio.create_serial_connection(
loop,
nerdrage_controller_bridge.NerdRageControllerSerialProtocol,
args.port,
baudrate=115200)
loop.run_until_complete(serial_coro)
runner = autobahn.asyncio.wamp.ApplicationRunner(args.address, args.realm)
wamp_session_coro = runner.run(
nerdrage_controller_bridge.NerdRageControllerBridgeWampSession,
start_loop=False)
loop.run_until_complete(wamp_session_coro)
try:
loop.run_forever()
except KeyboardInterrupt:
print("exit")
finally:
self.transport = transport
print('port opened', transport)
transport.serial.rts = False # You can manipulate Serial object via transport
transport.write(b'Hello, World!\n') # Write serial data via transport
def data_received(self, data):
print('data received', repr(data))
if b'\n' in data:
self.transport.close()
def connection_lost(self, exc):
print('port closed')
self.transport.loop.stop()
def pause_writing(self):
print('pause writing')
print(self.transport.get_write_buffer_size())
def resume_writing(self):
print(self.transport.get_write_buffer_size())
print('resume writing')
loop = asyncio.get_event_loop()
coro = serial_asyncio.create_serial_connection(loop,
Output,
'/dev/ttyUSB0',
baudrate="external_parameters")
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
print('Received: {!r}'.format(command_raw))
try:
packet_ascii = self.interface.process_command(tokens)
if tokens[-1] not in skip_print:
print('Sending: {!r}'.format(packet_ascii))
self.transport.write(packet_ascii.encode())
except Exception:
print("INVALID")
fut = asyncio.ensure_future(cmd_queue.get())
fut.add_done_callback(self.process_user_input)
if __name__ == '__main__':
loop = asyncio.get_event_loop()
loop.add_reader(sys.stdin, process_stdin_data, cmd_queue)
coroutine0 = serial_asyncio.create_serial_connection(
loop, CANUartServer, '/dev/tty232-0', 115200)
loop.run_until_complete(coroutine0)
coroutine1 = serial_asyncio.create_serial_connection(
loop, EncoderUartServer, '/dev/ttyJ1', 115200)
loop.run_until_complete(coroutine1)
coroutine2 = loop.create_server(IOServer, '127.0.0.1', 1978)
server = loop.run_until_complete(coroutine2)
coroutine3 = loop.create_task(periodic_polling())
coroutine4 = loop.create_task(process_response())
loop.run_until_complete(asyncio.gather(coroutine3, coroutine4))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
# Close the server
try:
msgPublish = client.publish(mqtt_topicBase + msg[0],
msg[1],
retain=msg[2])
await msgPublish.wait_for_publish()
print("MQTT publish - Retain: " + str(msg[2]) + " Topic: " +
mqtt_topicBase + msg[0] + " - Message: " + str(msg[1]))
except IndexError:
print("MQTT publish failed: ")
print(msg)
canRxQueue = asyncio.Queue()
canTxQueue = asyncio.Queue()
mqttTxQueue = asyncio.Queue()
canPartial = partial(canRxTx, canRxQueue, canTxQueue)
loop = asyncio.get_event_loop()
canAIO = serial_asyncio.create_serial_connection(loop,
canPartial,
port,
baudrate=baud)
asyncio.ensure_future(canAIO)
asyncio.ensure_future(procCANRx(canRxQueue, mqttTxQueue))
asyncio.ensure_future(
mqtt(mqttTxQueue, canTxQueue, mqtt_server, mqtt_port, mqtt_topicBase,
mqtt_user, mqtt_pass, mqtt_ca))
loop.run_forever()
loop.close()
def handle_sighup():
logger.info("Received SIGHUP, reopening log file")
log_file_handler.close()
logger.info("Received SIGHUP, log file reopened")
loop.add_signal_handler(signal.SIGHUP, handle_sighup)
# Connect to serial port
serial_transport, serial_protocol = loop.run_until_complete(
serial_asyncio.create_serial_connection(
loop,
VelbusSerialProtocol,
args.serial_port,
baudrate=38400,
bytesize=serial.EIGHTBITS,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
))
try:
logger.debug("Old DTR/RTS: {}/{}".format(serial_transport._serial.dtr,
serial_transport._serial.rts))
serial_transport._serial.dtr = False # low
serial_transport._serial.rts = True # high
logger.debug("New DTR/RTS: {}/{}".format(serial_transport._serial.dtr,
serial_transport._serial.rts))
except OSError as e:
logger.warning(
"Could not set DTR/RTS status, trying anyway... ({})".format(str(e)))
arguments = {
'read_address': 1,
'read_count': 8,
'write_address': 1,
'write_registers': [20] * 8,
}
log.debug("Read write registeres simulataneously")
rq = await client.readwrite_registers(unit=UNIT, **arguments)
rr = await client.read_holding_registers(1, 8, unit=UNIT)
assert (rq.function_code < 0x80) # test that we are not an error
assert (rq.registers == [20] * 8) # test the expected value
assert (rr.registers == [20] * 8) # test the expected value
# create_serial_connection doesn't allow to pass arguments
# to protocol so that this is kind of workaround
def make_protocol():
return ModbusClientProtocol(framer=ModbusRtuFramer(ClientDecoder()))
if __name__ == '__main__':
loop = asyncio.get_event_loop()
coro = create_serial_connection(loop,
make_protocol,
'/dev/ptyp0',
baudrate=9600)
transport, protocol = loop.run_until_complete(asyncio.gather(coro))[0]
loop.run_until_complete(start_async_test(protocol))
loop.close()
def connection_made(self, transport: serial_asyncio.SerialTransport):
self.transport = transport
print('UartServer serial port opened')
self.transport.serial.rts = False
def connection_lost(self, exc: Optional[Exception]):
print('port closed')
self.transport.loop.stop()
def data_received(self, data: bytes):
self.buffer.append(data.decode())
contents = "".join(self.buffer)
if '\n' in contents:
# print(contents)
if contents.startswith("f 0"):
print("fbk0")
self.transport.write("111111.111 0.0\n".encode())
elif contents.startswith("f 1"):
print("fbk1")
self.transport.write("222222.222 0.0\n".encode())
else:
print(contents)
self.buffer = []
if __name__ == '__main__':
loop = asyncio.get_event_loop()
coroutine1 = serial_asyncio.create_serial_connection(loop, UartServer, '/dev/ttyJ1', 921600)
loop.run_until_complete(coroutine1)
loop.run_forever()
"""
if b'\n' in data:
self.transport.close()
"""
def connection_lost(self, exc):
print('port closed')
self.transport.loop.stop()
def pause_writing(self):
print('pause writing')
print(self.transport.get_write_buffer_size())
def resume_writing(self):
print(self.transport.get_write_buffer_size())
print('resume writing')
if __name__ == '__main__':
# 创建事件循环
loop = asyncio.get_event_loop()
# 创建协程
coro = serial_asyncio.create_serial_connection(loop,
Controller,
'COM5',
baudrate=9600)
# 事件循环运行
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
def thread_worker_func(self, port, function_class):
# Utility functions
def writeOutToUI(message):
# NOTE: The following should do a deep copy which is needed 'cause
# another thread will be accessing this data later
# NOTE: Tkinter textbox uses '\n' for newline regardless of OS
message = message + '\n'
# We push serial data from controller to a queue which will be
# accessed by GUI thread later to write text safely to GUI text control
self.gui_dispatcher_queue.append(
lambda: self.txt_serialoutput.insert(tk.END, message))
return message
# This thread:
# 1. Reads and shows incoming data from slave Arduino.
# 2. If 'COMPLETED' message is received from LED controller, next set of frames are written out.
try:
# Start async serial read write
class ControllerSerialHandler(asyncio.Protocol):
END_OF_MESSAGE_BYTE = ord(
'\n'
) # In CRLF line ending of a message, LF signifies end-of-message
def _handle_message(self, message):
if not self.is_daemon:
writeOutToUI(message)
if not self.controller_ready and message == settings.CONTROLLER_READY_MESSAGE:
# LED controller is now ready after soft reset
self.controller_ready = True
self.next_frame = self.compressor.feed(
self.function.get_frame())
elif self.controller_ready:
if message.startswith(
settings.CONTROLLER_SYNC_MESSAGE):
self.get_serial().write(self.next_frame)
self.next_frame = self.compressor.feed(
self.function.get_frame())
elif message.startswith(
settings.CONTROLLER_ERROR_MESSAGE):
raise Exception(message)
def __init__(self, is_daemon, function, event_loop,
compressor):
self.controller_ready = False
self.read_buffer = bytearray()
self.transport = None
self.is_daemon = is_daemon
self.function = function
self.event_loop = event_loop
self.compressor = compressor
self.next_frame = None
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, exc_traceback):
if self.transport:
self.get_serial().write(
makeResetCommand(IntervalEnum.MSECS_1000))
self.get_serial().flush()
def get_serial(self):
return self.transport.serial
def connection_made(self, transport):
self.transport = transport
self.get_serial().rts = False
self.get_serial().set_buffer_size(rx_size=256,
tx_size=2048)
self.get_serial().reset_input_buffer()
self.get_serial().reset_output_buffer()
time.sleep(.1)
while self.get_serial().in_waiting:
self.get_serial().read(self.get_serial().in_waiting)
# Ask controller to reset
self.get_serial().write(
makeResetCommand(self.function.get_interval()))
self.get_serial().flush()
def data_received(self, data):
for data_byte in data:
self.read_buffer.append(data_byte)
if data_byte == self.END_OF_MESSAGE_BYTE:
message = self.read_buffer.decode(
'utf-8'
)[:-len(settings.
CONTROLLER_MESSAGE_END_SEQUENCE_BYTES)]
self.read_buffer.clear()
# Determine the kind of message received and perform actions accordingly
self._handle_message(message)
def connection_lost(self, exc):
self.transport = None
self.event_loop.stop()
with function_class(
os.path.join(settings.FUNCTIONS_DIRECTORY,
function_class.__name__)) as function:
self.event_loop = asyncio.new_event_loop()
with ControllerSerialHandler(
self.is_daemon, function, self.event_loop,
Compressor()) as controller_serialhandler:
conn = serial_asyncio.create_serial_connection(
self.event_loop, lambda: controller_serialhandler,
port, **settings.CONTROLLER_COM_PORT_CONFIG)
self.event_loop.run_until_complete(conn)
self.event_loop.run_forever()
self.event_loop.close()
self.event_loop = None
except Exception as ex:
if not self.is_daemon:
ex_str = str(
ex
) # CAUTION: Needs to be outside separately as 'ex' will be out of scope outside this block
self.gui_dispatcher_queue.append(
lambda: self.lbl_status.configure(text=ex_str))
def run_async_loop(self):
''' called by connect in a new thread to setup and start the asyncio loop '''
global async_main_loop
if async_main_loop:
self.log.error("Comms: Already running cannot connect again")
self.app.main_window.async_display(
'>>> Already running cannot connect again')
return
newloop = asyncio.new_event_loop()
asyncio.set_event_loop(newloop)
loop = asyncio.get_event_loop()
async_main_loop = loop
f = asyncio.Future()
# if tcp connection port will be net://ipaddress[:port]
# otherwise it will be serial:///dev/ttyACM0 or serial://COM2:
if self.port.startswith('net://'):
sc_factory = functools.partial(
SerialConnection, cb=self, f=f,
is_net=True) # uses partial so we can pass a parameter
self.net_connection = True
ip = self.port[6:]
ip = ip.split(':')
if len(ip) == 1:
self.port = 23
else:
self.port = ip[1]
self.ipaddress = ip[0]
self.log.info('Comms: Connecting to Network at {} port {}'.format(
self.ipaddress, self.port))
serial_conn = loop.create_connection(sc_factory, self.ipaddress,
self.port)
if self.app.fast_stream: # optional do not use ping pong for network connections
self.ping_pong = False
elif self.port.startswith('serial://'):
sc_factory = functools.partial(
SerialConnection, cb=self,
f=f) # uses partial so we can pass a parameter
self.net_connection = False
self.port = self.port[9:]
serial_conn = serial_asyncio.create_serial_connection(
loop, sc_factory, self.port, baudrate=115200)
else:
loop.close()
self.log.error('Comms: Not a valid connection port: {}'.format(
self.port))
self.app.main_window.async_display(
'>>> Connect failed: unknown connection type, use "serial://" or "net://"'
.format(self.port))
self.app.main_window.disconnected()
loop.close()
async_main_loop = None
return
try:
transport, self.proto = loop.run_until_complete(
serial_conn
) # sets up connection returning transport and protocol handler
self.log.debug('Comms: serial connection task completed')
# this is when we are really setup and ready to go, notify upstream
self.app.main_window.connected()
# issue a M115 command to get things started
self._write('\n')
self._write('M115\n')
if self.report_rate > 0:
# start a timer to get the reports
self.timer = loop.call_later(self.report_rate,
self._get_reports)
# wait until we are disconnected
self.log.debug('Comms: waiting until disconnection')
loop.run_until_complete(f)
# clean up and notify upstream we have been disconnected
self.proto = None # no proto now
self._stream_pause(False,
True) # abort the stream if one is running
if self.timer: # stop the timer if we have one
self.timer.cancel()
self.timer = None
self.app.main_window.disconnected(
) # tell upstream we disconnected
# we wait until all tasks are complete
pending = asyncio.Task.all_tasks()
self.log.debug(
'Comms: waiting for all tasks to complete: {}'.format(pending))
loop.run_until_complete(asyncio.gather(*pending))
# loop.run_forever()
except asyncio.CancelledError:
pass
except Exception as err:
# self.log.error('Comms: {}'.format(traceback.format_exc()))
self.log.error(
"Comms: Got serial error opening port: {0}".format(err))
self.app.main_window.async_display(
">>> Connect failed: {0}".format(err))
self.app.main_window.disconnected()
finally:
loop.close()
async_main_loop = None
self.log.info('Comms: comms thread Exiting...')
# asyncio.Protocol
def pause_writing(self):
Log.info('pause writing')
print(self.transport.get_write_buffer_size())
# asyncio.Protocol
def resume_writing(self):
Log.info(self.transport.get_write_buffer_size())
Log.info('resume writing')
if __name__ == '__main__':
# Test with debug tracing
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s %(levelname)s:%(name)s:%(message)s',
datefmt='%m-%d-%Y %H:%M:%S')
loop = asyncio.get_event_loop()
# Include asyncio debug tracing
loop.set_debug(True)
coro = serial_asyncio.create_serial_connection(loop,
ZigbeeAsyncSerialBase,
"/dev/ttyUSB0",
baudrate=115200)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
log.info("%d %s", len(data), repr(data))
if data[0] != 0x42 or data[1] != 0x4d:
log.info("skipping %s %s %s", repr(data), data[0], data[1])
return
frame_len = (data[2] << 8) + data[3]
data = data[4:frame_len]
higher = data[::2]
lower = data[1::2]
proc_data = [(d1 << 8) + d2 for d1, d2 in zip(higher, lower)]
if len(proc_data) != 12:
log.info("aaa %s", repr(data))
log.info("%d %s", len(proc_data), proc_data)
rrdtool.update("pm_2_5_ct.rrd", "N:%d" % (proc_data[9]))
def connection_lost(self, exc):
log.info('port closed')
asyncio.get_event_loop().stop()
loop = asyncio.get_event_loop()
coro = serial_asyncio.create_serial_connection(loop,
Monitor,
'/dev/serial0',
baudrate=9600)
transport, protocol = loop.run_until_complete(coro)
loop.run_forever()
loop.close()
# asyncio.run(main())
transport.serial.rts = False # You can manipulate Serial object via transport
transport.write(b'Hello, World!\n') # Write serial data via transport
def data_received(self, data):
print('data received', repr(data))
if b'\n' in data:
self.transport.close()
def connection_lost(self, exc):
print('port closed')
self.transport.loop.stop()
def pause_writing(self):
print('pause writing')
print(self.transport.get_write_buffer_size())
def resume_writing(self):
print(self.transport.get_write_buffer_size())
print('resume writing')
port = 'COM3'
baudrate = 57600
eventloop = asyncio.get_event_loop()
AsyncSerial = serial_asyncio.create_serial_connection(eventloop, Output, port,
baudrate)
eventloop.run_until_complete(AsyncSerial)
eventloop.run_forever()
eventloop.close()
def main() :
import argparse
import logging
parser = argparse.ArgumentParser(description='''
py_tsip_proxy is a proxy for the Trimble Standard Interface Protocol
(TSIP). It allows several clients to connect to one single TSIP capable
device. Assuming the TSIP capable device is a GPS controlled clock (e.g.
timing standard, GPSDO (GPS disciplined oscillator), a logfile can be
written to disk for monitoring purposes.
This software lives at https://github.com/vogelchr/py_tsip_proxy and has
been tested with a Trimbe Thunderbolt http://www.leapsecond.com/tbolt-faq.htm.
''')
parser.add_argument('-d', '--debug', action='store_true', default=False,
help='''Write packets sent/received by each client. (def: don't)''')
grp = parser.add_argument_group('Serial or Network Connection to GPS Device')
grp.add_argument('-t', '--tcp', metavar='PORT', dest='tcp_port',
type=int, action='store', default=None,
help='Use TCP connection and specify port number. (def: use serial)')
grp.add_argument('-b', '--baud', dest='baud',
type=int, action='store', default=9600,
help='Baudrate to use on serial device (def: 9600)')
grp.add_argument('tty_or_host', metavar='TTY|HOST',
type=str, action='store', default=None,
help='Serial device or hostname when using TCP connection.')
grp = parser.add_argument_group('Listening Sockets')
grp.add_argument('-l', '--listen', dest='listen',
type=int, action='store', default=4321, metavar='PORT',
help='''Listen for local connections on tcp port whose
packets will be forwarded to the device (def: 4321).''')
grp.add_argument('-m', '--listen-mute', dest='listen_mute',
type=int, action='store', default=None, metavar='PORT',
help='''Listen for local connections on tcp port whose
packets will not be forwarded to the device (def: None).''')
grp = parser.add_argument_group('Logging to ASCII Files')
grp.add_argument('-o', '--logfile', dest='logfile',
type=str, action='store', default=None, metavar='BASE',
help='''Write GPS stats (primary and supplemental timing
information and GPS satellite data) to logfile, files will be
named BASE_YYYYmmdd.txt and reopened at midnight local time.
(def: no logfile)''')
grp.add_argument('-f', '--flush', action='store_true',
default=False, help='''Flush logfiles after each line. Useful
if you are watching with "tail -f", but wears out storage
faster as the file will fsync() after every single line. (def:
no flush)''')
args = parser.parse_args()
logging.basicConfig(
format='%(asctime)-15s %(message)s',
level=logging.DEBUG if args.debug else logging.INFO)
loop = asyncio.get_event_loop()
if args.tcp_port :
conn_future = loop.create_connection(TSIP_Protocol_Master,
args.tty_or_host, args.tcp_port)
else :
conn_future = serial_asyncio.create_serial_connection(loop,
TSIP_Protocol_Master, args.tty_or_host, baudrate=args.baud)
transport, protocol_master = loop.run_until_complete(conn_future)
slave = TSIP_Protocol_Slave(protocol_master)
###
# listen socket
###
bind_future = loop.create_server(
lambda: TSIP_Protocol_Slave(protocol_master, True), port=args.listen)
loop.run_until_complete(bind_future)
if args.listen_mute :
bind_future = loop.create_server(
lambda: TSIP_Protocol_Slave(protocol_master, False),
port=args.listen_mute)
loop.run_until_complete(bind_future)
if args.logfile :
logger = TSIP_Logger(args.logfile, protocol_master, args.flush)
loop.run_forever()
print('land')
if(((msg)[2])==53):#5
drone.add_action( PercisionLand( 1.0, np.array([1, 1]) ) )
print('percision_land')
if(((msg)[2])==54):#6
drone.add_action(FlyToPoint(np.array([0,0,-10]),tolerance =1))
print('FlyToPoint0,0,-10')
if(((msg)[2])==55):#7
drone.add_action(Circle(velocity=2.0,radius=8.0,angle=0.0))
print('circle')
if(((msg)[2])==56):#8
drone.add_action(Spin())
print('Spin')
if(((msg)[2])==57):#9
drone.override_action(Killing())
print('Killing!')
except Exception as E:
print(E)
def connection_lost(self, exc):
print('port closed')
asyncio.get_event_loop().stop()
# drone = Craft("drone1","serial:///dev/serial0:1000000")
drone = Craft('drone0',"udp://:14540")
drone.start()
loop = asyncio.get_event_loop()
# coro = serial_asyncio.create_serial_connection(loop, Output, '/dev/ttyUSB0', baudrate=57600)
coro = serial_asyncio.create_serial_connection(loop, Output, '/dev/serial0', baudrate=1000000)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
self.transport = transport
print("port opened", transport)
# transport.serial.rts = False # You can manipulate Serial object via transport
transport.write(b"Hello, World!\n") # Write serial data via transport
def data_received(self, data):
print("data received", repr(data))
if b"\n" in data:
self.transport.close()
def connection_lost(self, exc):
print("port closed")
self.transport.loop.stop()
def pause_writing(self):
print("pause writing")
print(self.transport.get_write_buffer_size())
def resume_writing(self):
print(self.transport.get_write_buffer_size())
print("resume writing")
loop = asyncio.get_event_loop()
coro = serial_asyncio.create_serial_connection(
loop, Output, "/dev/ttyACM0", baudrate=115200
)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
rr = await client.read_input_registers(1, 8, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error
arguments = {
'read_address': 1,
'read_count': 8,
'write_address': 1,
'write_registers': [20]*8,
}
log.debug("Read write registeres simulataneously")
rq = await client.readwrite_registers(unit=UNIT, **arguments)
rr = await client.read_holding_registers(1, 8, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error
assert(rq.registers == [20]*8) # test the expected value
assert(rr.registers == [20]*8) # test the expected value
# create_serial_connection doesn't allow to pass arguments
# to protocol so that this is kind of workaround
def make_protocol():
return ModbusClientProtocol(framer=ModbusRtuFramer(ClientDecoder()))
if __name__ == '__main__':
loop = asyncio.get_event_loop()
coro = create_serial_connection(loop, make_protocol, '/dev/ptyp0',
baudrate=9600)
transport, protocol = loop.run_until_complete(asyncio.gather(coro))[0]
loop.run_until_complete(start_async_test(protocol))
loop.close()
