Russian Qt Forum

C++ (Qt)
    ReadData *thread;
    TCPClientQt s_Client;
.....
    thread=new ReadData(this);
    QObject::connect(&s_Client,SIGNAL(sig_Connected()),this, SLOT(slotIsConnected()),Qt::AutoConnection);
    QObject::connect(&s_Client,SIGNAL(sig_newInfo()),this, SLOT(getNewInfo()),Qt::AutoConnection);
    QObject::connect(&s_Client,SIGNAL(sig_Disconnected()),this, SLOT(slotIsDisonnected()),Qt::AutoConnection);
    s_Client.moveToThread(thread);
 

C++ (Qt)
//work
 connect(m_pTcpSocket, SIGNAL(connected()), SLOT(slotConnected()));
 connect(m_pTcpSocket, SIGNAL(disconnected()), SLOT(slotDisconnected()));
 connect(m_pTcpSocket, SIGNAL(readyRead()), SLOT(slotReadyRead()));
//not work
 connect(m_pTcpSocket, SIGNAL(error(QAbstractSocket::SocketError)),this, SLOT(slotError(QAbstractSocket::SocketError)));
 connect(m_pTcpSocket, SIGNAL(stateChanged(QAbstractSocket::SocketState socketState )),this, SLOT(slotStateChanged(QAbstractSocket::SocketState)));
 

C++ (Qt)
class ReadData : public QThread
{
    Q_OBJECT
 
private:
    int m_Result;
 
public:
    explicit ReadData(QObject *parent = 0);
    ~ReadData();
 
    void run();
 
signals:
 
public slots:
 
};
 

C++ (Qt)
ReadData::ReadData(QObject *parent) :
    QThread(parent)
{
 //moveToThread(this);
//пробовал тут, но поток сам в себя лезть не хочет :)
 m_Result=-1;
}
 
void ReadData::run()
{
    try
    {
      exec();
    }catch(const std::exception& ex)
    {
        m_Result=-2;
    }
 }
 
ReadData::~ReadData()
{
 
}
 

C++ (Qt)
class TCPClientQt : public QTcpSocket{
Q_OBJECT
 
public:
 explicit TCPClientQt();
    ~TCPClientQt();
 bool slotStartData(QString _cmdStart);
 bool m_IsConnected;
 int m_IsThread;//если в отдельном потоке, то выставляем 1
 int m_RecivedBytes;//сколько байт забрали из буфера
 QString m_StrInfo;
 QString m_CmdCfg;
 QString m_AnswerCfg;
 QString m_CmdStart;
 QString m_AnswerStart;
 QString m_CmdStop;
 QString m_AnswerStop;
 QString m_CmdGetTimer;
 QString m_CmdResetTimer;
 QString m_CmdResetADC;
 QTcpSocket *m_pTcpSocket;
 QFile m_LogFile;
 QString m_ApplPath;
 QByteArray arrReadBlock;
 //function
 QByteArray getCurrentData();
private:
 
 //адрес и порт
 QString m_strHost;
 int m_nPort;
 //это команда
 bool isCmd;
 //завершение данных
 bool isEnd;
 //сколько ожидаем
 uint ExpectedBytes;
 //сколько получили
 uint totalBytesRecived;
 //сколько забрали из массива
 uint currentPos;
  //QByteArray m_bufferRead;
 
signals:
  void sig_newInfo();
  void sig_Connected();
  void sig_Disconnected();
 
//private slots:
 public slots:
 void slotReadyRead();
 void slotError (QAbstractSocket::SocketError);
 void slotSendToServer(QString _cmdSend);
 void slotConnected();
 void slotDisconnected();
 void slotStateChanged ( QAbstractSocket::SocketState socketState );
 void slotConnectToServer(QString _ipHost);
 void slotClearLog();
 void slotCloseConnect();
 
};
 

