三菱FX5U PLC与C#通信开发指南

心疼你的一切2025-12-24 18:26

目录标题

引言

在工业自动化领域，PLC（可编程逻辑控制器）与上位机的通信是实现监控系统的重要组成部分。三菱FX5U系列PLC作为三菱电机推出的新一代小型PLC，具有高性能、高性价比的特点，广泛应用于各种工业控制场合。本文将详细介绍如何使用C#语言开发与三菱FX5U PLC的通信程序，包括通信原理、代码实现和实际应用案例。

一、三菱FX5U PLC概述

1-1、FX5U系列PLC特点

FX5U是三菱电机推出的第5代小型PLC，其主要特点包括：

  • 高速处理能力：基本指令处理速度达到34ns，大幅提升控制性能
  • 大容量存储：内置64KB程序存储器，支持SD卡扩展
  • 丰富的通信接口：内置Ethernet、USB、RS-232C/485接口
  • 模块化结构：支持多种功能模块扩展
  • 兼容性强：支持MODBUS、MC协议等多种通信协议

1-2、主要通信方式

FX5U PLC支持以下主要通信方式：

  1. 以太网通信（Ethernet）

    • TCP/IP协议
    • UDP协议
    • 支持Modbus/TCP

  2. 串行通信

    • RS-232C
    • RS-485
    • 支持Modbus/RTU

  3. USB通信

    • 用于编程和调试
    • 可用于数据采集

二、通信协议介绍

2-1、MC协议

MC协议（MELSEC Communication Protocol）是三菱PLC专用的通信协议，具有以下特点：

  • 二进制格式：传输效率高
  • 批量读写：支持一次性读写多个数据点
  • 安全机制：支持密码验证和通信加密

2-2、Modbus协议

Modbus是开放的工业通信协议，FX5U支持：

  • Modbus/TCP：基于以太网
  • Modbus/RTU：基于串行通信

本文主要介绍使用MC协议通过以太网与FX5U通信的方法。

三、开发环境准备

3-1、硬件要求

  • 三菱FX5U PLC一台
  • 以太网网线
  • 计算机（开发用）

3-2、软件要求

  • Visual Studio 2019/2022
  • .NET Framework 4.7.2或更高版本
  • 三菱GX Works3（用于PLC编程，可选）

3-3、PLC设置

  1. IP地址配置

    • 通过GX Works3设置PLC的IP地址
    • 确保与PC在同一网段

  2. 通信参数设置

    • 设置端口号（默认：5007）
    • 启用MC协议通信
    • 配置访问权限

四、C#通信类实现

4-1、基础通信框架

创建一个PLC通信类，实现基本的连接、断开和数据交换功能。

csharp 复制代码 
using System;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

public class FX5UCommunication
{
    private TcpClient tcpClient;
    private NetworkStream networkStream;
    private string ipAddress;
    private int port;

    // 构造函数
    public FX5UCommunication(string ip, int port = 5007)
    {
        this.ipAddress = ip;
        this.port = port;
        this.tcpClient = new TcpClient();
    }

    // 连接到PLC
    public async Task<bool> ConnectAsync()
    {
        try
        {
            await tcpClient.ConnectAsync(ipAddress, port);
            networkStream = tcpClient.GetStream();
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"连接失败: {ex.Message}");
            return false;
        }
    }

    // 断开连接
    public void Disconnect()
    {
        networkStream?.Close();
        tcpClient?.Close();
    }

    // 检查连接状态
    public bool IsConnected
    {
        get { return tcpClient.Connected; }
    }
}

4-2、MC协议封装

实现MC协议的命令封装和数据解析：

csharp 复制代码 
public class MCProtocol
{
    // 子命令定义
    public const byte SUBCMD_BATCH_READ = 0x04;
    public const byte SUBCMD_BATCH_WRITE = 0x14;
    public const byte SUBCMD_WORD_READ = 0x03;
    public const byte SUBCMD_WORD_WRITE = 0x13;

    // 设备类型定义
    public const byte DEV_X = 0x9C;        // 输入继电器
    public const byte DEV_Y = 0x9D;        // 输出继电器
    public const byte DEV_M = 0x90;        // 内部继电器
    public const byte DEV_D = 0xA8;        // 数据寄存器
    public const byte DEV_T = 0xC1;        // 定时器
    public const byte DEV_C = 0xC5;        // 计数器

