diff --git a/ecmcPlugin_FFT-loc/ecmcPlugin_FFTApp/src/ecmcFFT.cpp b/ecmcPlugin_FFT-loc/ecmcPlugin_FFTApp/src/ecmcFFT.cpp index e42402b..b67e8fb 100644 --- a/ecmcPlugin_FFT-loc/ecmcPlugin_FFTApp/src/ecmcFFT.cpp +++ b/ecmcPlugin_FFT-loc/ecmcPlugin_FFTApp/src/ecmcFFT.cpp @@ -16,12 +16,14 @@ #define ECMC_PLUGIN_ERROR_FFT_BASE 100 #define ECMC_PLUGIN_ERROR_FFT_ALLOC_FAIL 101 +#define ECMC_PLUGIN_ERROR_FFT_DATATYPE_NOT_SUPPORTED 102 #include "ecmcFFT.h" + +// New data callback from ecmc static int printMissingObjError = 1; -// data callback void f_dataUpdatedCallback(uint8_t* data, size_t size, ecmcEcDataType dt, void* obj) { if(!obj) { if(printMissingObjError){ @@ -37,6 +39,8 @@ void f_dataUpdatedCallback(uint8_t* data, size_t size, ecmcEcDataType dt, void* fftObj->dataUpdatedCallback(data,size,dt); } + +// ecmc FFT class ecmcFFT::ecmcFFT(ecmcDataItem* dataItem, ecmcAsynPortDriver* asynPort, size_t nfft) { bufferSizeBytes_ = 0; bytesInBuffer_ = 0; @@ -44,6 +48,7 @@ ecmcFFT::ecmcFFT(ecmcDataItem* dataItem, ecmcAsynPortDriver* asynPort, size_t nf asynPort_ = asynPort; nfft_ = nfft; dataBuffer_ = NULL; + errorId_ = 0; // Allocate buffer bufferSizeBytes_ = nfft_ * dataItem_->getEcmcDataElementSize(); @@ -52,8 +57,21 @@ ecmcFFT::ecmcFFT(ecmcDataItem* dataItem, ecmcAsynPortDriver* asynPort, size_t nf if(!dataBuffer_) { printf("%s/%s:%d: Error: Failed allocate dataBuffer of size %d (0x%x).\n", __FILE__, __FUNCTION__, __LINE__, bufferSizeBytes_, ECMC_PLUGIN_ERROR_FFT_ALLOC_FAIL); + errorId_ = ECMC_PLUGIN_ERROR_FFT_ALLOC_FAIL; + return; } + clearBuffer(); + + if( !dataTypeSupported(dataItem_->getEcmcDataType()) ) { + errorId_ = ECMC_PLUGIN_ERROR_FFT_DATATYPE_NOT_SUPPORTED; + return; + } + + errorId_ = connectToDataSource(); + if(errorId_) { + return; + } } ecmcFFT::~ecmcFFT() { @@ -62,7 +80,7 @@ ecmcFFT::~ecmcFFT() { } } -int ecmcFFT::ConnectToDataSource() { +int ecmcFFT::connectToDataSource() { //Register data callback return dataItem_->regDataUpdatedCallback(f_dataUpdatedCallback, this); } @@ -75,6 +93,8 @@ void ecmcFFT::dataUpdatedCallback(uint8_t* data, return; } + //printData(data,size,dt); + if(bytesInBuffer_ == bufferSizeBytes_) { printf("Buffer full (%d bytes appended).\n",bytesInBuffer_); } @@ -92,3 +112,199 @@ void ecmcFFT::clearBuffer() { memset(dataBuffer_,0,bufferSizeBytes_); bytesInBuffer_ = 0; } + +int ecmcFFT::getErrorId() { + return errorId_; +} + +void ecmcFFT::printData(uint8_t* data, + size_t size, + ecmcEcDataType dt) { + + size_t dataElementSize = getEcDataTypeByteSize(dt); + + uint8_t *pData = data; + + for(unsigned int i = 0; i < size / dataElementSize; ++i) { + switch(dt) { + case ECMC_EC_U8: + printf("%hhu\n",getUint8(pData)); + break; + case ECMC_EC_S8: + printf("%hhd\n",getInt8(pData)); + break; + case ECMC_EC_U16: + printf("%hu\n",getUint16(pData)); + break; + case ECMC_EC_S16: + printf("%hd\n",getInt16(pData)); + break; + case ECMC_EC_U32: + printf("%u\n",getUint32(pData)); + break; + case ECMC_EC_S32: + printf("%d\n",getInt32(pData)); + break; + case ECMC_EC_U64: + printf("%" PRIu64 "\n",getInt64(pData)); + break; + case ECMC_EC_S64: + printf("%" PRId64 "\n",getInt64(pData)); + break; + case ECMC_EC_F32: + printf("%f\n",getFloat32(pData)); + break; + case ECMC_EC_F64: + printf("%lf\n",getFloat64(pData)); + break; + default: + break; + } + } + // go to next element + pData += dataElementSize; +} + +int ecmcFFT::dataTypeSupported(ecmcEcDataType dt) { + + switch(dt) { + case ECMC_EC_NONE: + return 0; + break; + case ECMC_EC_B1: + return 0; + break; + case ECMC_EC_B2: + return 0; + break; + case ECMC_EC_B3: + return 0; + break; + case ECMC_EC_B4: + return 0; + break; + default: + return 1; + break; + } + return 1; +} + +uint8_t ecmcFFT::getUint8(uint8_t* data) { + return *data; +} + +int8_t ecmcFFT::getInt8(uint8_t* data) { + int8_t* p=(int8_t*)data; + return *p; +} + +uint16_t ecmcFFT::getUint16(uint8_t* data) { + uint16_t* p=(uint16_t*)data; + return *p; +} + +int16_t ecmcFFT::getInt16(uint8_t* data) { + int16_t* p=(int16_t*)data; + return *p; +} + +uint32_t ecmcFFT::getUint32(uint8_t* data) { + uint32_t* p=(uint32_t*)data; + return *p; +} + +int32_t ecmcFFT::getInt32(uint8_t* data) { + int32_t* p=(int32_t*)data; + return *p; +} + +uint64_t ecmcFFT::getUint64(uint8_t* data) { + uint64_t* p=(uint64_t*)data; + return *p; +} + +int64_t ecmcFFT::getInt64(uint8_t* data) { + int64_t* p=(int64_t*)data; + return *p; +} + +float ecmcFFT::getFloat32(uint8_t* data) { + float* p=(float*)data; + return *p; +} + +double ecmcFFT::getFloat64(uint8_t* data) { + double* p=(double*)data; + return *p; +} + +size_t ecmcFFT::getEcDataTypeByteSize(ecmcEcDataType dt){ + switch(dt) { + case ECMC_EC_NONE: + return 0; + break; + + case ECMC_EC_B1: + return 1; + break; + + case ECMC_EC_B2: + return 1; + break; + + case ECMC_EC_B3: + return 1; + break; + + case ECMC_EC_B4: + return 1; + break; + + case ECMC_EC_U8: + return 1; + break; + + case ECMC_EC_S8: + return 1; + break; + + case ECMC_EC_U16: + return 2; + break; + + case ECMC_EC_S16: + return 2; + break; + + case ECMC_EC_U32: + return 4; + break; + + case ECMC_EC_S32: + return 4; + break; + + case ECMC_EC_U64: + return 8; + break; + + case ECMC_EC_S64: + return 8; + break; + + case ECMC_EC_F32: + return 4; + break; + + case ECMC_EC_F64: + return 8; + break; + + default: + return 0; + break; + } + + return 0; +} diff --git a/ecmcPlugin_FFT-loc/ecmcPlugin_FFTApp/src/ecmcFFT.h b/ecmcPlugin_FFT-loc/ecmcPlugin_FFTApp/src/ecmcFFT.h index 6bcba15..a98a7f2 100644 --- a/ecmcPlugin_FFT-loc/ecmcPlugin_FFTApp/src/ecmcFFT.h +++ b/ecmcPlugin_FFT-loc/ecmcPlugin_FFTApp/src/ecmcFFT.h @@ -26,20 +26,42 @@ class ecmcFFT { ~ecmcFFT(); - //Register callback - int ConnectToDataSource(); + int getErrorId(); + // Add data to buffer void dataUpdatedCallback(uint8_t* data, size_t size, ecmcEcDataType dt); private: - void clearBuffer(); + int connectToDataSource(); + + void clearBuffer(); ecmcDataItem *dataItem_; ecmcAsynPortDriver *asynPort_; uint8_t* dataBuffer_; size_t nfft_; size_t bufferSizeBytes_; size_t bytesInBuffer_; + int errorId_; + static int dataTypeSupported(ecmcEcDataType dt); + + //Some utility functions + static uint8_t getUint8(uint8_t* data); + static int8_t getInt8(uint8_t* data); + static uint16_t getUint16(uint8_t* data); + static int16_t getInt16(uint8_t* data); + static uint32_t getUint32(uint8_t* data); + static int32_t getInt32(uint8_t* data); + static uint64_t getUint64(uint8_t* data); + static int64_t getInt64(uint8_t* data); + static float getFloat32(uint8_t* data); + static double getFloat64(uint8_t* data); + static size_t getEcDataTypeByteSize(ecmcEcDataType dt); + + static void printData(uint8_t* data, + size_t size, + ecmcEcDataType dt); + }; #endif /* ECMC_FFT_H_ */ diff --git a/ecmcPlugin_FFT-loc/ecmcPlugin_FFTApp/src/ecmcFFTWrap.cpp b/ecmcPlugin_FFT-loc/ecmcPlugin_FFTApp/src/ecmcFFTWrap.cpp index e9d2b85..c1f4466 100644 --- a/ecmcPlugin_FFT-loc/ecmcPlugin_FFTApp/src/ecmcFFTWrap.cpp +++ b/ecmcPlugin_FFT-loc/ecmcPlugin_FFTApp/src/ecmcFFTWrap.cpp @@ -52,5 +52,5 @@ int createFFT(char* source, int dbgMode) { } // Register callback - return fft->ConnectToDataSource(); + return fft->getErrorId(); }