C++ (Qt)
TCPClientQt::TCPClientQt(): QTcpSocket()
//
{
 m_strHost="192.168.1.7";//strHost;
 m_nPort=32000;//nPort;
 m_CmdCfg="+WIND:80:";//конфигурация префикс команды
 m_AnswerCfg="+WIND:81:";//конфигурация префикс ответ
 m_CmdStart="+WIND:82:";//старт команда
 m_AnswerStart="+WIND:83:";//старт префикс ответ
 m_CmdStop="+WIND:84:";//стоп команда
 m_AnswerStop="+WIND:85:";//стоп префикс ответ
 m_CmdGetTimer="+WIND:89:";//запрос таймера
 m_CmdResetTimer="+WIND:88:";//сброс таймера
 m_CmdResetADC="+WIND:99:";//сброс АЦП
 m_pTcpSocket = new QTcpSocket(this);
 m_ApplPath=QCoreApplication::applicationDirPath();
 m_LogFile.setFileName(m_ApplPath+"/TCPClientQt.log");
 m_StrInfo="Empty";
 m_IsThread=0;
 m_RecivedBytes=0;
 m_IsConnected=false;
 //признак наличия команды
 isCmd=false;
 isEnd=false;
 ExpectedBytes=0;
 totalBytesRecived=0;
 currentPos=0;
 arrReadBlock.clear();
 connect(m_pTcpSocket, SIGNAL(connected()), SLOT(slotConnected()));
 connect(m_pTcpSocket, SIGNAL(disconnected()), SLOT(slotDisconnected()));
 connect(m_pTcpSocket, SIGNAL(readyRead()), SLOT(slotReadyRead()));
 connect(m_pTcpSocket, SIGNAL(error(QAbstractSocket::SocketError)),this, SLOT(slotError(QAbstractSocket::SocketError)));
 connect(m_pTcpSocket, SIGNAL(stateChanged(QAbstractSocket::SocketState socketState )),this, SLOT(slotStateChanged(QAbstractSocket::SocketState)));
}
 
void TCPClientQt::slotClearLog()
{
    //m_ptxtInfo->clear();
}
 
void TCPClientQt::slotCloseConnect()
{
 
    if(m_pTcpSocket->state() == QAbstractSocket::UnconnectedState)
    {
        m_StrInfo="Нет открытого сокета";
    }else{
        m_pTcpSocket->close();
        m_IsConnected=false;
        m_StrInfo="Сокет закрыт";
    }
    if(m_LogFile.isOpen())
    {
     QByteArray arr=m_StrInfo.toAscii()+"\n";
      m_LogFile.write(arr);
      m_LogFile.close();
    }
    emit sig_Disconnected();
    emit sig_newInfo();
}
 
