H100PowerManger/src/pPowerManger/LowerCommManager.cpp

#include "LowerCommManager.h"
#include "PowerManger.h"
#include "driver.h"
#include "udpComm.h"

bool _ListenCB(void * pParam)
{
    LowerCommManager* pMe = (LowerCommManager* )pParam;
    return pMe->listenThreadFunc();
}

LowerCommManager::LowerCommManager(PowerManger* pm, long myPort, long ccuPort, const std::string& cccHost){
    m_pm = pm;
    m_udpComm = new udpComm();
    m_port = myPort;
    m_udpComm->ccuHost = cccHost;
    m_udpComm->ccuPort = ccuPort;
    m_udpComm->udpScoket = new XPCUdpSocket(m_port);

    std::cout << "PORT = " << m_port << std::endl;
    std::cout << "CCUHOST = " << m_udpComm->ccuHost << std::endl;
    std::cout << "CCUPORT = " << m_udpComm->ccuPort << std::endl;
}

LowerCommManager::~LowerCommManager(){
    try {
        stopListenThread();
        if (m_udpComm) {
            delete m_udpComm;
            m_udpComm = nullptr;
        }
    } catch (...) {
        cerr << "Error during cleanup" << endl;
    }
}
bool LowerCommManager::initUdpComm(){
  //设置UDP监听端口
  if(m_udpComm->udpScoket)
  {
    try
    {
        m_udpComm->udpScoket->vBindSocket();
        cout<<MOOS::ConsoleColours::green()<< "UDP set succeed!"<< MOOS::ConsoleColours::reset() << endl;
    }
    catch(const std::exception& e)
    {
        std::cerr << e.what() << '\n';
        cout<<MOOS::ConsoleColours::red()<< "UDP set Fild!"<< MOOS::ConsoleColours::reset() << endl;

        return false;
    }
  }
  else
  {
    cout<<MOOS::ConsoleColours::red()<< "UDP set Fild!"<< MOOS::ConsoleColours::reset() << endl;
    return false;
  }
  return true;
}
void LowerCommManager::processPeriodicTasks() {
    sendCcuCommand(m_pm->m_CcuColCmd);
    sendDisSysCommand(m_pm->m_targetDisBreakerState);
    m_udpComm->clearMsgQueue();
}

bool LowerCommManager::sendCcuCommand(const ccuColCmd cmd){
    // m_pm->m_db->insertCcuSysCmd(cmd);
    if(!m_udpComm->sendCcuColCmd(cmd))
        cout << "send ccu command failed!" << endl;
    return true;
}

bool LowerCommManager::sendDisSysCommand(const disSysBreakerList& cmd){
    //根据目标状态进行断路器操作
    //a. 高压母线的断路器
    disHighVolBusCmd a;
    a.fuelCellCircuitBreaker = getBreakerOption(cmd.bus1Breaker.fuelCellCircuitBreaker);
    a.lithiumBatteryGroupInstrumentCircuitBreaker = getBreakerOption(cmd.bus1Breaker.lithiumBatteryGroupInstrumentCircuitBreaker);
    a.dcDc5ModuleCircuitBreaker = getBreakerOption(cmd.bus1Breaker.dcDc5ModuleCircuitBreaker);
    a.powerLithiumBatteryCircuitBreaker = getBreakerOption(cmd.bus1Breaker.powerLithiumBatteryCircuitBreaker);
    a.propulsionMotorCircuitBreaker = getBreakerOption(cmd.bus1Breaker.propulsionMotorCircuitBreaker);
    a.bowHighVoltageDistributionBoxCircuitBreaker = getBreakerOption(cmd.bus1Breaker.bowHighVoltageDistributionBoxCircuitBreaker);
    a.tyzReservedCircuitBreaker = getBreakerOption(cmd.bus1Breaker.tyzReservedCircuitBreaker);
    a.sternFTDevice45CircuitBreaker = getBreakerOption(cmd.bus1Breaker.sternFTDevice45CircuitBreaker);
    a.sternRudderSwitch1CircuitBreaker = getBreakerOption(cmd.bus1Breaker.sternRudderSwitch1CircuitBreaker);
    a.sternRudderSwitch2CircuitBreaker = getBreakerOption(cmd.bus1Breaker.sternRudderSwitch2CircuitBreaker);
    a.reservedCircuitBreaker = getBreakerOption(cmd.bus1Breaker.reservedCircuitBreaker);
    a.fbReservedCircuitBreaker = getBreakerOption(cmd.bus1Breaker.fbReservedCircuitBreaker);
    m_udpComm->sendDisSysCmd(a);
    //b. 高压汇流排A断路器
    disHighAVolBusCmd b;
    b.bowFTDevice123CircuitBreaker = getBreakerOption(cmd.bus2Breaker.bowFTDevice123CircuitBreaker);
    b.actuatorCircuitBreaker = getBreakerOption(cmd.bus2Breaker.actuatorCircuitBreaker);
    b.mastSteeringGearControlBoxCircuitBreaker = getBreakerOption(cmd.bus2Breaker.mastSteeringGearControlBoxCircuitBreaker);
    b.xczCircuitBreaker = getBreakerOption(cmd.bus2Breaker.xczCircuitBreaker);
    b.bowRudderControlBoxCircuitBreaker = getBreakerOption(cmd.bus2Breaker.bowRudderControlBoxCircuitBreaker);
    b.openWaterCoverStartCylinderCircuitBreaker = getBreakerOption(cmd.bus2Breaker.openWaterCoverStartCylinderCircuitBreaker);
    m_udpComm->sendDisSysCmd(b);
    //c. 高压汇流排B断路器
    disHighBVolBusCmd c;
    c.lithiumBatteryGroupInstrumentCircuitBreaker = getBreakerOption(cmd.bus3Breaker.lithiumBatteryGroupInstrumentCircuitBreaker);
    c.bowLowVoltageDistributionBoxCircuitBreaker = getBreakerOption(cmd.bus3Breaker.bowLowVoltageDistributionBoxCircuitBreaker);
    c.unit4InstrumentDC48VCircuitBreaker = getBreakerOption(cmd.bus3Breaker.unit4InstrumentDC48VCircuitBreaker);
    c.dcC1DCDistributionPanelCircuitBreaker = getBreakerOption(cmd.bus3Breaker.dcC1DCDistributionPanelCircuitBreaker);
    c.reservedCircuitBreaker1 = getBreakerOption(cmd.bus3Breaker.reservedCircuitBreaker1);
    c.reservedCircuitBreaker2 = getBreakerOption(cmd.bus3Breaker.reservedCircuitBreaker2);
    c.emergencyLithiumBatteryGroup2CircuitBreaker = getBreakerOption(cmd.bus3Breaker.emergencyLithiumBatteryGroup2CircuitBreaker);
    m_udpComm->sendDisSysCmd(c);
    //d. 闭合低压汇流排断路器
    disLowBusCmd d;
    d.unit1CircuitBreaker = getBreakerOption(cmd.bus4Breaker.unit1CircuitBreaker);
    d.unit2CircuitBreaker = getBreakerOption(cmd.bus4Breaker.unit2CircuitBreaker);
    d.unit3CircuitBreaker = getBreakerOption(cmd.bus4Breaker.unit3CircuitBreaker);
    d.unit5CircuitBreaker = getBreakerOption(cmd.bus4Breaker.unit5CircuitBreaker);
    d.bowPZDeviceCircuitBreaker = getBreakerOption(cmd.bus4Breaker.bowPZDeviceCircuitBreaker);
    d.reservedCircuitBreaker1 = getBreakerOption(cmd.bus4Breaker.reservedCircuitBreaker1);
    d.reservedCircuitBreaker2 = getBreakerOption(cmd.bus4Breaker.reservedCircuitBreaker2);
    d.emergencyLithiumBatteryGroup1CircuitBreaker = getBreakerOption(cmd.bus4Breaker.emergencyLithiumBatteryGroup1CircuitBreaker);
    m_udpComm->sendDisSysCmd(d);
    //将指令写入数据库
    m_pm->m_db->insertDisSysCmd(a);
    m_pm->m_db->insertDisSysCmd(b);
    m_pm->m_db->insertDisSysCmd(c);
    m_pm->m_db->insertDisSysCmd(d);
    return true;
}


