donkey
/
toys
Not watched
1
0
Fork 0
Code
Releases 0 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branch: master
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'master'
${ noResults }
toys/qdataanalyzer/source/Process/AnalogProcess.cpp

484 lines
19 kB
Raw Permalink Blame History 

  1. #include "AnalogProcess.h"

  2. 

  3. AnalogProcess::AnalogProcess(QObject* parent) : IProcess(parent)

  4. {}

  5. AnalogProcess::~AnalogProcess()

  6. {

  7.     if (m_pConstBuffer) {

  8.         delete m_pConstBuffer;

  9.         m_pConstBuffer = nullptr;

  10.     }

  11.     m_file.write(m_fileArray);

  12.     m_file.flush();

  13.     m_file.close();

  14. }

  15. 

  16. void AnalogProcess::run()

  17. {

  18.     unsigned char* m_ReadBuffer = new unsigned char[m_pFrame->m_uiFrameLen];

  19.     unsigned short usReadLen    = 0;

  20.     double         dStartTime   = 0.0;

  21.     m_bNeedWork                 = true;

  22.     while (m_bNeedWork) {

  23.         usReadLen = m_pConstBuffer->read(m_ReadBuffer, m_pFrame->m_uiFrameLen);

  24.         if (usReadLen <= 0) {

  25.             QThread::usleep(1);

  26.             continue;

  27.         }

  28.         m_tempArray              = QByteArray((char*)m_ReadBuffer, m_pFrame->m_uiFrameLen);

  29.         unsigned char* pData     = (unsigned char*)m_tempArray.data();

  30.         unsigned int   uiCodePos = 0;

  31.         if (m_pFrame->m_usHeadAddr == 1) { // 帧头在每行最前

  32.             uiCodePos = 2;

  33.         } else if (m_pFrame->m_usHeadAddr == 2) { // 帧头在每行最后

  34.             uiCodePos = 0;

  35.         }

  36.         if (m_pParam->getCurveWidget()->m_bRefTime == false) {   // 未设置基准时间

  37.             dStartTime      = GetBCDTimeCode(pData + uiCodePos); // 初始时码值

  38.             QString strTime = "时间(ms)-基准时间：" + GetBCDTimeCodeHMS(pData + uiCodePos);

  39.             QCustomPlot* pCustomPlot = m_pParam->getCurveWidget()->getCustomplot();

  40.             pCustomPlot->xAxis->setLabel(strTime);

  41.             m_pParam->getCurveWidget()->m_bRefTime = true;

  42.         }

  43.         double dCodeTime = GetBCDTimeCode(pData + uiCodePos) - dStartTime; // 时码值

  44.         // 提取一个数据，添加一个时间

  45.         for (auto channel : m_pParam->m_pChannelGroup->m_vecChannel) {

  46.             m_validArray.append(m_tempArray.at(channel->m_uiAbsolutePos));

  47.         }

  48.         m_tempArray.clear();

  49.         m_ableArray = m_validArray;

  50.         m_validArray.clear();

  51.         // 将数据写入文件中

  52.         m_fileArray.append(m_ableArray);

  53.         if (DataAchiveBuffer <= m_fileArray.size()) {

  54.             m_file.write(m_fileArray);

  55.             m_file.flush();

  56.             m_fileArray.clear();

  57.         }

  58.         // 处理有效工程量数据

  59.         validDataDeal(dCodeTime);

  60.     }

  61. }

  62. 

  63. unsigned int AnalogProcess::getDataNum()

  64. {

  65.     unsigned int   uiChannelNum = m_pParam->m_pChannelGroup->m_uiChannelNum; // 所占通道数量

  66.     unsigned short usType       = m_pParam->m_usType;

  67.     unsigned int   uiDataNum    = 0;

  68.     // 计算有效数据个数

  69.     switch (usType) {

  70.     case 1:

  71.     case 2:

  72.         uiDataNum = uiChannelNum;

  73.         break;

  74.     case 3:

  75.     case 4:

  76.         uiDataNum = uiChannelNum / 2;

  77.         break;

  78.     case 5:

  79.     case 6:

  80.         uiDataNum = uiChannelNum / 4;

  81.         break;

  82.     case 7:

  83.     case 8:

  84.         uiDataNum = uiChannelNum / 8;

  85.         break;

  86.     default:

  87.         break;

  88.     }

  89.     return uiDataNum;

  90. }

  91. // 处理有效数据

  92. void AnalogProcess::validDataDeal(qreal time)

  93. {

  94.     // 获取时码

  95.     double       dFrameTime    = m_pFrame->m_dFrameTime; // 帧间隔

  96.     unsigned int uiDataNum     = getDataNum();           // 有效数据个数

  97.     double       dTimeInterval = dFrameTime / (uiDataNum * 1.0);

  98. 

  99.     unsigned short usModel      = m_pParam->m_usModel; // 参数类型

  100.     unsigned short usOrder      = m_pParam->m_usOrder; // 大小端

  101.     unsigned int   m_uiIndex    = 0;

  102.     unsigned int   m_uiNum      = 0;

  103.     double         dTime        = 0.0;

  104.     unsigned int   m_uiDataSize = m_ableArray.size();

  105.     unsigned char* pData        = (unsigned char*)m_ableArray.data();

  106.     if (usModel == 1) { // 模拟量

  107.         switch (m_pParam->m_usType) {

  108.         case 1: { // char

  109.             while (m_uiIndex < m_uiDataSize) {

  110.                 char cData = (char)m_ableArray.at(m_uiIndex);

  111.                 dTime      = time + dTimeInterval * m_uiNum;

  112.                 // 对char进行处理

  113.                 setCurveData(dTime, cData);

  114.                 ++m_uiIndex;

  115.                 ++m_uiNum;

  116.             }

  117.             break;

  118.         }

  119.         case 2: { // unsigned char

  120.             while (m_uiIndex < m_uiDataSize) {

  121.                 unsigned char ucData = (unsigned char)m_ableArray.at(m_uiIndex);

  122.                 dTime                = time + dTimeInterval * m_uiNum;

  123.                 // 对unsigned char进行处理

  124.                 setCurveData(dTime, ucData);

  125.                 ++m_uiIndex;

  126.                 ++m_uiNum;

  127.             }

  128.             break;

  129.         }

  130.         case 3: { // short

  131.             while (m_uiIndex + 2 <= m_uiDataSize) {

  132.                 short sData = 0x0000;

  133.                 if (usOrder == 1) { // 大端

  134.                     char cTemp       = pData[m_uiIndex];

  135.                     pData[m_uiIndex] = pData[m_uiIndex + 1];

  136.                     pData[m_uiIndex] = cTemp;

  137.                     sData            = *(reinterpret_cast<const short*>(pData + m_uiIndex));

  138.                 } else if (usOrder == 2) { // 小端

  139.                     sData = *(reinterpret_cast<const short*>(pData + m_uiIndex));

  140.                 }

  141.                 dTime = time + dTimeInterval * m_uiNum;

  142.                 setCurveData(dTime, sData);

  143.                 m_uiIndex += 2;

  144.                 ++m_uiNum;

  145.             }

  146.             break;

  147.         }

  148.         case 4: { // unsigned short

  149.             while (m_uiIndex + 2 <= m_uiDataSize) {

  150.                 unsigned short usData = 0x0000;

  151.                 if (usOrder == 1) { // 大端

  152.                     char cTemp       = pData[m_uiIndex];

  153.                     pData[m_uiIndex] = pData[m_uiIndex + 1];

  154.                     pData[m_uiIndex] = cTemp;

  155.                     usData = *(reinterpret_cast<const unsigned short*>(pData + m_uiIndex));

  156.                 } else if (usOrder == 2) { // 小端

  157.                     usData = *(reinterpret_cast<const unsigned short*>(pData + m_uiIndex));

  158.                 }

  159.                 dTime = time + dTimeInterval * m_uiNum;

  160.                 setCurveData(dTime, usData);

  161.                 m_uiIndex += 2;

  162.                 ++m_uiNum;

  163.             }

  164.             break;

  165.         }

  166.         case 5: { // int

  167.             while (m_uiIndex + 4 <= m_uiDataSize) {

  168.                 int iData = 0x00000000;

  169.                 if (usOrder == 1) { // 大端

  170.                     char cTemp[4] = {0x00, 0x00, 0x00, 0x00};

  171.                     cTemp[0]      = pData[m_uiIndex + 3];

  172.                     cTemp[1]      = pData[m_uiIndex + 2];

  173.                     cTemp[2]      = pData[m_uiIndex + 1];

  174.                     cTemp[3]      = pData[m_uiIndex];

  175.                     iData         = *(reinterpret_cast<const int*>(cTemp));

  176.                 } else if (usOrder == 2) { // 小端

  177.                     iData = *(reinterpret_cast<const int*>(pData));

  178.                 }

  179.                 dTime = time + dTimeInterval * m_uiNum;

  180.                 setCurveData(dTime, iData);

  181.                 m_uiIndex += 4;

  182.                 ++m_uiNum;

  183.             }

  184.             break;

  185.         }

  186.         case 6: { // unsigned int

  187.             while (m_uiIndex + 4 <= m_uiDataSize) {

  188.                 unsigned int uiData = 0x00000000;

  189.                 if (usOrder == 1) { // 大端

  190.                     char cTemp[4] = {0x00, 0x00, 0x00, 0x00};

  191.                     cTemp[0]      = pData[m_uiIndex + 3];

  192.                     cTemp[1]      = pData[m_uiIndex + 2];

  193.                     cTemp[2]      = pData[m_uiIndex + 1];

  194.                     cTemp[3]      = pData[m_uiIndex];

  195.                     uiData        = *(reinterpret_cast<const unsigned int*>(cTemp));

  196.                 } else if (usOrder == 2) { // 小端

  197.                     uiData = *(reinterpret_cast<const unsigned int*>(pData));

  198.                 }

  199.                 dTime = time + dTimeInterval * m_uiNum;

  200.                 setCurveData(dTime, uiData);

  201.                 m_uiIndex += 4;

  202.                 ++m_uiNum;

  203.             }

  204.             break;

  205.         }

  206.         case 7: { // long long

  207.             while (m_uiIndex + 8 <= m_uiDataSize) {

  208.                 long long llData = 0x0000000000000000;

  209.                 if (usOrder == 1) { // 大端

  210.                     char cTemp[4] = {0x00, 0x00, 0x00, 0x00};

  211.                     cTemp[0]      = pData[m_uiIndex + 7];

  212.                     cTemp[1]      = pData[m_uiIndex + 6];

  213.                     cTemp[2]      = pData[m_uiIndex + 5];

  214.                     cTemp[3]      = pData[m_uiIndex + 4];

  215.                     cTemp[4]      = pData[m_uiIndex + 3];

  216.                     cTemp[5]      = pData[m_uiIndex + 2];

  217.                     cTemp[6]      = pData[m_uiIndex + 1];

  218.                     cTemp[7]      = pData[m_uiIndex];

  219.                     llData        = *(reinterpret_cast<const long long*>(cTemp));

  220.                 } else if (usOrder == 2) { // 小端

  221.                     llData = *(reinterpret_cast<const long long*>(pData));

  222.                 }

  223.                 dTime = time + dTimeInterval * m_uiNum;

  224.                 setCurveData(dTime, llData);

  225.                 m_uiIndex += 8;

  226.                 ++m_uiNum;

  227.             }

  228.             break;

  229.         }

  230.         case 8: { // unsigned long long

  231.             while (m_uiIndex + 8 <= m_uiDataSize) {

  232.                 unsigned long long ullData = 0x0000000000000000;

  233.                 if (usOrder == 1) { // 大端

  234.                     char cTemp[4] = {0x00, 0x00, 0x00, 0x00};

  235.                     cTemp[0]      = pData[m_uiIndex + 7];

  236.                     cTemp[1]      = pData[m_uiIndex + 6];

  237.                     cTemp[2]      = pData[m_uiIndex + 5];

  238.                     cTemp[3]      = pData[m_uiIndex + 4];

  239.                     cTemp[4]      = pData[m_uiIndex + 3];

  240.                     cTemp[5]      = pData[m_uiIndex + 2];

  241.                     cTemp[6]      = pData[m_uiIndex + 1];

  242.                     cTemp[7]      = pData[m_uiIndex];

  243.                     ullData       = *(reinterpret_cast<const unsigned long long*>(cTemp));

  244.                 } else if (usOrder == 2) { // 小端

  245.                     ullData = *(reinterpret_cast<const unsigned long long*>(pData));

  246.                 }

  247.                 dTime = time + dTimeInterval * m_uiNum;

  248.                 setCurveData(dTime, ullData);

  249.                 m_uiIndex += 8;

  250.                 ++m_uiNum;

  251.             }

  252.             break;

  253.         }

  254.         default:

  255.             break;

  256.         }

  257.     } else if (usModel == 4) {                    // 状态量

  258.         QString      strBit = m_pParam->m_strBit; // 状态量比特位

  259.         unsigned int iBit   = strBit.toInt(nullptr, 16);

  260.         switch (m_pParam->m_usType) {

  261.         case 1: { // char

  262.             while (m_uiIndex < m_uiDataSize) {

  263.                 char cData = (char)m_ableArray.at(m_uiIndex);

  264.                 // 对char进行处理

  265.                 char cBit  = *(char*)&iBit;

  266.                 cData &= cBit;

  267.                 dTime = time + dTimeInterval * m_uiNum;

  268.                 setCurveData(dTime, cData);

  269.                 ++m_uiIndex;

  270.                 ++m_uiNum;

  271.             }

  272.             break;

  273.         }

  274.         case 2: { // unsigned char

  275.             while (m_uiIndex < m_uiDataSize) {

  276.                 unsigned char ucData = (unsigned char)m_ableArray.at(m_uiIndex);

  277.                 // 对unsigned char进行处理

  278.                 unsigned char cBit   = *(unsigned char*)&iBit;

  279.                 ucData &= cBit;

  280.                 dTime = time + dTimeInterval * m_uiNum;

  281.                 setCurveData(dTime, ucData);

  282.                 ++m_uiIndex;

  283.                 ++m_uiNum;

  284.             }

  285.             break;

  286.         }

  287.         case 3: { // short

  288.             while (m_uiIndex + 2 <= m_uiDataSize) {

  289.                 short sData = 0x0000;

  290.                 if (usOrder == 1) { // 大端

  291.                     char cTemp       = pData[m_uiIndex];

  292.                     pData[m_uiIndex] = pData[m_uiIndex + 1];

  293.                     pData[m_uiIndex] = cTemp;

  294.                     sData            = *(reinterpret_cast<const short*>(pData + m_uiIndex));

  295.                 } else if (usOrder == 2) { // 小端

  296.                     sData = *(reinterpret_cast<const short*>(pData + m_uiIndex));

  297.                 }

  298.                 sData &= (short)iBit;

  299.                 dTime = time + dTimeInterval * m_uiNum;

  300.                 setCurveData(dTime, sData);

  301.                 m_uiIndex += 2;

  302.                 ++m_uiNum;

  303.             }

  304.             break;

  305.         }

  306.         case 4: { // unsigned short

  307.             while (m_uiIndex + 2 <= m_uiDataSize) {

  308.                 unsigned short usData = 0x0000;

  309.                 if (usOrder == 1) { // 大端

  310.                     char cTemp       = pData[m_uiIndex];

  311.                     pData[m_uiIndex] = pData[m_uiIndex + 1];

  312.                     pData[m_uiIndex] = cTemp;

  313.                     usData = *(reinterpret_cast<const unsigned short*>(pData + m_uiIndex));

  314.                 } else if (usOrder == 2) { // 小端

  315.                     usData = *(reinterpret_cast<const unsigned short*>(pData + m_uiIndex));

  316.                 }

  317.                 usData &= (unsigned short)iBit;

  318.                 dTime = time + dTimeInterval * m_uiNum;

  319.                 setCurveData(dTime, usData);

  320.                 m_uiIndex += 2;

  321.                 ++m_uiNum;

  322.             }

  323.             break;

  324.         }

  325.         case 5: { // int

  326.             while (m_uiIndex + 4 <= m_uiDataSize) {

  327.                 int iData = 0x00000000;

  328.                 if (usOrder == 1) { // 大端

  329.                     char cTemp[4] = {0x00, 0x00, 0x00, 0x00};

  330.                     cTemp[0]      = pData[m_uiIndex + 3];

  331.                     cTemp[1]      = pData[m_uiIndex + 2];

  332.                     cTemp[2]      = pData[m_uiIndex + 1];

  333.                     cTemp[3]      = pData[m_uiIndex];

  334.                     iData         = *(reinterpret_cast<const int*>(cTemp));

  335.                 } else if (usOrder == 2) { // 小端

  336.                     iData = *(reinterpret_cast<const int*>(pData));

  337.                 }

  338.                 iData &= (int)iBit;

  339.                 dTime = time + dTimeInterval * m_uiNum;

  340.                 setCurveData(dTime, iData);

  341.                 m_uiIndex += 4;

  342.                 ++m_uiNum;

  343.             }

  344.             break;

  345.         }

  346.         case 6: { // unsigned int

  347.             while (m_uiIndex + 4 <= m_uiDataSize) {

  348.                 unsigned int uiData = 0x00000000;

  349.                 if (usOrder == 1) { // 大端

  350.                     char cTemp[4] = {0x00, 0x00, 0x00, 0x00};

  351.                     cTemp[0]      = pData[m_uiIndex + 3];

  352.                     cTemp[1]      = pData[m_uiIndex + 2];

  353.                     cTemp[2]      = pData[m_uiIndex + 1];

  354.                     cTemp[3]      = pData[m_uiIndex];

  355.                     uiData        = *(reinterpret_cast<const unsigned int*>(cTemp));

  356.                 } else if (usOrder == 2) { // 小端

  357.                     uiData = *(reinterpret_cast<const unsigned int*>(pData));

  358.                 }

  359.                 uiData &= (unsigned int)iBit;

  360.                 dTime = time + dTimeInterval * m_uiNum;

  361.                 setCurveData(dTime, uiData);

  362.                 m_uiIndex += 4;

  363.                 ++m_uiNum;

  364.             }

  365.             break;

  366.         }

  367.         case 7: { // long long

  368.             while (m_uiIndex + 8 <= m_uiDataSize) {

  369.                 long long llData = 0x0000000000000000;

  370.                 if (usOrder == 1) { // 大端

  371.                     char cTemp[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

  372.                     cTemp[0]      = pData[m_uiIndex + 7];

  373.                     cTemp[1]      = pData[m_uiIndex + 6];

  374.                     cTemp[2]      = pData[m_uiIndex + 5];

  375.                     cTemp[3]      = pData[m_uiIndex + 4];

  376.                     cTemp[4]      = pData[m_uiIndex + 3];

  377.                     cTemp[5]      = pData[m_uiIndex + 2];

  378.                     cTemp[6]      = pData[m_uiIndex + 1];

  379.                     cTemp[7]      = pData[m_uiIndex];

  380.                     llData        = *(reinterpret_cast<const long long*>(cTemp));

  381.                 } else if (usOrder == 2) { // 小端

  382.                     llData = *(reinterpret_cast<const long long*>(pData));

  383.                 }

  384.                 llData &= (long long)iBit;

  385.                 dTime = time + dTimeInterval * m_uiNum;

  386.                 setCurveData(dTime, llData);

  387.                 m_uiIndex += 8;

  388.                 ++m_uiNum;

  389.             }

  390.             break;

  391.         }

  392.         case 8: { // unsigned long long

  393.             while (m_uiIndex + 8 <= m_uiDataSize) {

  394.                 unsigned long long ullData = 0x0000000000000000;

  395.                 if (usOrder == 1) { // 大端

  396.                     char cTemp[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

  397.                     cTemp[0]      = pData[m_uiIndex + 7];

  398.                     cTemp[1]      = pData[m_uiIndex + 6];

  399.                     cTemp[2]      = pData[m_uiIndex + 5];

  400.                     cTemp[3]      = pData[m_uiIndex + 4];

  401.                     cTemp[4]      = pData[m_uiIndex + 3];

  402.                     cTemp[5]      = pData[m_uiIndex + 2];

  403.                     cTemp[6]      = pData[m_uiIndex + 1];

  404.                     cTemp[7]      = pData[m_uiIndex];

  405.                     ullData       = *(reinterpret_cast<const unsigned long long*>(cTemp));

  406.                 } else if (usOrder == 2) { // 小端

  407.                     ullData = *(reinterpret_cast<const unsigned long long*>(pData));

  408.                 }

  409.                 ullData &= (unsigned long long)iBit;

  410.                 dTime = time + dTimeInterval * m_uiNum;

  411.                 setCurveData(dTime, ullData);

  412.                 m_uiIndex += 8;

  413.                 ++m_uiNum;

  414.             }

  415.             break;

  416.         }

  417.         default:

  418.             break;

  419.         }

  420.     }

  421.     m_uiDataSize = 0;

  422.     m_uiIndex    = 0;

  423.     m_ableArray.clear();

  424. }

  425. 

  426. void AnalogProcess::setCurveData(qreal time, qreal value)

  427. {

  428.     m_mutex.lock();

  429.     qreal qValue = value;

  430.     if (m_pParam->m_formula.equaNum != 0) {

  431.         qValue = convertData(value); // 对原始数据进行处理

  432.     }

  433.     // QMutexLocker locker(&m_mutex);

  434. 

  435.     CurveInfo* curveInfo = m_pParam->getCurveWidget()->getCurveInfo();

  436.     // 对char进行处理

  437.     curveInfo->m_vecAxisX.push_back(time);

  438.     curveInfo->m_vecAxisY.push_back(qValue);

  439.     /*   if (curveInfo->m_vecAxisX.size() > 3000) {

  440.            curveInfo->m_vecAxisX.erase(curveInfo->m_vecAxisX.begin(), curveInfo->m_vecAxisX.end() -

  441.        2000);

  442.        }

  443.        if (curveInfo->m_vecAxisY.size() > 3000) {

  444.            curveInfo->m_vecAxisY.erase(curveInfo->m_vecAxisY.begin(), curveInfo->m_vecAxisY.end() -

  445.        2000);

  446.        }*/

  447.     curveInfo->maxX = time;

  448.     // if (curveInfo->m_bIsZeroX == false) {   //false:固定间距显示

  449.     curveInfo->minX = curveInfo->maxX - 200;

  450.     //}

  451.     // else if(curveInfo->m_bIsZeroX==true){   //true:从零开始显示

  452.     // curveInfo->minX = 0;

  453.     //}

  454.     if (curveInfo->m_bIsInited == false) {

  455.         curveInfo->minY        = 0.99 * qValue;

  456.         curveInfo->maxY        = 1.01 * qValue;

  457.         curveInfo->m_bIsInited = true;

  458.     }

  459. 

  460.     if (curveInfo->minY > qValue) {

  461.         curveInfo->minY = qValue;

  462.     }

  463.     if (curveInfo->maxY < qValue) {

  464.         curveInfo->maxY = qValue;

  465.     }

  466.     m_mutex.unlock();

  467. }

  468. 

  469. qreal AnalogProcess::convertData(qreal value)

  470. {

  471.     qreal  qValue    = 0.0;

  472.     int    iEqualNum = m_pParam->m_formula.equaNum; // 最高次方

  473.     double Equation[10];

  474.     for (int i = 0; i < 10; i++) {

  475.         Equation[i] = m_pParam->m_formula.Equation[i];

  476.     }

  477.     for (int j = iEqualNum; j >= 0; j--) {

  478.         for (int k = 0; k < j; k++) {

  479.             Equation[j] *= value;

  480.         }

  481.         qValue += Equation[j];

  482.     }

  483.     return qValue;

  484. }