PLC通信交互系统技术分享

news2025/2/21 20:31:20

0、前言

1、模块划分

2、状态机

3、通信层增强

4、异常处理机制

5、核心代码

关键状态处理示例

6、部署与测试方案

1. 环境要求

2. 性能测试指标

0、前言

这是一个C++程序，用于与西门子PLC进行通信，处理SN码、拍照信号、检测结果等流程。代码中使用了状态机，通过不同的状态来管理交互步骤。

1、模块划分

class PLCManager {          // PLC连接管理 
    TS7Client* client;       // 通信客户端 
    ConnectionStatus status; // 连接状态机 
public:
    bool reconnect(int max_retry);
    void safeDisconnect();
};
 
class StateProcessor {      // 状态处理器 
    enum class WorkflowState : uint8_t {
        WAIT_SN = 0,        // 状态枚举 
        PROCESS_IMAGE = 50,
        DEFECT_DETECTION =70 
    };
public:
    void transitionState(WorkflowState new_state);
};
 
class DataConverter {       // 数据转换工具 
public:
    static std::string vectorToPLCFormat(const std::vector<int>& data);
    static std::vector<int> parsePLCSignal(byte* raw_data);
};

2、状态机

状态转换表

当前状态	触发条件	下一状态	超时时间
WAIT_SN	收到DB16.1=1	READ_SN	30s
READ_SN	成功读取SN字符串	ACK_SN	10s
ACK_SN	收到PLC确认信号	WAIT_CAPTURE	60s

3、通信层增强

连接管理

// 指数退避重连算法 
bool PLCManager::reconnect(int max_retry) {
    constexpr int base_delay = 1; // 秒 
    int current_delay = base_delay;
    
    for (int i=0; i<max_retry; ++i){
        if(connect()) return true;
        
        std::this_thread::sleep_for(
            std::chrono::seconds(current_delay)
        );
        current_delay *= 2; // 退避策略 
    }
    return false;
}

数据读写

使用内存映射替代离散读写

#pragma pack(push, 1)
struct PLCDB16 {  // 映射DB16数据结构 
    byte reserve1[16];
    uint16_t send_signal;  // 偏移16 
    uint16_t ack_signal;   // 偏移18 
    uint16_t result_flag;  // 偏移20 
    uint16_t subzone[12];  // 偏移22-44 
    char sn_code[32];      // 偏移46 
};
#pragma pack(pop)
 
// 批量读写示例 
PLCDB16 db_data;
client->DBRead(16, 0, sizeof(PLCDB16), &db_data);

4、异常处理机制

分层错误码设计

@startuml 
enum ErrorCode {
    NETWORK_FAILURE = 0x1000,
    PROTOCOL_ERROR  = 0x2000,
    DATA_INVALID    = 0x3000 
}
 
class RetryStrategy {
    + MAX_RETRY_TIMES = 5 
    + BACKOFF_BASE = 1s 
}
 
PLCManager --> ErrorCode 
PLCManager --> RetryStrategy 
@enduml

结构化日志输出

class PLCLogger {
    enum class LogLevel {
        TRACE,
        DEBUG,
        INFO,
        WARN,
        ERROR 
    };
    
    void log(LogLevel level, 
            const std::string& tag,
            const std::string& msg) {
        auto now = std::chrono::system_clock::now();
        std::cout << fmt::format(
            "[{:%Y-%m-%d %H:%M:%S}] [{}] [{}] {}",
            now, 
            levelToString(level),
            tag,
            msg 
        ) << std::endl;
    }
};

5、核心代码

PLCManager plc(PLC_IP); 
StateProcessor processor;
DefectDetector detector;
 
plc.connectWithRetry(3);  // 3次重试 
 
while(running) {
    auto current_state = processor.currentState(); 
    
    switch(current_state) {
    case State::WAIT_SN:
        handleWaitSN(plc, processor);
        break;
    case State::IMAGE_CAPTURE:
        handleImageCapture(plc, detector);
        break;
    case State::DEFECT_ANALYSIS:
        handleDefectAnalysis(plc, detector);
        break;
    default:
        logError("Invalid state");
    }
    
    checkTimeout(processor); // 状态超时检测 
}

关键状态处理示例

SN码处理流程

void handleSNProcessing(PLCManager& plc, StateProcessor& sp) {
    PLCDB16 db;
    plc.readDB16(db);  // 读取完整DB块 
    
    if(db.send_signal  == 1) {
        std::string sn = db.sn_code; 
        if(validateSN(sn)) {
            sp.transition(State::ACK_SN); 
            plc.writeAckSignal(1);  // 写入确认信号 
            logInfo(fmt::format("Valid SN: {}", sn));
        } else {
            plc.writeErrorCode(0x3001);  // 数据无效错误 
            logError("Invalid SN format");
        }
    }
}

性能监控实现

class PerformanceMonitor {
    std::map<State, std::chrono::milliseconds> state_durations;
    std::chrono::time_point<Clock> state_start;
    
public:
    void onStateChanged(State new_state) {
        auto duration = Clock::now() - state_start;
        state_durations[current_state] += duration;
        state_start = Clock::now();
    }
    
    void printReport() {
        for(auto& [state, dur] : state_durations) {
            std::cout << stateToString(state) << ": " 
                     << dur.count()  << "ms\n";
        }
    }
};