void LowerCommManager::clearMsgQueue(){
    m_udpComm->clearMsgQueue();
}

bool LowerCommManager::listenThreadFunc()
{
    cout<<MOOS::ConsoleColours::green()<< "LowerCommManager::listenThreadFunc" << MOOS::ConsoleColours::reset() << endl;
    unsigned char Buff[1024];
    while(!m_ListenThread.IsQuitRequested())
    {
        try
        {
            int nRead = m_udpComm->udpScoket->iRecieveMessage(Buff, sizeof(Buff));
            cout<<MOOS::ConsoleColours::yellow()<< "RECEVE DATA COUNT:" << nRead << MOOS::ConsoleColours::reset() << endl;
            if(nRead > 0)
            {
                try {
                    if(!m_udpComm->pushMsgToQueue(Buff))
                    {
                        for(int i=0; i<m_udpComm->sError.size(); i++)
                        {
                            cout<<MOOS::ConsoleColours::red()<< m_udpComm->sError[i] << MOOS::ConsoleColours::reset() << endl;
                        }
                    }
                }
                catch(const std::exception& e) {
                    cerr << "Error processing message: " << e.what() << endl;
                }
            }
            
            // 打印通信错误信息
            if(!m_udpComm->sError.empty())
            {
                for(int i=0; i<m_udpComm->sError.size(); i++)
                {
                    cout<<MOOS::ConsoleColours::red() << m_udpComm->sError[i] << MOOS::ConsoleColours::reset() << endl;
                }
                m_udpComm->sError.clear();
            }
        }
        catch(const XPCException& e)
        {
            cerr << "XPCException in listenThreadFunc" << endl;
            // 短暂休眠后继续尝试
            MOOSPause(100);
        }
        catch(const std::exception& e)
        {
            cerr << "Exception in listenThreadFunc: " << e.what() << endl;
            MOOSPause(100);
        }
        catch(...)
        {
            cerr << "Unknown exception in listenThreadFunc" << endl;
            MOOSPause(100);
        }
    }
    return true;
}

void LowerCommManager::startListenThread()
{
    if(!m_ListenThread.IsThreadRunning())
    {
        m_ListenThread.Initialise(_ListenCB,this);
        m_ListenThread.Start();
        std::cout << "LowerCommManager::startListenThread" << std::endl;
    }
}

void LowerCommManager::stopListenThread()
{
    if(m_ListenThread.IsThreadRunning())
    {
        m_ListenThread.Stop();
    }
}

char LowerCommManager::getBreakerOption(char cmd)
{
    if(cmd ==1)
        return 0x55;
    else if(cmd ==0)
        return 0xAA;
    else 
        return 0x00;
}