    // 构建读取命令
    public static byte[] BuildReadCommand(byte deviceType, ushort startAddress, ushort pointCount)
    {
        byte[] command = new byte[21];

        // 副标题
        command[0] = 0x50;
        command[1] = 0x00;

        // 网络编号
        command[2] = 0x00;

        // PC编号
        command[3] = 0xFF;

        // 请求目标模块I/O编号
        command[4] = 0xFF;
        command[5] = 0x03;

        // 请求目标模块站号
        command[6] = 0x00;

        // 请求数据长度
        command[7] = 0x0C;
        command[8] = 0x00;

        // CPU监视定时器
        command[9] = 0x10;
        command[10] = 0x00;

        // 命令
        command[11] = 0x01;
        command[12] = 0x04;

        // 子命令
        command[13] = SUBCMD_BATCH_READ;

        // 设备类型
        command[14] = deviceType;

        // 起始地址
        byte[] addressBytes = BitConverter.GetBytes(startAddress);
        command[15] = addressBytes[0];
        command[16] = addressBytes[1];
        command[17] = 0x00;
        command[18] = 0x00;

        // 点数
        byte[] pointBytes = BitConverter.GetBytes(pointCount);
        command[19] = pointBytes[0];
        command[20] = pointBytes[1];

        return command;
    }

    // 构建写入命令
    public static byte[] BuildWriteCommand(byte deviceType, ushort startAddress, byte[] data)
    {
        int commandLength = 21 + data.Length;
        byte[] command = new byte[commandLength];

        // 基础命令部分（与读取命令类似）
        command[0] = 0x50;
        command[1] = 0x00;
        command[2] = 0x00;
        command[3] = 0xFF;
        command[4] = 0xFF;
        command[5] = 0x03;
        command[6] = 0x00;

        // 数据长度（基础部分+写入数据）
        ushort dataLength = (ushort)(12 + data.Length);
        byte[] lengthBytes = BitConverter.GetBytes(dataLength);
        command[7] = lengthBytes[0];
        command[8] = lengthBytes[1];

        // CPU监视定时器
        command[9] = 0x10;
        command[10] = 0x00;

        // 命令
        command[11] = 0x01;
        command[12] = 0x14;

        // 子命令
        command[13] = SUBCMD_BATCH_WRITE;

        // 设备类型
        command[14] = deviceType;

        // 起始地址
        byte[] addressBytes = BitConverter.GetBytes(startAddress);
        command[15] = addressBytes[0];
        command[16] = addressBytes[1];
        command[17] = 0x00;
        command[18] = 0x00;

        // 点数
        ushort pointCount = (ushort)(data.Length / 2);
        byte[] pointBytes = BitConverter.GetBytes(pointCount);
        command[19] = pointBytes[0];
        command[20] = pointBytes[1];

        // 写入数据
        Array.Copy(data, 0, command, 21, data.Length);

        return command;
    }

    // 解析响应数据
    public static byte[] ParseResponse(byte[] response)
    {
        // 检查响应是否有效
        if (response == null || response.Length < 22)
        {
            return null;
        }

        // 检查结束代码（0x0000表示成功）
        ushort endCode = BitConverter.ToUInt16(response, 9);
        if (endCode != 0)
        {
            throw new Exception($"PLC返回错误代码: {endCode:X4}");
        }

        // 提取数据部分
        int dataLength = response.Length - 22;
        byte[] data = new byte[dataLength];
        Array.Copy(response, 22, data, 0, dataLength);

        return data;
    }
}

4-3、扩展通信类

在基础通信类中添加读写方法：

