修改了上电操作

src/pPowerManger/PowerManger.cpp

@@ -341,11 +341,11 @@ void PowerManger::initControlCmd()
   //================初始化复合管控=============================
   m_CcuColCmd.fcmode = 0x00; //默认无效
   m_CcuColCmd.fcuCmd = 0x00; //无效指令
-  m_CcuColCmd.fcuPowerEfficiency = 15; //默认为15kw
+  m_CcuColCmd.fcuPowerEfficiency = 8; //默认为8kw
   m_CcuColCmd.insChargeEnable = 0x30; //不允许充电
   m_CcuColCmd.insBatCmd = 0x00; //无效指令
   m_CcuColCmd.powerBatCmd = 0x00; //无效指令
-  m_CcuColCmd.powerBatEfficiency = 230; //默认为最大
+  m_CcuColCmd.powerBatEfficiency = 00; //默认为最大
   m_CcuColCmd.heartbeat = 0;
   m_CcuColCmd.masterState = 0xAA;//主站状态,运行中
   //================初始化上位机指令=========================
@@ -374,3 +374,24 @@ void PowerManger::injectFault(unsigned type,unsigned int faultCode){
   TestEvent testEvent("故障注入测试",type,faultCode);
   PowerManagerFsm::dispatch(testEvent);
 }
+
+
+void PowerManger::pushDeviceCommand(DeviceSwitchCmd cmd) {
+    std::lock_guard<std::mutex> lock(m_deviceCmdMutex);
+    m_deviceCmdQuenue.push(cmd);
+}
+
+bool PowerManger::popDeviceCommand(DeviceSwitchCmd &cmd) {
+    std::lock_guard<std::mutex> lock(m_deviceCmdMutex);
+    if(m_deviceCmdQuenue.empty()) {
+        return false;
+    }
+    cmd = m_deviceCmdQuenue.front();
+    m_deviceCmdQuenue.pop();
+    return true;
+}
+
+bool PowerManger::isDeviceCmdEmpty() const {
+    std::lock_guard<std::mutex> lock(m_deviceCmdMutex);
+    return m_deviceCmdQuenue.empty();
+}

src/pPowerManger/PowerManger.h

@@ -102,7 +102,12 @@ class PowerManger : public AppCastingMOOSApp
   unsigned int  m_faultNum;
   Driver m_driver; //设备表处理
   unsigned char m_leakage;
-  // std::string m_pmEvent;  // 状态机事件描述
+  //============================Device Option================================
+  std::queue<DeviceSwitchCmd> m_deviceCmdQuenue;
+  mutable std::mutex m_deviceCmdMutex;
+  void pushDeviceCommand(DeviceSwitchCmd cmd);
+  bool popDeviceCommand(DeviceSwitchCmd &cmd);
+  bool isDeviceCmdEmpty() const;
   //===========================CONFIG========================================
   long          m_lPort;
   unsigned int  m_nReceiveBufferSizeKB;

src/pPowerManger/UpperCommManager.cpp

