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);
}
