async def async_serial_init(self, n=1):
"""
Asynchronous function for initializing serial connection
"""
try:
self.serial = aioserial.AioSerial(
loop=self.loop,
port=self.config.get("interface",
{}).get("port", "/dev/serial0"),
baudrate=self.config.get("interface",
{}).get("baudrate", 115200),
)
except aioserial.serialutil.SerialException as e:
if n <= 20:
self.logger.info(
"unable to connect to serial, trying again in 2 seconds. Exception: %s",
str(e),
)
elif n == 21:
self.logger.warning(
"unable to connect to serial for more than 40 seconds, logging for this issue stopped until the attempts to connect are successful. Exception: %s",
str(e),
)
await asyncio.sleep(1 + (n * (n < 25) or 24))
await self.async_serial_init(n + 1)
def __init__(self, port):
self.tx_lock = asyncio.Lock()
self.rx_lock = asyncio.Lock()
self.rx_buffer = bytearray(264)
if not isinstance(port, str):
port = port.device
self.port = aioserial.AioSerial(port, 230400)
def __init__(self, core: "Core", config: Dict):
self.core = core
self.instances = {}
self.config = config
for name, port in self.config.items():
try:
instance = aioserial.AioSerial()
if isinstance(port, str):
instance.port = port
conn = Connection(instance, port, name, self.core)
else:
instance.port = port["port"]
conn = Connection(
instance,
port["port"],
name,
self.core,
reconnect=port.get("reconnect", False),
reconnect_time=port.get("reconnect_time", 5),
silent=port.get("silent", True),
)
self.instances[name] = conn
except:
pass
def __init__(self, port, handle_fn):
self.serial = aioserial.AioSerial(port, baudrate=115200)
self.handle_fn = handle_fn
self.tags = self.get_session_tags()
self.line_queue = asyncio.Queue()
self.parser = TextProtocolParser()
self.last_point_datetime = None
def initPort(self,
serialSettings: SerialCommSettings,
raiseException: bool = True) -> bool:
"""
Initialize serial port with a given settings and return True on success, False otherwise.
@param raiseException: if True, raise exception if port is not open.
"""
try:
self.closePort()
self._portHandle = aioserial.AioSerial(
port=serialSettings.port,
baudrate=serialSettings.baudrate,
bytesize=serialSettings.dataSize,
parity=serialSettings.parity,
stopbits=serialSettings.stopbits,
xonxoff=serialSettings.swFlowControl,
rtscts=serialSettings.hwFlowControl,
dsrdtr=False, # disable hardware (DSR/DTR) flow control
timeout=serialSettings.readTimeoutMs / 1000,
write_timeout=serialSettings.writeTimeoutMs / 1000)
self.portSettings = serialSettings
return True
except Exception as err:
if raiseException:
errorMsg = f"Unable to init serial port with following settings: {serialSettings}"
errorMsg += f"\nError:\n{err}"
raise Exception
return False
async def connect(self, product):
"""Creates connection to server at given address.
Arguments:
product (str):
USB product string to search for
"""
port = None
devices = list_ports.comports()
for dev in devices:
# FIXME: Generalize for cross platform
if dev.product == product or (
dev.pid == 0x5740 and dev.vid == 0x0483) or (
dev.vid == 0x0694
and dev.pid == 0x0010) or (dev.vid == 0x0694
and dev.pid == 0x0009):
port = dev.device
break
if port is None:
raise ValueError("Could not find hub.")
print("Connecting to {0}".format(port))
self.ser = aioserial.AioSerial(port)
self.connected = True
self.task = asyncio.create_task(self._read_loop())
await asyncio.sleep(0.5)
def __init__(self, serial_device=SERIAL_DEVICE, baud=BAUD_RATE):
self.ser = aioserial.AioSerial(serial_device, baud) # open serial port
logging.info('Attached to serial port: {}'.format(self.ser.name))
# Bypass an go into raw serial mode.
self.ser.write(BYPASS_COMMAND)
logging.info('Entered Bypass mode')
self.raw_message = ''
self.parser = MessageParser()
def get_serial(port: str = default_port,
baud: int = default_baud) -> aioserial.AioSerial:
''' Opens a new serial connection
params:
port - the logical port on your computer for the microbit
baud - the serial baud rate of the connect, defaults to 115200
'''
s: aioserial.AioSerial = aioserial.AioSerial(port=port, baudrate=baud)
return s
def __init__(self, port):
self.counter = 1
self.aioserial_instance = aioserial.AioSerial(port)
self.loop = asyncio.get_event_loop()
try:
self.loop.run_until_complete(self.receive_measurements())
finally:
self.loop.run_until_complete(
self.loop.shutdown_asyncgens()) # Python 3.6 only
self.loop.close()
def connect(self, deviceName):
if deviceName not in self.configDut:
raise AssertionError(
'Device {} is not found, please check config file for it'.
format(deviceName))
dut = self.configDut[deviceName]
dut['serialport'] = aioserial.AioSerial(port=dut['com'],
baudrate=dut['baudrate'])
print('Serial port {} opened successfully'.format(dut['com']))
def __init__(self, port: str, ipc_tunnel_address: str = ''):
self.port: str = port
self.baud: int = 115200
self.serial_instance: aioserial.AioSerial = aioserial.AioSerial(self.port, self.baud)
self.hooks: List[Tuple[Callable, str]] = []
self.hook_repeat_count: int = 0
self.load_buffer = StringIOQueue(4000)
self.send_buffer = None
self.progress_notifier: ProgressNotifier = ProgressNotifier(ipc_tunnel_address)
def __init__(self, serial_port=None, unit_id=0):
import aioserial
self.ser = aioserial.AioSerial(serial_port,
baudrate=19200,
parity="E",
stopbits=1,
timeout=0.02)
# Unit id encoding is offset by 128 per GSIOC specification
self.gsioc_id = 0x80 + unit_id
def main():
loop = asyncio.get_event_loop()
signal.signal(signal.SIGINT, signal_handler)
while True:
try:
global central_serial
central_serial = aioserial.AioSerial(
port=os.path.realpath('/dev/serial/by-id/usb-ZEPHYR_N39_BLE_KEYKEEPER_0.01-if00'))
loop.run_until_complete(manage_serial(central_serial))
except serial.serialutil.SerialException:
print("LOST CONNECTION. RECONNECTING...", file=sys.stderr)
loop.run_until_complete(asyncio.sleep(5))
def _open_stream(self, port, speed, homing):
if self.dry_run:
print("#DRY _open_stream: port=%s" % port)
return
self.s = aioserial.AioSerial(port=port, baudrate=speed)
self.flush()
# Go through homing or unlock
if homing:
self.send("$H")
else:
self.send("$X")
def __enter__(self):
import aioserial
self.ser = aioserial.AioSerial(
self.serial_port, 115200, parity=aioserial.PARITY_NONE, stopbits=1
)
# Listen to sensor's self-introduction
# (gives it time for internal init)
self.ser.readline()
return self
def __try_open_port(port):
new_connection = aioserial.AioSerial()
new_connection.port = port.device
i = 0
while not new_connection.is_open and i < 5: # Make multiple attempts in case device is busy
i += 1
try:
new_connection.open()
except SerialException as e:
time.sleep(1)
if not new_connection.is_open: # Failed to connect
return False, None
return True, new_connection
def __enter__(self):
import aioserial
self._ser = aioserial.AioSerial(
self.serial_port,
9600,
parity=aioserial.PARITY_NONE,
stopbits=1,
timeout=0.1,
write_timeout=0.1,
)
return self
async def main(device: str):
serial_port = aioserial.AioSerial(port=device, baudrate=115200)
print("Talking with your device")
meas = await get_measurement(serial_port)
print(meas)
if not meas:
return
print(
"OK - Please rotate thru the range of brightnesses to determine the limits. Press enter when done"
)
brightness_extrema = RunningExtrema()
input_task = asyncio.create_task(aioconsole.ainput())
while True:
meas = await get_measurement_or_enter(input_task, serial_port)
if not meas:
# they hit enter
break
if brightness_extrema.process(meas.brightness):
print(brightness_extrema.min_val, brightness_extrema.max_val)
if brightness_extrema.min_val == 0:
print("Got a brightness of zero, not OK. Is your sensor connected right?")
return
print("OK, limits found.")
if brightness_extrema.get_range() < 200:
print(
"Range not large enough: improve sensitivity of sensor or connection to display"
)
return
print("OK, recording to disk, enter to stop.")
with open(FILENAME, "w") as fp:
# header row
fp.write("us,drx,dry,drz,brightness\n")
base_meas = await get_measurement(serial_port)
if not base_meas:
raise RuntimeError("Could not get our baseline timestamp")
zero_time = base_meas.us
# the task watching for the enter press
input_task = asyncio.create_task(aioconsole.ainput())
while True:
meas = await get_measurement_or_enter(input_task, serial_port)
if not meas:
# they hit enter
break
# Offset the timestamp for ease of use.
meas.us -= zero_time
fp.write(meas.get_csv_line())
print(f"All done! Go move/rename {FILENAME} and analyze it!")
def setup_connection(self):
try:
self.serialConection = aioserial.AioSerial(
port=self.SERIAL_PORT,
baudrate=self.BAUDRATE,
bytesize=serial.EIGHTBITS,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
timeout=2,
write_timeout=2)
return self.serialConection
except Exception as e:
print(e)
async def connect_serial(self, websocket):
print("Tentando conexão com a serial...")
try:
self.aio_instance = aioserial.AioSerial(port=self.port,
baudrate=self.baudrate)
self.aio_instance.flush()
print("Conexão estabelecida")
self.is_connected = True
await websocket.send(json.dumps(self.connected_json))
except serial.serialutil.SerialException:
self.is_connected = False
await websocket.send(json.dumps(self.handshake_json))
if self.logger_except != None:
self.logger_except.exception('')
def __init__(self, device: str, timeout: int = 30, callback=None):
"""
A connection to one or more Acmeda hubs on the given RS485 device.
Timeout is how long to wait for any single response.
A callback, if given, will be called as a task with parameters
(hub, motor) when an update is detected.
"""
self.device = device
self.ser = aioserial.AioSerial(port=device,
baudrate=9600,
timeout=timeout)
self.hubs: Dict[str, Hub] = {}
self.callback = callback
# Start a watcher
asyncio.create_task(self.monitor_updates())
async def init_all(port=8001):
# Open serial port
ser = aioserial.AioSerial(port='/dev/ttyUSB1', baudrate=9600, timeout=2)
print('Port opened')
# Open socket
reader, writer = await asyncio.open_connection('127.0.0.1', port)
print('Socket opened')
# Create queues
from_serial = asyncio.Queue()
to_serial = asyncio.Queue()
# Run everything
await asyncio.gather(serial_reader(ser, from_serial),
serial_writer(ser, to_serial),
socket_reader(reader, to_serial),
socket_writer(writer, from_serial))
async def serialConnect(self):
# init serial
self.serialIsConnecting = True
self.serialIsConnected = False
while self.serialIsConnected == False:
try:
print("... Waiting for serial Connection to {}".format(
self.serialData['path']))
self.serial = aioserial.AioSerial(
port=self.serialData['path'],
baudrate=self.serialData['option']['baudRate'])
self.serialIsConnected = True
self.serialIsConnecting = False
print("... Serial Connected")
except:
print("Serial Connection Failed")
self.serialIsConnected = False
await asyncio.sleep(2)
return
def serial_init(self):
"""
Synchronous function for initializing serial connection - deprecated as of 0.7
"""
try:
self.serial = aioserial.AioSerial(
loop=self.loop,
port=self.config.get("interface",
{}).get("port", "/dev/serial0"),
baudrate=self.config.get("interface",
{}).get("baudrate", 115200),
)
except aioserial.serialutil.SerialException as e:
self.logger.debug(
"unable to connect to serial, trying again in 2 seconds. Exception: %s",
str(e),
)
sleep(2)
self.serial_init()
def main():
SERIAL_PORT = 'COM4'
BAUDRATE = 115200
global result
#
serialConection = aioserial.AioSerial(port=SERIAL_PORT,
baudrate=BAUDRATE,
bytesize=serial.EIGHTBITS,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
timeout=2,
write_timeout=2)
#
send = asyncio.run(write_serial(serialConection))
print(send)
#
data = asyncio.run(read_and_print_serial(serialConection))
#
print("######################## RESULT ######################## ")
print(data)
async def main():
parser = create_parser()
args = parser.parse_args()
counter = 0
serial = aioserial.AioSerial(port=args.device.name, baudrate=BAUD_RATE)
initialized = False
running = True
player = SoundPlayer()
sounds_db = SoundsDB(args.greeting_dir, args.bye_dir, args.random_dir)
while running:
msg = (await serial.readline_async(-1)).decode(errors="ignore")
eye_pos, closed, sound = unpack_msg(msg)
# print(f"sound {sound} player: {player.is_playing}")
valid_sound = sound is not None and len(sound.strip()) > 0
if valid_sound and not player.is_playing:
sound_path = sounds_db.get_sound_file(sound)
player.start_playing(sound_path)
async def run_async(self):
self.current_coin = Coin()
first_start = True
while True:
try:
self.central_serial = aioserial.AioSerial(port=os.path.realpath(
'/dev/serial/by-id/usb-ZEPHYR_N39_BLE_KEYKEEPER_0.01-if00')
)
self.central_serial.write(b'\r\n\r\n')
if first_start:
self.central_serial.write(b'reboot\r\n')
first_start = False
await self._wait_until_done()
else:
await self._manage_serial()
except serial.serialutil.SerialException:
os.write(self.status_pipe,
str("status: connecting to central").encode('utf8'))
await asyncio.sleep(1)
async def main():
s = aioserial.AioSerial('/dev/cu.usbmodem3341731', baudrate=1000000)
r = CobsReader(s)
def handler(data):
i, = struct.unpack_from("<I", data)
print("Got {}".format(i))
if i == 100:
r.close()
asyncio.get_event_loop().call_soon(
lambda: asyncio.get_event_loop().stop())
else:
r.write(struct.pack("<I", i + 1))
r.set_receiver(handler)
r.run()
# Kick off
r.write(struct.pack("<I", 1))
await asyncio.sleep(1)
async def task_main(port, baudrate, client):
inst = aioserial.AioSerial(port=port, baudrate=baudrate, rtscts=True)
# Make sure app is running
inst.send_break(.5)
await cmd(inst, APP_CMD)
# App doesn't respond until first input
await cmd(inst, '')
# Configure S-registers
for srec in SREGISTER_VALUES:
await cmd(inst, SREG_SET_CMD.format(srec[0], srec[1]))
await cmd(inst, SREG_STORE_CMD)
# Reset (no response)
await inst.write_async(RESET_CMD.encode())
# Wait for module to reboot
time.sleep(2)
# Start app again
await cmd(inst, APP_CMD)
await cmd(inst, '')
# Start the scanning task
asyncio.create_task(scan_and_filter(inst, client))
while True:
## this will allow developers to have a responsive ctr-C
await asyncio.sleep(1)
)
ch.setFormatter(formatter)
logger.addHandler(ch)
logger.setLevel(logging.DEBUG)
hwid = "VID:PID=04D8:FD92"
# https://stackoverflow.com/questions/24683987/executable-out-of-script-containing-serial-for-url/24688413#24688413
# __import__('serial.urlhandler.protocol_hwgrep')
# self.port = sys.modules['serial.urlhandler.protocol_hwgrep'].Serial(f'hwgrep://{hwid}')
read_version()
# port =
# asyncio.run(read_and_print(aioserial.serial_for_url(f'hwgrep://{hwid}')))
# port = aioserial.AioSerial(port="COM5")
port = aioserial.serial_for_url(f"hwgrep://{hwid}")
port_com = port.name
logger.debug(f"name: {port_com}")
port.close()
port = aioserial.AioSerial(port=port_com)
# # port = serial.serial_for_url(f'hwgrep://{hwid}')
# port.write("V".encode('ascii')+b'\r')
# time.sleep(0.05)
# b = port.in_waiting
# print(port.read(size=b))
# port.close()
start_time = time.time()
asyncio.run(write_and_read(port))
duration = time.time() - start_time
logger.debug(f"duration: {duration}")