@@ -141,7 +141,7 @@ bool UpperCommManager::processUpperMsg(const string& key, const string& strJson)
     else if(key == m_taskStopMsg.key) 
     {
         #ifdef _DEBUG
-        m_taskStopMsg_st_debug = std::make_pair(key, strJson);
+            m_taskStopMsg_st_debug = std::make_pair(key, strJson);
         #endif
         bool stop = m_taskStopMsg.getTaskStop(key, strJson);
         if (stop) {
@@ -170,9 +170,9 @@ void UpperCommManager::processPeriodicTasks() {
     //发送仪表电状态
     m_pm->sendNotification(m_equInsStateMsg.key,m_equInsStateMsg.buildMsg(m_pm->m_subDisSysState));
     #ifdef _DEBUG
-    m_equInsStateMsg_fb_degub = std::make_pair(m_equInsStateMsg.key,m_equInsStateMsg.buildMsg(m_pm->m_subDisSysState));
+        m_equInsStateMsg_fb_degub = std::make_pair(m_equInsStateMsg.key,m_equInsStateMsg.buildMsg(m_pm->m_subDisSysState));
-    m_secdistStateMsg_cmd_debug = std::make_pair(m_secdistStateMsg.key_cmd,strJson);
+        m_secdistStateMsg_cmd_debug = std::make_pair(m_secdistStateMsg.key_cmd,strJson);
-    m_equStateMsg_fb_debug = std::make_pair(m_equStateMsg.key_cmd,m_equStateMsg.buildMsg(m_pm->m_currentDriverState));
+        m_equStateMsg_fb_debug = std::make_pair(m_equStateMsg.key_cmd,m_equStateMsg.buildMsg(m_pm->m_currentDriverState));
     #endif
 }
 

src/pPowerManger/driver.cpp

@@ -14,6 +14,140 @@ void Driver::setDebug(bool debug)
     this->debug = debug;
 }
 
+void Driver::setDeviceState(DriverTable &driverTable, DeviceId::Type deviceId, unsigned char s) {
+    switch(deviceId) {
+        case DeviceId::depth1: driverTable.depth1 = s; break;
+        case DeviceId::depth2: driverTable.depth2 = s; break;
+        case DeviceId::depth3: driverTable.depth3 = s; break;
+        case DeviceId::overDeep1: driverTable.overDeep1 = s; break;
+        case DeviceId::overDeep2: driverTable.overDeep2 = s; break;
+        case DeviceId::ctd1: driverTable.ctd1 = s; break;
+        case DeviceId::ctd2: driverTable.ctd2 = s; break;
+        case DeviceId::soundVeloc: driverTable.soundVeloc = s; break;
+        case DeviceId::commMast: driverTable.commMast = s; break;
+        case DeviceId::ins: driverTable.ins = s; break;
+        case DeviceId::ntp: driverTable.ntp = s; break;
+        case DeviceId::inputWaterSensor1: driverTable.inputWaterSensor1 = s; break;
+        case DeviceId::inputWaterSensor2: driverTable.inputWaterSensor2 = s; break;
+        case DeviceId::inputWaterSensor3: driverTable.inputWaterSensor3 = s; break;
+        case DeviceId::singleBeamSonar1: driverTable.singleBeamSonar1 = s; break;
+        case DeviceId::singleBeamSonar2: driverTable.singleBeamSonar2 = s; break;
+        case DeviceId::singleBeamSonar3: driverTable.singleBeamSonar3 = s; break;
+        case DeviceId::singleBeamSonar4: driverTable.singleBeamSonar4 = s; break;
+        case DeviceId::singleBeamSonar5: driverTable.singleBeamSonar5 = s; break;
+        case DeviceId::singleBeamSonar6: driverTable.singleBeamSonar6 = s; break;
+        case DeviceId::singleBeamSonar7: driverTable.singleBeamSonar7 = s; break;
+        case DeviceId::singleBeamSonar8: driverTable.singleBeamSonar8 = s; break;
+        case DeviceId::forwardSonar: driverTable.forwardSonar = s; break;
+        case DeviceId::DVL: driverTable.DVL = s; break;
+        case DeviceId::lowFreqSonar: driverTable.lowFreqSonar = s; break;
+        case DeviceId::USBL: driverTable.USBL = s; break;
+        case DeviceId::bowWaterInet1: driverTable.bowWaterInet1 = s; break;
+        case DeviceId::bowWaterInet2: driverTable.bowWaterInet2 = s; break;
+        case DeviceId::bowWaterInet3: driverTable.bowWaterInet3 = s; break;
+        case DeviceId::bowWaterInet4: driverTable.bowWaterInet4 = s; break;
+        case DeviceId::bowWaterInet5: driverTable.bowWaterInet5 = s; break;
+        case DeviceId::bowWaterInet6: driverTable.bowWaterInet6 = s; break;
+        case DeviceId::bowWaterInet7: driverTable.bowWaterInet7 = s; break;
+        case DeviceId::bowWaterInet8: driverTable.bowWaterInet8 = s; break;
+        case DeviceId::bowRudderDeploy: driverTable.bowRudderDeploy = s; break;
+        case DeviceId::bowRudderServo1: driverTable.bowRudderServo1 = s; break;
+        case DeviceId::bowRudderServo2: driverTable.bowRudderServo2 = s; break;
+        case DeviceId::bowCover1: driverTable.bowCover1 = s; break;
+        case DeviceId::bowCover2: driverTable.bowCover2 = s; break;
+        case DeviceId::bowCover3: driverTable.bowCover3 = s; break;
+        case DeviceId::bowCover4: driverTable.bowCover4 = s; break;
+        case DeviceId::bowCover5: driverTable.bowCover5 = s; break;
+        case DeviceId::bowCover6: driverTable.bowCover6 = s; break;
+        case DeviceId::waterInject: driverTable.waterInject = s; break;
+        case DeviceId::mastLiftingServo: driverTable.mastLiftingServo = s; break;
+        case DeviceId::buoyancyAdjust1: driverTable.buoyancyAdjust1 = s; break;
+        case DeviceId::buoyancyAdjust2: driverTable.buoyancyAdjust2 = s; break;
+        case DeviceId::buoyancyAdjust3: driverTable.buoyancyAdjust3 = s; break;
+        case DeviceId::buoyancyAdjust4: driverTable.buoyancyAdjust4 = s; break;
+        case DeviceId::buoyancyAdjust5: driverTable.buoyancyAdjust5 = s; break;
+        case DeviceId::sternRudderServo1: driverTable.sternRudderServo1 = s; break;
+        case DeviceId::sternRudderServo2: driverTable.sternRudderServo2 = s; break;
+        case DeviceId::sternRudderServo3: driverTable.sternRudderServo3 = s; break;
+        case DeviceId::sternRudderServo4: driverTable.sternRudderServo4 = s; break;
+        case DeviceId::thruster: driverTable.thruster = s; break;
+        case DeviceId::bowThrow: driverTable.bowThrow = s; break;
+        case DeviceId::sternThrow: driverTable.sternThrow = s; break;
+        case DeviceId::photoSensor: driverTable.photoSensor = s; break;
+        case DeviceId::electSensor: driverTable.electSensor = s; break;
+        case DeviceId::launchControler: driverTable.launchControler = s; break;
+        case DeviceId::sideSonar: driverTable.sideSonar = s; break;
+        case DeviceId::buoyage: driverTable.buoyage = s; break;
+        default: break;
+    }
+}
+unsigned char Driver::getDeviceState(const DriverTable &driverTable, DeviceId::Type deviceId) {
+    switch(deviceId) {
+        case DeviceId::depth1: return driverTable.depth1;
+        case DeviceId::depth2: return driverTable.depth2;
+        case DeviceId::depth3: return driverTable.depth3;
+        case DeviceId::overDeep1: return driverTable.overDeep1;
+        case DeviceId::overDeep2: return driverTable.overDeep2;
+        case DeviceId::ctd1: return driverTable.ctd1;
+        case DeviceId::ctd2: return driverTable.ctd2;
+        case DeviceId::soundVeloc: return driverTable.soundVeloc;
+        case DeviceId::commMast: return driverTable.commMast;
+        case DeviceId::ins: return driverTable.ins;
+        case DeviceId::ntp: return driverTable.ntp;
+        case DeviceId::inputWaterSensor1: return driverTable.inputWaterSensor1;
+        case DeviceId::inputWaterSensor2: return driverTable.inputWaterSensor2;
+        case DeviceId::inputWaterSensor3: return driverTable.inputWaterSensor3;
+        case DeviceId::singleBeamSonar1: return driverTable.singleBeamSonar1;
+        case DeviceId::singleBeamSonar2: return driverTable.singleBeamSonar2;
+        case DeviceId::singleBeamSonar3: return driverTable.singleBeamSonar3;
+        case DeviceId::singleBeamSonar4: return driverTable.singleBeamSonar4;
+        case DeviceId::singleBeamSonar5: return driverTable.singleBeamSonar5;
+        case DeviceId::singleBeamSonar6: return driverTable.singleBeamSonar6;
+        case DeviceId::singleBeamSonar7: return driverTable.singleBeamSonar7;
+        case DeviceId::singleBeamSonar8: return driverTable.singleBeamSonar8;
+        case DeviceId::forwardSonar: return driverTable.forwardSonar;
+        case DeviceId::DVL: return driverTable.DVL;
+        case DeviceId::lowFreqSonar: return driverTable.lowFreqSonar;
+        case DeviceId::USBL: return driverTable.USBL;
+        case DeviceId::bowWaterInet1: return driverTable.bowWaterInet1;
+        case DeviceId::bowWaterInet2: return driverTable.bowWaterInet2;
+        case DeviceId::bowWaterInet3: return driverTable.bowWaterInet3;
+        case DeviceId::bowWaterInet4: return driverTable.bowWaterInet4;
+        case DeviceId::bowWaterInet5: return driverTable.bowWaterInet5;
+        case DeviceId::bowWaterInet6: return driverTable.bowWaterInet6;
+        case DeviceId::bowWaterInet7: return driverTable.bowWaterInet7;
+        case DeviceId::bowWaterInet8: return driverTable.bowWaterInet8;
+        case DeviceId::bowRudderDeploy: return driverTable.bowRudderDeploy;
+        case DeviceId::bowRudderServo1: return driverTable.bowRudderServo1;
+        case DeviceId::bowRudderServo2: return driverTable.bowRudderServo2;
+        case DeviceId::bowCover1: return driverTable.bowCover1;
+        case DeviceId::bowCover2: return driverTable.bowCover2;
+        case DeviceId::bowCover3: return driverTable.bowCover3;
+        case DeviceId::bowCover4: return driverTable.bowCover4;
+        case DeviceId::bowCover5: return driverTable.bowCover5;
+        case DeviceId::bowCover6: return driverTable.bowCover6;
+        case DeviceId::waterInject: return driverTable.waterInject;
+        case DeviceId::mastLiftingServo: return driverTable.mastLiftingServo;
+        case DeviceId::buoyancyAdjust1: return driverTable.buoyancyAdjust1;
+        case DeviceId::buoyancyAdjust2: return driverTable.buoyancyAdjust2;
+        case DeviceId::buoyancyAdjust3: return driverTable.buoyancyAdjust3;
+        case DeviceId::buoyancyAdjust4: return driverTable.buoyancyAdjust4;
+        case DeviceId::buoyancyAdjust5: return driverTable.buoyancyAdjust5;
+        case DeviceId::sternRudderServo1: return driverTable.sternRudderServo1;
+        case DeviceId::sternRudderServo2: return driverTable.sternRudderServo2;
+        case DeviceId::sternRudderServo3: return driverTable.sternRudderServo3;
+        case DeviceId::sternRudderServo4: return driverTable.sternRudderServo4;
+        case DeviceId::thruster: return driverTable.thruster;
+        case DeviceId::bowThrow: return driverTable.bowThrow;
+        case DeviceId::sternThrow: return driverTable.sternThrow;
+        case DeviceId::photoSensor: return driverTable.photoSensor;
+        case DeviceId::electSensor: return driverTable.electSensor;
+        case DeviceId::launchControler: return driverTable.launchControler;
+        case DeviceId::sideSonar: return driverTable.sideSonar;
+        case DeviceId::buoyage: return driverTable.buoyage;
+        default: return 0; // 默认返回0表示无效状态
+    }
+}
 void Driver::getSTANDBYTable(DriverTable* driverTable)
 {
     //打开所有传感器

src/pPowerManger/driver.h

@@ -5,6 +5,7 @@
 #include "iostream"
 #include <sstream>
 #include <vector>
+#include "pmSysvariable.h"
 
 #define DRIVER_POWER_OFF 0x00
 #define DRIVER_FULL_POWER_ON 0x01
@@ -101,10 +102,8 @@ public:
     std::unique_ptr<DriverTable> nextDriverTable;
 
     //操作函数，操作指定设备
-    //TODO: 增加设备操作函数
+    void setDeviceState(DriverTable &driverTable, DeviceId::Type deviceId, unsigned char s);
-    void operateSubDriver(int id, int cmd, DriverTable* driverTable);
+    unsigned char getDeviceState(const DriverTable &driverTable, DeviceId::Type deviceId);
-    // void setDriverTable(DriverTable* driverTable, ,DriverCmd::Type cmd);
-
 
     void getSTANDBYTable(DriverTable* driverTable);
     void getSHORE_BASED_READYable(DriverTable* driverTable);

src/pPowerManger/fsm/PowerManagerFsm.hpp

@@ -82,9 +82,9 @@ public:
 
     virtual void react(tinyfsm::Event const &) { std::cout << "[ Reseve Envt ] " << "No Idear" << std::endl; }
     virtual void react(InitEvent const &) {};
-    virtual void react(StandbyEvent const &) { };
+    virtual void react(StandbyEvent const &) {};
     virtual void react(MasterCommandEvent const &) { LOG_F(INFO, "MasterCommandEvent");};
-    virtual void react(DeviceCmd const &);
+    // virtual void react(DeviceCmd const &);
     virtual void react(DevCmdExt const &e);
     virtual void react(TaskStartEvent const &e);
     virtual void react(FaultEvent const &e);
@@ -94,22 +94,38 @@ public:
     //测试事件
     virtual void react(TestEvent const &);
 
-    //操作函数
+    //======================操作函数=============================
     void handelPowerCmd();
     void handleModCmd();
     void handleWorkCmd();
     void handleDeviceCmd();
 
+    // 非水声仪表设备
     void handleNoPowerDeviceCmd(int id , int cmd);
+    // 水声设备处理
+    void handleHydroacousticDeviceCmd(int id , int cmd);
+    // 艏舵设备处理
     void handleBowRudderSystemCmd(int id, int cmd);
+    // 启闭机构处理
     void handleActuatorCmd(int id, int cmd);
+    // 艉舵设备处理
     void handleSternRudderCmd(int id, int cmd);
+    // 推进电机处理
     void handlePropulsionMotorCmd(int id, int cmd);
+    // 浮调设备处理
     void handleBuoyancyAdjustmentCmd(int id, int cmd);
+    // FB设备处理
     void handleFBSystemCmd(int id, int cmd);
+    // 舷侧设备处理
     void handleSideSonarCmd(int id, int cmd);
+    // 桅杆设备处理
     void handleMastFoldingSystemCmd(int id, int cmd);
 
+    //获取仅仪表设备状态
+    // void getNoPowerDeviceStatus()
+
+
+
     bool handPowerProtection(DevCmdExt const &e);
     //故障处理
     void basicNavigationFault(FaultEvent const &e);

src/pPowerManger/httpserver/data.h

@@ -1727,10 +1727,10 @@ function getDCDCStatusText(status) {
 function getEmergencyStatusText(status) {
     const statuses = {
         0: '正常',
-        58: '一级紧急',
+        58: '四级紧急',
-        59: '二级紧急',
+        59: '三级紧急',
-        60: '三级紧急',
+        60: '二级紧急',
-        61: '四级紧急',
+        61: '一级紧急',
     };
     return statuses[status] || '未知状态';
 }

src/pPowerManger/httpserver/httpserver.cpp

@@ -656,6 +656,7 @@ void HttpServer::pushSystemData() {
     j["moosdb"]["serverHost"] = Json::Value(m_powerManger->GetServerHost());
     j["moosdb"]["serverPort"] = Json::Value(m_powerManger->GetServerPort());
     
+
     // degub
     #ifdef _DEBUG
     //订阅消息
@@ -714,6 +715,17 @@ void HttpServer::pushSystemData() {
     j["debug"]["m_liBatStateMsg_st_debug"]["name"] = Json::Value(m_powerManger->m_upperCommManager->m_liBatStateMsg_st_debug.first);
     j["debug"]["m_liBatStateMsg_st_debug"]["content"] = Json::Value(m_powerManger->m_upperCommManager->m_liBatStateMsg_st_debug.second);
     #endif
+
+    j["ccuColCmd"]["fcmode"] = Json::Value(m_powerManger->m_CcuColCmd.fcmode);
+    j["ccuColCmd"]["fcuCmd"] = Json::Value(m_powerManger->m_CcuColCmd.fcuCmd);
+    j["ccuColCmd"]["fcuPowerEfficiency"] = Json::Value(m_powerManger->m_CcuColCmd.fcuPowerEfficiency);
+    j["ccuColCmd"]["insChargeEnable"] = Json::Value(m_powerManger->m_CcuColCmd.insChargeEnable);
+    j["ccuColCmd"]["insBatCmd"] = Json::Value(m_powerManger->m_CcuColCmd.insBatCmd);
+    j["ccuColCmd"]["powerBatCmd"] = Json::Value(m_powerManger->m_CcuColCmd.powerBatCmd);
+    j["ccuColCmd"]["powerBatEfficiency"] = Json::Value(m_powerManger->m_CcuColCmd.powerBatEfficiency);
+    j["ccuColCmd"]["heartbeat"] = Json::Value(m_powerManger->m_CcuColCmd.heartbeat);
+    j["ccuColCmd"]["masterState"] = Json::Value(m_powerManger->m_CcuColCmd.masterState);
+
     // 时间戳
     j["timestamp"] = Json::Value((Json::UInt64)(std::chrono::duration_cast<std::chrono::milliseconds>(
         std::chrono::system_clock::now().time_since_epoch()).count()));

src/pPowerManger/pmSysvariable.h

@@ -679,7 +679,7 @@ namespace TaskType {
   }
 }
 
-namespace DriverCmd {
+namespace EquipmentCommand {
   enum Type : unsigned char {
     OFF = 0, //断电
     ON = 1,  //上电
@@ -773,6 +773,74 @@ namespace DeviceId {
     inputWaterSensor2 = 60,
     inputWaterSensor3 = 61,
   };
+  inline const std::string toString(Type type) {
+    static const std::map<Type, std::string> names = {
+        {singleBeamSonar1, "singleBeamSonar1"},
+        {singleBeamSonar2, "singleBeamSonar2"},
+        {singleBeamSonar3, "singleBeamSonar3"},
+        {singleBeamSonar4, "singleBeamSonar4"},
+        {singleBeamSonar5, "singleBeamSonar5"},
+        {singleBeamSonar6, "singleBeamSonar6"},
+        {singleBeamSonar7, "singleBeamSonar7"},
+        {singleBeamSonar8, "singleBeamSonar8"},
+        {forwardSonar, "forwardSonar"},
+        {bowCover1, "bowCover1"},
+        {bowCover2, "bowCover2"},
+        {bowCover3, "bowCover3"},
+        {bowCover4, "bowCover4"},
+        {bowCover5, "bowCover5"},
+        {bowCover6, "bowCover6"},
+        {bowRudderDeploy, "bowRudderDeploy"},
+        {bowRudderServo1, "bowRudderServo1"},
+        {bowRudderServo2, "bowRudderServo2"},
+        {depth1, "depth1"},
+        {depth2, "depth2"},
+        {depth3, "depth3"},
+        {overDeep1, "overDeep1"},
+        {overDeep2, "overDeep2"},
+        {ctd1, "ctd1"},
+        {ctd2, "ctd2"},
+        {soundVeloc, "soundVeloc"},
+        {waterInject, "waterInject"},
+        {bowWaterInet1, "bowWaterInet1"},
+        {bowWaterInet2, "bowWaterInet2"},
+        {bowWaterInet3, "bowWaterInet3"},
+        {bowWaterInet4, "bowWaterInet4"},
+        {bowWaterInet5, "bowWaterInet5"},
+        {bowWaterInet6, "bowWaterInet6"},
+        {bowWaterInet7, "bowWaterInet7"},
+        {bowWaterInet8, "bowWaterInet8"},
+        {sideSonar, "sideSonar"},
+        {lowFreqSonar, "lowFreqSonar"},
+        {launchControler, "launchControler"},
+        {photoSensor, "photoSensor"},
+        {electSensor, "electSensor"},
+        {commMast, "commMast"},
+        {mastLiftingServo, "mastLiftingServo"},
+        {USBL, "USBL"},
+        {DVL, "DVL"},
+        {buoyancyAdjust1, "buoyancyAdjust1"},
+        {buoyancyAdjust2, "buoyancyAdjust2"},
+        {buoyancyAdjust3, "buoyancyAdjust3"},
+        {buoyancyAdjust4, "buoyancyAdjust4"},
+        {buoyancyAdjust5, "buoyancyAdjust5"},
+        {sternRudderServo1, "sternRudderServo1"},
+        {sternRudderServo2, "sternRudderServo2"},
+        {sternRudderServo3, "sternRudderServo3"},
+        {sternRudderServo4, "sternRudderServo4"},
+        {thruster, "thruster"},
+        {bowThrow, "bowThrow"},
+        {sternThrow, "sternThrow"},
+        {buoyage, "buoyage"},
+        {ins, "ins"},
+        {ntp, "ntp"},
+        {inputWaterSensor1, "inputWaterSensor1"},
+        {inputWaterSensor2, "inputWaterSensor2"},
+        {inputWaterSensor3, "inputWaterSensor3"}
+    };
+    auto it = names.find(type);
+    return it != names.end() ? it->second : "unknown";
+  }
 }
 
 namespace FaultEnable {

test/disSysTest/PowerManagerApp.py

@@ -25,20 +25,24 @@ class PowerManagerApp:
         style.configure('.', font=('Microsoft YaHei', 10))
         
         self.root.title("电源管理系统")
-        self.root.geometry("1200x800")
         self.root.tk.call('tk', 'scaling', 1.5)  # 适配高DPI显示
+        # 移除固定窗口大小设置，实现自适应
+        self.root.minsize(800, 600)  # 设置最小窗口大小
         
         # UDP通信配置
         # self.udp_ip = "127.0.0.1"
-        self.udp_ip = "192.168.0.224"
+        self.udp_ip = "192.168.0.140"
-        self.udp_port = 5002
+        self.udp_port = 7000
         self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
         self.sock.bind((self.udp_ip, self.udp_port))
 
         self.disSysPortC1 = 6000
         self.disSysHostC1 = '192.168.1.154'
+        # self.disSysHostC1 = '127.0.0.1'
         self.disSysPortC2 = 6000
         self.disSysHostC2 = '192.168.1.158'
+        # self.disSysHostC2 = '127.0.0.1'
+
 
         # self.disSysPortC1 = 7000
         # self.disSysHostC1 = '192.168.0.140'
@@ -210,12 +214,14 @@ class PowerManagerApp:
         # 主框架
         main_frame = ttk.Frame(self.root, padding="10")
         main_frame.pack(fill=tk.BOTH, expand=True)
+        self.root.grid_rowconfigure(0, weight=1)
+        self.root.grid_columnconfigure(0, weight=1)
         
         # 状态显示区
         status_frame = ttk.LabelFrame(main_frame, text="系统状态", padding="10")
-        status_frame.pack(fill=tk.X, pady=5)
+        status_frame.pack(fill=tk.BOTH, expand=True, pady=5)
         
-        # 状态显示区 - 使用Notebook组织不同母线状态
+        # 创建Canvas和Scrollbar
         self.notebook = ttk.Notebook(status_frame)
         self.notebook.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
         
@@ -242,10 +248,39 @@ class PowerManagerApp:
         # 控制区
         control_frame = ttk.LabelFrame(main_frame, text="控制面板", padding="10")
         control_frame.pack(fill=tk.BOTH, expand=True, pady=5)
+        control_frame.grid_rowconfigure(0, weight=1)
+        control_frame.grid_columnconfigure(0, weight=1)
+
+        # 创建Canvas和Scrollbar
+        canvas = tk.Canvas(control_frame)
+        scrollbar = ttk.Scrollbar(control_frame, orient="vertical", command=canvas.yview)
+        canvas.configure(yscrollcommand=scrollbar.set)
+
+        # 将Canvas和Scrollbar放入控制区
+        canvas.pack(side="left", fill="both", expand=True)
+        scrollbar.pack(side="right", fill="y")
+
+        # 创建内部Frame用于放置Notebook
+        inner_frame = ttk.Frame(canvas)
+        self.inner_frame_id = canvas.create_window((0, 0), window=inner_frame, anchor="nw")
+
+        # 配置Canvas滚动区域
+        def configure_canvas(event):
+            canvas.configure(scrollregion=canvas.bbox("all"))
+            canvas.itemconfig(self.inner_frame_id, width=event.width)
+
+        inner_frame.bind("<Configure>", configure_canvas)
+        canvas.bind("<Configure>", configure_canvas)
+
+        # 绑定鼠标滚轮事件
+        def on_mousewheel(event):
+            canvas.yview_scroll(int(-1*(event.delta/120)), "units")
+
+        canvas.bind_all("<MouseWheel>", on_mousewheel)
 
         # 状态显示区 - 使用Notebook组织不同母线状态
-        self.notebook_c = ttk.Notebook(control_frame)
+        self.notebook_c = ttk.Notebook(inner_frame)
-        self.notebook_c.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
+        self.notebook_c.pack(fill="both", expand=True, padx=5, pady=5)
 
         high_vol_control_frame = ttk.Frame(self.notebook_c)
         self.notebook_c.add(high_vol_control_frame, text="高压母线")
@@ -266,6 +301,8 @@ class PowerManagerApp:
         # 日志区
         log_frame = ttk.LabelFrame(main_frame, text="系统日志", padding="10")
         log_frame.pack(fill=tk.BOTH, expand=True, pady=5)
+        log_frame.grid_rowconfigure(0, weight=1)
+        log_frame.grid_columnconfigure(0, weight=1)
         
         self.log_text = tk.Text(log_frame, height=10, state=tk.DISABLED)
         self.log_text.pack(fill=tk.BOTH, expand=True)
@@ -465,6 +502,9 @@ class PowerManagerApp:
             cmd.emergencyLithiumBatteryGroup2CircuitBreaker = state
 
         # self.send_udp_command(cmd.pack())
+        print(breaker_name,state)
+        print(cmd)
+        # print(cmd.unpack())
         self.send_udp_command(cmd.pack(), self.disSysHostC2, self.disSysPortC2)
         self.db.insertLowMainBusCmd(cmd)
         if state==0x55:
@@ -703,7 +743,7 @@ class PowerManagerApp:
         """处理接收到的UDP消息"""
         try:
             msg_id = int.from_bytes(data[2:4], byteorder='little')
-            print('----------------------------',hex(msg_id))
+            # print('----------------------------',hex(msg_id))
             if msg_id == 0x0005:  # 高压母线状态
                 msg = msg_disHighVolBusFbMsg()
                 if msg.unpack(data):
@@ -865,10 +905,12 @@ class PowerManagerApp:
                     #     bus["alarms"]["应急电源故障"] = 1
                     bus["alarms"]["应急电源故障"] = msg.emergencyPowerFailureSignal
                     # bus["insulation"] = msg.instrumentBusbarInsulationLow
-                    if msg.instrumentBusbarInsulationLow == 0x55:
+                    bus["insulation"] = msg.instrumentBusbarInsulationLow
-                        bus["insulation"] = 0
+
-                    else:
+                    # if msg.instrumentBusbarInsulationLow == 0x55:
-                        bus["insulation"] = 1
+                    #     bus["insulation"] = 0
+                    # else:
+                    #     bus["insulation"] = 1
                     
                     self.log_message("收到仪表主母线状态更新")
                 else:
@@ -1097,7 +1139,7 @@ class PowerManagerApp:
         try:
             # self.sock.sendto(data, (self.udp_ip, self.udp_port + 1))
             self.sock.sendto(data, (ip, port))
-            print(f"发送命令到 {ip}:{port} ", data)
+            print(f"发送命令到 {ip}:{port} ", data.hex())
         except Exception as e:
             self.log_message(f"发送命令失败: {str(e)}")
     

test/disSysTest/udpMsg.py

@@ -627,13 +627,13 @@ class msg_disLVMBCmdMsg:
         self.checkCode = 0x00
         
         # disLowMainBusCmd成员
-        self.lithiumBatteryGroupInstrumentCircuitBreaker = 0x55
+        self.lithiumBatteryGroupInstrumentCircuitBreaker = 0x00
-        self.bowLowVoltageDistributionBoxCircuitBreaker = 0x55
+        self.bowLowVoltageDistributionBoxCircuitBreaker = 0x00
-        self.unit4InstrumentDC48VCircuitBreaker = 0x55
+        self.unit4InstrumentDC48VCircuitBreaker = 0x00
         self.dcC1DCDistributionPanelCircuitBreaker = 0x00
-        self.reservedCircuitBreaker1 = 0x55
+        self.reservedCircuitBreaker1 = 0x00
-        self.reservedCircuitBreaker2 = 0x55
+        self.reservedCircuitBreaker2 = 0x00
-        self.emergencyLithiumBatteryGroup2CircuitBreaker = 0x55
+        self.emergencyLithiumBatteryGroup2CircuitBreaker = 0x00
 
     def pack(self):
         self.checkCode = 0x00