Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Comms: Convert TCP to Signals/Slots #11740

Draft
wants to merge 1 commit into
base: master
Choose a base branch
from
+181 −191
Draft

Comms: Convert TCP to Signals/Slots #11740

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
269 changes: 142 additions & 127 deletions src/Comms/TCPLink.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,196 +9,211 @@

#include "TCPLink.h"
#include "DeviceInfo.h"
#include "QGCLoggingCategory.h"

#include <QtCore/QList>
#include <QtNetwork/QTcpSocket>
#include <QtTest/QSignalSpy>

TCPLink::TCPLink(SharedLinkConfigurationPtr& config)
: LinkInterface(config)
QGC_LOGGING_CATEGORY(TCPLinkLog, "TEST.comms.tcplink")

// MAVLINK_COMM_NUM_BUFFERS

TCPLink::TCPLink(SharedLinkConfigurationPtr &config, QObject *parent)
: LinkInterface(config, parent)
, _tcpConfig(qobject_cast<const TCPConfiguration*>(config.get()))
, _socket(nullptr)
, _socketIsConnected(false)
, _socket(new QTcpSocket())
{
Q_ASSERT(_tcpConfig);
}
// qCDebug(TCPLinkLog) << Q_FUNC_INFO << this;

TCPLink::~TCPLink()
{
disconnect();
}
Q_CHECK_PTR(_tcpConfig);

#ifdef TCPLINK_READWRITE_DEBUG
void TCPLink::_writeDebugBytes(const QByteArray data)
{
QString bytes;
QString ascii;
for (int i=0, size = data.size(); i<size; i++)
{
unsigned char v = data[i];
bytes.append(QString::asprintf("%02x ", v));
if (data[i] > 31 && data[i] < 127)
{
ascii.append(data[i]);
}
else
{
ascii.append(219);
}
}
qDebug() << "Sent" << size << "bytes to" << _tcpConfig->host() << ":" << _tcpConfig->port() << "data:";
qDebug() << bytes;
qDebug() << "ASCII:" << ascii;
}
_socket->setSocketOption(QAbstractSocket::KeepAliveOption, 1);
// _socket->setSocketOption(QAbstractSocket::TypeOfServiceOption, 32);
// MAVLINK_MAX_PACKET_LEN
_socket->setSocketOption(QAbstractSocket::SendBufferSizeSocketOption, 1024);
_socket->setSocketOption(QAbstractSocket::ReceiveBufferSizeSocketOption, 1024);
// _socket->setReadBufferSize(1024);

(void) QObject::connect(_socket, &QTcpSocket::connected, this, &TCPLink::connected, Qt::AutoConnection);
(void) QObject::connect(_socket, &QTcpSocket::disconnected, this, &TCPLink::disconnected, Qt::AutoConnection);

(void) QObject::connect(_socket, &QTcpSocket::errorOccurred, this, [this](QTcpSocket::SocketError error) {
qCWarning(TCPLinkLog) << "TCP Link Error:" << error << _socket->errorString();
emit communicationError(QStringLiteral("TCP Link Error"), QStringLiteral("Link: %1, %2.").arg(_tcpConfig->name(), _socket->errorString()));
}, Qt::AutoConnection);

#ifdef QT_DEBUG
(void) QObject::connect(_socket, &QTcpSocket::stateChanged, this, [](QTcpSocket::SocketState state) {
qCDebug(TCPLinkLog) << "TCP State Changed:" << state;
}, Qt::AutoConnection);

(void) QObject::connect(_socket, &QTcpSocket::hostFound, this, []() {
qCDebug(TCPLinkLog) << "TCP Host Found";
}, Qt::AutoConnection);
#endif
}

void TCPLink::_writeBytes(const QByteArray &data)
TCPLink::~TCPLink()
{
#ifdef TCPLINK_READWRITE_DEBUG
_writeDebugBytes(data);
#endif
_socket->deleteLater();

if (_socket) {
_socket->write(data);
emit bytesSent(this, data);
}
// qCDebug(TCPLinkLog) << Q_FUNC_INFO << this;
}