csharp 复制代码 
// 扩展FX5UCommunication类
public partial class FX5UCommunication
{
    // 批量读取数据
    public async Task<byte[]> ReadAsync(byte deviceType, ushort startAddress, ushort pointCount)
    {
        if (!IsConnected)
        {
            throw new InvalidOperationException("PLC未连接");
        }

        try
        {
            // 构建读取命令
            byte[] command = MCProtocol.BuildReadCommand(deviceType, startAddress, pointCount);

            // 发送命令
            await networkStream.WriteAsync(command, 0, command.Length);

            // 读取响应
            byte[] response = new byte[1024];
            int bytesRead = await networkStream.ReadAsync(response, 0, response.Length);

            // 调整响应数组大小
            byte[] actualResponse = new byte[bytesRead];
            Array.Copy(response, actualResponse, bytesRead);

            // 解析响应
            return MCProtocol.ParseResponse(actualResponse);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"读取数据失败: {ex.Message}");
            return null;
        }
    }

    // 批量写入数据
    public async Task<bool> WriteAsync(byte deviceType, ushort startAddress, byte[] data)
    {
        if (!IsConnected)
        {
            throw new InvalidOperationException("PLC未连接");
        }

        try
        {
            // 构建写入命令
            byte[] command = MCProtocol.BuildWriteCommand(deviceType, startAddress, data);

            // 发送命令
            await networkStream.WriteAsync(command, 0, command.Length);

            // 读取响应
            byte[] response = new byte[1024];
            int bytesRead = await networkStream.ReadAsync(response, 0, response.Length);

            // 调整响应数组大小
            byte[] actualResponse = new byte[bytesRead];
            Array.Copy(response, actualResponse, bytesRead);

            // 检查响应
            MCProtocol.ParseResponse(actualResponse);
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"写入数据失败: {ex.Message}");
            return false;
        }
    }
}

五、基础读写操作

5-1、读取数据示例

csharp 复制代码 
public class PLCReader
{
    private FX5UCommunication plc;

    public PLCReader(string ipAddress)
    {
        plc = new FX5UCommunication(ipAddress);
    }

    // 读取D寄存器（16位数据）
    public async Task<short> ReadDRegisterAsync(ushort address)
    {
        byte[] data = await plc.ReadAsync(MCProtocol.DEV_D, address, 1);
        if (data != null && data.Length >= 2)
        {
            return BitConverter.ToInt16(data, 0);
        }
        return 0;
    }

    // 读取D寄存器（32位数据）
    public async Task<int> ReadDRegister32Async(ushort address)
    {
        byte[] data = await plc.ReadAsync(MCProtocol.DEV_D, address, 2);
        if (data != null && data.Length >= 4)
        {
            return BitConverter.ToInt32(data, 0);
        }
        return 0;
    }

    // 读取M继电器（位数据）
    public async Task<bool> ReadMCoilAsync(ushort address)
    {
        byte[] data = await plc.ReadAsync(MCProtocol.DEV_M, address / 16, 1);
        if (data != null && data.Length >= 2)
        {
            ushort wordData = BitConverter.ToUInt16(data, 0);
            int bitPosition = address % 16;
            return (wordData & (1 << bitPosition)) != 0;
        }
        return false;
    }

    // 读取多个连续的D寄存器
    public async Task<short[]> ReadDRegisterRangeAsync(ushort startAddress, ushort count)
    {
        byte[] data = await plc.ReadAsync(MCProtocol.DEV_D, startAddress, count);
        if (data != null && data.Length >= count * 2)
        {
            short[] values = new short[count];
            for (int i = 0; i < count; i++)
            {
                values[i] = BitConverter.ToInt16(data, i * 2);
            }
            return values;
        }
        return null;
    }
}

5-2、写入数据示例

csharp 复制代码 
public class PLCWriter
{
    private FX5UCommunication plc;

    public PLCWriter(string ipAddress)
    {
        plc = new FX5UCommunication(ipAddress);
    }

    // 写入D寄存器（16位数据）
    public async Task<bool> WriteDRegisterAsync(ushort address, short value)
    {
        byte[] data = BitConverter.GetBytes(value);
        return await plc.WriteAsync(MCProtocol.DEV_D, address, data);
    }

    // 写入D寄存器（32位数据）
    public async Task<bool> WriteDRegister32Async(ushort address, int value)
    {
        byte[] data = BitConverter.GetBytes(value);
        return await plc.WriteAsync(MCProtocol.DEV_D, address, data);
    }

