From fa62fbf918cf87df3c613f1e3cbd9bddcb36263f Mon Sep 17 00:00:00 2001 From: Anders Sandstrom Date: Wed, 10 Mar 2021 14:37:40 +0100 Subject: [PATCH] Add asyn params for pdo, add write callbacks for sdo and pdo. --- .../src/ecmcCANOpenDevice.cpp | 2 + .../src/ecmcCANOpenPDO.cpp | 104 ++++++++- .../src/ecmcCANOpenPDO.h | 8 + .../src/ecmcCANOpenSDO.cpp | 217 ++++++------------ .../src/ecmcCANOpenSDO.h | 9 +- iocsh/pvs.log | 24 +- 6 files changed, 199 insertions(+), 165 deletions(-) diff --git a/ecmc_plugin_socketcan/ecmc_plugin_socketcanApp/src/ecmcCANOpenDevice.cpp b/ecmc_plugin_socketcan/ecmc_plugin_socketcanApp/src/ecmcCANOpenDevice.cpp index 812cc14..874ba36 100644 --- a/ecmc_plugin_socketcan/ecmc_plugin_socketcanApp/src/ecmcCANOpenDevice.cpp +++ b/ecmc_plugin_socketcan/ecmc_plugin_socketcanApp/src/ecmcCANOpenDevice.cpp @@ -124,6 +124,7 @@ int ecmcCANOpenDevice::addPDO(uint32_t cobId, } pdos_[pdoCounter_] = new ecmcCANOpenPDO(writeBuffer_, + nodeId_, cobId, rw, ODSize, @@ -161,6 +162,7 @@ int ecmcCANOpenDevice::addSDO(uint32_t cobIdTx, // 0x580 + CobId exeSampleTimeMs_, name, &sdo1Lock_, + sdoCounter_, dbgMode_); sdoCounter_++; return 0; diff --git a/ecmc_plugin_socketcan/ecmc_plugin_socketcanApp/src/ecmcCANOpenPDO.cpp b/ecmc_plugin_socketcan/ecmc_plugin_socketcanApp/src/ecmcCANOpenPDO.cpp index 88ae5b3..3db5739 100644 --- a/ecmc_plugin_socketcan/ecmc_plugin_socketcanApp/src/ecmcCANOpenPDO.cpp +++ b/ecmc_plugin_socketcan/ecmc_plugin_socketcanApp/src/ecmcCANOpenPDO.cpp @@ -15,11 +15,34 @@ #include #include "ecmcCANOpenPDO.h" +#include "ecmcAsynPortDriver.h" +#include "ecmcPluginClient.h" + +// Calback function to init write from asyn +asynStatus asynWritePDOValue(void* data, size_t bytes, asynParamType asynParType,void *userObj) { + // userobj = NULL + if(!userObj) { + printf("Error: asynWritePDOValue() fail, no user obj defined.\n"); + return asynError; + } + ecmcCANOpenPDO* pdo = (ecmcCANOpenPDO*)userObj; + int bytesToCp = bytes; + if (bytes > 8) { + bytesToCp = 8; + } + uint64_t tempData = 0; + + memcpy(&tempData,data,bytesToCp); + pdo->setValue(tempData); + pdo->writeValue(); + return asynSuccess; +} /** * ecmc ecmcCANOpenPDO class */ ecmcCANOpenPDO::ecmcCANOpenPDO(ecmcSocketCANWriteBuffer* writeBuffer, + uint32_t nodeId, uint32_t cobId, // 0x580 + CobId ecmc_can_direction rw, uint32_t ODSize, @@ -30,6 +53,7 @@ ecmcCANOpenPDO::ecmcCANOpenPDO(ecmcSocketCANWriteBuffer* writeBuffer, int dbgMode) { writeBuffer_ = writeBuffer; + nodeId_ = nodeId; cobId_ = cobId; ODSize_ = ODSize; name_ = strdup(name); @@ -60,7 +84,7 @@ ecmcCANOpenPDO::ecmcCANOpenPDO(ecmcSocketCANWriteBuffer* writeBuffer, writeFrame_.data[7] = 0; dataMutex_ = epicsMutexCreate(); - + initAsyn(); } ecmcCANOpenPDO::~ecmcCANOpenPDO() { @@ -148,3 +172,81 @@ int ecmcCANOpenPDO::writeValue() { } return writeBuffer_->addWriteCAN(&writeFrame_); } + +void ecmcCANOpenPDO::initAsyn() { + + ecmcAsynPortDriver *ecmcAsynPort = (ecmcAsynPortDriver *)getEcmcAsynPortDriver(); + if(!ecmcAsynPort) { + printf("ERROR: ecmcAsynPort NULL."); + throw std::runtime_error( "ERROR: ecmcAsynPort NULL." ); + } + + // Add resultdata "plugin.can.dev%d." + std::string paramName = ECMC_PLUGIN_ASYN_PREFIX + std::string(".dev") + + to_string(nodeId_) + ".pdo" /*+ to_string(objIndex_) */ + + "." + std::string(name_); + + dataParam_ = ecmcAsynPort->addNewAvailParam( + paramName.c_str(), // name + asynParamInt8Array, // asyn type + dataBuffer_, // pointer to data + ODSize_, // size of data + ECMC_EC_U8, // ecmc data type + 0); // die if fail + + if(!dataParam_) { + printf("ERROR: Failed create asyn param for data."); + throw std::runtime_error( "ERROR: Failed create asyn param for data: " + paramName); + } + + // Allow different types depending on size + if(ODSize_>1){ + dataParam_->addSupportedAsynType(asynParamInt16Array); + } + if(ODSize_>3){ + dataParam_->addSupportedAsynType(asynParamInt32Array); + dataParam_->addSupportedAsynType(asynParamFloat32Array); + dataParam_->addSupportedAsynType(asynParamInt32); + } + if(ODSize_>7){ + dataParam_->addSupportedAsynType(asynParamFloat64Array); + dataParam_->addSupportedAsynType(asynParamFloat64); + } + + dataParam_->setAllowWriteToEcmc(rw_ == DIR_WRITE); + + if(rw_ == DIR_WRITE) { + dataParam_->setExeCmdFunctPtr(asynWritePDOValue,this); + } + + dataParam_->refreshParam(1); // read once into asyn param lib + ecmcAsynPort->callParamCallbacks(ECMC_ASYN_DEFAULT_LIST, ECMC_ASYN_DEFAULT_ADDR); + + // Add resultdata "plugin.can.dev%d.error" + paramName = ECMC_PLUGIN_ASYN_PREFIX + std::string(".dev") + + to_string(nodeId_) + ".sdo" /*+ to_string(objIndex_)*/ + std::string(".error"); + + errorParam_ = ecmcAsynPort->addNewAvailParam( + paramName.c_str(), // name + asynParamInt32, // asyn type + (uint8_t*)&errorCode_, // pointer to data + sizeof(errorCode_), // size of data + ECMC_EC_U32, // ecmc data type + 0); // die if fail + + if(!errorParam_) { + printf("ERROR: Failed create asyn param for data."); + throw std::runtime_error( "ERROR: Failed create asyn param for data: " + paramName); + } + + errorParam_->setAllowWriteToEcmc(false); // need to callback here + errorParam_->refreshParam(1); // read once into asyn param lib + ecmcAsynPort->callParamCallbacks(ECMC_ASYN_DEFAULT_LIST, ECMC_ASYN_DEFAULT_ADDR); +} + +// Avoid issues with std:to_string() +std::string ecmcCANOpenPDO::to_string(int value) { + std::ostringstream os; + os << value; + return os.str(); +} diff --git a/ecmc_plugin_socketcan/ecmc_plugin_socketcanApp/src/ecmcCANOpenPDO.h b/ecmc_plugin_socketcan/ecmc_plugin_socketcanApp/src/ecmcCANOpenPDO.h index af06899..86d5895 100644 --- a/ecmc_plugin_socketcan/ecmc_plugin_socketcanApp/src/ecmcCANOpenPDO.h +++ b/ecmc_plugin_socketcan/ecmc_plugin_socketcanApp/src/ecmcCANOpenPDO.h @@ -30,6 +30,7 @@ class ecmcCANOpenPDO { public: ecmcCANOpenPDO(ecmcSocketCANWriteBuffer* writeBuffer, + uint32_t nodeId, uint32_t cobId, ecmc_can_direction rw, uint32_t ODSize, @@ -48,6 +49,7 @@ class ecmcCANOpenPDO { int validateFrame(can_frame *frame); ecmcSocketCANWriteBuffer *writeBuffer_; uint32_t cobId_; // with cobid + uint32_t nodeId_; int readTimeoutMs_; int writeCycleMs_; int exeSampleTimeMs_; @@ -63,6 +65,12 @@ class ecmcCANOpenPDO { epicsMutexId dataMutex_; char* name_; + static std::string to_string(int value); + + //ASYN + void initAsyn(); + ecmcAsynDataItem *dataParam_; + ecmcAsynDataItem *errorParam_; }; #endif /* ECMC_CANOPEN_PDO_H_ */ diff --git a/ecmc_plugin_socketcan/ecmc_plugin_socketcanApp/src/ecmcCANOpenSDO.cpp b/ecmc_plugin_socketcan/ecmc_plugin_socketcanApp/src/ecmcCANOpenSDO.cpp index 7424859..7d27c41 100644 --- a/ecmc_plugin_socketcan/ecmc_plugin_socketcanApp/src/ecmcCANOpenSDO.cpp +++ b/ecmc_plugin_socketcan/ecmc_plugin_socketcanApp/src/ecmcCANOpenSDO.cpp @@ -21,6 +21,19 @@ #define ECMC_SDO_TRANSFER_MAX_BYTES 7 +// Calback function to init write from asyn +asynStatus asynWriteSDOValue(void* data, size_t bytes, asynParamType asynParType,void *userObj) { + // userobj = NULL + if(!userObj) { + printf("Error: asynWriteSDOValue() fail, no user obj defined.\n"); + return asynError; + } + ecmcCANOpenSDO* sdo = (ecmcCANOpenSDO*)userObj; + + sdo->setValue((uint8_t*)data,bytes); + sdo->writeValue(); + return asynSuccess; +} /** * ecmc ecmcCANOpenSDO class */ @@ -36,6 +49,7 @@ ecmcCANOpenSDO::ecmcCANOpenSDO(ecmcSocketCANWriteBuffer* writeBuffer, int exeSampleTimeMs, const char *name, std::atomic_flag *ptrSdo1Lock, + int objIndex, int dbgMode) { writeBuffer_ = writeBuffer; @@ -45,13 +59,16 @@ ecmcCANOpenSDO::ecmcCANOpenSDO(ecmcSocketCANWriteBuffer* writeBuffer, ODIndex_ = ODIndex; ODSubIndex_ = ODSubIndex; ODSize_ = ODSize; + objIndex_ = objIndex; dbgMode_ = dbgMode; name_ = strdup(name); errorCode_ = 0; ptrSdo1Lock_ = ptrSdo1Lock; dataMutex_ = epicsMutexCreate(); getLockMutex_ = epicsMutexCreate(); - + errorParam_ = NULL; + dataParam_ = NULL; + writePending_ = NULL; // convert to ODIndex_ to indiviual bytes struct memcpy(&ODIndexBytes_, &ODIndex, 2); memcpy(&ODLengthBytes_, &ODSize_, 4); @@ -66,7 +83,7 @@ ecmcCANOpenSDO::ecmcCANOpenSDO(ecmcSocketCANWriteBuffer* writeBuffer, writeStates_ = WRITE_IDLE; useTg1Frame_ = 1; dataBuffer_ = new uint8_t(ODSize_); - tempReadBuffer_ = new uint8_t(ODSize_); + tempDataBuffer_ = new uint8_t(ODSize_); busyCounter_ = 0; // Request data (send on slave RX) // w 0x603 [8] 0x40 0x40 0x26 0x00 0x00 0x00 0x00 0x00 @@ -179,13 +196,13 @@ ecmcCANOpenSDO::ecmcCANOpenSDO(ecmcSocketCANWriteBuffer* writeBuffer, writeConfReqFrameTg1_.data[6] = 0; writeConfReqFrameTg1_.data[7] = 0; busy_ = false; - + initAsyn(); } ecmcCANOpenSDO::~ecmcCANOpenSDO() { delete[] dataBuffer_; - delete[] tempReadBuffer_; + delete[] tempDataBuffer_; free(name_); } @@ -200,14 +217,19 @@ void ecmcCANOpenSDO::execute() { if(busyCounter_>ECMC_SDO_REPLY_TIMOUT_MS) { // cancel read or write printf("SDO BUSY timeout!! %s\n",name_); - memset(tempReadBuffer_,0,ODSize_); + memset(tempDataBuffer_,0,ODSize_); readStates_ = READ_IDLE; writeStates_ = WRITE_IDLE; exeCounter_ = 0; busyCounter_ = 0; errorCode_ = ECMC_CAN_ERROR_SDO_TIMEOUT; + errorParam_->refreshParamRT(1); unlockSdo1(); } + if(!busy_ && writePending_) { + // Try to write pending value in tempDataBuffer_ + writeValue(); + } if(exeCounter_* exeSampleTimeMs_ < readSampleTimeMs_ && rw_ == DIR_READ) { // do not risk overflow exeCounter_++; @@ -258,6 +280,10 @@ void ecmcCANOpenSDO::newRxFrame(can_frame *frame) { else { // Write errorCode = writeDataStateMachine(frame); } + if(errorCode && errorCode_ != errorCode) { + errorCode_ = errorCode; + errorParam_->refreshParamRT(1); + } } int ecmcCANOpenSDO::readDataStateMachine(can_frame *frame) { @@ -283,7 +309,7 @@ int ecmcCANOpenSDO::readDataStateMachine(can_frame *frame) { } if(bytesToRead + recivedBytes_ <= ODSize_) { - memcpy(tempReadBuffer_ + recivedBytes_, &(frame->data[1]),bytesToRead); + memcpy(tempDataBuffer_ + recivedBytes_, &(frame->data[1]),bytesToRead); recivedBytes_ += bytesToRead; } if(recivedBytes_ < ODSize_) { // Ask for more data but must toggle so alternat the prepared frames @@ -304,13 +330,14 @@ int ecmcCANOpenSDO::readDataStateMachine(can_frame *frame) { useTg1Frame_ = 0; epicsMutexLock(dataMutex_); - memcpy(dataBuffer_,tempReadBuffer_,ODSize_); + memcpy(dataBuffer_,tempDataBuffer_,ODSize_); epicsMutexUnlock(dataMutex_); if(dbgMode_) { printf("STATE = READ_IDLE %s\n",name_); printf("All data read from slave SDO.\n"); //copy complete data to dataBuffer_ printBuffer(); + dataParam_->refreshParamRT(1); } unlockSdo1(); return 0; @@ -457,8 +484,9 @@ void ecmcCANOpenSDO::setValue(uint8_t *data, size_t bytes) { if(bytesToCopy == 0) { return; } + // always write to tempDatabuffer then transfer epicsMutexLock(dataMutex_); - memcpy(dataBuffer_, &data, ODSize_); + memcpy(tempDataBuffer_, data, ODSize_); epicsMutexUnlock(dataMutex_); } @@ -467,18 +495,26 @@ int ecmcCANOpenSDO::writeValue() { printf("WRITEVALUE %s\n",name_); if(busy_) { + writePending_ = true; return ECMC_CAN_ERROR_SDO_WRITE_BUSY; } if(!tryLockSdo1()) { // wait for busy to go down + writePending_ = true; return ECMC_CAN_ERROR_SDO_WRITE_BUSY; } if(writeStates_ != WRITE_IDLE ) { + writePending_ = true; return ECMC_CAN_ERROR_SDO_WRITE_BUSY; } - + writePending_ = false; + + epicsMutexLock(dataMutex_); + memcpy(dataBuffer_, tempDataBuffer_, ODSize_); + epicsMutexUnlock(dataMutex_); + writeStates_ = WRITE_REQ_TRANSFER; if(dbgMode_) { printf("STATE = WRITE_REQ_TRANSFER %s\n",name_); @@ -551,7 +587,9 @@ void ecmcCANOpenSDO::initAsyn() { } // Add resultdata "plugin.can.dev%d." - std::string paramName = ECMC_PLUGIN_ASYN_PREFIX + std::string(".dev") + to_string(nodeId_) + "." + std::string(name_); + std::string paramName = ECMC_PLUGIN_ASYN_PREFIX + std::string(".dev") + + to_string(nodeId_) + ".sdo" /*+ to_string(objIndex_) */ + + "." + std::string(name_); dataParam_ = ecmcAsynPort->addNewAvailParam( paramName.c_str(), // name @@ -582,157 +620,34 @@ void ecmcCANOpenSDO::initAsyn() { dataParam_->setAllowWriteToEcmc(rw_ == DIR_WRITE); + if(rw_ == DIR_WRITE) { + dataParam_->setExeCmdFunctPtr(asynWriteSDOValue,this); + } + dataParam_->refreshParam(1); // read once into asyn param lib ecmcAsynPort->callParamCallbacks(ECMC_ASYN_DEFAULT_LIST, ECMC_ASYN_DEFAULT_ADDR); - // Add enable "plugin.scope%d.enable" - /*paramName = ECMC_PLUGIN_ASYN_PREFIX + to_string(objectId_) + - "." + ECMC_PLUGIN_ASYN_ENABLE; + // Add resultdata "plugin.can.dev%d.error" + paramName = ECMC_PLUGIN_ASYN_PREFIX + std::string(".dev") + + to_string(nodeId_) + ".sdo" /*+ to_string(objIndex_)*/ + std::string(".error"); - enbaleParam_ = ecmcAsynPort->addNewAvailParam( + errorParam_ = ecmcAsynPort->addNewAvailParam( paramName.c_str(), // name asynParamInt32, // asyn type - (uint8_t*)&cfgEnable_, // pointer to data - sizeof(cfgEnable_), // size of data - ECMC_EC_S32, // ecmc data type + (uint8_t*)&errorCode_, // pointer to data + sizeof(errorCode_), // size of data + ECMC_EC_U32, // ecmc data type 0); // die if fail - if(!enbaleParam_) { - SOCKETCAN_DBG_PRINT("ERROR: Failed create asyn param for enable."); - throw std::runtime_error( "ERROR: Failed create asyn param for enable: " + paramName); + if(!errorParam_) { + printf("ERROR: Failed create asyn param for data."); + throw std::runtime_error( "ERROR: Failed create asyn param for data: " + paramName); } - - enbaleParam_->setAllowWriteToEcmc(true); - enbaleParam_->refreshParam(1); // read once into asyn param lib - ecmcAsynPort->callParamCallbacks(ECMC_ASYN_DEFAULT_LIST, ECMC_ASYN_DEFAULT_ADDR); - - // Add missed triggers "plugin.scope%d.missed" - paramName = ECMC_PLUGIN_ASYN_PREFIX + to_string(objectId_) + - "." + ECMC_PLUGIN_ASYN_MISSED; - - asynMissedTriggs_ = ecmcAsynPort->addNewAvailParam( - paramName.c_str(), // name - asynParamInt32, // asyn type - (uint8_t*)&missedTriggs_, // pointer to data - sizeof(missedTriggs_), // size of data - ECMC_EC_S32, // ecmc data type - 0); // die if fail - - if(!asynMissedTriggs_) { - SOCKETCAN_DBG_PRINT("ERROR: Failed create asyn param for missed trigg counter."); - throw std::runtime_error( "ERROR: Failed create asyn param for missed trigg counter: " + paramName); - } - - asynMissedTriggs_->setAllowWriteToEcmc(false); - asynMissedTriggs_->refreshParam(1); // read once into asyn param lib - ecmcAsynPort->callParamCallbacks(ECMC_ASYN_DEFAULT_LIST, ECMC_ASYN_DEFAULT_ADDR); - - // Add trigger counter "plugin.scope%d.count" - paramName = ECMC_PLUGIN_ASYN_PREFIX + to_string(objectId_) + - "." + ECMC_PLUGIN_ASYN_TRIGG_COUNT; - - asynTriggerCounter_ = ecmcAsynPort->addNewAvailParam( - paramName.c_str(), // name - asynParamInt32, // asyn type - (uint8_t*)&triggerCounter_, // pointer to data - sizeof(triggerCounter_), // size of data - ECMC_EC_S32, // ecmc data type - 0); // die if fail - - if(!asynTriggerCounter_) { - SOCKETCAN_DBG_PRINT("ERROR: Failed create asyn param for trigg counter."); - throw std::runtime_error( "ERROR: Failed create asyn param for trigg counter: " + paramName); - } - - asynTriggerCounter_->setAllowWriteToEcmc(false); - asynTriggerCounter_->refreshParam(1); // read once into asyn param lib - ecmcAsynPort->callParamCallbacks(ECMC_ASYN_DEFAULT_LIST, ECMC_ASYN_DEFAULT_ADDR); - - // Add trigger counter "plugin.scope%d.scantotrigg" - paramName = ECMC_PLUGIN_ASYN_PREFIX + to_string(objectId_) + - "." + ECMC_PLUGIN_ASYN_SCAN_TO_TRIGG_OFFSET; - - asynTimeTrigg2Sample_ = ecmcAsynPort->addNewAvailParam( - paramName.c_str(), // name - asynParamFloat64, // asyn type - (uint8_t*)&samplesSinceLastTrigg_, // pointer to data - sizeof(samplesSinceLastTrigg_), // size of data - ECMC_EC_S64, // ecmc data type - 0); // die if fail - - if(!asynTimeTrigg2Sample_) { - SOCKETCAN_DBG_PRINT("ERROR: Failed create asyn param for time trigg to sample."); - throw std::runtime_error( "ERROR: Failed create asyn param for time trigg to sample: " + paramName); - } - - asynTimeTrigg2Sample_->addSupportedAsynType(asynParamFloat64); - asynTimeTrigg2Sample_->setAllowWriteToEcmc(false); - asynTimeTrigg2Sample_->refreshParam(1); // read once into asyn param lib - ecmcAsynPort->callParamCallbacks(ECMC_ASYN_DEFAULT_LIST, ECMC_ASYN_DEFAULT_ADDR); - - // Add enable "plugin.scope%d.source" - paramName = ECMC_PLUGIN_ASYN_PREFIX + to_string(objectId_) + - "." + ECMC_PLUGIN_ASYN_SCOPE_SOURCE; - - sourceStrParam_ = ecmcAsynPort->addNewAvailParam( - paramName.c_str(), // name - asynParamInt8Array, // asyn type - (uint8_t*)cfgDataSourceStr_,// pointer to data - strlen(cfgDataSourceStr_), // size of data - ECMC_EC_U8, // ecmc data type - 0); // die if fail - - if(!sourceStrParam_) { - SOCKETCAN_DBG_PRINT("ERROR: Failed create asyn param for data source."); - throw std::runtime_error( "ERROR: Failed create asyn param for data source: " + paramName); - } - - sourceStrParam_->setAllowWriteToEcmc(false); // read only - sourceStrParam_->refreshParam(1); // read once into asyn param lib - ecmcAsynPort->callParamCallbacks(ECMC_ASYN_DEFAULT_LIST, ECMC_ASYN_DEFAULT_ADDR); - - // Add enable "plugin.scope%d.trigg" - paramName = ECMC_PLUGIN_ASYN_PREFIX + to_string(objectId_) + - "." + ECMC_PLUGIN_ASYN_SCOPE_TRIGG; - - triggStrParam_ = ecmcAsynPort->addNewAvailParam( - paramName.c_str(), // name - asynParamInt8Array, // asyn type - (uint8_t*)cfgTriggStr_,// pointer to data - strlen(cfgTriggStr_), // size of data - ECMC_EC_U8, // ecmc data type - 0); // die if fail - - if(!triggStrParam_) { - SOCKETCAN_DBG_PRINT("ERROR: Failed create asyn param for trigger."); - throw std::runtime_error( "ERROR: Failed create asyn param for trigger: " + paramName); - } - - triggStrParam_->setAllowWriteToEcmc(false); // read only - triggStrParam_->refreshParam(1); // read once into asyn param lib - ecmcAsynPort->callParamCallbacks(ECMC_ASYN_DEFAULT_LIST, ECMC_ASYN_DEFAULT_ADDR); - - // Add enable "plugin.scope%d.nexttime" - paramName = ECMC_PLUGIN_ASYN_PREFIX + to_string(objectId_) + - "." + ECMC_PLUGIN_ASYN_SCOPE_NEXT_SYNC; - - sourceNexttimeStrParam_ = ecmcAsynPort->addNewAvailParam( - paramName.c_str(), // name - asynParamInt8Array, // asyn type - (uint8_t*)cfgDataNexttimeStr_,// pointer to data - strlen(cfgDataNexttimeStr_), // size of data - ECMC_EC_U8, // ecmc data type - 0); // die if fail - - if(!sourceNexttimeStrParam_) { - SOCKETCAN_DBG_PRINT("ERROR: Failed create asyn param for nexttime."); - throw std::runtime_error( "ERROR: Failed create asyn param for nexttime: " + paramName); - } - - sourceNexttimeStrParam_->setAllowWriteToEcmc(false); // read only - sourceNexttimeStrParam_->refreshParam(1); // read once into asyn param lib + + errorParam_->setAllowWriteToEcmc(false); // need to callback here + errorParam_->refreshParam(1); // read once into asyn param lib ecmcAsynPort->callParamCallbacks(ECMC_ASYN_DEFAULT_LIST, ECMC_ASYN_DEFAULT_ADDR); -*/ + } // Avoid issues with std:to_string() diff --git a/ecmc_plugin_socketcan/ecmc_plugin_socketcanApp/src/ecmcCANOpenSDO.h b/ecmc_plugin_socketcan/ecmc_plugin_socketcanApp/src/ecmcCANOpenSDO.h index 7d35f27..ae3934c 100644 --- a/ecmc_plugin_socketcan/ecmc_plugin_socketcanApp/src/ecmcCANOpenSDO.h +++ b/ecmc_plugin_socketcan/ecmc_plugin_socketcanApp/src/ecmcCANOpenSDO.h @@ -44,6 +44,7 @@ class ecmcCANOpenSDO { int exeSampleTimeMs, const char *name, std::atomic_flag *ptrSdo1Lock, + int objIndex, int dbgMode); ~ecmcCANOpenSDO(); void execute(); @@ -86,8 +87,10 @@ class ecmcCANOpenSDO { int dbgMode_; int errorCode_; + int objIndex_; + uint8_t *dataBuffer_; - uint8_t *tempReadBuffer_; + uint8_t *tempDataBuffer_; uint32_t recivedBytes_; int useTg1Frame_; ecmc_read_states readStates_; @@ -100,12 +103,16 @@ class ecmcCANOpenSDO { int busyCounter_; std::atomic_flag *ptrSdo1Lock_; bool busy_; + bool writePending_; //ASYN void initAsyn(); static std::string to_string(int value); ecmcAsynDataItem *dataParam_; + ecmcAsynDataItem *errorParam_; + }; + #endif /* ECMC_CANOPEN_SDO_H_ */ diff --git a/iocsh/pvs.log b/iocsh/pvs.log index b409767..2cfa54e 100644 --- a/iocsh/pvs.log +++ b/iocsh/pvs.log @@ -1,12 +1,12 @@ -REQMOD:mcag-trgt-muts--26598:MODULES -REQMOD:mcag-trgt-muts--26598:VERSIONS -REQMOD:mcag-trgt-muts--26598:MOD_VER -REQMOD:mcag-trgt-muts--26598:exit -REQMOD:mcag-trgt-muts--26598:BaseVersion -REQMOD:mcag-trgt-muts--26598:require_VER -REQMOD:mcag-trgt-muts--26598:ecmccfg_VER -REQMOD:mcag-trgt-muts--26598:asyn_VER -REQMOD:mcag-trgt-muts--26598:exprtk_VER -REQMOD:mcag-trgt-muts--26598:motor_VER -REQMOD:mcag-trgt-muts--26598:ecmc_VER -REQMOD:mcag-trgt-muts--26598:ecmc_plugin_socketcan_VER +REQMOD:mcag-trgt-muts--6100:MODULES +REQMOD:mcag-trgt-muts--6100:VERSIONS +REQMOD:mcag-trgt-muts--6100:MOD_VER +REQMOD:mcag-trgt-muts--6100:exit +REQMOD:mcag-trgt-muts--6100:BaseVersion +REQMOD:mcag-trgt-muts--6100:require_VER +REQMOD:mcag-trgt-muts--6100:ecmccfg_VER +REQMOD:mcag-trgt-muts--6100:asyn_VER +REQMOD:mcag-trgt-muts--6100:exprtk_VER +REQMOD:mcag-trgt-muts--6100:motor_VER +REQMOD:mcag-trgt-muts--6100:ecmc_VER +REQMOD:mcag-trgt-muts--6100:ecmc_plugin_socketcan_VER