void TCPClientQt::slotSendToServer(QString _cmdSend)
{
    if(m_pTcpSocket->state() == QAbstractSocket::ConnectedState)
    {
       m_StrInfo=QTime::currentTime().toString("hh:mm:ss.zzz")+" Отправка команды "+_cmdSend;
       emit sig_newInfo();
       if(m_LogFile.isOpen())
       {
        QByteArray arr=m_StrInfo.toAscii()+"\n";
         m_LogFile.write(arr);
       }
       currentPos=0;
    }else
    {
      m_StrInfo=QTime::currentTime().toString("hh:mm:ss.zzz")+" Нет открытого соединения!";
      emit sig_newInfo();
      return;
    }
 QByteArray arrSend;
 QString cmdSend=_cmdSend;
 arrSend=cmdSend.toAscii();
 m_pTcpSocket->write(arrSend);
  if(m_LogFile.isOpen())
  {
   QByteArray arr=m_StrInfo.toAscii()+"\n";
    m_LogFile.write(arr);
  }
}
 
 
void TCPClientQt::slotReadyRead()
{
 //доступно байт в текущий момент
 uint bytesAvailable=0;
 //полученные текущие байты
 QByteArray currArr;
 //для перегона в строку, если команда или ответ
 QByteArray strArr;
 //полученная строка ответа по команде старт
 QByteArray strAnswerStart;
//размер ответа в байтах 
//яя
 int pos=-1;
 //размер команды с ответом
 uint sizeCmd=20;
 //int bytesArray=0;
 //Цикл нужен потому, что с сервера не все данные могут прийти одновременно.
 //Поэтому клиент должен быть в состоянии получать как весь блок целиком,
 //так и только часть блока или даже все блоки сразу.
 m_RecivedBytes=0;
 isEnd=false;
 isCmd=false;
 if(m_pTcpSocket->state() == QAbstractSocket::UnconnectedState)
 {
 
     m_StrInfo=QTime::currentTime().toString("hh:mm:ss.zzz")+" UnconnectedState";
     if(m_LogFile.isOpen())
     {
      QByteArray arr=m_StrInfo.toAscii()+"\n";
       m_LogFile.write(arr);
     }
     emit sig_newInfo();
    return;
 }
  while(true){
 
    strArr.clear();
    currArr.clear();
        bytesAvailable=m_pTcpSocket->bytesAvailable();
        if(bytesAvailable < sizeof(quint16)){
            //&#1085;&#1077;&#1090; &#1076;&#1072;&#1085;&#1085;&#1099;&#1093;
            m_StrInfo=QTime::currentTime().toString("hh:mm:ss.zzz")+" bytesAvailable 0 &#1055;&#1091;&#1089;&#1090;&#1086;";
            if(m_LogFile.isOpen())
            {
             QByteArray arr=m_StrInfo.toAscii()+"\n";
              m_LogFile.write(arr);
            }
            emit sig_newInfo();
            break;
        }else
        {
         //
        }
        //&#1077;&#1089;&#1090;&#1100; &#1076;&#1072;&#1085;&#1085;&#1099;&#1077;
        totalBytesRecived=totalBytesRecived+bytesAvailable;
            currArr=m_pTcpSocket->read(bytesAvailable);
            arrReadBlock.append(currArr);
            //&#1077;&#1089;&#1083;&#1080; &#1082;&#1091;&#1089;&#1086;&#1095;&#1077;&#1082; &#1084;&#1077;&#1085;&#1077;&#1077; 20 &#1073;&#1072;&#1081;&#1090;
            if(bytesAvailable<sizeCmd && !currArr.contains(m_AnswerStop.toAscii())){
                strArr=currArr.left(sizeCmd);
                //&#1086;&#1090;&#1074;&#1077;&#1090; &#1082;&#1086;&#1085;&#1092;&#1080;&#1075;&#1091;&#1088;&#1072;&#1094;&#1080;&#1080;
                if(currArr.contains(m_AnswerCfg.toAscii()))
                {
                  strArr=currArr.left(17);
                  m_StrInfo=QTime::currentTime().toString("hh:mm:ss.zzz")+" Answer CFG "
                                     +QString::fromAscii(strArr);
                  if(m_LogFile.isOpen())
                  {
                   QByteArray arr=m_StrInfo.toAscii()+"\n";
                    m_LogFile.write(arr);
                  }
                  emit sig_newInfo();
                }else
                {
                  //
                }
                if(currArr.contains(m_CmdGetTimer.toAscii()))
                {
                    strArr=currArr.left(20);
                    m_StrInfo=QTime::currentTime().toString("hh:mm:ss.zzz")+" Answer GetTimer "
                                       +QString::fromAscii(strArr);
                    if(m_LogFile.isOpen())
                    {
                     QByteArray arr=m_StrInfo.toAscii()+"\n";
                      m_LogFile.write(arr);
                    }
                    emit sig_newInfo();                   
                }else
                {
                  //
                }
                if(currArr.contains(m_CmdResetTimer.toAscii()))
                {
                    strArr=currArr.left(20);
                    m_StrInfo=QTime::currentTime().toString("hh:mm:ss.zzz")+" Answer ResetTimer "
                                       +QString::fromAscii(strArr);
                    if(m_LogFile.isOpen())
                    {
                     QByteArray arr=m_StrInfo.toAscii()+"\n";
                      m_LogFile.write(arr);
                    }
                    emit sig_newInfo();
                }else
                {
                  //
                }
                isCmd=true;
                break;
            }else{
                m_StrInfo=QTime::currentTime().toString("hh:mm:ss.zzz")
                                +" bytesAvailable "+QString::number(bytesAvailable);
                if(m_LogFile.isOpen())
                {
                 QByteArray arr=m_StrInfo.toAscii()+"\n";
                  m_LogFile.write(arr);
                }
                emit sig_newInfo();
            }
            //&#1077;&#1089;&#1090;&#1100; &#1085;&#1072;&#1095;&#1072;&#1083;&#1086; +WIND:83:
            if(currArr.contains(m_AnswerStart.toAscii()))
            {
                isCmd=false;
                pos=17;
                strArr=currArr.left(pos);
                m_StrInfo=QTime::currentTime().toString("hh:mm:ss.zzz")
                                   +" Begin "+QString::fromAscii(strArr);
                if(m_LogFile.isOpen())
                {
                 QByteArray arr=m_StrInfo.toAscii()+"\n";
                  m_LogFile.write(arr);
                }
                //&#1074;&#1099;&#1103;&#1089;&#1085;&#1103;&#1077;&#1084;, &#1089;&#1082;&#1086;&#1083;&#1100;&#1082;&#1086; &#1073;&#1072;&#1081;&#1090; &#1076;&#1086;&#1083;&#1078;&#1085;&#1086; &#1087;&#1088;&#1080;&#1083;&#1077;&#1090;&#1077;&#1090;&#1100; &#1080;&#1089;&#1093;&#1086;&#1076;&#1103; &#1080;&#1079; &#1079;&#1072;&#1075;&#1086;&#1083;&#1086;&#1074;&#1082;&#1072; &#1086;&#1090;&#1074;&#1077;&#1090;&#1072; &#1089;&#1077;&#1088;&#1074;&#1077;&#1088;&#1072; +WIND:83:XX:XX:XX
                //&#1088;&#1072;&#1079;&#1073;&#1086;&#1088; &#1079;&#1072;&#1075;&#1086;&#1083;&#1086;&#1074;&#1082;&#1072;
                strAnswerStart.clear();
                strAnswerStart.append(strArr.data()[9]);
                strAnswerStart.append(strArr.data()[10]);
                int F=strAnswerStart.toInt();
                strAnswerStart.clear();
                strAnswerStart.append(strArr.data()[12]);
                strAnswerStart.append(strArr.data()[13]);
                int C=strAnswerStart.toInt();
                strAnswerStart.clear();
                strAnswerStart.append(strArr.data()[15]);
                strAnswerStart.append(strArr.data()[16]);
                int T=strAnswerStart.toInt();
                strAnswerStart.clear();
                //&#1089;&#1082;&#1086;&#1083;&#1100;&#1082;&#1086; &#1073;&#1072;&#1081;&#1090;
                ExpectedBytes=F*1000*C*T+34;
                emit sig_newInfo();
            }else{
                //
            }
            //&#1077;&#1089;&#1090;&#1100; &#1082;&#1086;&#1085;&#1077;&#1094;
            if(currArr.contains(m_AnswerStop.toAscii()))
            {
                isEnd=true;
                pos=arrReadBlock.indexOf(m_AnswerStop);
                strArr=currArr.right(17);
                m_StrInfo=QTime::currentTime().toString("hh:mm:ss.zzz")
                                   +" End "+QString::fromAscii(strArr);
                if(m_LogFile.isOpen())
                {
                 QByteArray arr=m_StrInfo.toAscii()+"\n";
                  m_LogFile.write(arr);
                }
                emit sig_newInfo();
                break;
 
            }else{
              //
            }
 
        //&#1080; &#1085;&#1072; &#1085;&#1086;&#1074;&#1099;&#1081; &#1094;&#1080;&#1082;&#1083; &#1087;&#1086;&#1089;&#1083;&#1077; &#1086;&#1078;&#1080;&#1076;&#1072;&#1085;&#1080;&#1103;
        m_pTcpSocket->waitForReadyRead(550);//&#1074;&#1088;&#1077;&#1084;&#1103; &#1086;&#1078;&#1080;&#1076;&#1072;&#1085;&#1080;&#1103; &#1086;&#1095;&#1077;&#1088;&#1077;&#1076;&#1085;&#1086;&#1075;&#1086; &#1087;&#1072;&#1082;&#1077;&#1090;&#1072; &#1074;  &#1084;&#1089;
 }
  //&#1079;&#1072;&#1074;&#1077;&#1088;&#1096;&#1077;&#1085;&#1080;&#1077; &#1087;&#1088;&#1080;&#1077;&#1084;&#1072; &#1076;&#1072;&#1085;&#1085;&#1099;&#1093;
  if(isEnd)
  {
    m_StrInfo=QTime::currentTime().toString("hh:mm:ss.zzz")
                      +" Total Expected: "
                      +QString::number(ExpectedBytes);
    if(m_LogFile.isOpen())
    {
     QByteArray arr=m_StrInfo.toAscii()+"\n";
      m_LogFile.write(arr);
    }
    emit sig_newInfo();
     m_StrInfo=QTime::currentTime().toString("hh:mm:ss.zzz")
                     +" Total Recive: "
                     +QString::number(totalBytesRecived);
     if(m_LogFile.isOpen())
     {
      QByteArray arr=m_StrInfo.toAscii()+"\n";
       m_LogFile.write(arr);
     }
    emit sig_newInfo();
    m_StrInfo=QTime::currentTime().toString("hh:mm:ss.zzz")
                     +" Lost: "
                     +QString::number(ExpectedBytes-totalBytesRecived);
    if(m_LogFile.isOpen())
    {
     QByteArray arr=m_StrInfo.toAscii()+"\n";
      m_LogFile.write(arr);
    }
    emit sig_newInfo();
    isEnd=false;
  }
 totalBytesRecived=0;
 ExpectedBytes=0;
 arrReadBlock.clear();
 return;
}
 
 
 