    // 写入M继电器（位数据）
    public async Task<bool> WriteMCoilAsync(ushort address, bool value)
    {
        // 先读取整个字
        byte[] currentData = await plc.ReadAsync(MCProtocol.DEV_M, address / 16, 1);
        if (currentData == null || currentData.Length < 2)
            return false;

        // 修改指定位
        ushort wordData = BitConverter.ToUInt16(currentData, 0);
        int bitPosition = address % 16;

        if (value)
            wordData |= (ushort)(1 << bitPosition);
        else
            wordData &= (ushort)~(1 << bitPosition);

        // 写回整个字
        byte[] newData = BitConverter.GetBytes(wordData);
        return await plc.WriteAsync(MCProtocol.DEV_M, address / 16, newData);
    }

    // 写入多个连续的D寄存器
    public async Task<bool> WriteDRegisterRangeAsync(ushort startAddress, short[] values)
    {
        byte[] data = new byte[values.Length * 2];
        for (int i = 0; i < values.Length; i++)
        {
            byte[] valueBytes = BitConverter.GetBytes(values[i]);
            Array.Copy(valueBytes, 0, data, i * 2, 2);
        }
        return await plc.WriteAsync(MCProtocol.DEV_D, startAddress, data);
    }
}

六、实际应用案例

6-1、案例1：温度监控系统

实现一个简单的温度监控系统，读取PLC中的温度数据并在界面上显示。

csharp 复制代码 
using System;
using System.Threading.Tasks;
using System.Windows.Forms;

public partial class TemperatureMonitorForm : Form
{
    private FX5UCommunication plc;
    private bool isMonitoring = false;

    public TemperatureMonitorForm()
    {
        InitializeComponent();
        plc = new FX5UCommunication("192.168.0.10");
    }

    // 连接按钮点击事件
    private async void btnConnect_Click(object sender, EventArgs e)
    {
        if (await plc.ConnectAsync())
        {
            btnConnect.Text = "已连接";
            btnConnect.Enabled = false;
            btnStartMonitoring.Enabled = true;
            MessageBox.Show("PLC连接成功！");
        }
        else
        {
            MessageBox.Show("PLC连接失败！");
        }
    }

    // 开始监控按钮点击事件
    private async void btnStartMonitoring_Click(object sender, EventArgs e)
    {
        if (!isMonitoring)
        {
            isMonitoring = true;
            btnStartMonitoring.Text = "停止监控";
            await MonitorTemperaturesAsync();
        }
        else
        {
            isMonitoring = false;
            btnStartMonitoring.Text = "开始监控";
        }
    }

    // 监控温度数据
    private async Task MonitorTemperaturesAsync()
    {
        while (isMonitoring)
        {
            try
            {
                // 读取温度传感器值（D100-D103）
                short[] temperatures = new short[4];
                for (int i = 0; i < 4; i++)
                {
                    temperatures[i] = await ReadDRegister((ushort)(100 + i));
                }

                // 更新UI（需要在UI线程执行）
                Invoke(new Action(() =>
                {
                    txtTemp1.Text = temperatures[0].ToString() + "°C";
                    txtTemp2.Text = temperatures[1].ToString() + "°C";
                    txtTemp3.Text = temperatures[2].ToString() + "°C";
                    txtTemp4.Text = temperatures[3].ToString() + "°C";

                    // 检查温度报警
                    for (int i = 0; i < 4; i++)
                    {
                        if (temperatures[i] > 80)
                        {
                            lblAlarm.Text = $"温度{i + 1}过高报警！";
                            lblAlarm.ForeColor = System.Drawing.Color.Red;
                        }
                        else if (temperatures[i] < 10)
                        {
                            lblAlarm.Text = $"温度{i + 1}过低报警！";
                            lblAlarm.ForeColor = System.Drawing.Color.Blue;
                        }
                    }
                }));

                await Task.Delay(1000); // 1秒更新一次
            }
            catch (Exception ex)
            {
                MessageBox.Show($"监控出错: {ex.Message}");
                break;
            }
        }
    }

    // 读取D寄存器的辅助方法
    private async Task<short> ReadDRegister(ushort address)
    {
        byte[] data = await plc.ReadAsync(MCProtocol.DEV_D, address, 1);
        if (data != null && data.Length >= 2)
        {
            return BitConverter.ToInt16(data, 0);
        }
        return 0;
    }

    // 窗体关闭事件
    private void TemperatureMonitorForm_FormClosing(object sender, FormClosingEventArgs e)
    {
        isMonitoring = false;
        plc.Disconnect();
    }
}

