438 lines
11 KiB
C++
438 lines
11 KiB
C++
#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;
|
|
}
|
|
|