void TCPClientQt::slotError(QAbstractSocket::SocketError err)
{
 QString strError =
    (err == QAbstractSocket::HostNotFoundError ?
    "The host was not found. "+QString::number(-1) :
    err == QAbstractSocket::RemoteHostClosedError ?
    "The remote host is closed. "+QString::number(-2) :
    err == QAbstractSocket::ConnectionRefusedError ?
    "The connection was refused. "+QString::number(-3) :
    QString(m_pTcpSocket->errorString())
 );
 
    m_StrInfo=QTime::currentTime().toString("hh:mm:ss.zzz")+" Error: "+strError;
    if(m_LogFile.isOpen())
    {
    QByteArray arr=m_StrInfo.toAscii()+"\n";
    m_LogFile.write(arr);
    }
 emit sig_newInfo();
}
 
void TCPClientQt::slotStateChanged(QAbstractSocket::SocketState socketState)
{
     m_StrInfo=QTime::currentTime().toString("hh:mm:ss.zzz")+" StateChanged";
    if(m_LogFile.isOpen())
    {
      QByteArray arr=m_StrInfo.toAscii()+"\n";
      m_LogFile.write(arr);
    }
}
 
void TCPClientQt::slotConnected()
{
 
    m_StrInfo=QTime::currentTime().toString("hh:mm:ss.zzz")+" Connected";
    m_IsConnected=true;
    emit sig_Connected();
    emit sig_newInfo();
    if(!m_LogFile.isOpen())
    {
        m_LogFile.open(QIODevice::ReadWrite);
        m_LogFile.seek(m_LogFile.size());
        QByteArray arr=m_StrInfo.toAscii()+"\n";
        m_LogFile.write(arr);
    }
}
 
