Why is receive data lost in this program (QSerialPort used)? - qt

Question

I'm using Qt5 (with QSerialPort) to write a modbus master. The program works, but sometimes (chance of 20%) the receive message is lost, even if the slave device has responded (the receive light on the DB9 connector has flashed). I want to figure out whether the data lost is caused by bugs in my program.
I use a state machine to design the program:
Since modbus protocol is used, the expected head and length of response data is known for each message. So the head and length of the receive data is checked to identify one receive message. On receive data timeout, what is left in the receive buffer is printed.
Here is the code:
struct CommMaster{
typedef enum{
Idle,
WaitForReceive
}MainState;
typedef enum{
WaitForHead,
WaitForComplete
}SubState;
MainState mainState;
SubState subState;
CommMaster(){
mainState=Idle;
}
};
class MainWindow : public QMainWindow{
//...
CommMaster comm;
QSerialPort *serial;
QQueue<QByteArray> sendQueue;
QByteArray expectReceiveHead;
int expectReceiveLength;
QTime lastSendTime;
QByteArray receive;//receive buffer
}
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
//...
connect(serial,&QSerialPort::readyRead,this,&MainWindow::serial_read);
}
void MainWindow::timer_timeout()//5ms period timer
{
if(serial->isOpen()){
QTime current=QTime::currentTime();
int passedTime=lastSendTime.msecsTo(current);
//state machine
switch(comm.mainState){
case CommMaster::Idle:
if(passedTime>=sendPeriod){
if(sendQueue.length()>0){
SendOneMessageAndSetExpectReceive(sendQueue,expectReceiveHead,expectReceiveLength);//send one message from sendQueue, and get expected receive message head and length
lastSendTime=current;
comm.mainState=CommMaster::WaitForReceive;
comm.subState=CommMaster::WaitForHead;
}
}
break;
case CommMaster::WaitForReceive:
if(passedTime>=kReceiveTimeout){
QByteArray readAll=serial->readAll();
qDebug()<<"Receive timeout, receive="<<receive<<" serial->readAll()="<<readAll;
comm.mainState=CommMaster::Idle;
receive.clear();
}
break;
default:
qDebug()<<"Wrong main state"<<comm.mainState;
}
}else{
sendQueue.clear();
}
}
void MainWindow::serial_read()
{
if(comm.mainState==CommMaster::WaitForReceive){
QByteArray read=serial->readAll();
switch(comm.subState){
case CommMaster::WaitForHead:{
int headIdx=read.indexOf(expectReceiveHead);
if(headIdx>=0){//head found
int length=read.length()-headIdx;
if(length>=expectReceiveLength){
handleReceive((read.data(),expectReceiveLength));
receive.clear();
comm.mainState=CommMaster::Idle;
}else{
receive=read.mid(headIdx);
}
}
break;
}
case CommMaster::WaitForComplete:{
int length=receive.length()+read.length();
receive.append(read);
if(length>=expectReceiveLength){
handleReceive(receive.data(),expectReceiveLength);
receive.clear();
comm.mainState=CommMaster::Idle;
}
break;
}
default:
break;
}
}
void MainWindow::SendOneMessageAndSetExpectReceive(const QQueue<QByteArray> &sendQueue,QByteArray &expectHead,int &expectLength)
{
QByteArray send=sendQueue.dequeue();
expectHead=QByteArray::fromHex("0210");
expectLength=8;
serial->write(send);
}
Here is the debug output:
Receive timeout, receive= "" serial->readAll()= ""
Receive timeout, receive= "" serial->readAll()= ""
Receive timeout, receive= "" serial->readAll()= ""
Receive timeout, receive= "" serial->readAll()= ""