6-2、案例2：设备控制系统

实现一个设备控制系统，可以控制电机的启停和调节运行速度。

csharp 复制代码 
using System;
using System.Threading.Tasks;
using System.Windows.Forms;

public partial class DeviceControlForm : Form
{
    private FX5UCommunication plc;
    private PLCReader reader;
    private PLCWriter writer;

    public DeviceControlForm()
    {
        InitializeComponent();
        plc = new FX5UCommunication("192.168.0.20");
        reader = new PLCReader(plc);
        writer = new PLCWriter(plc);
    }

    // 连接PLC
    private async void btnConnect_Click(object sender, EventArgs e)
    {
        if (await plc.ConnectAsync())
        {
            btnConnect.Text = "已连接";
            btnConnect.Enabled = false;
            grpControl.Enabled = true;
            await StartStatusMonitoring();
            MessageBox.Show("PLC连接成功！");
        }
    }

    // 启动电机
    private async void btnStart_Click(object sender, EventArgs e)
    {
        await writer.WriteMCoil(0, true); // M0 = ON
        await Task.Delay(100);
        await writer.WriteMCoil(0, false); // M0 = OFF (脉冲)
    }

    // 停止电机
    private async void btnStop_Click(object sender, EventArgs e)
    {
        await writer.WriteMCoil(1, true); // M1 = ON
        await Task.Delay(100);
        await writer.WriteMCoil(1, false); // M1 = OFF (脉冲)
    }

    // 复位系统
    private async void btnReset_Click(object sender, EventArgs e)
    {
        await writer.WriteMCoil(2, true); // M2 = ON
        await Task.Delay(100);
        await writer.WriteMCoil(2, false); // M2 = OFF (脉冲)
    }

    // 速度调节滑块值改变事件
    private async void trkSpeed_ValueChanged(object sender, EventArgs e)
    {
        int speed = trkSpeed.Value;
        lblSpeedValue.Text = speed.ToString();

        // 写入速度设定值到D200
        await writer.WriteDRegisterAsync(200, (short)speed);
    }

    // 监控设备状态
    private async Task StartStatusMonitoring()
    {
        while (true)
        {
            try
            {
                // 读取运行状态 (M10-M13)
                bool isRunning = await reader.ReadMCoil(10);
                bool isStopped = await reader.ReadMCoil(11);
                bool hasAlarm = await reader.ReadMCoil(12);
                bool isReset = await reader.ReadMCoil(13);

                // 读取当前速度 (D210)
                short currentSpeed = await reader.ReadDRegisterAsync(210);

                // 读取报警代码 (D220)
                short alarmCode = await reader.ReadDRegisterAsync(220);

                // 更新UI
                Invoke(new Action(() =>
                {
                    lblStatus.Text = isRunning ? "运行中" : "已停止";
                    lblStatus.ForeColor = isRunning ?
                        System.Drawing.Color.Green : System.Drawing.Color.Red;

                    lblCurrentSpeed.Text = currentSpeed.ToString() + " RPM";

                    if (hasAlarm)
                    {
                        lblAlarmInfo.Text = $"报警代码: {alarmCode}";
                        lblAlarmInfo.ForeColor = System.Drawing.Color.Red;
                    }
                    else
                    {
                        lblAlarmInfo.Text = "系统正常";
                        lblAlarmInfo.ForeColor = System.Drawing.Color.Green;
                    }
                }));

                await Task.Delay(500); // 500ms更新一次
            }
            catch
            {
                break;
            }
        }
    }

    // 自动模式切换
    private async void chkAutoMode_CheckedChanged(object sender, EventArgs e)
    {
        await writer.WriteMCoil(5, chkAutoMode.Checked); // M5 = 自动模式
        grpManual.Enabled = !chkAutoMode.Checked;
    }
}

6-3、案例3：数据记录系统

实现一个数据记录系统，定期采集PLC数据并保存到数据库。

csharp 复制代码 
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SQLite;
using System.IO;
using System.Threading.Tasks;

public class DataLogger
{
    private FX5UCommunication plc;
    private string dbPath;
    private bool isLogging = false;

    public DataLogger(string ipAddress, string databasePath)
    {
        plc = new FX5UCommunication(ipAddress);
        dbPath = databasePath;
        InitializeDatabase();
    }