void TCPClientQt::slotDisconnected()
{
    m_StrInfo=m_StrInfo=QTime::currentTime().toString("hh:mm:ss.zzz")+" Disconnected";
    if(m_LogFile.isOpen())
    {
     QByteArray arr=m_StrInfo.toAscii()+"\n";
      m_LogFile.write(arr);
      m_LogFile.close();
    }
    m_IsConnected=false;
    emit sig_Disconnected();
}
 
QByteArray TCPClientQt::getCurrentData()
{
    QByteArray result;
    .....
    return result;
}
 
void TCPClientQt::slotConnectToServer(QString _ipHost)
{
    if(m_pTcpSocket!=0)
    {
    if(m_pTcpSocket->state() == QAbstractSocket::UnconnectedState)
    {
        m_strHost=_ipHost;
        m_pTcpSocket->connectToHost(m_strHost, m_nPort);
    }else{
        m_StrInfo=QTime::currentTime().toString("hh:mm:ss.zzz")+" &#1045;&#1089;&#1090;&#1100; &#1086;&#1090;&#1082;&#1088;&#1099;&#1090;&#1086;&#1077; &#1089;&#1086;&#1077;&#1076;&#1080;&#1085;&#1077;&#1085;&#1080;&#1077;";
        emit sig_newInfo();
    }
    }else
    {
        //
    }
    if(m_LogFile.isOpen())
    {
        QByteArray arr=m_StrInfo.toAscii()+"\n";
        m_LogFile.write(arr);
    }
}
 
