def test_show():
cb = CircIoBuffer(TEST_STRING, byte_size=TEST_STRING_LEN)
print
expected_result = ' H <-0\n' \
'|t|e|s|t| |s|t|r|i|n|g| 11\n' \
' T <-0'
assert cb.show() == expected_result
class MainW(QtGui.QMainWindow):
"""
Mainw to host and run one single thread
"""
def __init__(self):
QtGui.QMainWindow.__init__(self)
self.mutex = QMutex()
self.thr = GuiThread(process=self.fun, period=0.1)
self.thr2 = GuiThread(process=self.fun2, period=0.1)
self.buff = CircIoBuffer(byte_size=15 * len('rafal miecznik'))
self.thr.start()
self.thr2.start()
time.sleep(2)
print(self.buff.read())
for d in dir(self.mutex):
print(d)
def fun(self):
print(self.mutex.tryLock())
self.buff.write(' rafal')
self.mutex.unlock()
#print self.thr.currentThreadId()
def fun2(self):
self.mutex.lock()
self.buff.write(' miecznik')
def __init__(self):
QtGui.QMainWindow.__init__(self)
self.mutex = QMutex()
self.thr = GuiThread(process=self.fun, period=0.1)
self.thr2 = GuiThread(process=self.fun2, period=0.1)
self.buff = CircIoBuffer(byte_size=15 * len('rafal miecznik'))
self.thr.start()
self.thr2.start()
time.sleep(2)
print(self.buff.read())
for d in dir(self.mutex):
print(d)
def test_tail_markger():
size = 5
cb = CircIoBuffer(byte_size=size)
assert cb._tail == 0
cb = CircIoBuffer(byte_size=size, initial_buffer='12')
assert cb._tail == 2
cb = CircIoBuffer(byte_size=size, initial_buffer='12345')
assert cb._tail == 0
cb.write('12')
assert cb._tail == 2
cb.write('3451')
assert cb._tail == 1
assert len(cb) == size
assert cb._available == size
def init_rxbuffers(self):
self.raw_buffer = CircIoBuffer(byte_size=256 * 16 + 2)
class Emulator():
def __init__(self, port, address, event_handler=None, timeout=1, rcv_chunk_size=256):
debug("Init of {}".format(Emulator.__name__))
#TODO: add procedure in main window to estiamte best rcv_chunksize in loop
self.__rcv_chunk_size = rcv_chunk_size
self.__lock = False
self.connected = False
self.event_handler = event_handler
self.emu_timeout = timeout
self.port = port
self.address = address
self.init_rxbuffers()
#self.__dump_file = open(os.path.join(LOG_PATH, 'rx_dump.dmp'), 'w')
def set_rcv_chunk_size(self, value):
self.__rcv_chunk_size = value
def get_rcv_chunk_size(self):
return self.__rcv_chunk_size
def init_rxbuffers(self):
self.raw_buffer = CircIoBuffer(byte_size=256 * 16 + 2)
def lock(self):
#get remaining data first
time.sleep(self.emu_timeout)
if self.rx_buffer.available():
self.event_handler.get_emu_rx_buffer_slot()
self.__lock = True
def is_locked(self):
return self.__lock
def unlock(self):
info("Unlock emu buffer")
self.__lock = False
def receive_data_amount(self, amount=1, timeout=2, rcv_ready_signal=None, failed_signal=None, period=0.5, unlock_emu=True):
if not rcv_ready_signal:
rcv_ready_signal = self.event_handler.get_emu_rx_buffer_slot()
tstamp = time.time()
while self.rx_buffer.available() < amount:
time.sleep(period)
if time.time() - tstamp > timeout:
if failed_signal:
failed_signal()
return False
rcv_ready_signal()
return True
def set_event_handler(self, event_handler):
self.event_handler = event_handler
def connect(self, port, address):
self.address = address
self.port = port
if not self.connected:
self._connect()
else:
self.event_handler.message("Already connected")
def disconnect(self):
try:
if self.bt_connection:
self.bt_connection.close()
self.bt_connection = False
self.connected = False
self.event_handler.message("disconnected from emu device")
except AttributeError as A:
if A.message != "Emulator instance has no attribute 'bt_connection'":
raise AttributeError(A)
def _connect(self):
msg = "Connecting to bt device addr: {}, port: {}".format(self.address, self.port)
self.event_handler.message(msg)
try_num = 0
num_of_tries = 3
while try_num < num_of_tries:
try:
emu = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
#emu.connect((self.address, int(self.port)))
emu.connect((self.address, int(self.port)))
self.bt_connection = emu
#emu.settimeout((float(self.__rcv_chunk_size) * 9)/115200)
emu.settimeout(0)
self.event_handler.message("connected to emu device")
self.connected = True
return
except (bluetooth.btcommon.BluetoothError, IOError) as err:
try_num += 1
self.event_handler.message(err)
self.event_handler.message("Connection fail. Try: {}".format(try_num))
self.event_handler.message("Could not connect")
def set_timeout(self, value):
self.bt_connection.settimeout(value)
def get_connection_status(self):
return self.connected
def flush(self):
#self.bt_connection.recv(256*16)
self.raw_buffer.flush()
self.rx_buffer.flush()
def __try_get_data(self):
try:
rcv = self.bt_connection.recv(self.__rcv_chunk_size)
rx_debug("Received data amount: {}".format(len(rcv)))
rx_debug("rcv: {} ..".format(rcv[0:50]))
#self.__dump_file.write(rcv)
return rcv
except (bluetooth.btcommon.BluetoothError, IOError) as e:
#Linux and Windows support different exceptions here
#print e
return None
def __get_data(self):
try:
rx_data = self.bt_connection.recv(self.__rcv_chunk_size)
rx_debug("Received data amount: {}".format(len(rx_data)))
rx_debug("rcv: {} ..".format(rx_data[0:50]))
return rx_data
except (bluetooth.btcommon.BluetoothError, IOError) as e:
pass
def receive_data(self):
"""
:param rx_buffer:
:param rx_buffer_ready_slot:
:return:
"""
rx_data = self.__get_data()
while rx_data:
self.raw_buffer.write(rx_data)
rx_data = self.__get_data()
if self.raw_buffer.available():
self.event_handler.get_raw_rx_buffer_slot()
def send(self, data):
if not self.__lock:
if self.bt_connection:
try:
self.bt_connection.send(data)
except bluetooth.btcommon.BluetoothError as e:
error("LOST BT CONNECTION")
self.event_handler.lost_connection_slot()
raise e
else:
error("No bt_connection established")
else:
debug("Trying send: '{}', but emulator locked".format(data))
def test_peek():
cb = CircIoBuffer(TEST_STRING)
assert cb.peek() == TEST_STRING
assert len(cb) == TEST_STRING_LEN
assert cb.read() == TEST_STRING
assert len(cb) == 0
def test_read_big_buffers():
test_string = '12345'
size = len(test_string)
cb = CircIoBuffer(byte_size=size, initial_buffer=test_string)
assert len(cb) == len(test_string)
cb.write('x')
assert len(cb) == len(test_string)
assert cb.read(1) == '2'
assert len(cb) == len(test_string) - 1
assert cb.read() == '345x'
assert len(cb) == 0
assert cb._tail == 1
assert cb._head == 1
cb.write('a')
assert len(cb) == 1
assert cb._tail == 2
assert cb._head == 1
assert cb.read(0) == ''
assert cb._tail == 2
assert cb._head == 1
cb.write('12345')
assert cb._tail == (2 + size) % size
assert cb._head == (2 + size) % size
assert cb.read() == '12345'
cb.write('abcde67890x')
assert cb.read() == '7890x'
def test_read():
cb = CircIoBuffer(initial_buffer=TEST_STRING, byte_size=TEST_STRING_LEN)
assert len(cb) == TEST_STRING_LEN
assert cb.read() == TEST_STRING
assert len(cb) == 0
def test_contains():
cb = CircIoBuffer(TEST_STRING)
assert 'test' in cb
cb.read(len('test'))
assert 'test' not in cb
def test_tail_circularity():
cb = CircIoBuffer(byte_size=5)
cb.write('12')
assert cb.tell() == 2
cb.write('345')
assert cb.tell() == 0
def test_circ_buffer_len():
cb = CircIoBuffer(TEST_STRING)
assert len(TEST_STRING) == len(cb)
def test_flush_unit_sequence_not_present():
cb = CircIoBuffer('this is test buffer', byte_size=20)
cb.flush_until('xxx')
assert cb.available() == 0
def test_flush_until():
cb = CircIoBuffer('this is test buffer', byte_size=20)
cb.flush_until('test')
assert cb.read() == ' buffer'
def test_writelines():
cb = CircIoBuffer()
try:
cb.writelines()
except NotImplementedError:
pass
def test_circbuffer_init():
""""Check if circ buffer is IOBase instance"""
from io import IOBase
cb = CircIoBuffer()
assert isinstance(cb, IOBase)
def test_head_marker():
cb = CircIoBuffer(byte_size=5)
assert cb._head == 0
cb = CircIoBuffer(byte_size=5, initial_buffer='12')
assert cb._head == 0
cb = CircIoBuffer(byte_size=5, initial_buffer='12345')
assert cb._head == 0
cb.write('12')
assert cb._head == 2
cb.write('3450')
assert cb._head == 1
cb.write('0000')
assert cb._head == 0
def test_flush():
cb = CircIoBuffer(TEST_STRING, byte_size=123)
cb.flush()
assert cb._limit == 123
assert cb.read() == ''
cb.write('tmp')
assert len(cb) == 3
assert cb.read() == 'tmp'
cb.write(123*'dd')
assert len(cb) == 123
assert cb.read() == 123*'d'