    // 初始化数据库
    private void InitializeDatabase()
    {
        if (!File.Exists(dbPath))
        {
            SQLiteConnection.CreateFile(dbPath);
            using (var conn = new SQLiteConnection($"Data Source={dbPath}"))
            {
                conn.Open();
                string sql = @"
                    CREATE TABLE [DataLog] (
                        [ID] INTEGER PRIMARY KEY AUTOINCREMENT,
                        [Timestamp] DATETIME NOT NULL,
                        [Temperature] REAL,
                        [Pressure] REAL,
                        [FlowRate] REAL,
                        [MotorSpeed] INTEGER,
                        [AlarmStatus] INTEGER
                    )";
                using (var cmd = new SQLiteCommand(sql, conn))
                {
                    cmd.ExecuteNonQuery();
                }
            }
        }
    }

    // 开始数据记录
    public async Task StartLoggingAsync(int intervalMs = 1000)
    {
        isLogging = true;

        while (isLogging)
        {
            try
            {
                // 采集数据
                var data = await CollectDataAsync();

                // 保存到数据库
                await SaveDataAsync(data);

                // 触发数据更新事件
                OnDataUpdated?.Invoke(data);

                await Task.Delay(intervalMs);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"数据记录错误: {ex.Message}");
            }
        }
    }

    // 停止数据记录
    public void StopLogging()
    {
        isLogging = false;
    }

    // 采集PLC数据
    private async Task<PLCData> CollectDataAsync()
    {
        var reader = new PLCReader(plc);

        return new PLCData
        {
            Timestamp = DateTime.Now,
            Temperature = await reader.ReadDRegisterAsync(100) / 10.0f,
            Pressure = await reader.ReadDRegisterAsync(101) / 100.0f,
            FlowRate = await reader.ReadDRegisterAsync(102) / 10.0f,
            MotorSpeed = await reader.ReadDRegisterAsync(103),
            AlarmStatus = await reader.ReadMCoil(50) ? 1 : 0
        };
    }

    // 保存数据到数据库
    private async Task SaveDataAsync(PLCData data)
    {
        using (var conn = new SQLiteConnection($"Data Source={dbPath}"))
        {
            await conn.OpenAsync();
            string sql = @"
                INSERT INTO [DataLog]
                ([Timestamp], [Temperature], [Pressure], [FlowRate], [MotorSpeed], [AlarmStatus])
                VALUES
                (@Timestamp, @Temperature, @Pressure, @FlowRate, @MotorSpeed, @AlarmStatus)";

            using (var cmd = new SQLiteCommand(sql, conn))
            {
                cmd.Parameters.AddWithValue("@Timestamp", data.Timestamp);
                cmd.Parameters.AddWithValue("@Temperature", data.Temperature);
                cmd.Parameters.AddWithValue("@Pressure", data.Pressure);
                cmd.Parameters.AddWithValue("@FlowRate", data.FlowRate);
                cmd.Parameters.AddWithValue("@MotorSpeed", data.MotorSpeed);
                cmd.Parameters.AddWithValue("@AlarmStatus", data.AlarmStatus);

                await cmd.ExecuteNonQueryAsync();
            }
        }
    }

    // 查询历史数据
    public async Task<List<PLCData>> QueryHistoryDataAsync(DateTime startTime, DateTime endTime)
    {
        var result = new List<PLCData>();

        using (var conn = new SQLiteConnection($"Data Source={dbPath}"))
        {
            await conn.OpenAsync();
            string sql = @"
                SELECT * FROM [DataLog]
                WHERE [Timestamp] BETWEEN @StartTime AND @EndTime
                ORDER BY [Timestamp]";

            using (var cmd = new SQLiteCommand(sql, conn))
            {
                cmd.Parameters.AddWithValue("@StartTime", startTime);
                cmd.Parameters.AddWithValue("@EndTime", endTime);

                using (var reader = await cmd.ExecuteReaderAsync())
                {
                    while (await reader.ReadAsync())
                    {
                        result.Add(new PLCData
                        {
                            Timestamp = reader.GetDateTime("Timestamp"),
                            Temperature = reader.GetFloat("Temperature"),
                            Pressure = reader.GetFloat("Pressure"),
                            FlowRate = reader.GetFloat("FlowRate"),
                            MotorSpeed = reader.GetInt32("MotorSpeed"),
                            AlarmStatus = reader.GetInt32("AlarmStatus")
                        });
                    }
                }
            }
        }

        return result;
    }

    // 数据更新事件
    public event Action<PLCData> OnDataUpdated;
}