TCPClientQt::~ TCPClientQt ()
{
    if(m_LogFile.isOpen())
    {
      m_LogFile.close();
    }
    if(m_pTcpSocket!=0)
    { if(m_pTcpSocket->state() != QAbstractSocket::UnconnectedState)
        {
         m_pTcpSocket->close();
        }else
        {
            //
        }
        m_pTcpSocket=0;
    }
}
 

C++ (Qt)
ReadData::ReadData(QObject *parent) :
    QThread(parent)
{
 
 m_Client=new TCPClientQt(this);
 QObject::connect(m_Client,SIGNAL(sig_Connected()),this->parent(), SLOT(slotIsConnected()),Qt::AutoConnection);
 QObject::connect(m_Client,SIGNAL(sig_newInfo()),this->parent(), SLOT(getNewInfo()),Qt::AutoConnection);
 QObject::connect(m_Client,SIGNAL(sig_Disconnected()),this->parent(), SLOT(slotIsDisonnected()),Qt::AutoConnection);
 moveToThread(this);
}
//тест кодировки
 

C++ (Qt)
void TCPClientQt::slotError(QAbstractSocket::SocketError err)
 

C++ (Qt)
void 
connect(m_pTcpSocket, SIGNAL(readyRead()), SLOT(slotReadyRead()));
 

C++ (Qt)
ReadData::ReadData(QObject *parent) :
    QThread(parent)
{
 m_Socket=new QTcpSocket(this);
 moveToThread(this);
}
 

