def listen(self):
high_resolution_time = self.perf_counter_origin < 0
timestamp_origin = self.timestamp_origin
perf_counter_origin = self.perf_counter_origin
while True:
if self.closeEvent.isSet():
return
if not self.commPort.inWaiting():
continue
if high_resolution_time:
recv_timestamp = time()
else:
recv_timestamp = timestamp_origin + perf_counter(
) - perf_counter_origin
length, counter = self.HEADER.unpack(
self.commPort.read(self.HEADER_SIZE))
response = self.commPort.read(length)
self.timing.stop()
if len(response) != length:
raise types.FrameSizeError("Size mismatch.")
self.processResponse(response, length, counter, recv_timestamp)
def processResponse(self, response, length, counter):
self.counterReceived = counter
if hasattr(self, 'use_tcp'):
use_tcp = self.use_tcp
else:
use_tcp = False
if not use_tcp:
# for TCP this error cannot occur, instead a timeout
# will be reaised while waiting for the correct number
# of bytes to be received to complete the message
if len(response) != length:
raise types.FrameSizeError("Size mismatch.")
pid = response[0]
if pid >= 0xFC:
self.logger.debug("<- L{} C{} {}".format(
length,
counter,
hexDump(response),
))
if pid >= 0xfe:
self.resQueue.put(response)
elif pid == 0xfd:
self.evQueue.put(response)
elif pid == 0xfc:
self.servQueue.put(response)
else:
if self.first_daq_timestamp is None:
self.first_daq_timestamp = datetime.now()
self.daqQueue.put((response, counter, length))
def processResponse(self, response):
if len(response) < self.HEADER_SIZE:
raise types.FrameSizeError("Frame too short.")
self.logger.debug("<- {}\n".format(hexDump(response)))
packetLen, self.counterReceived = struct.unpack(
self.HEADER, response[:4])
xcpPDU = response[4:]
if len(xcpPDU) != packetLen:
raise types.FrameSizeError("Size mismatch.")
pid = xcpPDU[0]
if pid == 0xff or xcpPDU[0] == 0xfe:
self.resQueue.put(xcpPDU)
elif pid == 0xfd:
self.evQueue.put(xcpPDU)
elif pid == 0xfc:
self.servQueue.put(xcpPDU)
else:
self.daqQueue.put(xcpPDU)
def listen(self):
while True:
if self.closeEvent.isSet():
return
if not self.commPort.inWaiting():
continue
length, counter = self.HEADER.unpack(
self.commPort.read(self.HEADER_SIZE))
response = self.commPort.read(length)
self.timing.stop()
if len(response) != length:
raise types.FrameSizeError("Size mismatch.")
self.processResponse(response, length, counter)
def processResponse(self, response, length, counter):
self.counterReceived = counter
response = response
if len(response) != length:
raise types.FrameSizeError("Size mismatch.")
pid = response[0]
if pid >= 0xFC:
self.logger.debug("<- L{} C{} {}\n".format(
length,
counter,
hexDump(response),
))
if pid >= 0xfe:
self.resQueue.put(response)
elif pid == 0xfd:
self.evQueue.put(response)
elif pid == 0xfc:
self.servQueue.put(response)
else:
if self.first_daq_timestamp is None:
self.first_daq_timestamp = datetime.now()
self.daqQueue.put((response, counter, length))
def listen(self):
HEADER_UNPACK = self.HEADER.unpack
HEADER_SIZE = self.HEADER_SIZE
use_tcp = self.use_tcp
processResponse = self.processResponse
EVENT_READ = selectors.EVENT_READ
close_event_set = self.closeEvent.isSet
socket_fileno = self.sock.fileno
select = self.selector.select
high_resolution_time = self.perf_counter_origin > 0
timestamp_origin = self.timestamp_origin
perf_counter_origin = self.perf_counter_origin
if use_tcp:
sock_recv = self.sock.recv
else:
sock_recv = self.sock.recvfrom
while True:
try:
if close_event_set() or socket_fileno() == -1:
return
sel = select(0.1)
for _, events in sel:
if events & EVENT_READ:
if high_resolution_time:
recv_timestamp = time()
else:
recv_timestamp = timestamp_origin + perf_counter() - perf_counter_origin
if use_tcp:
# first try to get the header in one go
# if we are lucky this will avoid creating a
# bytearray and extending it
header = sock_recv(HEADER_SIZE)
size = len(header)
if size != HEADER_SIZE:
start = perf_counter()
header = bytearray(header)
while len(header) != HEADER_SIZE:
header.extend(
sock_recv(HEADER_SIZE - len(header))
)
if perf_counter() - start > 2:
raise types.XcpTimeoutError("Eth frame header read timed out.") from None
length, counter = HEADER_UNPACK(header)
try:
# first try to get the response in one go
# similar to the header
response = sock_recv(length)
size = len(response)
if size != length:
start = perf_counter()
response = bytearray(response)
while len(response) != length:
response.extend(
sock_recv(length - len(response))
)
if perf_counter() - start > 2:
raise types.XcpTimeoutError("Eth frame payload read timed out.") from None
except Exception as e:
self.logger.error(str(e))
continue
else:
try:
response, _ = sock_recv(
Eth.MAX_DATAGRAM_SIZE
)
length, counter = HEADER_UNPACK(
response[:HEADER_SIZE]
)
response = response[HEADER_SIZE:]
if len(response) != length:
raise types.FrameSizeError("Size mismatch.")
except Exception as e:
self.logger.error(str(e))
continue
processResponse(response, length, counter, recv_timestamp)
except Exception:
self.status = 0 # disconnected
break