void TCPLink::_readBytes()
bool TCPLink::isConnected() const
{
if (_socket) {
qint64 byteCount = _socket->bytesAvailable();
if (byteCount)
{
QByteArray buffer;
buffer.resize(byteCount);
_socket->read(buffer.data(), buffer.size());
emit bytesReceived(this, buffer);
#ifdef TCPLINK_READWRITE_DEBUG
writeDebugBytes(buffer.data(), buffer.size());
#endif
}
}
return ((_socket->state() == QAbstractSocket::ConnectedState) || (_socket->state() == QAbstractSocket::ConnectingState));
}

void TCPLink::disconnect(void)
void TCPLink::disconnect()
{
if (_socket) {
// This prevents stale signal from calling the link after it has been deleted
QObject::disconnect(_socket, &QIODevice::readyRead, this, &TCPLink::_readBytes);
_socketIsConnected = false;
_socket->disconnectFromHost(); // Disconnect tcp
_socket->deleteLater(); // Make sure delete happens on correct thread
_socket = nullptr;
emit disconnected();
}
(void) QObject::disconnect(_socket, &QTcpSocket::readyRead, this, &TCPLink::_readBytes);

_socket->disconnectFromHost();
}

bool TCPLink::_connect(void)
bool TCPLink::_connect()
{
if (_socket) {
qWarning() << "connect called while already connected";
if (isConnected()) {
return true;
}

return _hardwareConnect();
}

bool TCPLink::_hardwareConnect()
{
Q_ASSERT(_socket == nullptr);
_socket = new QTcpSocket();
QObject::connect(_socket, &QIODevice::readyRead, this, &TCPLink::_readBytes);
static const QString title = tr("TCP Link Connect Error");
static const QString error = tr("Link %1: %2.");

QSignalSpy errorSpy(_socket, &QAbstractSocket::errorOccurred);
QObject::connect(_socket, &QAbstractSocket::errorOccurred, this, &TCPLink::_socketError);
(void) QObject::connect(_socket, &QTcpSocket::readyRead, this, &TCPLink::_readBytes, Qt::AutoConnection);
// (void) connect(_socket, &QTcpSocket::bytesWritten, this, [this](qint64 written) {});

_socket->connectToHost(_tcpConfig->host(), _tcpConfig->port());

// Give the socket a second to connect to the other side otherwise error out
if (!_socket->waitForConnected(1000))
{
// Whether a failed connection emits an error signal or not is platform specific.
// So in cases where it is not emitted, we emit one ourselves.
if (errorSpy.count() == 0) {
emit communicationError(tr("Link Error"), tr("Error on link %1. Connection failed").arg(_config->name()));
}
delete _socket;
_socket = nullptr;
if (!_socket->isValid()) {
return false;
}
_socketIsConnected = true;
emit connected();

if (!_socket->waitForConnected(1000)) {
emit communicationError(title, error.arg(_tcpConfig->name(), tr("Connection failed")));
}

return true;
}

void TCPLink::_socketError(QAbstractSocket::SocketError socketError)
void TCPLink::_writeBytes(const QByteArray &bytes)
{
Q_UNUSED(socketError);
emit communicationError(tr("Link Error"), tr("Error on link %1. Error on socket: %2.").arg(_config->name()).arg(_socket->errorString()));
if (!_socket->isValid()) {
return;
}

static const QString title = tr("TCP Link Write Error");
static const QString error = tr("Link %1: %2.");

if (!isConnected()) {
emit communicationError(title, error.arg(_tcpConfig->name(), tr("Could Not Send Data - Link is Disconnected!")));
return;
}

const qint64 bytesWritten = _socket->write(bytes);
if (bytesWritten < 0) {
emit communicationError(title, error.arg(_tcpConfig->name(), tr("Could Not Send Data - Write Failed!")));
return;
}

if (bytesWritten < bytes.size()) {
qCWarning(TCPLinkLog) << "Wrote" << bytesWritten << "Out of" << bytes.size() << "total bytes";
// const QByteArray remainingBytes = bytes.sliced(bytesWritten - 1, bytes.size() - bytesWritten);
// writeBytesThreadSafe(remainingBytes.constData(), remainingBytes.size());
}

emit bytesSent(this, bytes);
}

/**
* @brief Check if connection is active.
*
* @return True if link is connected, false otherwise.
**/
bool TCPLink::isConnected() const
void TCPLink::_readBytes()
{
return _socketIsConnected;
if (!_socket->isValid()) {
return;
}

static const QString title = tr("TCP Link Read Error");
static const QString error = tr("Link %1: %2.");

if (!isConnected()) {
emit communicationError(title, error.arg(_tcpConfig->name(), tr("Could Not Read Data - link is Disconnected!")));
return;
}

const qint64 byteCount = _socket->bytesAvailable();
// MAVLINK_NUM_NON_PAYLOAD_BYTES
if (byteCount <= 0) {
emit communicationError(title, error.arg(_tcpConfig->name(), tr("Could Not Read Data - No Data Available!")));
return;
}

QByteArray buffer(byteCount, Qt::Initialization::Uninitialized);
// _socket->readAll()
if (_socket->read(buffer.data(), buffer.size()) < 0) {
emit communicationError(title, error.arg(_tcpConfig->name(), tr("Could Not Read Data - Read Failed!")));
return;
}

emit bytesReceived(this, buffer);
}

bool TCPLink::isSecureConnection()
{
return QGCDeviceInfo::isNetworkWired();
}

//--------------------------------------------------------------------------
//-- TCPConfiguration
/*===========================================================================*/

TCPConfiguration::TCPConfiguration(const QString& name) : LinkConfiguration(name)
TCPConfiguration::TCPConfiguration(const QString &name, QObject *parent)
: LinkConfiguration(name, parent)
{
_port = QGC_TCP_PORT;
_host = QLatin1String("0.0.0.0");
// qCDebug(TCPLinkLog) << Q_FUNC_INFO << this;
}

TCPConfiguration::TCPConfiguration(const TCPConfiguration* source) : LinkConfiguration(source)
TCPConfiguration::TCPConfiguration(const TCPConfiguration *copy, QObject *parent)
: LinkConfiguration(copy, parent)
, _host(copy->host())
, _port(copy->port())
{
_port = source->port();
_host = source->host();
}
// qCDebug(TCPLinkLog) << Q_FUNC_INFO << this;

void TCPConfiguration::copyFrom(const LinkConfiguration *source)
{
LinkConfiguration::copyFrom(source);
const TCPConfiguration* usource = qobject_cast<const TCPConfiguration*>(source);
Q_ASSERT(usource != nullptr);
_port = usource->port();
_host = usource->host();
Q_CHECK_PTR(copy);

LinkConfiguration::copyFrom(copy);
}

void TCPConfiguration::setPort(quint16 port)
TCPConfiguration::~TCPConfiguration()
{
_port = port;
// qCDebug(TCPLinkLog) << Q_FUNC_INFO << this;
}

void TCPConfiguration::setHost(const QString host)
void TCPConfiguration::copyFrom(const LinkConfiguration *source)
{
_host = host;
Q_CHECK_PTR(source);
LinkConfiguration::copyFrom(source);

const TCPConfiguration* const tcpSource = qobject_cast<const TCPConfiguration*>(source);
Q_CHECK_PTR(tcpSource);

setHost(tcpSource->host());
setPort(tcpSource->port());
}

void TCPConfiguration::saveSettings(QSettings& settings, const QString& root)
void TCPConfiguration::loadSettings(QSettings &settings, const QString &root)
{
settings.beginGroup(root);
settings.setValue("port", (int)_port);
settings.setValue("host", _host);

setHost(settings.value(QStringLiteral("host"), host()).toString());
setPort(static_cast<quint16>(settings.value(QStringLiteral("port"), port()).toUInt()));

settings.endGroup();
}

void TCPConfiguration::loadSettings(QSettings& settings, const QString& root)
void TCPConfiguration::saveSettings(QSettings &settings, const QString &root)
{
settings.beginGroup(root);
_port = (quint16)settings.value("port", QGC_TCP_PORT).toUInt();
_host = settings.value("host", _host).toString();

settings.setValue(QStringLiteral("host"), host());
settings.setValue(QStringLiteral("port"), port());

settings.endGroup();
}
Loading
Loading