C++ (Qt)
void SBThread::run()
{
    m_pTcpSocket = new QTcpSocket(this);
 
    connect(m_pTcpSocket, SIGNAL(connected()), SLOT(slotConnected()));
    connect(m_pTcpSocket, SIGNAL(disconnected()), SLOT(disconnected()));
    connect(m_pTcpSocket, SIGNAL(readyRead()), SLOT(readyRead()));
    connect(m_pTcpSocket, SIGNAL(error(QAbstractSocket::SocketError)),this, SLOT(error(QAbstractSocket::SocketError)));
....
 

C++ (Qt)
void SBThread::run()
{
    QTcpSocket m_pTcpSocket;
 
    connect(&m_pTcpSocket, SIGNAL(connected()), SLOT(slotConnected()));
    connect(&m_pTcpSocket, SIGNAL(disconnected()), SLOT(disconnected()));
    connect(&m_pTcpSocket, SIGNAL(readyRead()), SLOT(readyRead()));
    connect(&m_pTcpSocket, SIGNAL(error(QAbstractSocket::SocketError)),this, SLOT(error(QAbstractSocket::SocketError)));
....
 

C++ (Qt)
class Worker : public QObject
{
    Q_OBJECT
 
public slots:
    void doWork(const QString &parameter) {
        QString result;
        /* ... here is the expensive or blocking operation ... */
        emit resultReady(result);
    }
 
signals:
    void resultReady(const QString &result);
};
 
class Controller : public QObject
{
    Q_OBJECT
    QThread workerThread;
public:
    Controller() {
        Worker *worker = new Worker;
        worker->moveToThread(&workerThread);
        connect(&workerThread, &QThread::finished, worker, &QObject::deleteLater);
        connect(this, &Controller::operate, worker, &Worker::doWork);
        connect(worker, &Worker::resultReady, this, &Controller::handleResults);
        workerThread.start();
    }
    ~Controller() {
        workerThread.quit();
        workerThread.wait();
    }
public slots:
    void handleResults(const QString &);
signals:
    void operate(const QString &);
};
 

C++ (Qt)
class WorkerThread : public QThread
{
    Q_OBJECT
    void run() Q_DECL_OVERRIDE {
        QString result;
        /* ... here is the expensive or blocking operation ... */
        emit resultReady(result);
    }
signals:
    void resultReady(const QString &s);
};
 
void MyObject::startWorkInAThread()
{
    WorkerThread *workerThread = new WorkerThread(this);
    connect(workerThread, &WorkerThread::resultReady, this, &MyObject::handleResults);
    connect(workerThread, &WorkerThread::finished, workerThread, &QObject::deleteLater);
    workerThread->start();
}
 

C++ (Qt)
void SBThread::run()
{
    m_pTcpSocket = new QTcpSocket(this);
 
    connect(m_pTcpSocket, SIGNAL(connected()), SLOT(slotConnected()));
    connect(m_pTcpSocket, SIGNAL(disconnected()), SLOT(disconnected()));
    connect(m_pTcpSocket, SIGNAL(readyRead()), SLOT(readyRead()));
    connect(m_pTcpSocket, SIGNAL(error(QAbstractSocket::SocketError)),this, SLOT(error(QAbstractSocket::SocketError)));
....
 

C++ (Qt)
if (!m_pTcpSocket) {
  m_pTcpSocket = new QTcpSocket(this);
}
 

C++ (Qt)
if (!m_pTcpSocket) {
  m_pTcpSocket = new QTcpSocket(this);
}
 

C++ (Qt)
thread=new QThread(this);
socket=new QTcpSocket(this);
socket->moveToThread(thread);
 

C++ (Qt)
thread=new QThread(this);
QTcpSocket socket;
socket->moveToThread(thread);
 

C++ (Qt)
class Calculator : public QObject
{
Q_OBJECT
signals:
  void finished (int sum);
public slots:
    void calculate () {
        int result = 0;
        for (int i = 0; i < 99999; ++i) {
                result += i;
        }
 
        emit finished (result);
    }
}
 
.............................
Calculator *calculator = new Calculator;
QThread *thread = new QThread
 
calculator->moveToThread (thread);
connect(thread, &QThread::started, calculator, &Calculator::calculate);
connect(thread, &QThread::finished, calculator, &Calculator::deleteLater);
 
connect(calculator, &Calculator::finished, [] (int result) {qDebug () << result;});
connect(calculator, &Calculator::finished, thread, &QThread::quit);
connect(calculator, &Calculator::destroyed, thread, &QThread::deleteLater);
thread->start();
 
 

C++ (Qt)
SIGNAL(readyRead()) 

C++ (Qt)
void TCPClientQt::slotReadyRead()
{
 ....
 isEnd=false;
 isCmd=false;
  while(true)
  {
     currArr=read(now_BytesAvailable);
        totalBytesRecived=totalBytesRecived+now_BytesAvailable;
            if(now_BytesAvailable < sizeCmd && !currArr.contains(m_AnswerStop.toAscii())){
 
				.//..
                isCmd=true;
                break;
            }else{
		//....			
            }
            arrReadBlock.append(currArr);
		//...
                   if(currArr.contains(m_AnswerStop.toAscii())){              
		//..
                break;
        waitForReadyRead(900);//
 }
  //
  if(isEnd)
  {
     m_StrInfo=QTime::currentTime().toString("hh:mm:ss.zzz")
                     +" R bytes: "
                     +QString::number(totalBytesRecived);
     emit sig_newInfo();
 return;
}
 

C++ (Qt)
        if(now_BytesAvailable < sizeof(quint16)){
            m_StrInfo=QTime::currentTime().toString("hh:mm:ss.zzz")+" 0 bytes";
            emit sig_newInfo();
            break;
 

C++ (Qt)
TCPClientQt::TCPClientQt(QObject *parent): QTcpSocket(parent)
 

C++ (Qt)
 connect(this, SIGNAL(connected()), SLOT(slotConnected()),Qt::AutoConnection);
 connect(this, SIGNAL(disconnected()), SLOT(slotDisconnected()),Qt::AutoConnection);
 connect(this, SIGNAL(readyRead()), SLOT(slotReadyRead()),Qt::AutoConnection);
 connect(this, SIGNAL(error(QAbstractSocket::SocketError)), this,SLOT(slotError(QAbstractSocket::SocketError)),Qt::AutoConnection);
 connect(this, SIGNAL(stateChanged(QAbstractSocket::SocketState)),this, SLOT(slotStateChanged(QAbstractSocket::SocketState)),Qt::AutoConnection);
 

C++ (Qt)
 connect(this, SIGNAL(connected()), SLOT(slotConnected()),Qt::AutoConnection);
 connect(this, SIGNAL(disconnected()), SLOT(slotDisconnected()),Qt::AutoConnection);
 connect(this, SIGNAL(readyRead()), SLOT(slotReadyRead()),Qt::AutoConnection);
 

C++ (Qt)
 connect(this, SIGNAL(error(QAbstractSocket::SocketError)), this,SLOT(slotError(QAbstractSocket::SocketError)),Qt::AutoConnection);
 connect(this, SIGNAL(stateChanged(QAbstractSocket::SocketState)),this, SLOT(slotStateChanged(QAbstractSocket::SocketState)),Qt::AutoConnection);
 

C++ (Qt)
connect(m_pTcpSocket, SIGNAL(readyRead()), SLOT(slotReadyRead()));

C++ (Qt)
m_pTcpSocket->waitForReadyRead(550);//время ожидания очередного пакета в  мс

C++ (Qt)
class TCPClient : ...
{
    ...
private:
    QByteArray m_buffer;
};
 
// Слот обработки сигнала readyRead()
void TCPClient::onReadData()
{
    m_buffer += readAll();
 
    // Мы все вычитываем в буфер m_buffer
    // Здесь мы может проверить находится ли в буфере полный пакет данных для обработки, если да - обрабатываем его и выкусываем из буфера
    // Если в буфере осталась только часть пакета, то просто выходим и ждем следующую порцию данных
}
 

C++ (Qt)
// Слот обработки сигнала readyRead()
void TCPClientQt::onReadData()
{
 
    QString strArr="";
    int pos;
    m_ReadBuffer += m_pTcpSocket->readAll();
    //m_ptxtInfo->append(QTime::currentTime().toString("hh:mm:ss.zzz")
                       //+" onReadData "+QString::number(m_ReadBuffer.size()));
    //m_count=m_pTcpSocket->bytesAvailable()+m_count;m_count=+m_count;
    // Мы все вычитываем в буфер m_buffer
    // Здесь мы можем проверить находится ли в буфере полный пакет данных для обработки, если да - обрабатываем его и выкусываем из буфера
    if(!isBegin && m_ReadBuffer.contains("+WIND:83:"))
    {
        pos=17;
        strArr=m_ReadBuffer.left(pos);
        m_ptxtInfo->append(QTime::currentTime().toString("hh:mm:ss.zzz")
                           +" Begin "+QString::fromAscii("+WIND:83:"));
        isBegin=true;
    }
    if(!isEnd && m_ReadBuffer.contains("+WIND:85:"))
    {
        pos=m_ReadBuffer.indexOf("+WIND:85:");
        strArr=m_ReadBuffer.right(17);
        m_ptxtInfo->append(QTime::currentTime().toString("hh:mm:ss.zzz")
                           +" End "+QString::fromAscii("+WIND:85:"));
       isEnd=true;
    }
    m_ptxtInfo->append(QTime::currentTime().toString("hh:mm:ss.zzz")
                       +" Recive "+QString::number(m_count));
    //Если в буфере осталась только часть пакета, то просто выходим и ждем следующую порцию данных
}