lp-data-alarm/AlarmRecognition/Module.cpp

#include "Module.h"
#include <QJsonArray>
#include <QJsonObject>
#include <QJsonDocument>
#include <QtCore/QVariant>
#include <QtCore/QDebug>
#include <stdlib.h>
#include <math.h>

Module::Module()
    :BaseModule()
{
    m_pDataConsumer = nullptr;
    m_szOutputs.clear();
    m_mpRangeConfig.clear();
    m_mpDataValue.clear();
}

bool Module::isInheritedFrom(std::string tp)
{
    bool bEqual = (strcasecmp(tp.c_str(), "BaseModule") == 0);
    return bEqual;
}

void Module::regConsumer(DataConsumer* pDC)
{
    m_pDataConsumer = pDC;
}

void Module::Setup(ModuleInfo mi)
{
    std::list<DataItem>::iterator itrO;
    for( itrO = mi.Properties.begin(); itrO != mi.Properties.end(); ++itrO )
    {
        m_szOutputs.push_back(mi.Code + "." + itrO->Code);
    }

    std::vector<Setting>::iterator itr;
    for( itr = mi.vSettings.begin(); itr != mi.vSettings.end(); ++itr )
    {
        QJsonDocument jsonDoc(QJsonDocument::fromJson(itr->qValue.toString().toLocal8Bit().toStdString().c_str()));
        QJsonObject json = jsonDoc.object();
        QStringList keys = json.keys();

        tagRange tr;
        if( keys.contains("KeepTimes",Qt::CaseInsensitive) )
        {
            tr.uWinSize = abs(json["KeepTimes"].toInt());
        }
        if( keys.contains("Operator",Qt::CaseInsensitive) )
        {
            double dbOperator1 = 0;
            if( keys.contains("Operator1",Qt::CaseInsensitive) )
            {
                dbOperator1 = json["Operator1"].toDouble();
            }

            double dbOperator2 = 0;
            if( keys.contains("Operator2",Qt::CaseInsensitive) )
            {
                dbOperator2 = json["Operator2"].toDouble();
            }

            std::string szOp = json["Operator"].toString().toLocal8Bit().toStdString();
            if( strcasecmp(szOp.c_str(), "rang") == 0)
            {
                tr.dbMin = dbOperator1;
                tr.dbMax = dbOperator2;
            }
            else if( strcasecmp(szOp.c_str(), "above") == 0)
            {
                tr.dbMax = dbOperator1;
            }
            else if( strcasecmp(szOp.c_str(), "below") == 0)
            {
                tr.dbMin = dbOperator1;
            }
            m_mpRangeConfig["topic_" + itr->Name] = tr;
        }
    }
}

void Module::OnSubData(std::string name,std::string val)
{
    if( m_mpRangeConfig.find(name) == m_mpRangeConfig.end())
    {
        return;
    }
    uint nMaxWinSize = m_mpRangeConfig[name].uWinSize;

    // add data
    m_objDataLock.lockForWrite();
    if( m_mpDataValue.find(name) == m_mpDataValue.end())
    {
        m_mpDataValue[name].push_back(tagKeyValue(name,val.length()>0 ? std::stod(val):0));
    }
    else
    {
        while( m_mpDataValue[name].size() >= nMaxWinSize)
        {
            m_mpDataValue[name].erase(m_mpDataValue[name].begin());
        }
        m_mpDataValue[name].push_back(tagKeyValue(name,val.length()>0 ? std::stod(val):0));
    }

    // alarm recognition
    m_mpRangeConfig[name].nStatus = EAS_Both;
    std::list<tagKeyValue>::iterator itrV;
    for( itrV = m_mpDataValue[name].begin(); itrV != m_mpDataValue[name].end(); ++itrV)
    {
        tagKeyValue tKV = *itrV;

        if( itrV->value > m_mpRangeConfig[name].dbMax )
        {
            m_mpRangeConfig[name].nStatus &= 0x01;
        }
        else if( itrV->value < m_mpRangeConfig[name].dbMin )
        {
            m_mpRangeConfig[name].nStatus &= 0x02;
        }
        else
        {
            m_mpRangeConfig[name].nStatus = EAS_Normal;
        }
    }
    m_objDataLock.unlock();

    qDebug() << __FILE__ << __LINE__ << name.c_str() << m_mpRangeConfig[name].nStatus;
    std::vector<std::string>::iterator itr;
    for( itr = m_szOutputs.begin(); itr != m_szOutputs.end(); ++itr )
    {
        m_pDataConsumer->OnData(*itr,QVariant(m_mpRangeConfig[name].nStatus));
    }
}

BaseModule* instance()
{
    return new Module();
}

void destroy(BaseModule* pInstance)
{
    if( pInstance )
    {
        delete pInstance;
    }
}