class TcpDevice(DataDevice):
'''
classdocs
'''
def __init__(self, params={}, parent=None):
'''
Constructor
'''
super(TcpDevice, self).__init__(params, parent)
self.iodevice = QTcpSocket()
self.reconnect = int(params.get('Reconnect', 1000))
self.host = params.get('Host', None)
self.port = int(params.get('Port', 2000))
self.gpsdInit = bool(params.get('GpsdInit', False))
self.iodevice.readyRead.connect(self.readyRead)
self.iodevice.error.connect(self.socketError)
self.iodevice.connected.connect(self.socketConnected)
self.iodevice.disconnected.connect(self.socketDisconnected)
@pyqtSlot(QAbstractSocket.SocketError)
def socketError(self, error):
if self.iodevice.state() != QAbstractSocket.BoundState:
if self.reconnect > 0:
QTimer.singleShot(self.reconnect, self.onReconnectTimer)
def connectDevice(self):
self.iodevice.connectToHost(self.host, self.port)
def disconnectDevice(self):
if self.iodevice.state() is QAbstractSocket.ConnectedState:
self.iodevice.disconnectFromHost()
def readData(self):
size = self.iodevice.bytesAvailable()
data = self.iodevice.read(size)
return data
def readLine(self):
if self.iodevice.canReadLine():
return str(self.iodevice.readLine())
return ''
@pyqtSlot()
def socketConnected(self):
self.deviceConnected.emit(True)
if self.gpsdInit:
self.iodevice.writeData('?WATCH={"class":"WATCH","nmea":true}')
@pyqtSlot()
def socketDisconnected(self):
self.deviceDisconnected.emit(True)
class TcpClient(QObject):
packet = pyqtSignal(str)
connected = pyqtSignal()
disconnected = pyqtSignal()
def __init__(self, host):
super().__init__()
self._sock = QTcpSocket()
self._host = host
self._log = logging.getLogger('tcp')
self._sock.connected.connect(self.greet)
self._sock.connected.connect(self.connected.emit)
self._sock.disconnected.connect(self.disconnected.emit)
self._sock.readyRead.connect(self.recv)
def set_host(self, host):
self._sock.disconnectFromHost()
self._host = host
def try_connect(self, port):
msg = 'connecting to ({}:{})'
msg = msg.format(self._host.toString(), port)
self._log.debug(msg)
self._sock.connectToHost(self._host, port)
ok = self._sock.waitForConnected()
if ok:
self._log.debug('connection successful')
else:
self._log.error('failed to connect')
def greet(self):
self.send(query_tag('port', 'udp'), '')
def recv(self):
while self._sock.canReadLine():
data = bytes(self._sock.readLine()) # handle QByteArray
message = data.decode()
self.packet.emit(message)
def send(self, tag, payload):
message = tag + ':' + payload + '\n'
data = message.encode()
self._sock.write(data)
class TcpClient(QObject):
packet = pyqtSignal(str)
connected = pyqtSignal()
disconnected = pyqtSignal()
def __init__(self, host):
super().__init__()
self._sock = QTcpSocket()
self._pending = None
self._host = host
self._log = logging.getLogger("tcp")
self._sock.connected.connect(self.greet)
self._sock.connected.connect(self.connected.emit)
self._sock.disconnected.connect(self.disconnected.emit)
self._sock.readyRead.connect(self.recv)
def set_host(self, host):
self._sock.disconnectFromHost()
self._host = host
def _cancel_pending(self):
self._pending.stop()
self._pending = None
self._sock.connected.disconnect(self._connection_success)
@pyqtSlot()
def _connection_success(self):
self._cancel_pending()
self._log.debug("connection successful")
@pyqtSlot()
def _connection_failure(self):
self._cancel_pending()
self._log.debug("connection failed")
def try_connect(self, port):
if self._pending:
self._cancel_pending()
self._sock.disconnectFromHost()
if self._sock.state() != QAbstractSocket.UnconnectedState:
self._sock.waitForDisconnected()
msg = "connecting to ({}:{})"
msg = msg.format(self._host.toString(), port)
self._log.debug(msg)
self._pending = QTimer()
self._pending.timeout.connect(self._connection_failure)
self._pending.setSingleShot(True)
self._sock.connected.connect(self._connection_success)
self._pending.start(10000)
self._sock.connectToHost(self._host, port)
def greet(self):
self.send(query_tag("port", "udp"), "")
def recv(self):
while self._sock.canReadLine():
data = bytes(self._sock.readLine()) # handle QByteArray
message = data.decode()
self.packet.emit(message)
def send(self, tag, payload):
message = tag + ":" + payload + "\n"
data = message.encode()
self._sock.write(data)
class TcpClient(QObject):
packet = pyqtSignal(str)
connected = pyqtSignal()
disconnected = pyqtSignal()
def __init__(self, host):
super().__init__()
self._sock = QTcpSocket()
self._pending = None
self._host = host
self._log = logging.getLogger('tcp')
self._sock.connected.connect(self.greet)
self._sock.connected.connect(self.connected.emit)
self._sock.disconnected.connect(self.disconnected.emit)
self._sock.readyRead.connect(self.recv)
def set_host(self, host):
self._sock.disconnectFromHost()
self._host = host
def _cancel_pending(self):
self._pending.stop()
self._pending = None
self._sock.connected.disconnect(self._connection_success)
@pyqtSlot()
def _connection_success(self):
self._cancel_pending()
self._log.debug('connection successful')
@pyqtSlot()
def _connection_failure(self):
self._cancel_pending()
self._log.debug('connection failed')
def try_connect(self, port):
if self._pending:
self._cancel_pending()
self._sock.disconnectFromHost()
if self._sock.state() != QAbstractSocket.UnconnectedState:
self._sock.waitForDisconnected()
msg = 'connecting to ({}:{})'
msg = msg.format(self._host.toString(), port)
self._log.debug(msg)
self._pending = QTimer()
self._pending.timeout.connect(self._connection_failure)
self._pending.setSingleShot(True)
self._sock.connected.connect(self._connection_success)
self._pending.start(10000)
self._sock.connectToHost(self._host, port)
def greet(self):
self.send(query_tag('port', 'udp'), '')
def recv(self):
while self._sock.canReadLine():
data = bytes(self._sock.readLine()) # handle QByteArray
message = data.decode()
self.packet.emit(message)
def send(self, tag, payload):
message = tag + ':' + payload + '\n'
data = message.encode()
self._sock.write(data)
