This repository has been archived on 2024-06-03. You can view files and clone it, but cannot push or open issues or pull requests.
app/sources/baseconn.cpp

438 lines
11 KiB
C++
Raw Normal View History

#include "headers/baseconn.h"
BaseConn::BaseConn(QObject *parent) : QObject(parent)
{
socket = new QTcpSocket();
this->setState("disconnected");
connect(this->socket, SIGNAL(error(QAbstractSocket::SocketError)),
this, SLOT(gotError(QAbstractSocket::SocketError)));
this->nextConnectionId = 1;
this->speedTimers.append(pGlobalSpeedTimer);
this->refreshTimer = new QTimer();
refreshTimer->setInterval(1);
refreshTimer->setSingleShot(true);
refreshTimer->connect(this->refreshTimer, &QTimer::timeout, this, &BaseConn::refreshTimers);
refreshTimer->start();
}
bool BaseConn::connectToHost() {
qDebug() << "connecting";
setState("connecting");
this->connection_progress = 0;
QEventLoop loop;
QTimer timer;
timer.setSingleShot(true);
// quit the loop when the timer times out
loop.connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit()));
//quit the loop when the connection was established
loop.connect(this->socket, SIGNAL(connected()), &loop, SLOT(quit()));
// start the timer before starting to connect
timer.start(3000);
//connect
this->socket->connectToHost(this->ip, this->port);
//wait for the connection to finish (programm gets stuck in here)
loop.exec();
//loop finish
if(timer.remainingTime() == -1){
//the time has been triggered -> timeout
this->socket->abort();
setState("disconnected");
return(false);
}
// stop the timer as the connection has been established
timer.stop();
connect(this->socket, &QTcpSocket::readyRead, this, &BaseConn::readyRead);
this->connection_progress = 100;
setState("connected");
this->speedTimers[0]->remoteControlled = true;
return(true);
}
void BaseConn::closeConnection()
{
qDebug() << "closing connection";
switch (socket->state())
{
case 0:
socket->disconnectFromHost();
break;
case 2:
socket->abort();
break;
default:
socket->abort();
}
setState("disconnected");
// for(int i = 0; i < this->waitingRequests.length(); i++){
// this->waitingRequests[i].reply = "ERR_NOT_CONNECTED";
// this->waitingRequests[i].loop->quit();
// return;
// }
}
void BaseConn::gotError(QAbstractSocket::SocketError err)
{
//qDebug() << "got error";
QString strError = "unknown";
switch (err)
{
case 0:
strError = "Connection was refused";
break;
case 1:
strError = "Remote host closed the connection";
this->closeConnection();
break;
case 2:
strError = "Host address was not found";
break;
case 5:
strError = "Connection timed out";
break;
default:
strError = "Unknown error";
}
emit gotError(strError);
qDebug() << "got socket error: " << strError;
}
QVariantMap BaseConn::sendCommand(int header, QJsonValue data = ""){
if(this->state != "connected"){
return {{"status", 910}, {"data", "not connected"}};
}
// generate id and witing requests entry
int thisId = nextConnectionId;
nextConnectionId ++;
QEventLoop loop;
QJsonObject reply;
this->waitingRequests.append({thisId, &loop, reply});
QJsonObject requestObj;
requestObj.insert("id", thisId);
requestObj.insert("header", header);
requestObj.insert("data", data);
QString jsonRequest = QJsonDocument(requestObj).toJson();
QByteArray arrBlock;
QDataStream out(&arrBlock, QIODevice::WriteOnly);
//out.setVersion(QDataStream::Qt_5_10);
out << quint16(0) << jsonRequest;
out.device()->seek(0);
out << quint16(ulong(arrBlock.size()) - sizeof(quint16));
QTimer timer;
timer.setSingleShot(true);
// quit the loop when the timer times out
loop.connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit()));
// quit the loop when the connection was established
// loop.connect(this, &BaseConn::gotReply, &loop, &QEventLoop::quit);
// start the timer before starting to connect
timer.start(3000);
//write data
socket->write(arrBlock);
//wait for an answer to finish (programm gets stuck in here)
loop.exec();
//loop finished
if(timer.remainingTime() == -1){
//the time has been triggered -> timeout
return {{"status", 911}, {"data", ""}};
}
for(int i = 0; i<this->waitingRequests.length(); i++){
if(this->waitingRequests[i].id == thisId){
reply = this->waitingRequests[i].reply;
}
}
// stop the timer as the connection has been established
timer.stop();
timer.deleteLater();
//remoteSessions.release(1);
return {{"status", reply.value("header").toInt()}, {"data", reply.value("data").toVariant()}};
}
void BaseConn::readyRead() {
QDataStream in(socket);
//in.setVersion(QDataStream::Qt_5_10);
qint16 nextBlockSize = 0;
for (;;)
{
if (!nextBlockSize)
{
if (ulong(socket->bytesAvailable()) < sizeof(quint16)) { break; }
in >> nextBlockSize;
}
if (socket->bytesAvailable() < nextBlockSize) { break; }
QString str; in >> str;
// if (str == "0")
// {
// str = "Connection closed";
// closeConnection();
// }
nextBlockSize = 0;
QString reply = str;
int id = 0;
QJsonDocument jsonReply = QJsonDocument::fromJson(reply.toUtf8());
QJsonObject replyObj = jsonReply.object();
if(!replyObj.isEmpty()){
id = replyObj.value("id").toInt();
for(int i = 0; i < this->waitingRequests.length(); i++){
if(this->waitingRequests[i].id == id){
this->waitingRequests[i].reply = replyObj;
this->waitingRequests[i].loop->quit();
return;
}
}
}
latestReadReply = str;
emit gotUnexpectedReply(str);
}
}
int BaseConn::writeRemoteSetting(QString key, QString value) {
QJsonArray requestData;
requestData.append(key);
requestData.append(value);
return this->sendCommand(3000, requestData)["status"].toInt();
}
void BaseConn::refreshTimers(){
if(this->state != "connected"){
this->refreshTimer->start();
return;
}
QVariantMap tmpReply = this->sendCommand(2000);
if(tmpReply["status"] != 200){
return;
}
int remoteRaceState = tmpReply["data"].toInt();
switch (remoteRaceState) {
case 0:
{
// case IDLE
if(speedTimers[0]->state != 0){
speedTimers[0]->setState(SpeedTimer::IDLE);
}
break;
}
case 1:
{
// case STARTING
if(speedTimers[0]->state != 1){
speedTimers[0]->setState(SpeedTimer::STARTING);
}
tmpReply = sendCommand(2004);
if(tmpReply["status"] != 200){
//handle Error!!
qDebug() << "+--- getting next start action from basestation failed: " << tmpReply["status"];
this->refreshTimer->start();
return;
}
else {
if(this->nextRemoteAction != tmpReply["data"].toString()){
this->nextRemoteAction = tmpReply["data"].toString();
this->nextRemoteActionChanged();
}
}
tmpReply = sendCommand(2005);
if(tmpReply["status"] != 200){
//handle error!!
qDebug() << "+--- getting next start action progress from basestation failed";
this->refreshTimer->start();
return;
}
else {
if(this->nextRemoteActionDelayProg != tmpReply["data"].toFloat()){
this->nextRemoteActionDelayProg = tmpReply["data"].toFloat();
this->nextRemoteActionDelayProgChanged();
}
}
break;
}
case 2:
{
// case RUNNING
if(speedTimers[0]->state != 2){
speedTimers[0]->setState(SpeedTimer::RUNNING);
}
// get current time
tmpReply = sendCommand(2001, 0);
if(tmpReply["status"] != 200){
//handle error!!
qDebug() << "+--- getting current time (timer 0) from basestation failed";
this->refreshTimer->start();
return;
}
else {
speedTimers[0]->stoppedTime = tmpReply["data"].toInt();
}
break;
}
case 3:
{
// case STOPPED
if(speedTimers[0]->state != 3){
speedTimers[0]->setState(SpeedTimer::STOPPED);
}
// get current time
tmpReply = sendCommand(2001, 0);
if(tmpReply["status"] != 200){
//handle error!!
qDebug() << "+--- getting current time (timer 0) from basestation failed";
return;
}
else {
speedTimers[0]->stoppedTime = tmpReply["data"].toInt();
}
break;
}
default:
{
// some error
break;
}
}
this->refreshTimer->start();
}
bool BaseConn::startTimers(){
qDebug() << "starting timers";
QVariantMap reply = this->sendCommand(1000);
if(reply["status"] != 200){
//handle Error!!
return false;
}
this->speedTimers[0]->setState(SpeedTimer::STARTING);
return true;
}
bool BaseConn::stopTimers(QString type){
qDebug() << "stopping timers";
QVariantMap reply = this->sendCommand(1001);
if(reply["status"] != 200){
//handle Error!!
return false;
}
this->speedTimers[0]->stop(type);
qDebug() << "stopped timers";
return true;
}
bool BaseConn::resetTimers(){
qDebug() << "resetting timers";
QVariantMap reply = this->sendCommand(1002);
if(reply["status"] != 200){
//handle Error!!
return false;
}
this->speedTimers[0]->reset();
return true;
}
void BaseConn::setIP(const QString &ipAdress){
this->ip = ipAdress;
}
QString BaseConn::getIP() const
{
return(this->ip);
}
QString BaseConn::getState() const
{
return(this->state);
}
void BaseConn::setState(QString newState){
this->state = newState;
emit stateChanged();
}
int BaseConn::getProgress() const
{
return(connection_progress);
}
bool BaseConn::refreshConnections() {
QVariantMap reply = this->sendCommand(2006);
if(reply["status"] != 200){
//handle Error!!
qDebug() << "+--- error refreshing connections: " << reply["status"];
return false;
}
connections = reply["data"].toString().split("|||");
return true;
}
QStringList BaseConn::getConnections() {
return(connections);
}
QString BaseConn::getNextRemoteAction() {
return this->nextRemoteAction;
}
float BaseConn::getNextRemoteActionDelayProg(){
return this->nextRemoteActionDelayProg;
}