• linux 下 C++ 与三菱PLC 通过MC Qna3E 二进制 协议进行交互

    西门子plc 有snap7库 进行交互，并且支持c++ 而且跨平台。但是三菱系列PLC并没有现成的开源项目，没办法只能自己拼接，我这里实现了MC 协议 Qna3E 帧，并使用二进制进行交互。

    1. #pragma once
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12.  
    13. #include 
    14. #include 
    15. using namespace std;
    16.  
    17. namespace MelsecMC
    18. {
    19.     class PlcSocket
    20.     {
    21.     private:
    22.         bool is_open;
    23.         int global_socket_fd; // 用于发送/接受数据
    24.         mutex m;
    25.  
    26.     public:
    27.         PlcSocket();
    28.         ~PlcSocket();
    29.  
    30.         // 初始化socket
    31.         bool initSocket(string ip, int port, int milSecond);
    32.         // 关闭socket
    33.         bool closeSocket();
    34.         // 发送数据
    35.         bool write(unsigned char *buffer, int len);
    36.         // 接收数据
    37.         bool read(unsigned char *buffer, int len);
    38.     };
    39. }
    1. #include "socket.h"
    2. #include <chrono>
    3. #include <thread>
    4.  
    5. namespace MelsecMC
    6. {
    7.     PlcSocket::PlcSocket()
    8.     {
    9.         global_socket_fd = -1;
    10.     }
    11.  
    12.     PlcSocket::~PlcSocket()
    13.     {
    14.     }
    15.  
    16.     bool PlcSocket::initSocket(string ip, int port, int milSecond)
    17.     {
    18.         // create
    19.         int socket_fd = socket(AF_INET, SOCK_STREAM, 0);
    20.         if (socket_fd == -1)
    21.         {
    22.             cout << "socket 创建失败:" << endl;
    23.             return false;
    24.         }
    25.  
    26.         struct sockaddr_in addr;
    27.         addr.sin_family = PF_INET;
    28.         addr.sin_port = htons(port);
    29.         addr.sin_addr.s_addr = inet_addr(ip.c_str());
    30.  
    31.         // connect
    32.         int res = connect(socket_fd, (struct sockaddr *)&addr, sizeof(addr));
    33.         if (res == -1)
    34.         {
    35.             cout << "connect 链接失败:" << endl;
    36.             return false;
    37.         }
    38.         cout << "connect 链接成功:" << endl;
    39.  
    40.         // 设置timeout
    41.         setsockopt(socket_fd, SOL_SOCKET, SO_SNDTIMEO, (char *)20, sizeof(int));
    42.         setsockopt(socket_fd, SOL_SOCKET, SO_RCVTIMEO, (char *)20, sizeof(int));
    43.  
    44.         cout << "setsockopt 成功:" << endl;
    45.         global_socket_fd = socket_fd;
    46.  
    47.         return true;
    48.     }
    49.     bool PlcSocket::write(unsigned char *buffer, int len)
    50.     {
    51.         m.lock();
    52.         long result = send(global_socket_fd, buffer, len, 0);
    53.         m.unlock();
    54.         if (result < 0)
    55.         {
    56.             return false;
    57.         }
    58.         return true;
    59.     }
    60.     bool PlcSocket::read(unsigned char *buffer, int len)
    61.     {
    62.         m.lock();
    63.         long result = recv(global_socket_fd, buffer, len, 0);
    64.         m.unlock();
    65.         if (result < 0)
    66.         {
    67.             cout << "recv失败:" << endl;
    68.             return false;
    69.         }
    70.         return true;
    71.     }
    72.     bool PlcSocket::closeSocket()
    73.     {
    74.         close(global_socket_fd);
    75.         return true;
    76.     }
    77. }
    1. /***
    2. MC协议的通讯方式有很多种：4C、3C、2C、1C、4E、3E、1E帧格式 数据格式分为二进制格式和ASCII码格式
    3. 本代码采用 3E + 二进制格式
    4. https://www.jianshu.com/p/ca7f1609c8c1
    5. ***/
    6. #pragma once
    7. #include <sys/sem.h>
    8. #include <sys/shm.h>
    9. #include <iostream>
    10. #include <memory>
    11. #include "socket.h"
    12.  
    13. namespace MelsecMC
    14. {
    15.     class MelsecMcClient : public std::enable_shared_from_this<MelsecMcClient>
    16.     {
    17.     public:
    18.         using Ptr = std::shared_ptr<MelsecMcClient>;
    19.  
    20.         explicit MelsecMcClient();
    21.         ~MelsecMcClient();
    22.    
    23.         bool connectTo(const string & ip, int port);
    24. 	    bool disconnect();
    25.  
    26.         bool readInt32(std::string area,int start,int &value);
    27.         bool writeInt32(std::string area,int start,int value);
    28.  
    29.         bool readShort(std::string area,int start,short &value);
    30.         bool writeShort(std::string area,int start,short value);
    31.  
    32.     private:
    33.         PlcSocket socket;
    34.         unsigned char head[7] = {0x50,0x00,0x00,0xFF,0xFF,0x03,0x00};
    35.     
    36.     private:
    37.         unsigned char decodeArea(std::string area);
    38.     };
    39. }
    1. #include "client.h"
    2. #include <sstream>
    3. #include <iomanip>
    4. namespace MelsecMC
    5. {
    6.     MelsecMcClient::MelsecMcClient()
    7.     {
    8.     }
    9.  
    10.     MelsecMcClient::~MelsecMcClient()
    11.     {
    12.         disconnect();
    13.     }
    14.  
    15.     bool MelsecMcClient::connectTo(const string &ip, int port)
    16.     {
    17.         return socket.initSocket(ip, port, 2000);
    18.     }
    19.  
    20.     bool MelsecMcClient::disconnect()
    21.     {
    22.         return socket.closeSocket();
    23.     }
    24.  
    25.     bool MelsecMcClient::writeInt32(std::string area,int start,int value)
    26.     {
    27.         unsigned char cmd[25] = {0};
    28.         // 头
    29.         memcpy(cmd, head, 7);
    30.  
    31.         //50 00 00 FF FF 03 00   10 00   0A 00   01 14  00 00    64 00 00   A8  02 00  01 00 00 00 写1
    32.         //请求数据物理长度
    33.         cmd[7] = 0x10;
    34.         cmd[8] = 0x00;
    35.  
    36.         // CPU监视定时器 表示等待PLC响应的timeout时间
    37.         cmd[9] = 0x0A;
    38.         cmd[10] = 0x00;
    39.  
    40.         //写命令 跟读的差别是：读是0104，写是0114 ；就是04和14的差别
    41.         cmd[11] = 0x01;
    42.         cmd[12] = 0x14;
    43.  
    44.         //(子命令) ： 值是0表示按字读写入1个字=16位),如果值是1就按位写入
    45.         cmd[13] = 0x00;
    46.         cmd[14] = 0x00;
    47.  
    48.         //(首地址)：地址因为跨度比较大，所以用了3个字节；值640000  返过来是000064，十进制就是100
    49.         cmd[17] = start / 255 / 255 % 255;
    50.         cmd[16] = start / 255 % 255;
    51.         cmd[15] = start % 255;
    52.  
    53.         //(软元件 读取的区域) ： 表示读取PLC寄存器的类型： 这里的A8表示D点；其他常见的有： 90-M点；9C-X点；9D-Y点；B0-ZR外部存储卡
    54.         unsigned char areaHex = decodeArea(area);
    55.         if (areaHex == 0x00)
    56.         {
    57.             std::cout << "不存在的地址 " << area << std::endl;
    58.             return false;
    59.         }
    60.         cmd[18] = areaHex;
    61.  
    62.         //写入长度 00 02  =10进制2个字 =32位 = 4个字节 =1个int
    63.         cmd[19] = 0x02;
    64.         cmd[20] = 0x00;
    65.  
    66.         //写入int值
    67.         cmd[24] = (value >> 24) & 0xFF;
    68.         cmd[23] = (value >> 16) & 0xFF;  
    69.         cmd[22] = (value >> 8) & 0xFF;
    70.         cmd[21] = value & 0xFF;
    71.  
    72.         if (!socket.write(cmd, sizeof(cmd)))
    73.         {
    74.             return false;
    75.         }
    76.  
    77.         // 读取数据
    78.         unsigned char recv[512] = {0};
    79.         if (!socket.read(recv, sizeof(recv)))
    80.         {
    81.             return false;
    82.         }
    83.         if (recv[0] != 0xD0 && recv[1] != 0x00)
    84.         {
    85.             std::cout << "数据格式不正确" << std::endl;
    86.             return false;
    87.         }
    88.  
    89.         return true;
    90.     }
    91.  
    92.     bool MelsecMcClient::readInt32(std::string area, int start, int &value)
    93.     {
    94.         unsigned char cmd[21] = {0};
    95.         // 头
    96.         memcpy(cmd, head, 7);
    97.  
    98.         //请求数据长度 也要反过来，值是000C,也就是12；表示后面的报文内容的长度是12
    99.         cmd[7] = 0x0C;
    100.         cmd[8] = 0x00;
    101.  
    102.         // CPU监视定时器 表示等待PLC响应的timeout时间
    103.         cmd[9] = 0x0A;
    104.         cmd[10] = 0x00;
    105.  
    106.         // 批量读命令 值是0401(所有值都要反过来看)；表示批量读取；如果是1401就是随机写取；
    107.         cmd[11] = 0x01;
    108.         cmd[12] = 0x04;
    109.  
    110.         //(子命令) ： 值是0表示按字读取(1个字=16位),如果值是1就按位读取
    111.         cmd[13] = 0x00;
    112.         cmd[14] = 0x00;
    113.  
    114.         //(首地址)：地址因为跨度比较大，所以用了3个字节；值640000  返过来是000064，十进制就是100
    115.         cmd[17] = start / 255 / 255 % 255;
    116.         cmd[16] = start / 255 % 255;
    117.         cmd[15] = start % 255;
    118.  
    119.         //(软元件 读取的区域) ： 表示读取PLC寄存器的类型： 这里的A8表示D点；其他常见的有： 90-M点；9C-X点；9D-Y点；B0-ZR外部存储卡
    120.         unsigned char areaHex = decodeArea(area);
    121.         if (areaHex == 0x00)
    122.         {
    123.             std::cout << "不存在的地址 " << area << std::endl;
    124.             return false;
    125.         }
    126.         cmd[18] = areaHex;
    127.  
    128.         // 读取长度 00 02  =10进制2个字 =32位 = 4个字节 =1个int
    129.         cmd[19] = 0x02;
    130.         cmd[20] = 0x00;
    131.  
    132.         // 发送数据
    133.         if (!socket.write(cmd, sizeof(cmd)))
    134.         {
    135.             return false;
    136.         }
    137.  
    138.         // 读取数据
    139.         unsigned char recv[512] = {0};
    140.         if (!socket.read(recv, sizeof(recv)))
    141.         {
    142.             return false;
    143.         }
    144.  
    145.         // 解析数据
    146.         // D0 00 00 FF FF 03 00 06 00 00 00 BB 02 96 49
    147.         // D0 00 （响应） :表示反馈信息，固定D0 00
    148.         // 00 (网络编号 ): 与上同
    149.         // FF (PLC编号) : 与上同
    150.         // FF 03 (请求目标模块IO编号) : 与上同
    151.         // 00 （请求目标模块站编号): 与上同
    152.         // 06 00  应答数据物理长度
    153.         if (recv[0] != 0xD0 && recv[7] != 0x06)
    154.         {
    155.             std::cout << "数据格式不正确" << std::endl;
    156.             return false;
    157.         }
    158.         value = recv[14] << 24 | recv[13] << 16 | recv[12] << 8 | recv[11];
    159.         std::cout << "value " << value << std::endl;
    160.         return true;
    161.     }
    162.  
    163.     bool MelsecMcClient::readShort(std::string area,int start,short &value){
    164.         unsigned char cmd[21] = {0};
    165.         memcpy(cmd, head, 7);
    166.  
    167.         cmd[7] = 0x0C;
    168.         cmd[8] = 0x00;
    169.  
    170.         cmd[9] = 0x0A;
    171.         cmd[10] = 0x00;
    172.  
    173.         cmd[11] = 0x01;
    174.         cmd[12] = 0x04;
    175.  
    176.         cmd[13] = 0x00;
    177.         cmd[14] = 0x00;
    178.  
    179.         cmd[17] = start / 255 / 255 % 255;
    180.         cmd[16] = start / 255 % 255;
    181.         cmd[15] = start % 255;
    182.  
    183.         unsigned char areaHex = decodeArea(area);
    184.         if (areaHex == 0x00)
    185.         {
    186.             std::cout << "不存在的地址 " << area << std::endl;
    187.             return false;
    188.         }
    189.         cmd[18] = areaHex;
    190.  
    191.         cmd[19] = 0x01;
    192.         cmd[20] = 0x00;
    193.  
    194.         if (!socket.write(cmd, sizeof(cmd)))
    195.         {
    196.             return false;
    197.         }
    198.  
    199.         unsigned char recv[512] = {0};
    200.         if (!socket.read(recv, sizeof(recv)))
    201.         {
    202.             return false;
    203.         }
    204.  
    205.         if (recv[0] != 0xD0 && recv[7] != 0x04)
    206.         {
    207.             std::cout << "数据格式不正确" << std::endl;
    208.             return false;
    209.         }
    210.         value = recv[12] << 8 | recv[11];
    211.         std::cout << "value " << value << std::endl;
    212.         return true;
    213.     }
    214.     
    215.     bool MelsecMcClient::writeShort(std::string area,int start,short value){
    216.         unsigned char cmd[23] = {0};
    217.         memcpy(cmd, head, 7);
    218.  
    219.         cmd[7] = 0x0E;
    220.         cmd[8] = 0x00;
    221.  
    222.         cmd[9] = 0x0A;
    223.         cmd[10] = 0x00;
    224.  
    225.         cmd[11] = 0x01;
    226.         cmd[12] = 0x14;
    227.  
    228.         cmd[13] = 0x00;
    229.         cmd[14] = 0x00;
    230.  
    231.         cmd[17] = start / 255 / 255 % 255;
    232.         cmd[16] = start / 255 % 255;
    233.         cmd[15] = start % 255;
    234.  
    235.         unsigned char areaHex = decodeArea(area);
    236.         if (areaHex == 0x00)
    237.         {
    238.             std::cout << "不存在的地址 " << area << std::endl;
    239.             return false;
    240.         }
    241.         cmd[18] = areaHex;
    242.  
    243.         cmd[19] = 0x01;
    244.         cmd[20] = 0x00;
    245.  
    246.         //写入short值 
    247.         cmd[22] = (value >> 8) & 0xFF;
    248.         cmd[21] = value & 0xFF;
    249.  
    250.         if (!socket.write(cmd, sizeof(cmd)))
    251.         {
    252.             return false;
    253.         }
    254.  
    255.         unsigned char recv[512] = {0};
    256.         if (!socket.read(recv, sizeof(recv)))
    257.         {
    258.             return false;
    259.         }
    260.         if (recv[0] != 0xD0 && recv[1] != 0x00)
    261.         {
    262.             std::cout << "数据格式不正确" << std::endl;
    263.             return false;
    264.         }
    265.  
    266.         return true;
    267.     }
    268.  
    269.     unsigned char MelsecMcClient::decodeArea(std::string area)
    270.     {
    271.         if (area == "D")
    272.         {
    273.             return 0xA8;
    274.         }
    275.         else if (area == "M")
    276.         {
    277.             return 0x90;
    278.         }
    279.         else if (area == "X")
    280.         {
    281.             return 0x9C;
    282.         }
    283.         else if (area == "Y")
    284.         {
    285.             return 0x9D;
    286.         }
    287.         else if (area == "ZR")
    288.         {
    289.             return 0xB0;
    290.         }
    291.         else
    292.         {
    293.             return 0x00;
    294.         }
    295.     }
    296. }
    1. #include "client.h"
    2.  
    3. using namespace MelsecMC;
    4.  
    5. int main(int argc, char **argv)
    6. {
    7.     MelsecMcClient::Ptr client = std::make_shared<MelsecMcClient>();
    8.     client->connectTo("10.10.14.60",6000);
    9.  
    10.     //int value;
    11.     //melsecMcNet->readInt32("D",100,value);
    12.  
    13.     //client->writeInt32("D",101,122234);
    14.     //client->writeShort("D",102,223);
    15.     short value;
    16.     client->readShort("D",102,value);
    17.     return 0;
    18. }
    19.

    可利用 这个工具进行测试：

     协议参考：

    https://www.jianshu.com/p/ca7f1609c8c1

  • 相关阅读:
    【unocss】apply聚合语法，unocss配置
    Python 实践
    如何实现条件组合组件
    OC-块对象
    【Hive】快速入门~
    数据库及ADO.NET学习（七）
    1-Docker安装MySQL8.0
    网络篇 DHCP静态绑定地址-17.1
    $attrs,$listeners
    003_IO 扩展(串转并)-74HC595
  • 原文地址：https://blog.csdn.net/weixin_38416696/article/details/132709315