bool ModbusClient::proceedWriteSingleRegisterResponse() { if(byteArrayInput.size()!=12) { emit transactionFinished(false, MODBUS_ERROR_BADFORMAT); return false; } for (int i=0 ; i<12 ; i++) { if(byteArrayOutput[i]!=byteArrayInput[i]) { emit transactionFinished(false, MODBUS_ERROR_BADFORMAT); return false; } } emit transactionFinished(false,MODBUS_ERROR_SUCCESS); return true; }
bool ModbusClient::proceedReadHoldingRegistersResponse() { quint16 startingAddress; getQInt16(byteArrayOutput, 8, startingAddress); quint16 quantityOfRegisters; getQInt16(byteArrayOutput, 10, quantityOfRegisters); if(byteArrayInput.size() != (9+2*quantityOfRegisters)) { emit transactionFinished(false, MODBUS_ERROR_BADFORMAT); return false; } quint8 bytesCount; getQInt8(byteArrayInput, 8 , bytesCount); if(bytesCount!=quantityOfRegisters*2) { emit transactionFinished(false, MODBUS_ERROR_BADFORMAT); return false; } quint16 value; for(int i=0; i<quantityOfRegisters; i++) { getQInt16(byteArrayInput, (9+i*2), value); holdingRegisters[startingAddress+i] = value; } emit transactionFinished(true, MODBUS_ERROR_SUCCESS); return true; }
void QxThreadPool::initServices() { QMutexLocker locker(& m_mutex); qRegisterMetaType<qx::service::QxTransaction_ptr>("qx::service::QxTransaction_ptr"); qRegisterMetaType<qx::service::QxTransaction_ptr>("QxTransaction_ptr"); for (long l = 0; l < QxConnect::getSingleton()->getThreadCount(); l++) { QxThread * pNewThread = new QxThread(this); QObject::connect(pNewThread, SIGNAL(error(const QString &, qx::service::QxTransaction_ptr)), this, SIGNAL(error(const QString &, qx::service::QxTransaction_ptr))); QObject::connect(pNewThread, SIGNAL(transactionStarted(qx::service::QxTransaction_ptr)), this, SIGNAL(transactionStarted(qx::service::QxTransaction_ptr))); QObject::connect(pNewThread, SIGNAL(transactionFinished(qx::service::QxTransaction_ptr)), this, SIGNAL(transactionFinished(qx::service::QxTransaction_ptr))); m_lstAllServices.append(pNewThread); m_lstAvailable.enqueue(pNewThread); pNewThread->start(); } }
void QxThread::doProcess(QTcpSocket & socket) { if (! socket.setSocketDescriptor(m_iSocketDescriptor)) { Q_EMIT error("[QxOrm] invalid socket descriptor : cannot start transaction", QxTransaction_ptr()); return; } qx_bool bReadOk = readSocket(socket); if (! bReadOk) { Q_EMIT error(QString("[QxOrm] unable to read request from socket : '") + bReadOk.getDesc() + QString("'"), QxTransaction_ptr()); return; } if (! m_bIsRunning) { return; } Q_EMIT transactionStarted(m_pTransaction); try { m_pTransaction->executeServer(); } catch (const qx::exception & x) { qx_bool xb = x.toQxBool(); m_pTransaction->setMessageReturn(xb); } catch (const std::exception & e) { m_pTransaction->setMessageReturn(qx_bool(QX_ERROR_UNKNOWN, e.what())); } catch (...) { m_pTransaction->setMessageReturn(qx_bool(QX_ERROR_UNKNOWN, "unknown error")); } if (! m_bIsRunning) { return; } qx_bool bWriteOk = writeSocket(socket); if (! bWriteOk) { Q_EMIT error(QString("[QxOrm] unable to write reply to socket : '") + bWriteOk.getDesc() + QString("'"), m_pTransaction); } Q_EMIT transactionFinished(m_pTransaction); }
bool ZmdUpdaterCore::qt_emit( int _id, QUObject* _o ) { switch ( _id - staticMetaObject()->signalOffset() ) { case 0: userListing((QValueList<Identity>)(*((QValueList<Identity>*)static_QUType_ptr.get(_o+1)))); break; case 1: serviceListing((QValueList<Service>)(*((QValueList<Service>*)static_QUType_ptr.get(_o+1)))); break; case 2: catalogListing((QValueList<Catalog>)(*((QValueList<Catalog>*)static_QUType_ptr.get(_o+1)))); break; case 3: patchListing((QValueList<Patch>)(*((QValueList<Patch>*)static_QUType_ptr.get(_o+1)))); break; case 4: updateListing((QValueList<Package>)(*((QValueList<Package>*)static_QUType_ptr.get(_o+1)))); break; case 5: lockListing((QValueList<PackageLock>)(*((QValueList<PackageLock>*)static_QUType_ptr.get(_o+1)))); break; case 6: packageInfo((Package)(*((Package*)static_QUType_ptr.get(_o+1)))); break; case 7: packageDetails((PackageDetails)(*((PackageDetails*)static_QUType_ptr.get(_o+1)))); break; case 8: realPackages((QValueList<Package>)(*((QValueList<Package>*)static_QUType_ptr.get(_o+1))),(QValueList<Package>)(*((QValueList<Package>*)static_QUType_ptr.get(_o+2))),(QValueList<Package>)(*((QValueList<Package>*)static_QUType_ptr.get(_o+3)))); break; case 9: transactionFinished((int)static_QUType_int.get(_o+1),(QString)static_QUType_QString.get(_o+2)); break; case 10: serviceAdded((QString)static_QUType_QString.get(_o+1),(int)static_QUType_int.get(_o+2),(QString)static_QUType_QString.get(_o+3)); break; case 11: generalFault((QString)static_QUType_QString.get(_o+1),(int)static_QUType_int.get(_o+2)); break; case 12: progress((Progress)(*((Progress*)static_QUType_ptr.get(_o+1)))); break; case 13: downloadProgress((Progress)(*((Progress*)static_QUType_ptr.get(_o+1)))); break; default: return QObject::qt_emit(_id,_o); } return TRUE; }
void ModbusClient::readDataAndCheck() { //Stop counting timeout responseTimer->stop(); byteArrayInput.clear(); byteArrayInput = mySocket->readAll(); if(!isWaitingForResponse) return; isWaitingForResponse = false; //Analyze Modbus frame //Check minimum size if(byteArrayInput.size()<8) { emit transactionFinished(false,MODBUS_ERROR_BADFORMAT); return ; } //Check transaction ID quint16 incomingTransactionID; getQInt16(byteArrayInput, 0, incomingTransactionID); if(incomingTransactionID!=transactionID) { emit transactionFinished(false,MODBUS_ERROR_BADTRANSACTIONID); return; } transactionID++; //Check protocolIdentyfier quint16 protocolIdentyfier; getQInt16(byteArrayInput, 2, protocolIdentyfier ); if(protocolIdentyfier!= 0) { emit transactionFinished(false,MODBUS_ERROR_BADPROTOCOLID); return; } //Check data length quint16 length; getQInt16(byteArrayInput, 4, length); if(byteArrayInput.size()!=length+6) { emit transactionFinished(false, MODBUS_ERROR_BADFORMAT); return; } //Check unit ID // It really doesnt matter quint8 unitID; getQInt8(byteArrayInput, 6, unitID); if(unitID!=255) { emit transactionFinished(false,MODBUS_ERROR_BADUNITID); return; } //Get function Code quint8 functionCode; getQInt8(byteArrayInput, 7, functionCode); //Check last request code, and see if response is good switch(waitingFunctionCode) { case MODBUS_FC_WRITE_SINGLE_REGISTER: { switch(functionCode) { case MODBUS_FC_WRITE_SINGLE_REGISTER + 0x80: { proceedIncomingError(); return; } case MODBUS_FC_WRITE_SINGLE_REGISTER: { proceedWriteSingleRegisterResponse(); return; } default: { emit transactionFinished(false, MODBUS_ERROR_BADRESPONSEFC); return; } } } case MODBUS_FC_WRITE_MULTIPLE_REGISTERS: { switch(functionCode) { case MODBUS_FC_WRITE_MULTIPLE_REGISTERS + 0x80: { proceedIncomingError(); return; } case MODBUS_FC_WRITE_MULTIPLE_REGISTERS: { proceedWriteMultipleRegistersResponse(); return; } default: { emit transactionFinished(false, MODBUS_ERROR_BADRESPONSEFC); return ; } } } case MODBUS_FC_READ_HOLDING_REGISTERS: { switch(functionCode) { case MODBUS_FC_READ_HOLDING_REGISTERS + 0x80: { proceedIncomingError(); return; } case MODBUS_FC_READ_HOLDING_REGISTERS: { proceedReadHoldingRegistersResponse(); return; } default: { emit transactionFinished(false, MODBUS_ERROR_BADRESPONSEFC); return ; } } } default: { qDebug()<<"That should never happen becouse we dont use different modbus functions"; return; } } }
void ModbusClient::transactionTimeout() { responseTimer->stop(); isWaitingForResponse = false; emit transactionFinished(false, MODBUS_ERROR_TIMEOUT); }