• C#上位机与三菱PLC的通信11---开发自己的通讯工具软件(WPF版)

    1、先看颜值

    2、开始干

    1、创建项目

    2、引入前面的通讯库

     创建目录将前面生成的通讯库dll文件复制到项目的目录

    本项目引入dll文件

     

     3、创建命令基类

    RelayCommand.cs代码

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    6. using System.Windows.Input;
    7.  
    8. namespace MitsubishiMcToolWPF.Common
    9. {
    10.     /// 
    11.     /// 命令实现类
    12.     /// 
    13.     public class RelayCommand : ICommand
    14.     {
    15.         public event EventHandler CanExecuteChanged;
    16.         /// 
    17.         /// 要执行的操作
    18.         /// 
    19.         private Action<object> executeActions;
    20.         /// 
    21.         /// 是否可以执行的委托
    22.         /// 
    23.         private Func<object, bool> canExecuteFunc;
    24.         /// 
    25.         /// 构造函数 无参构造
    26.         /// 
    27.         public RelayCommand() { }
    28.         /// 
    29.         /// 通过执行的委托构造
    30.         /// 
    31.         /// 
    32.         public RelayCommand(Action<object> execute) : this(execute, null)
    33.         {
    34.  
    35.         }
    36.         /// 
    37.         /// 通过执行的操作与是否可执行的委托
    38.         /// 
    39.         /// 要执行的操作
    40.         /// 是否可以被执行
    41.         public RelayCommand(Action<object> execute, Func<object, bool> canExecute)
    42.         {
    43.             this.executeActions = execute;
    44.             this.canExecuteFunc = canExecute;
    45.         }
    46.  
    47.         /// 
    48.         /// 命令是否可以执行
    49.         /// 
    50.         /// 
    51.         /// 
    52.         public bool CanExecute(object parameter)
    53.         {
    54.             if (canExecuteFunc != null)
    55.                 return this.canExecuteFunc(parameter);
    56.             else
    57.                 return true;
    58.         }
    59.  
    60.         /// 
    61.         /// 要执行的操作
    62.         /// 
    63.         /// 
    64.         public void Execute(object parameter)
    65.         {
    66.             if (executeActions == null)
    67.                 return;
    68.             this.executeActions(parameter);
    69.         }
    70.  
    71.         /// 
    72.         /// 执行CanExecuteChanged事件
    73.         /// 
    74.         public void OnCanExecuteChanged()
    75.         {
    76.             this.CanExecuteChanged?.Invoke(this, new EventArgs());
    77.         }
    78.     }
    79. }

     4、创建PLC实体类

    PLCMemoryModel.cs代码

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    6.  
    7. namespace MitsubishiMcToolWPF.Model
    8. {
    9.     /// 
    10.     /// PLC内存模型类
    11.     /// 
    12.     public class PLCMemoryModel
    13.     {
    14.         /// 
    15.         /// 存储区
    16.         /// 
    17.         public string Area { get; set; } = "";
    18.         /// 
    19.         /// 地址
    20.         /// 
    21.  
    22.         public string Address { get; set; } = "";
    23.         /// 
    24.         /// 数据类型
    25.         /// 
    26.  
    27.         public string DataType { get; set; } = "";
    28.         /// 
    29.         /// 读取或写入数据
    30.         /// 
    31.  
    32.         public string Count { get; set; } = "";
    33.     }
    34. }

     5、添加资源字典，即样式文件

    CommonResource.xaml完整代码

    1.   
    2.  
    3.  
    4.  
    5.  
    6.  
    7.  
    8.  
    9.  
    10.  
    11.  
    12.  
    13.  
    14.  
    15.  "ComboBox.Static.Background" EndPoint="0,1" StartPoint="0,0">
    16.      "White" Offset="0"/>
    17.      "#FFE4E4E4" Offset="1"/>
    18.  
    19.  "ComboBox.Static.Border" Color="#FF105190"/>
    20.  
    21.  
    22.

     

     6、创建viewmodel

    viewmodel是视图模型，wpf采用的是mvvm的渲染模式，即控件绑定对象的属性，属性发生更改时，驱动控件的数据显示，而控件动作是由命令command执行

    1、模型基类

    ViewModelBase.cs代码

    1. using System;
    2. using System.Collections.Generic;
    3. using System.ComponentModel;
    4. using System.Linq;
    5. using System.Runtime.CompilerServices;
    6. using System.Text;
    7. using System.Threading.Tasks;
    8. using static MitsubishiMcToolWPF.MsgBoxWindow;
    9.  
    10. namespace MitsubishiMcToolWPF.ViewModel
    11. {
    12.     /// 
    13.     /// 视图模型基类
    14.     /// 
    15.     public class ViewModelBase : INotifyPropertyChanged
    16.     {
    17.         /// 
    18.         /// 属性值发生更改时触发
    19.         /// 
    20.         public event PropertyChangedEventHandler PropertyChanged;
    21.  
    22.  
    23.  
    24.         /// 
    25.         /// 执行更改
    26.         /// C#5.0中的新特性CallerMemberName
    27.         /// 
    28.         /// 
    29.         protected void OnPropertyChanged([CallerMemberName] string propertyName = "")
    30.         {
    31.             if (PropertyChanged != null)
    32.             {
    33.                 PropertyChanged.Invoke(this, new PropertyChangedEventArgs(propertyName));
    34.             }
    35.         }
    36.  
    37.  
    38.         /// 
    39.         /// 成功消息提示
    40.         /// 
    41.         /// 
    42.         /// 
    43.         /// 
    44.         public void ShowMessage(string message, string title = "提示", CustomMessageBoxButton buttons = CustomMessageBoxButton.OK)
    45.         {
    46.             Show(message, title, buttons, CustomMessageBoxIcon.Infomation);
    47.         }
    48.  
    49.         /// 
    50.         /// 错误消息框
    51.         /// 
    52.         /// 
    53.         /// 
    54.         /// 
    55.         public void ShowError(string message, string title = "错误", CustomMessageBoxButton buttons = CustomMessageBoxButton.OK)
    56.         {
    57.             Show(message, title, buttons, CustomMessageBoxIcon.Error);
    58.         }
    59.  
    60.         /// 
    61.         /// 询问消息框
    62.         /// 
    63.         /// 
    64.         /// 
    65.         /// 
    66.         /// 
    67.         public CustomMessageBoxResult ShowQuestion(string message, string title = "询问", CustomMessageBoxButton buttons = CustomMessageBoxButton.OKCancel)
    68.         {
    69.             return Show(message, title, buttons, CustomMessageBoxIcon.Question);
    70.         }
    71.  
    72.  
    73.  
    74.     }
    75. }

     2、主页模型mainviewmodel

    MainViewModel.cs代码

     

    1. using Mitsubishi.Communication.MC.Mitsubishi;
    2. using MitsubishiMcToolWPF.Common;
    3. using MitsubishiMcToolWPF.Model;
    4. using System;
    5. using System.Collections.Generic;
    6. using System.Linq;
    7. using System.Text;
    8. using System.Threading.Tasks;
    9. using System.Windows.Input;
    10.  
    11. namespace MitsubishiMcToolWPF.ViewModel
    12. {
    13.     /// 
    14.     /// 视图模型
    15.     /// 
    16.     public class MainViewModel : ViewModelBase
    17.     {
    18.         /// 
    19.         /// mctcp对象
    20.         /// 
    21.         A3E mctcp;
    22.  
    23.         #region 属性
    24.  
    25.         PLCMemoryModel readPLCModel = SetInitModel();
    26.         /// 
    27.         /// 读取PLC
    28.         /// 
    29.         public PLCMemoryModel ReadPLCModel
    30.         {
    31.             get { return readPLCModel; }
    32.             set
    33.             {
    34.                 readPLCModel = ReadPLCModel;
    35.                 OnPropertyChanged();//属性通知
    36.             }
    37.         }
    38.  
    39.         PLCMemoryModel writePLCModel = SetInitModel();
    40.         /// 
    41.         /// 写入PLC
    42.         /// 
    43.         public PLCMemoryModel WritePLCModel
    44.         {
    45.             get { return writePLCModel; }
    46.             set
    47.             {
    48.                 writePLCModel = WritePLCModel;
    49.                 OnPropertyChanged();
    50.             }
    51.         }
    52.         /// 
    53.         /// 初始化页面参数
    54.         /// 
    55.         /// 
    56.         private static PLCMemoryModel SetInitModel()
    57.         {
    58.             PLCMemoryModel model = new PLCMemoryModel();
    59.             model.Area = "D";
    60.             model.DataType = "short";
    61.             model.Address = "100";
    62.             model.Count = "1";
    63.             return model;
    64.         }
    65.  
    66.         private string hostName = "192.168.1.7";
    67.         /// 
    68.         /// PLC地址
    69.         /// 
    70.         public string HostName
    71.         {
    72.             get
    73.             {
    74.                 return hostName;
    75.             }
    76.             set
    77.             {
    78.                 hostName = value;
    79.             }
    80.         }
    81.  
    82.         private string hostPort = "6000";
    83.         /// 
    84.         /// PLC端口
    85.         /// 
    86.         public string HostPort
    87.         {
    88.             get { return hostPort; }
    89.             set
    90.             {
    91.                 hostPort = value;
    92.             }
    93.         }
    94.  
    95.  
    96.         /// 
    97.         /// 存储区下拉框数据源
    98.         /// 
    99.         public List<string> CboCustTypes
    100.         {
    101.             get
    102.             {
    103.                 return new List<string>() { "D", "X", "Y", "M", "R", "S", "TS" };
    104.             }
    105.         }
    106.  
    107.         /// 
    108.         /// 数据类型
    109.         /// 
    110.         public List<string> CboCustDatas
    111.         {
    112.             get
    113.             {
    114.                 return new List<string>() { "short", "float", "bool" };
    115.             }
    116.         }
    117.  
    118.         private string readWords = "";
    119.         /// 
    120.         /// 读数结果
    121.         /// 
    122.         public string ReadWords
    123.         {
    124.             get { return readWords; }
    125.             set
    126.             {
    127.                 readWords = value;
    128.                 OnPropertyChanged();
    129.             }
    130.         }
    131.         private string writeWords = "";
    132.         /// 
    133.         /// 写入数据
    134.         /// 
    135.         public string WriteWords
    136.         {
    137.             get { return writeWords; }
    138.             set
    139.             {
    140.                 writeWords = value;
    141.                 OnPropertyChanged();
    142.             }
    143.         }
    144.  
    145.         private string connectWords = "当前未连接";
    146.         /// 
    147.         /// 连接状态
    148.         /// 
    149.         public string ConnectWords
    150.         {
    151.             get { return connectWords; }
    152.             set
    153.             {
    154.                 connectWords = value;
    155.                 OnPropertyChanged();
    156.             }
    157.         }
    158.         #endregion
    159.  
    160.         #region 命令
    161.  
    162.         /// 
    163.         /// 
    164.         ///连接按钮的命令 
    165.         /// 
    166.         public ICommand ConnCommand
    167.         {
    168.             get
    169.             {
    170.                 return new RelayCommand(o =>
    171.                 {
    172.                     var name = HostName;
    173.                     var port = HostPort;
    174.                     mctcp = new A3E(name, short.Parse(port));// 创建连接 
    175.                     var result = mctcp.Connect();// 开始连接PLC
    176.                     if (!result.IsSuccessed)
    177.                     {
    178.                         ShowError(result.Message, "错误");
    179.                         return;
    180.                     }
    181.                     ConnectWords = "PLC已连接";
    182.                     ShowMessage("PLC连接成功", "提示");
    183.                 });
    184.             }
    185.         }
    186.  
    187.  
    188.         /// 
    189.         /// 
    190.         ///断开按钮的命令 
    191.         /// 
    192.         public ICommand CloseCommand
    193.         {
    194.             get
    195.             {
    196.                 return new RelayCommand(o =>
    197.                 {
    198.                     if (mctcp == null)
    199.                     {
    200.                         ShowError("PLC没有连接，不能断开", "错误");
    201.                         return;
    202.                     }
    203.                     mctcp = null;
    204.                     ConnectWords = "PLC已断开";
    205.                 });
    206.             }
    207.         }
    208.  
    209.  
    210.         /// 
    211.         /// 
    212.         /// 读取按钮的命令 
    213.         /// 
    214.         public ICommand ReadCommand
    215.         {
    216.             get
    217.             {
    218.                 return new RelayCommand(o =>
    219.                 {
    220.                     ReadWords = "";
    221.                     var d = ReadPLCModel;
    222.                     if (mctcp == null)
    223.                     {
    224.                         ShowError("PLC未连接，不能读取数据", "错误");
    225.                         return;
    226.                     }
    227.                     //内存地址
    228.                     string plcAddr = ReadPLCModel.Area + ReadPLCModel.Address;
    229.                     //读取数量
    230.                     short readCount = short.Parse(ReadPLCModel.Count);
    231.                     //数据类型
    232.                     string dataType = ReadPLCModel.DataType;
    233.                     switch (dataType)
    234.                     {
    235.                         case "short":
    236.                             var datas2 = mctcp.Read<short>(plcAddr, readCount);
    237.                             if (!datas2.IsSuccessed)
    238.                             {
    239.                                 ShowMessage(datas2.Message, "提示");
    240.                                 return;
    241.                             }
    242.                             ReadWords = string.Join(",", datas2.Datas);
    243.                             break;
    244.                         case "float":
    245.                             var datas3 = mctcp.Read<float>(plcAddr, readCount);
    246.                             if (!datas3.IsSuccessed)
    247.                             {
    248.                                 ShowMessage(datas3.Message, "提示");
    249.                                 return;
    250.                             }
    251.                             ReadWords = string.Join(",", datas3.Datas);
    252.                             break;
    253.                         case "bool":
    254.                             var datas4 = mctcp.Read<bool>(plcAddr, readCount);
    255.                             if (!datas4.IsSuccessed)
    256.                             {
    257.                                 ShowMessage(datas4.Message, "提示");
    258.                                 return;
    259.                             }
    260.                             ReadWords = string.Join(",", datas4.Datas);
    261.                             break;
    262.                     }
    263.                 });
    264.             }
    265.         }
    266.  
    267.  
    268.         /// 
    269.         /// 
    270.         /// 写入按钮的命令处理
    271.         /// 
    272.         public ICommand WriteCommand
    273.         {
    274.             get
    275.             {
    276.                 return new RelayCommand(o =>
    277.                 {
    278.                     if (mctcp == null)
    279.                     {
    280.                         ShowError("PLC未连接，不能写入数据", "错误");
    281.                         return;
    282.                     }
    283.                     var d = WritePLCModel;
    284.                     //内存地址
    285.                     string plcAddr = WritePLCModel.Area + WritePLCModel.Address;
    286.                     //写入数量 
    287.                     ushort writeCount = ushort.Parse(WritePLCModel.Count);
    288.                     //数据类型
    289.                     string dataType = WritePLCModel.DataType;
    290.                     //实际数量
    291.                     string objWriteVals = WriteWords;
    292.                     ushort objWCount = (ushort)objWriteVals.Split(',').Length;
    293.                     //实际数量与要求数量不一致，不允许操作
    294.                     if (writeCount != objWCount)
    295.                     {
    296.                         ShowError("写入值的数量不正确!");
    297.                         return;
    298.                     }
    299.                     List<string> vals = objWriteVals.Split(',').ToList();
    300.                     switch (dataType)
    301.                     {
    302.                         case "short":
    303.                             //实际数值转换成list集合 short类型
    304.                             List<short> objshort = new List<short>();
    305.                             vals.ForEach((x) =>
    306.                             {
    307.                                 objshort.Add(short.Parse(x));
    308.                             });
    309.                             var finish2 = mctcp.Write<short>(objshort, plcAddr);
    310.                             if (finish2.IsSuccessed)
    311.                             {
    312.                                 ShowMessage("写入成功", "提示");
    313.                             }
    314.                             break;
    315.                         case "float":
    316.                             //实际数值转换成list集合 float
    317.                             List<float> objfloat = new List<float>();
    318.                             vals.ForEach((x) =>
    319.                             {
    320.                                 objfloat.Add(float.Parse(x));
    321.                             });
    322.                             var finish3 = mctcp.Write<float>(objfloat, plcAddr);
    323.                             if (finish3.IsSuccessed)
    324.                             {
    325.                                 ShowMessage("写入成功", "提示");
    326.                             }
    327.                             break;
    328.                         case "bool":
    329.                             //实际数值转换成list集合bool
    330.                             List<bool> objbool = new List<bool>();
    331.                             vals.ForEach((x) =>
    332.                             {
    333.                                 if (x == "1")
    334.                                 {
    335.                                     objbool.Add(true);
    336.                                 }
    337.                                 else
    338.                                 {
    339.                                     objbool.Add(false);
    340.                                 }
    341.                             });
    342.                             var finish4 = mctcp.Write<bool>(objbool, plcAddr);
    343.                             if (finish4.IsSuccessed)
    344.                             {
    345.                                 ShowMessage("写入成功", "提示");
    346.                             }
    347.                             break;
    348.                     }
    349.                 });
    350.             }
    351.         }
    352.         #endregion
    353.  
    354.     }
    355. }

    7、主界面布局

    MainWindow.xaml完整代码

    1. "MitsubishiMcToolWPF.MainWindow"
    2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    4.         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    5.         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    6.         xmlns:local="clr-namespace:MitsubishiMcToolWPF.ViewModel"
    7.         mc:Ignorable="d"   
    8.         FontSize="13" FontFamily="Microsoft YaHei"  ResizeMode="CanMinimize" Title="三菱PLC通讯工具" FontWeight="ExtraLight" WindowStartupLocation="CenterScreen"  Height="450" Width="880" Name="mainWin"  >
    9.     
    10.         
    11.     
    12.     "true">
    13.         
    14.             "62"/>
    15.             
    16.         
    17.  
    18.         
    19.         "0" Background="BlanchedAlmond">
    20.             
    21.                 "100" />
    22.                 
    23.             
    24.             "0" Source="/imgs/log1.png"  Width="60" Height="60" Margin="20,0" />
    25.             "1"   Text="三菱MC协议通讯调试助手(Qna-3E模式)" FontSize="23" VerticalAlignment="Center"  FontWeight="Bold" />
    26.         
    27.  
    28.         
    29.         "1" Margin="0 10 0 0">
    30.             
    31.                 "200"/>
    32.                 "4"/>
    33.                 
    34.             
    35.             
    36.             "0" Margin="20">
    37.                 "PLC地址"/>
    38.                 "30" VerticalContentAlignment="Center" Padding="5,0" Margin="0,10" Text="{Binding HostName}"  />
    39.                 "端口号" Margin="0,10,0,0"/>
    40.                 "30" VerticalContentAlignment="Center" Padding="5,0" Margin="0,10" Text="{Binding HostPort}"  />
    41.                 
    42.                 
    43.                 "{Binding ConnectWords,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}"  Margin="0,10,0,0"  Foreground="Blue"/>
    44.             
    45.             
    46.             "1" Background="#4490AC" Width="2" Height="450" Margin="0 -11 0 0">
    47.             
    48.             "2">
    49.                 
    50.                     "60"/>
    51.                     "80"/>
    52.                     "30"/>
    53.                     "60"/>
    54.                     "80"/>
    55.                 
    56.                 
    57.                     
    58.                     
    59.                 
    60.                 "Horizontal" Grid.Row="0" Grid.Column="0" Grid.ColumnSpan="2" Margin="10">
    61.                     "存储区："  Style="{StaticResource  txtTextBlockStyle}" Margin="0 0 0 0" >
    62.                     "{Binding CboCustTypes}" SelectedValue="{Binding  ReadPLCModel.Area}"  Width="70"  Style="{StaticResource cboStyle}">
    63.                     "数据类型："  Style="{StaticResource  txtTextBlockStyle}" >
    64.                     "{Binding CboCustDatas}" SelectedValue="{Binding ReadPLCModel.DataType}"  Width="70"  Style="{StaticResource cboStyle}">
    65.                     "地址：" Style="{StaticResource  txtTextBlockStyle}" >
    66.                     "{Binding ReadPLCModel.Address}"  Width="100"  Style="{StaticResource  txtTextBoxStyle}" />
    67.                     "数量：" Style="{StaticResource  txtTextBlockStyle}" >
    68.                     "{Binding ReadPLCModel.Count}"  Width="60" Style="{StaticResource  txtTextBoxStyle}"  />
    69.                     
    70.                 
    71.  
    72.                 "Vertical" Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2"  Margin="10">
    73.                     "读取结果(多个数据之间用逗号隔开)"  Style="{StaticResource  txtTextBlockStyle}" Margin="0 3 0 9">
    74.                     "{Binding ReadWords,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}"  Width="616" Style="{StaticResource  txtTextBoxStyle}"  Margin="-23,0,0,0"   />
    75.                 
    76.  
    77.                 "Horizontal"  Grid.Row="2"  Grid.Column="0" Grid.ColumnSpan="2" Background="#4490AC" Width="706" Height="2" Margin="-1,0,0,0">
    78.  
    79.                 "Horizontal" Grid.Row="3" Grid.Column="0" Grid.ColumnSpan="2"  Margin="10">
    80.                     "存储区：" Style="{StaticResource  txtTextBlockStyle}" Margin="0 0 0 0">
    81.                     "{Binding CboCustTypes}" SelectedValue="{Binding WritePLCModel.Area }"  Width="70"  Style="{StaticResource cboStyle}">
    82.                     "数据类型：" Style="{StaticResource  txtTextBlockStyle}" >
    83.                     "{Binding CboCustDatas}" SelectedValue="{Binding WritePLCModel.DataType }"  Width="70"  Style="{StaticResource cboStyle}">
    84.                     "地址：" Style="{StaticResource  txtTextBlockStyle}" >
    85.                     "{Binding  WritePLCModel.Address }"  Width="100"  Style="{StaticResource  txtTextBoxStyle}"  />
    86.                     "数量：" Style="{StaticResource  txtTextBlockStyle}" >
    87.                     "{Binding WritePLCModel.Count}"  Width="60"   Style="{StaticResource  txtTextBoxStyle}"  />
    88.                     
    89.                 
    90.  
    91.                 "Vertical" Grid.Row="4" Grid.Column="0" Grid.ColumnSpan="2"  Margin="10">
    92.                     "写入数据(多个数据之间用逗号隔开)" Style="{StaticResource  txtTextBlockStyle}"  Margin="0 3 0 9" >
    93.                     "{Binding WriteWords ,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}"  Width="616" Style="{StaticResource  txtTextBoxStyle}"  Margin="-23,0,0,0"  />
    94.                 
    95.  
    96.             
    97.         
    98.     
    100.

     

     8、启动MC服务器

     9、异常错误处理

     

    10、操作测试

    1、连接PLC

    2、读取数据，short,float,bool

     

    3、写入数据，short,float

     写入short

    写入float

     

    3、小结

     

    走过路过不要错过，点赞关注收藏又圈粉，共同致富。

    欢迎抄袭，复制，分享，转载，学习，截图..............

    欢迎抄袭，复制，分享，转载，学习，截图..............

  • 相关阅读:
    Android开发 期末复习
    React - ref 命令为什么代替父子组件的数据传递
    CRM软件系统维护客户的主要方法
    IDEA中创建Web工程流程
    SpringBoot概念、创建和运行
    Instance Tunnel 使用
    做web自动化测试遇到Chrome浏览器老是自动更新，怎么办 ？ 这里提供两个解决办法 。
    用 Rust 编写 eBPF/XDP 负载均衡器
    计算机网络（自顶向下方法）-链路层和局域网
    SSE图像算法优化系列三十一：RGB2HSL/RGB2HSV及HSL2RGB/HSV2RGB的指令集优化-上。
  • 原文地址：https://blog.csdn.net/hqwest/article/details/136250638