def get_ack(self) -> int:
"""Get response code from PSLab.
Returns
-------
int
Response code. Meanings:
0x01 ACK
0x10 I2C ACK
0x20 I2C bus collision
0x10 Radio max retransmits
0x20 Radio not present
0x40 Radio reply timout
"""
response = self.read(1)
if not response:
raise serial.SerialException("Timeout while waiting for ACK.")
ack = CP.Byte.unpack(response)[0]
if not (ack & 0x01):
raise serial.SerialException(
"Received non ACK byte while waiting for ACK.")
return ack
def read_tracks_raw(self, tracks=None, timeout=30):
'''Wait for a card swype and return the raw timing data'''
tracks = tracks if tracks else self._defracks
if (tracks & ~(PyMAKInt.TRACK1 | PyMAKInt.TRACK2 | PyMAKInt.TRACK3)) != 0 or \
(tracks & (PyMAKInt.TRACK1 | PyMAKInt.TRACK2 | PyMAKInt.TRACK3)) == 0:
raise ValueError('Invalid track specified')
self._serialobj.timeout = 1
self._serialobj.write(b'R' + bytes([tracks]))
readbytes = self._serialobj.read(5)
if readbytes != b'Ready':
raise serial.SerialException('Error initialising card read')
self._serialobj.timeout = timeout
readbytes = self._serialobj.read(3)
if readbytes == b'':
raise serial.SerialException('Card read timeout occurred')
elif readbytes != b'RD ':
raise serial.SerialException('Invalid data from reader')
self._serialobj.timeout = 1
readbytes = self._serialobj.read(2)
tickcount = (readbytes[0] << 8) + readbytes[1]
ticksbytes = (tickcount * 2) + (2 if (tickcount % 2) != 0 else 0)
databytes = self._serialobj.read(ticksbytes)
readbytes = self._serialobj.read(5)
if readbytes != b'RD=OK':
raise serial.SerialException('Error, data alignment problem')
return PyMAKDat(list(databytes[0:tickcount * 2]))
def serial_class_for_url(url):
"""extract host and port from an URL string"""
parts = urlparse.urlsplit(url)
if parts.scheme != 'alt':
raise serial.SerialException(
'expected a string in the form "alt://port[?option[=value][&option[=value]]]": not starting with alt:// (%r)'
% (parts.scheme, ))
class_name = 'Serial'
try:
for option, values in urlparse.parse_qs(parts.query, True).items():
if option == 'class':
class_name = values[0]
else:
raise ValueError('unknown option: %r' % (option, ))
except ValueError as e:
raise serial.SerialException(
'expected a string in the form "alt://port[?option[=value][&option[=value]]]": %s'
% e)
if not hasattr(serial, class_name):
raise ValueError('unknown class: %r' % (class_name, ))
cls = getattr(serial, class_name)
if not issubclass(cls, serial.Serial):
raise ValueError('class %r is not an instance of Serial' %
(class_name, ))
return (''.join([parts.netloc, parts.path]), cls)
def readAnglesFb(self):
ret_pack = self.readSerial()
if (ret_pack.pop(0) != 0x05):
raise serial.SerialException("mismatching pack type")
if (ret_pack.pop(0) != ANGLE_FEEDBACK_ID):
raise serial.SerialException("mismatching pack type")
return ret_pack[1:]
def find_port(old_port=None):
# If we are reopening, and we know the location of the old port, require
# to match on location.
if old_port and old_port.location:
for x in serial.tools.list_ports.comports():
if x.location and x.location == old_port.location:
return x.device
raise serial.SerialException('Could not reopen Greaseweazle device')
# Score each serial port
best_score, best_port = 0, None
for x in serial.tools.list_ports.comports():
score = 0
if x.manufacturer == "Keir Fraser" and x.product == "Greaseweazle":
score = 20
elif x.vid == 0x1209 and x.pid == 0x4d69:
# Our very own properly-assigned PID. Guaranteed to be us.
score = 20
elif x.vid == 0x1209 and x.pid == 0x0001:
# Our old shared Test PID. It's not guaranteed to be us.
score = 10
if score > 0 and valid_ser_id(x.serial_number):
if not old_port or not valid_ser_id(old_port.serial_number):
score = 20
elif x.serial_number == old_port.serial_number:
score = 30
else:
score = 0
if score > best_score:
best_score, best_port = score, x
if best_port:
return best_port.device
raise serial.SerialException('Could not auto-probe Greaseweazle device')
def connect(self):
"""
Connects to CO2 Sensor identified by Serial Number.
"""
if self.port is not None:
p = portscan(self.port)
if p is not None:
self.port = p.device
self.ID = p.serial_number
self.name = get_sensor_name(self.ID)
else:
raise serial.SerialException("Can't find port: {}".format(
self.port))
elif self.ID is not None:
p = portscan(self.ID)
if p is not None:
self.port = p.device
self.ID = p.serial_number
self.name = get_sensor_name(self.ID)
else:
raise serial.SerialException(
"Can't find port with ID: {}".format(self.ID))
else:
self.ID, self.name, self.port = find_sensor('CO2')
self.label = "CO2 sensor {} ({}) on port {}\n".format(
self.name, self.ID, self.port)
print("\n" + '*' * len(self.label) + '\n' + self.label +
'*' * len(self.label) + '\n')
self.sensor = serial.Serial(self.port, baudrate=9600, timeout=.5)
return
def from_url(self, url):
"""extract host and port from an URL string"""
parts = urlparse.urlsplit(url)
if parts.scheme != 'spy':
raise serial.SerialException(
'expected a string in the form '
'"spy://port[?option[=value][&option[=value]]]": '
'not starting with spy:// ({!r})'.format(parts.scheme))
# process options now, directly altering self
formatter = FormatHexdump
color = False
output = sys.stderr
try:
for option, values in urlparse.parse_qs(parts.query, True).items():
if option == 'file':
output = open(values[0], 'w')
elif option == 'color':
color = True
elif option == 'raw':
formatter = FormatRaw
elif option == 'all':
self.show_all = True
else:
raise ValueError('unknown option: {!r}'.format(option))
except ValueError as e:
raise serial.SerialException(
'expected a string in the form '
'"spy://port[?option[=value][&option[=value]]]": {}'.format(e))
self.formatter = formatter(output, color)
return ''.join([parts.netloc, parts.path])
def erase_eeprom(self):
'''Erase the EEPROM, not tested'''
self._serialobj.write(b'H')
self._serialobj.timeout = 10
erres = self._serialobj.read(5)
if erres == b'':
raise serial.SerialException('Error, timeout while erasing device')
elif erres != b'EZ=OK':
raise serial.SerialException(
'Error, invalid confirmation from device')
def detect_port() -> ListPortInfo:
devices = list(serial.tools.list_ports.grep(usb_regexp))
if len(devices) < 1:
raise serial.SerialException("Unable to find TI CC device using auto mode")
if len(devices) > 1:
raise serial.SerialException(
"Unable to select TI CC device, multiple devices found: {}".format(
", ".join(map(lambda d: str(d), devices))
)
)
return devices[0]
def write_register(self, category: int, index: int, page: int,
data: List[int]):
# Number of registers to write.
num_registers = len(data)
# Convert the 16 bit registers into a byte stream used as payload in the Modbus write-command.
payload = self._pack(data)
# Construct the entire Modbus command including CRC.
modbus_cmd = bytes([
self._id, self.Commands.write, category, index, page, num_registers
]) + payload
modbus_cmd += self._crc(modbus_cmd)
# Write registers.
self._dialout.reset_input_buffer()
self._dialout.reset_output_buffer()
self._dialout.write(modbus_cmd)
self._dialout.flush()
# Read response. On success the written payload will be read back to us.
status = self._dialout.read(self._header_length + len(payload) +
self._crc_length)
# Handle some basic failures.
# First check if we have enough data for an error-response.
if len(status) < 3:
raise serial.SerialException('No response on write.')
# If an error-code was returned the command-field will not match.
if status[1] != self.Commands.write:
error_code = hex(status[1])
raise serial.SerialException(
'Received error code: {} in response to register-write.'.
format(error_code))
# Validate written data.
length = status[2]
written_data = status[3:-2]
crc = status[-2:]
if length != len(written_data):
raise serial.SerialException(
'Received incomplete data in response to write.')
if crc != self._crc(status[:-2]):
raise serial.SerialException(
'CRC error in received response to write.')
if written_data != payload:
raise serial.SerialException(
'Incorrect data written to register. Expected "{}" but got "{}".'
.format(data, written_data))
def open(self):
if self._port is None:
import serial
raise serial.SerialException("Port must be configured before use.")
self._dump = False
self.sock = None
try:
self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
self.sock.connect(self.portstr)
except Exception, msg:
self.sock = None
import serial
raise serial.SerialException("Could not open port: %s" % msg)
def connect_serial(port, baudrate=115200, timeout=1, writeTimeout=1):
"""
Return Serial object after making sure that the port is accessible and that the port is expressed as a string.
:param port: str or int (ie "COM4" or 4 for Windows).
:param baudrate: baudrate.
:param timeout: read timeout in seconds, default 1 sec.
:param writeTimeout: write timeout in seconds, default 1 sec.
:return: serial port object.
:rtype: serial.Serial
"""
if isinstance(port, int):
port = "COM{0}".format(port)
names_list = list()
for i in list_ports.comports():
names_list.append(i[0])
if port not in names_list:
print("Serial not found on {0}.".format(port))
print('Listing current serial ports with devices:')
for ser in list_ports.comports():
ser_str = '\t{0}: {1}'.format(ser[0], ser[1])
print ser_str
time.sleep(
.01
) # just to let the above lines print before the exemption is raised. cleans console output.
raise serial.SerialException(
'Requested COM port: {0} is not listed as connected.'.format(port))
else:
return serial.Serial(port,
baudrate=baudrate,
timeout=timeout,
writeTimeout=writeTimeout)
def _reconfigure_port(self, force_update=True):
"""Set communication parameters on opened port."""
super(VTIMESerial, self)._reconfigure_port()
fcntl.fcntl(self.fd, fcntl.F_SETFL, 0) # clear O_NONBLOCK
if self._inter_byte_timeout is not None:
vmin = 1
vtime = int(self._inter_byte_timeout * 10)
else:
vmin = 0
vtime = int(self._timeout * 10)
try:
orig_attr = termios.tcgetattr(self.fd)
iflag, oflag, cflag, lflag, ispeed, ospeed, cc = orig_attr
except termios.error as msg: # if a port is nonexistent but has a /dev file, it'll fail here
raise serial.SerialException("Could not configure port: {}".format(msg))
if vtime < 0 or vtime > 255:
raise ValueError('Invalid vtime: {!r}'.format(vtime))
cc[termios.VTIME] = vtime
cc[termios.VMIN] = vmin
termios.tcsetattr(
self.fd,
termios.TCSANOW,
[iflag, oflag, cflag, lflag, ispeed, ospeed, cc])
def __init__(self, port=None, baud=115200, filter_data=True, verbose=True, scaled_output=True, daisy=False, log=True,
timeout=None):
"""
:param port: The COM port that OpenBCI is connected to. If None (or given a port that doesn't work), we'll attempt to find the correct
comport and raise a Serial Exception if we are unsuccessful.
:param baud: A parameter to Open BCI (unsure of what exactly it does). Defaults to 115200, which should be fine for most circumstances.
:param verbose: If verbose, we'll print messages to the console detailing where we are in the OpenBCI setup.
:param filter_data: ?
:param scaled_output: ?
:param daisy: I think it changes something about the sample rate.
:param log: ?
:param timeout: ?
"""
self.log = log # print_incoming_text needs log
self.verbose = verbose
if self.verbose:
print("Connecting to V3 at port %s" % str(port))
port_val = 0
while True:
try:
if type(port) is int:
port = 'COM' + str(port)
self.ser = serial.Serial(port=port, baudrate=baud, timeout=timeout)
break
except serial.SerialException:
if port_val >= 10:
raise serial.SerialException("Unable to connect to the COMPORT")
port = port[:-1] + str(port_val)
port_val += 1
if self.verbose:
print("Serial established - port %s..." % str(port))
time.sleep(2)
# Initialize 32-bit board, doesn't affect 8-bit board
self.ser.write(b'v')
# wait for device to be ready
time.sleep(1)
self.print_incoming_text()
self.streaming = False
self.filtering_data = filter_data
self.scaling_output = scaled_output
self.eeg_channels_per_sample = 8 # number of EEG channels per sample *from the board*
self.aux_channels_per_sample = 3 # number of AUX channels per sample *from the board*
self.read_state = 0
self.daisy = daisy
self.last_odd_sample = OpenBCISample(-1, [], []) # used for daisy
self.log_packet_count = 0
self.attempt_reconnect = False
self.last_reconnect = 0
self.reconnect_freq = 5
self.packets_dropped = 0
# Disconnects from board when terminated
atexit.register(self.disconnect)
def __init__(self,
serdev,
callback=None,
refresh_callback=CameraPublisher.ALWAYS_REFRESH,
freq_callback=0.1,
baudrate=115200,
timeout=1):
super(DemoArUco, self).__init__()
self.name = self.__class__.__name__
print "Init %s..." % self.name
self.on_error = None
self.publisher = None
self._pid = None
self._gvcview = None
self._baudrate = baudrate
self._timeout = timeout
self._serdev = serdev
self._stop_event = threading.Event()
try:
self.publisher = CameraPublisher.CameraPublisher(
serdev, callback, refresh_callback, freq_callback, baudrate,
timeout)
print "%s set_on_error %s" % (self.name, str(
self.on_error_received))
self.publisher.set_on_error(self.on_error_received)
except serial.serialutil.SerialException as e:
self.close()
raise serial.SerialException(e)
print "Init %s done" % self.name
def _registerSer(self):
"""
Checks to see if another TecanAPISerial instance has registered the
same serial port in `ser_mapping`. If there is a conflict, checks to
see if the parameters match, and if they do, shares the connection.
Otherwise it raises a `serial.SerialException`.
"""
reg = TecanAPISerial.ser_mapping
port = self.ser_port
if self.ser_port not in reg:
reg[port] = {}
reg[port]['info'] = {k: v for k, v in self.ser_info.items()}
reg[port]['_ser'] = serial.Serial(
port=port,
baudrate=reg[port]['info']['baud'],
timeout=reg[port]['info']['timeout'])
reg[port]['_devices'] = [self.id_]
else:
if len(
set(self.ser_info.items())
& set(reg[port]['info'].items())) != 3:
raise serial.SerialException('TecanAPISerial conflict: ' \
'another device is already registered to {0} with ' \
'different parameters'.format(port))
else:
reg[port]['_devices'].append(self.id_)
self._ser = reg[port]['_ser']
def __init__(self, serdev, callback=None, refresh_callback=ALWAYS_REFRESH,
freq_callback=0.1, baudrate=115200, timeout=1):
'''try:
self._ser = serial.Serial(serdev, baudrate=baudrate, timeout=timeout)
except serial.SerialException as e:
print str(e)
raise serial.SerialException(e)'''
print "Init CameraPublisher"
self._ser = None
self._value = None
self._stop = False
self._prev_value = None
self.on_error = None
self._refresh_callback = refresh_callback
self._callback = callback
self._freq_callback = freq_callback
try:
self.jevois_serial = JevoisSerial.JevoisSerial(serdev, baudrate, timeout)
except serial.SerialException as e:
self.close()
raise serial.SerialException(e)
if self._callback is not None:
self._callback_get = Thread(target=self.callback_get_value)
else:
self._callback_get = None
self.publisher = Thread(target=self.publish_value)
print "Init CameraPublisher Done"
def Send(self, command):
"""Sends a command.
It blocks at most write_timeout seconds.
Args:
command: command to send.
Raises:
SerialTimeoutException if it is timeout and fails to send the command.
SerialException if it is disconnected during sending.
"""
try:
self._serial.write(command)
self._serial.flush()
if self.log:
logging.info('Successfully sent %r', command)
except serial.SerialTimeoutException:
error_message = 'Send %r timeout after %.2f seconds' % (
command, self._serial.getWriteTimeout())
if self.log:
logging.warning(error_message)
raise serial.SerialTimeoutException(error_message)
except serial.SerialException:
raise serial.SerialException('Serial disconnected')
def readSerial(self):
cnt = 0
# read pack head
while (True):
tmp = self.ser.read()
#print(tmp)
if (tmp == b'\xaa'):
tmp = self.ser.read()
if (tmp == b'\x77'):
break
cnt += 1
if (50 == cnt):
raise serial.SerialTimeoutException()
# from here data is to be returned
tmp = self.ser.read(3)
ret = [0xaa, 0x77, tmp[0], tmp[1], tmp[2]]
tmp = self.ser.read(ret[4] + 2)
for d in tmp:
ret.append(d)
crc = self.CRC16_MODBUS(ret[0:-2])
if ((crc & 0xff == ret[-2]) and ((crc >> 8) & 0xff == ret[-1])):
return ret[2:-2]
else:
# print(ret)
raise serial.SerialException("data corrupted")
def format_tracks(self, tracks=None, secs=10):
'''Format specific tracks to known state, ie, 10101..., not tested'''
tracks = tracks if tracks else self._deftracks
if (tracks & ~(PyMAKInt.TRACK1 | PyMAKInt.TRACK2 | PyMAKInt.TRACK3)) != 0 or \
(tracks & (PyMAKInt.TRACK1 | PyMAKInt.TRACK2 | PyMAKInt.TRACK3)) == 0:
raise ValueError('Invalid track specified')
self._serialobj.write(b'F' +
bytes([tracks] + bytes([secs * 8]) + b'\\'))
self._serialobj.timeout = 1
readbytes = self._serialobj.read(3)
if readbytes != b'FM ':
raise serial.SerialException('Error initializing card format')
self._serialobj.timeout = 1 + (secs * 8)
readbytes = self._serialobj.read(5)
if readbytes != b'FM=OK':
raise serial.SerialException('Error performing card format')
def Connect(self, driver=None, port=None,
baudrate=9600, bytesize=serial.EIGHTBITS,
parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE,
timeout=0.5, writeTimeout=0.5):
"""Opens a serial connection by port or by device driver name.
Args:
driver: driver name of the target serial connection. Used to look up port
if port is not specified.
port, baudrate, bytesize, parity, stopbits, timeout, writeTimeout: See
serial.Serial().
Raises:
SerialException on errors.
"""
if driver and not port:
port = FindTtyByDriver(driver)
if not port:
raise serial.SerialException(
'Serial device with driver %r not found' % driver)
self._port = port
self._serial = OpenSerial(
port=port, baudrate=baudrate, bytesize=bytesize, parity=parity,
stopbits=stopbits, timeout=timeout, writeTimeout=writeTimeout)
if self.log:
logging.info('Serial port %r opened', port)
def __init__(self, km232_serial_device, verbose=False):
'''
This is the constructor and will initiate serial connection
'''
self.serial_device = km232_serial_device
self.verbose = verbose
if self.verbose:
print("UsbKm232.serial_device= %s" % self.serial_device)
#LOGGER.info("UsbKm232.serial_device= %s"%self.serial_device)
if self.serial_device:
tries = 5
while tries > 0:
try:
self.serial = serial.Serial(self.serial_device,
baudrate=9600)
self.serial.setTimeout(0.5)
self.serial.setWriteTimeout(0.5)
except serial.SerialException, e:
# try maximum 5 times to initialize the serial
if tries == 1:
raise serial.SerialException(e)
tries = tries - 1
time.sleep(2)
else:
tries = 0
def readData(self, size=100):
cp = self._commport
if cp.is_open:
return cp.read(size).decode()
else:
raise serial.SerialException(
'Attempting to use a port that is not open')
def erase_tracks(self, tracks=None, secs=10, reverse=False):
'''Erase data on selected tracks in forward or reverse direction for secs seconds, not tested'''
tracks = tracks if tracks else self._deftracks
if (tracks & ~(PyMAKInt.TRACK1 | PyMAKInt.TRACK2 | PyMAKInt.TRACK3)) != 0 or \
(tracks & (PyMAKInt.TRACK1 | PyMAKInt.TRACK2 | PyMAKInt.TRACK3)) == 0:
raise ValueError('Invalid track specified')
self._serialobj.write((b'e' if reverse else b'E') + bytes([tracks]) +
bytes([secs]))
self._serialobj.timeout = 1
readbytes = self._serialobj.read(3)
if readbytes != (b'eR ' if reverse else b'Er '):
raise serial.SerialException('Error initialising card erase')
self._serialobj.timeout = 1 + secs
readbytes = self._serialobj.read(5)
if readbytes != (b'eR=OK' if reverse else b'Er=OK'):
raise serial.SerialException('Error card erase failure')
def Send(self, command, flush=True):
"""Sends a command.
It blocks at most write_timeout seconds.
Args:
command: command to send.
flush: call flush() after write(). Default True.
Raises:
SerialTimeoutException if it is timeout and fails to send the command.
SerialException if it is disconnected during sending.
"""
try:
start_time = time.time()
self._serial.write(command)
if flush:
self._serial.flush()
if self.log:
duration = time.time() - start_time
logging.info('Successfully sent %r. Took %.3f seconds',
command, duration)
except serial.SerialTimeoutException:
error_message = 'Send %r timeout after %.2f seconds' % (
command, self._serial.getWriteTimeout())
if self.log:
logging.warning(error_message)
raise serial.SerialTimeoutException(error_message)
except serial.SerialException:
raise serial.SerialException('Serial disconnected')
def serialComm(message, port, baudrate=9600, bytesize='8', parity='NONE', stopbits='1'):
bytesizeMap = {
'5': serial.FIVEBITS,
'6': serial.SIXBITS,
'7': serial.SEVENBITS,
'8': serial.EIGHTBITS
}
parityMap = {
'NONE': serial.PARITY_NONE,
'EVEN': serial.PARITY_EVEN,
'ODD': serial.PARITY_ODD
}
stopbitsMap = {
'1': serial.STOPBITS_ONE,
'1.5': serial.STOPBITS_ONE_POINT_FIVE,
'2': serial.STOPBITS_TWO
}
bytesize = bytesizeMap.get(bytesize, serial.EIGHTBITS)
parity = parityMap.get(parity, serial.PARITY_NONE)
stopbits = stopbitsMap.get(stopbits, serial.STOPBITS_ONE)
# 一个 ascii 8 位，停止位 2 位，起始位 1 位，校验位 1 位
timeout = math.ceil(12 * len(message) / baudrate)
with serial.Serial(port, baudrate, timeout=timeout, bytesize=bytesize,
parity=parity, stopbits=stopbits) as ser:
lenth = len(message)
message = bytes(message, 'ascii')
sentLenth = ser.write(message)
end = ser.readline()
if lenth != sentLenth:
raise serial.SerialException('Send data is incomplete')
def get_current_text_messages(self,
include_read=False,
leave_unread=False):
if self.__connected:
cmd = [self.__text_msg_commands['list_messages'], "="]
if include_read:
cmd.append('\"ALL\",')
else:
cmd.append('\"REC UNREAD\",')
cmd.append(str(int(leave_unread)))
cmd.append("\n")
raw_messages = self.__status_query("".join(cmd))
trimmed_messages = []
for line in raw_messages:
logging.debug(line)
if not str.startswith(line, "AT+CMGL"):
# Comes up at strange times. Discard.
if not str.startswith(line, "+CMTI"):
# Don't include lines that are only \r\n.
if not str.isspace(line):
# Strip off extra \r\n at the end of each line
trimmed_messages.append(line.rstrip())
messages = []
for i in range(0, int((len(trimmed_messages) - 1) / 2)):
messages.append(FonaMessage(trimmed_messages[2 * i:2 * i + 2]))
return messages
else:
raise serial.SerialException(
"Not connected to FONA. Can't read text messages.")
def __init__(self,
port='/dev/ttyUSB0',
deftracks=(TRACK1 | TRACK2 | TRACK3)):
'''Open the default USB port and check reader version, tested on MSUSB CZ.090211'''
self._portname = port
self._defracks = deftracks
try:
self._serialobj = serial.Serial(port, 38400, timeout=1)
except serial.serialutil.SerialException:
raise serial.SerialException('Error opening serial port')
self._serialobj.write(b'?')
self._rversion = self._serialobj.read(15)
if self._rversion == b'':
raise serial.SerialException('Reader not responding')
if self._rversion[0:5] != b'MSUSB':
raise serial.SerialException('Reader not valid')
def __init__(self,
addr,
baudrate=115200,
timeout=2,
verify_checksum=False,
verbose=0):
"""
Initiates the serial connection with the device in address addr, using a specified baudrate.
:param addr:
:param baudrate:
:param timeout:
"""
self.verbose = verbose
self.verify_checksum = verify_checksum
self.mutex = Lock()
try:
serial.Serial.__init__(self,
port=addr,
baudrate=baudrate,
timeout=timeout)
if self.verbose > 5:
print("Connection to " + addr + " was successful")
except serial.SerialException as e:
if self.verbose > 5:
print("Connection to " + addr + " failed with: " + str(e))
raise serial.SerialException(e)
def open(self):
if self.ser == None:
raise serial.SerialException(
'Serialino/open: Not connected to any serial port')
return -3
if self.ser.is_open:
sys.stderr.write(
'Attempt to open an already opened serial port {}\n'.format(
self.ser.name))
#return -1
if self.status == 1:
return 0
self.status = 0
#self.initstate = 0
if not self.ser.is_open:
try:
self.ser.open()
except serial.SerialException as e:
sys.stderr.write(
'Could not open Arduino serial port {}: {}\n'.format(
self.ser.name, e))
return -2
if self.RdThread == None:
self.serq = queue.Queue()
self.serqThread = threading.Thread(target=self.incoming,
daemon=True)
self.serqThread.start()
self.RdThread = SerThread(self.ser, SerTrans, self.serq)
self.RdThread.start()
self.RdThread.connect()
self.status = 1
return 0