// PLC数据结构
public class PLCData
{
    public DateTime Timestamp { get; set; }
    public float Temperature { get; set; }
    public float Pressure { get; set; }
    public float FlowRate { get; set; }
    public int MotorSpeed { get; set; }
    public int AlarmStatus { get; set; }
}

七、常见问题与解决方案

7-1、连接失败问题

问题描述：无法连接到PLC，出现超时或连接被拒绝错误。

解决方案：

  • 检查IP地址是否正确
  • 确认PLC已上电且网络连接正常
  • 检查防火墙设置，确保5007端口未被阻止
  • 验证PLC的MC协议通信是否已启用
csharp 复制代码 
// 增加重试机制的连接方法
public async Task<bool> ConnectWithRetryAsync(int retryCount = 3, int delayMs = 1000)
{
    for (int i = 0; i < retryCount; i++)
    {
        try
        {
            await tcpClient.ConnectAsync(ipAddress, port);
            networkStream = tcpClient.GetStream();
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"连接尝试 {i + 1} 失败: {ex.Message}");
            if (i < retryCount - 1)
            {
                await Task.Delay(delayMs);
            }
        }
    }
    return false;
}

7-2、数据读取错误

问题描述：读取的数据不正确或解析失败。

解决方案：

  • 检查设备地址是否正确
  • 确认数据类型是否匹配（字/位）
  • 验证数据点数设置
  • 检查字节数组的字节序
csharp 复制代码 
// 增加数据验证的读取方法
public async Task<short> SafeReadDRegisterAsync(ushort address)
{
    try
    {
        byte[] data = await ReadAsync(MCProtocol.DEV_D, address, 1);
        if (data != null && data.Length >= 2)
        {
            // 验证数据是否在合理范围内
            short value = BitConverter.ToInt16(data, 0);
            if (value >= -32768 && value <= 32767)
            {
                return value;
            }
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"读取D{address}失败: {ex.Message}");
    }
    return 0; // 返回默认值
}

7-3、通信性能优化

问题描述：通信速度慢，响应延迟高。

解决方案：

  • 使用批量读写操作
  • 合理设置通信超时时间
  • 避免频繁的小数据量通信
  • 使用异步操作提高响应性
csharp 复制代码 
// 批量读取优化示例
public async Task<Dictionary<string, short>> ReadMultiplePointsAsync(
    Dictionary<string, ushort> addressMap)
{
    // 找出连续的地址范围，减少通信次数
    var sortedAddresses = new List<KeyValuePair<string, ushort>>(addressMap);
    sortedAddresses.Sort((a, b) => a.Value.CompareTo(b.Value));

    var result = new Dictionary<string, short>();
    int rangeStart = 0;

    while (rangeStart < sortedAddresses.Count)
    {
        int rangeEnd = rangeStart;
        while (rangeEnd < sortedAddresses.Count - 1 &&
               sortedAddresses[rangeEnd + 1].Value ==
               sortedAddresses[rangeEnd].Value + 1)
        {
            rangeEnd++;
        }

        // 读取连续范围
        ushort startAddr = sortedAddresses[rangeStart].Value;
        ushort count = (ushort)(rangeEnd - rangeStart + 1);
        byte[] data = await ReadAsync(MCProtocol.DEV_D, startAddr, count);

        if (data != null)
        {
            for (int i = rangeStart; i <= rangeEnd; i++)
            {
                short value = BitConverter.ToInt16(data, (i - rangeStart) * 2);
                result[sortedAddresses[i].Key] = value;
            }
        }

        rangeStart = rangeEnd + 1;
    }

    return result;
}

7-4、异常处理优化

问题描述：程序经常因通信异常而崩溃。

解决方案：

  • 完善的异常处理机制
  • 实现自动重连功能
  • 添加心跳检测
  • 记录详细的错误日志
csharp 复制代码 
// 带异常保护和自动重连的通信类
public class RobustPLCCommunication : FX5UCommunication
{
    private int reconnectInterval = 5000;
    private bool autoReconnect = true;
    private CancellationTokenSource cancellationTokenSource;

    public RobustPLCCommunication(string ip, int port = 5007)
        : base(ip, port)
    {
        cancellationTokenSource = new CancellationTokenSource();
    }

    // 安全的读取方法，带自动重连
    public async Task<byte[]> SafeReadAsync(byte deviceType, ushort startAddress, ushort pointCount)
    {
        while (!cancellationTokenSource.Token.IsCancellationRequested)
        {
            try
            {
                if (!IsConnected)
                {
                    if (!await ConnectAsync())
                    {
                        await Task.Delay(reconnectInterval);
                        continue;
                    }
                }

                byte[] result = await ReadAsync(deviceType, startAddress, pointCount);
                if (result != null)
                {
                    return result;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"读取失败: {ex.Message}");
                Disconnect();
            }

            if (autoReconnect)
            {
                Console.WriteLine("尝试重新连接...");
                await Task.Delay(reconnectInterval);
            }
            else
            {
                break;
            }
        }

        return null;
    }

    // 启动心跳检测
    public async Task StartHeartbeatAsync(int intervalMs = 30000)
    {
        while (!cancellationTokenSource.Token.IsCancellationRequested)
        {
            try
            {
                if (IsConnected)
                {
                    // 读取一个简单的点作为心跳
                    await ReadAsync(MCProtocol.DEV_D, 0, 1);
                }
                else if (autoReconnect)
                {
                    await ConnectAsync();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"心跳检测失败: {ex.Message}");
                Disconnect();
            }

            await Task.Delay(intervalMs, cancellationTokenSource.Token);
        }
    }

    public void Stop()
    {
        cancellationTokenSource.Cancel();
        autoReconnect = false;
        Disconnect();
    }
}

壁纸分享

八、总结

本文详细介绍了使用C#语言开发与三菱FX5U PLC通信程序的方法，包括：

  1. 通信原理：理解MC协议和Modbus协议的基本原理
  2. 代码实现：提供完整的C#通信类实现代码
  3. 实际应用：展示了三个典型应用案例
  4. 问题解决：总结常见问题和解决方案

扩展建议

  1. 使用第三方库：考虑使用成熟的工业通信库，如EasyModbus、Sharp7等
  2. 配置管理：实现灵活的配置系统，支持多台PLC管理
  3. 数据可视化：集成图表控件，实现数据可视化展示
  4. 远程访问：添加Web API或远程桌面功能，实现远程监控
  5. 报警系统：完善的报警管理和通知机制

注意事项

  • 工业环境下的通信稳定性是首要考虑因素
  • 注意保护PLC通信安全，避免未经授权的访问
  • 合理规划通信频率，避免对PLC运行造成影响
  • 保留详细的通信日志，便于故障排查
相关推荐
Tim_102 小时前
【C++入门】04、C++浮点型
开发语言·c++
@淡 定2 小时前
Java内存模型(JMM)详解
java·开发语言
谈笑也风生2 小时前
经典算法题型之复数乘法（二）
开发语言·python·算法
hkNaruto2 小时前
【C++】记录一次C++程序编译缓慢原因分析——滥用stdafx.h公共头文件
开发语言·c++
czhc11400756632 小时前
C# 1221
java·servlet·c#
先知后行。2 小时前
python的类
开发语言·python
派大鑫wink3 小时前
【Day12】String 类详解：不可变性、常用方法与字符串拼接优化
java·开发语言
JIngJaneIL3 小时前
基于springboot + vue健康管理系统(源码+数据库+文档)
java·开发语言·数据库·vue.js·spring boot·后端
dyxal3 小时前
Python包导入终极指南：子文件如何成功调用父目录模块
开发语言·python
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03Linux下V2Ray安装配置指南04从快手“12·22”直播攻击事件看：一次教科书式的业务层饱和攻击05在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）06Gemini3 生成的基于手势控制3D粒子圣诞树07解决 WSL Ubuntu 中 /etc/resolv.conf 自动重置问题08Labelme从安装到标注：零基础完整指南09CentOS的ISO镜像下载10GLM-4.7 vs MiniMax-M2.1：代码工程理解