纯C++ 三菱FX5系列PLC通信实现源码

已于 2025-04-24 14:32:41 修改
阅读量998 收藏 5
点赞数 3
分类专栏： 三菱 C++ 文章标签： qt
于 2023-11-18 09:09:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43510515/article/details/134474160
版权

与三菱PLC通信走MC协议，看了一下三菱通信方面文档，用C++写了一个通信类，目前实现读取M,X,Y,D区数据，写入M和D区数据（都可批量读写）
根据三菱 MELSEC iQ-FFX5用户手册(SLMP篇) 实现

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
具体需要看三菱文档
VS2022 纯C++版本源码
代码实现：

tcpclient.h

#ifndef TCPCLIENT_H
#define TCPCLIENT_H

#include <WinSock2.h>
#include <string>

using namespace std;
const int PORT = 4997;
#define MaxBufSize 2048
#define _CRT_SECURE_NO_WARINGS

enum COMMAND {
    READ,
    WRITE
};

enum SUB_COMMAND {
    SUB_BIT,
    SUB_WORD
};

enum TYPE {
    XType,
    YType,
    MType,
    DType
};

class TcpClient
{
public:
    TcpClient();

public:
    int slot_Connect(string ip,int port);
    int ReadD(int address,int size,void *pData);
    int ReadM(int address,int size,void *pData);
    int ReadX(int address,int size,void *pData);
    int ReadY(int address,int size,void *pData);

    int WriteD(int address,int size,void *pData);
    int WriteM(int address,int size,void *pData);

    char* build(int address,int size,int command,int sub_command,int type);

    int ResDataLen(char* data);
    int ResError(char* data);

    void ReConnect();

    int ConnectStatus();

    size_t customStrlen(const char* data);

private:
    SOCKET		SocketClient;
    SOCKADDR_IN	ClientAddr;				//地址
    int nNum = 0;
    int nConnected = 1;
};

#endif // TCPCLIENT_H

tcpclient.cpp

#include "tcpclient.h"
#include <cstdio>
#include<iostream>
#include<string>
#include<WinSock2.h>
#include <cstring>
#include <WS2tcpip.h>

#pragma  comment(lib,"ws2_32.lib")

TcpClient::TcpClient()
{

}

int TcpClient::slot_Connect(string ip, int port)
{
    WSADATA wsd;
    WSAStartup(MAKEWORD(2, 2), &wsd);
    SocketClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    ClientAddr.sin_family = AF_INET;
   // in_addr addr;
    inet_pton(AF_INET, ip.c_str(), &ClientAddr.sin_addr.S_un.S_addr);//ClientAddr.sin_addr.S_un.S_addr
    ClientAddr.sin_port = htons(port);
    int n = 0;
    n = connect(SocketClient, (struct sockaddr*)&ClientAddr, sizeof(ClientAddr));
    if (n == SOCKET_ERROR) {
        nConnected = 1;
        closesocket(SocketClient);
        return 1;
    }
    nConnected = 0;
    nNum = 0;
    return 0;
}

int TcpClient::ReadD(int address, int size, void *pData)
{
    int nAllLen = 9;
    char* data = build(address,size,READ,SUB_WORD,DType);
    int nLen = 21;
    //char buf[data.size()];
    //memcpy(buf,data.data(),data.size());
    int nReg;
    nReg = send(SocketClient,data, nLen, 0);
    if (nReg < 0) {
        //qDebug() << "Faile" << endl;
        delete [] data;
        nConnected = 1;
//        ReConnect();
        return 1;
    }
    Sleep(5);
    nReg = 0;
    char RecvBuff[MaxBufSize];
    nReg = recv(SocketClient, RecvBuff, sizeof(RecvBuff), 0);
    if(nReg > 0) {
        char* revData = new char[nReg];
        //revData.resize(nReg);
        memcpy(revData,RecvBuff,nReg);
        int nLen = ResDataLen(revData);
        nAllLen += nLen;
        if(0 != ResError(revData)) {
            delete[] data;
            delete[] revData;
            return 1;
        }
        memcpy(pData,revData+11,nLen-2);
        delete[] data;
        delete[] revData;
        return 0;
    } else {
        delete[] data;
        return 1;
    }
    delete[] data;
    return 0;
}

int TcpClient::ReadM(int address, int size, void *pData)
{
    int nAllLen = 9;
    //QByteArray data;
    //QByteArray revData;
    int sizeM = size;
    if(sizeM <= 2) {
        sizeM = 1;
    }else {
        if(sizeM%2 == 0)  {
            sizeM = sizeM/2;
        }else {
            sizeM = (sizeM + 1)/2;
        }
    }
    char* data = build(address,size,READ,SUB_BIT,MType);
    int nLen = 21;
    //char buf[data.size()];
    //memcpy(buf,data.data(),data.size());
    int nReg = 0;
    nReg = send(SocketClient, data, nLen,0);
    if (nReg < 0) {
        //qDebug() << "Faile" << endl;
//        ReConnect();
        delete[] data;
        nConnected = 1;
        return 1;
    }
    Sleep(5);
    nReg = 0;
    char RecvBuff[MaxBufSize];
    nReg = recv(SocketClient, RecvBuff, sizeof(RecvBuff), 0);
    if(nReg > 0) {
        //revData.resize(nReg);
        char* revData = new char[nReg];
        memcpy(revData,RecvBuff,nReg);
        int nLen = ResDataLen(revData);
        nAllLen += nLen;
        if(0 != ResError(revData)) {
            delete[] data;
            delete[] revData;
            return 1;
        }
        uint8_t *dataTemp = new uint8_t[sizeM];
        uint8_t *dataM = new uint8_t[size];
        memcpy(dataTemp,revData+11,nLen-2);
        int nNum = 0;
        for(int i = 0; i < sizeM; i++) {
            uint8_t firstFourBits = (dataTemp[i] >> 4) & 0x0F;    //firstFourBits
            uint8_t lastFourBits = dataTemp[i] & 0x0F;         //lastFourBits
            if(0 == i) {
                memcpy(dataM+nNum,&firstFourBits,1);
                nNum += 1;
                if(nNum < size) {
                    memcpy(dataM+nNum,&lastFourBits,1);
                }
            } else {
                memcpy(dataM+nNum,&firstFourBits,1);
                nNum += 1;
                if((nNum) < size) {
                    memcpy(dataM+nNum,&lastFourBits,1);
                }
            }
            nNum++;
        }
        memcpy(pData,dataM,size);
        delete [] data;
        delete [] revData;
        delete [] dataM;
        delete [] dataTemp;
        return 0;
    } else {
        delete[] data;
        return 1;
    }
}

int TcpClient::ReadX(int address, int size, void *pData)
{
    int nAllLen = 9;
    //QByteArray data;
    //QByteArray revData;
    int sizeX = size;
    if(sizeX <= 2) {
        sizeX = 1;
    }else {
        if(sizeX%2 == 0)  {
            sizeX = sizeX/2;
        }else {
            sizeX = (sizeX + 1)/2;
        }
    }
    char* data = build(address,size,READ,SUB_BIT,XType);
    int nLen = 21;
    //char buf[data.size()];
    //memcpy(buf,data.data(),data.size());
    int nReg = 0;
    nReg = send(SocketClient,data, nLen,0);
    if (nReg < 0) {
        //qDebug() << "Faile" << endl;
//        ReConnect();
        delete[] data;
        nConnected = 1;
        return 1;
    }
    Sleep(5);
    nReg = 0;
    char RecvBuff[MaxBufSize];
    nReg = recv(SocketClient, RecvBuff, sizeof(RecvBuff), 0);
    if(nReg > 0) {
        //revData.resize(nReg);
        char* revData = new char[nReg];
        memcpy(revData,RecvBuff,nReg);
        int nLen = ResDataLen(revData);
        nAllLen += nLen;
        if(0 != ResError(revData)) {
            delete[] data;
            delete[] revData;
            return 1;
        }
        uint8_t *dataTemp = new uint8_t[sizeX];
        uint8_t *dataX = new uint8_t[size];
        memcpy(dataTemp,revData+11,nLen-2);
        int nNum = 0;
        for(int i = 0; i < sizeX; i++) {
            uint8_t firstFourBits = (dataTemp[i] >> 4) & 0x0F;
            uint8_t lastFourBits = dataTemp[i] & 0x0F;
            if(0 == i) {
                memcpy(dataX+nNum,&firstFourBits,1);
                nNum += 1;
                if(nNum < size) {
                    memcpy(dataX+nNum,&lastFourBits,1);
                }
            } else {
                memcpy(dataX+nNum,&firstFourBits,1);
                nNum += 1;
                if((nNum) < size) {
                    memcpy(dataX+nNum,&lastFourBits,1);
                }
            }
            nNum++;
        }
        memcpy(pData,dataX,size);
        delete [] data;
        delete [] revData;
        delete [] dataX;
        delete [] dataTemp;
        return 0;
    } else {
        delete[] data;
        return 1;
    }
}

int TcpClient::ReadY(int address, int size, void *pData)
{
    int nAllLen = 9;
    //QByteArray data;
    //QByteArray revData;
    int sizeY = size;
    if(sizeY <= 2) {
        sizeY = 1;
    }else {
        if(sizeY%2 == 0)  {
            sizeY = sizeY/2;
        }else {
            sizeY = (sizeY + 1)/2;
        }
    }
    char* data = build(address,size,READ,SUB_BIT,YType);
    int nLen = 21;
    //char buf[data.size()];
    //memcpy(buf,data.data(),data.size());
    int nReg = 0;
    nReg = send(SocketClient, data, nLen,0);
    if (nReg < 0) {
        //qDebug() << "Faile" << endl;
//        ReConnect();
        delete[] data;
        nConnected = 1;
        return 1;
    }
    Sleep(5);
    nReg = 0;
    char RecvBuff[MaxBufSize];
    nReg = recv(SocketClient, RecvBuff, sizeof(RecvBuff), 0);
    if(nReg > 0) {
        //revData.resize(nReg);
        char* revData = new char[nReg];
        memcpy(revData,RecvBuff,nReg);
        int nLen = ResDataLen(revData);
        nAllLen += nLen;
        if(0 != ResError(revData)) {
            delete [] data;
            delete [] revData;
            return 1;
        }
        uint8_t *dataTemp = new uint8_t[sizeY];
        uint8_t *dataY = new uint8_t[size];
        memcpy(dataTemp,revData+11,nLen-2);
        int nNum = 0;
        for(int i = 0; i < sizeY; i++) {
            uint8_t firstFourBits = (dataTemp[i] >> 4) & 0x0F;
            uint8_t lastFourBits = dataTemp[i] & 0x0F;
            if(0 == i) {
                memcpy(dataY+nNum,&firstFourBits,1);
                nNum += 1;
                if(nNum < size) {
                    memcpy(dataY+nNum,&lastFourBits,1);
                }
            } else {
                memcpy(dataY+nNum,&firstFourBits,1);
                nNum += 1;
                if((nNum) < size) {
                    memcpy(dataY+nNum,&lastFourBits,1);
                }
            }
            nNum++;
        }
        memcpy(pData,dataY,size);
        delete [] data;
        delete [] revData;
        delete [] dataY;
        delete [] dataTemp;
        return 0;
    } else {
        delete [] data;
        return 1;
    }
}

int TcpClient::WriteD(int address, int size, void *pData)
{
    int nAllLen = 9;
    //QByteArray data;
    //QByteArray revData;
    char* data = build(address,size,WRITE,SUB_WORD,DType);
    int nDataLen = 21;//data.size();
    int nLastLen = size*2;
    //data.resize(nDataLen + nLastLen);
    char* pDataAll = new char[nDataLen + nLastLen];
    
    //char buf[data.size()];
    memcpy(pDataAll,data, nDataLen);
    memcpy(pDataAll + nDataLen, pData, size * 2);
    int nReg = 0;
    nReg = send(SocketClient, pDataAll, nDataLen + nLastLen,0);
    if (nReg < 0) {
        //qDebug() << "Faile" << endl;
//        ReConnect();
        delete[] data;
        delete[] pDataAll;
        nConnected = 1;
        return 1;
    }
    Sleep(5);
    nReg = 0;
    char RecvBuff[MaxBufSize];
    nReg = recv(SocketClient, RecvBuff, sizeof(RecvBuff), 0);
    if(nReg > 0) {
        //revData.resize(nReg);
        char* revData = new char[nReg];
        memcpy(revData,RecvBuff,nReg);
        int nLen = ResDataLen(revData);
        nAllLen += nLen;
        if(0 != ResError(revData)) {
            delete[] data;
            delete[] pDataAll;
            delete[] revData;
            return 1;
        }
        delete[] data;
        delete[] pDataAll;
        delete[] revData;
        return 0;
    } else {
        delete[] data;
        delete[] pDataAll;
        return 1;
    }
    return 0;
}

int TcpClient::WriteM(int address, int size, void *pData)
{
    int nAllLen = 9;
    //QByteArray data;
    char* data;
    //QByteArray revData;
    data = build(address,size,WRITE,SUB_BIT,MType);
    int nDataLen = 21;//data.size();
    int nLastLen = size*1;
    char* pDataAll = new char[nDataLen + nLastLen];
    memcpy(pDataAll, data, nDataLen);
    //data.resize(nDataLen + nLastLen);
    memcpy(pDataAll +nDataLen,pData,size*1);
    //char *buf = new char[strlen(pDataAll)];
    //memcpy(buf,data.data(),data.size());
    int nReg = 0;
    nReg = send(SocketClient, pDataAll, nDataLen + nLastLen,0);
    if (nReg < 0) {
        //qDebug() << "Faile" << endl;
//        ReConnect();
        delete[] data;
        delete[] pDataAll;
        nConnected = 1;
        return 1;
    }
    Sleep(5);
    nReg = 0;
    char RecvBuff[MaxBufSize];
    nReg = recv(SocketClient, RecvBuff, sizeof(RecvBuff), 0);
    if(nReg > 0) {
        char* revData = new char[nReg];
        //revData.resize(nReg);
        memcpy(revData,RecvBuff,nReg);
        int nLen = ResDataLen(revData);
        nAllLen += nLen;
        if(0 != ResError(revData)) {
            delete[] data;
            delete[] pDataAll;
            delete[] revData;
            return 1;
        }
        delete[] data;
        delete[] pDataAll;
        delete[] revData;
        return 0;
    } else {
        delete[] data;
        delete[] pDataAll;
        return 1;
    }
    return 0;
}

char* TcpClient::build(int address, int size, int command, int sub_command, int type)
{
    //QByteArray array;
    //array.resize(21);
    char *array = new char[21];
    uint8_t data[21] = {0};
    data[0] = 0x50;
    data[1] = 0x00;
    data[2] = 0x00;
    data[3] = 0xFF;
    data[4] = 0xFF;
    data[5] = 0x03;
    data[6] = 0x00;
    if(command == READ) {
        data[7] = 0x0C;
        data[8] = 0x00;
        data[9] = 0x10;
        data[10] = 0x00;
        data[11] = 0x01;
        data[12] = 0x04;
    }else if(command == WRITE) {
        uint16_t reqLen = 0;
        if(sub_command == SUB_BIT)
            reqLen = 12 + (size*1);
        else if(sub_command == SUB_WORD)
            reqLen = 12 + (size*2);
        memcpy(&data[7],&reqLen,2);
        data[9] = 0x0A;
        data[10] = 0x00;
        data[11] = 0x01;
        data[12] = 0x14;
    }
    if(sub_command == SUB_BIT) {
        data[13] = 0x01;
        data[14] = 0x00;
    }else if(sub_command == SUB_WORD) {
        data[13] = 0x00;
        data[14] = 0x00;
    }
    memcpy(&data[15],&address,3);
    if(type == XType)
        data[18] = 0x9C;
    else if(type == YType)
        data[18] = 0x9D;
    else if(type == MType)
        data[18] = 0x90;
    else if(type == DType)
        data[18] = 0xA8;
    uint16_t dataLen = size;
    memcpy(&data[19],&dataLen,2);
    memcpy(array,data,21);
    return array;
}

int TcpClient::ResDataLen(char* data)
{
    int nLen = 0;
    memcpy(&nLen,data+7,2);
    return nLen;
}

int TcpClient::ResError(char* data)
{
    int nError = 0;
    memcpy(&nError,data+9,2);
    return nError;
}

void TcpClient::ReConnect()
{
    nConnected = 1;
    nNum += 1;
    closesocket(SocketClient);
    slot_Connect("127.0.0.1", 4999);
}

int TcpClient::ConnectStatus()
{
    return nConnected;
}

size_t TcpClient::customStrlen(const char* data) {
    size_t length = 0;
    while (data[length] != '\0') {
        ++length;
    }
    return length;
}

应用

#include <iostream>
#include "tcpclient.h"

int main()
{
    std::cout << "Hello World!\n";
    

    TcpClient client;
    int nReg = client.slot_Connect("127.0.0.1", 4999);
    if (0 == nReg)
        std::cout << "sucess" << endl;
    else
        std::cout << "failed" << endl;

    Sleep(100);

    //write D
    int16_t data1 = 222;
    int nReg1 = client.WriteD(100, 2, &data1);
    if (0 == nReg1)
        std::cout << "WriteD D100 sucess " << endl;
    else 
        std::cout << "WriteD D100 failed " << endl;
    //read D
    int16_t data2;
    int nReg2 = client.ReadD(100, 2, &data2);
    if(0 == nReg2)
        std::cout << "ReaD D100 = " << data2 << endl;

    //write M
    uint8_t data3 = 16; //16的十六进制就是10 如果写某一个M点写1要把写入之写成16  / 写0就不需要了直接写0就行
    int nReg3 = client.WriteM(200, 1, &data3);
    if (0 == nReg3)
        std::cout << "WriteD M200 sucess " << endl;
    else
        std::cout << "WriteD M200 failed " << endl;
    //read M
    uint8_t data4;
    int nReg4 = client.ReadM(200, 1, &data4);
    if (0 == nReg4)
        std::cout << "ReaD D200 = " << (int)data4 << endl;

    //write 字符串
    char pStr[] = "abcdefg";
    int nReg5 = client.WriteD(300, 7, &pStr);
    if (0 == nReg5)
        std::cout << "WriteStr D300 sucess " << endl;
    else
        std::cout << "WriteStr D300 failed " << endl;
    //read 字符串
    char str2[30];
    int nReg6 = client.ReadD(300, 15, &str2);
    if (0 == nReg6)
        std::cout << "ReadStr D300 =  " << str2 << endl;
    
    std::cin.get();
    return 0;
}

以上就是全部源码，希望能帮到各位小伙伴
（不发邮箱了，麻烦）

使用QT实现串口通信编程
TechProX的博客
09-13 240
在这篇文章中，我将介绍如何使用QT编程实现串口通信，并提供相应的源代码。如果成功打开，会输出"串口已打开"，然后进行串口通信操作；如果无法打开，会输出"无法打开串口"。静态函数获取可用串口的列表，并通过遍历打印每个串口的信息。函数用于读取串口接收缓冲区中的所有数据，并将其存储在。函数用于设置波特率，这里设置为9600。函数用于设置流控制，这里设置为无流控制。函数用于设置校验位，这里设置为无校验。函数用于设置数据位，这里设置为8位。函数用于设置停止位，这里设置为1位。接下来，在打开串口之后，连接串口的。
QT + VS2019 实现与三菱PLC的通讯
04-26
通过MX Component配置后，实现QT + VS2019 与三菱PLC的通讯功能，可以提示通讯是否成功，并显示PLC型号。使用的软件：QT 5.12.9 +VS 2019 + MX Conponent S4.19。
Qt中使用MXComponent与三菱PLC通信（PLC型号是FX5U）通过设置逻辑站取代MODBUSTCP 直接访问D0-D100的方法
最新发布
qq_40944337的博客
03-03 510
3.寄存器中如果是双字，也是需要反过来，例如D5和D6组成一个浮点数，解析的时候就要按D6 D5的循序解析，转为浮点数。2.开发机器装MXComponent软件，目标机也一定要装这个软件并且要设置，否则代码运行也会崩。安装好了后启动栏有软件 Communication Settings Utility。解压后先安装EnvMEL中的setup.exe，再安装文件夹中的setup.exe。1.三菱的通信类不可以在子线程中创建主线程调用，会崩亏。，找到这里点击下载，下载不了记得注册一个账号。
Qt中使用TCP和MC协议与三菱Q系列PLC通信
m0_73674113的博客
09-25 1603
Qt中使用TCP和MC协议与三菱Q系列PLC通信
轻松实现工业自动化：Qt与三菱Q系列PLC通信指南
gitblog_06585的博客
09-20 801
轻松实现工业自动化：Qt与三菱Q系列PLC通信指南 Qt中使用TCP和MC协议与三菱Q系列PLC通信 项目地址: https://gitcode.com/Resource-Bundle-Collection/139de ...
QT5.7关于PLC串口通讯
02-02
简单的qt关于plc串口通讯的例子，只有串口通讯的一部分，plc协议部分未添加
Qt 串口通信之使用三菱PLC控制程序
billy的博客
08-03 4814
作者：billy 版权声明：著作权归作者所有，商业转载请联系作者获得授权，非商业转载请注明出处 前言 上位机与PLC通信有很多种方式，比如CPU编程口、网口、串口、总线连接等等。本章节记录一下如何通过串口让PLC控制程序执行操作。博主之前写过一章使用网口与PLC通信，具体请参考：Qt使用 MX Component 插件与三菱PLC通信 功能预览 通信协议 所谓通信协议是指通信双方的一种约定。约定包括对数据格式、同步方式、传送速度、传送步骤、检纠错方式以及控制字符定义等问题做出统一规定，通信双方必须共同遵守，
S7-1200与三菱FX5U系列PLC通过简单CPU通信功能实现以太网通信的具体方法.docx
01-05
标题所述的文档主要介绍了如何使西门子S7-1200 PLC与三菱FX5U系列PLC之间通过简单的CPU通信功能实现以太网通信。以下是对这一具体方法的详细说明： 首先，确保西门子S7-1200 PLC的配置正确。在西门子TIA Portal软件...
三菱FX5U系列PLC通过简单CPU通信功能实现以太网通信的具体方法示例.docx
12-30
三菱FX5U系列PLC是三菱自动化产品线中的一款高性能小型PLC，具有强大的网络通信能力。本示例主要讲解如何利用其内置的简单CPU通信功能实现以太网通信，以便于不同设备间的数据交互。 首先，简单CPU通信功能允许FX5U...
三菱FX5U系列PLC与汇川IT6000系列触摸屏进行MODBUS TCP通信的具体方法.docx
12-12
总结来说，实现三菱FX5U系列PLC与汇川IT6000系列触摸屏的MODBUS TCP通信，主要涉及PLC的网络参数设置、MODBUS配置、触摸屏的设备添加、MODBUS地址设定以及相应程序的编写和测试。这一过程要求对MODBUS通信协议有深入...
三菱FX5U系列PLC使用FX5-CCL-MS模块无需编程即可实现CC-Link通信的具体操作步骤.docx
05-19
特别是三菱电机推出的FX5U系列PLC，配合FX5-CCL-MS模块，为实现高效稳定的CC-Link通信提供了便捷的途径。与以往需要编程实现的方式不同，FX5U系列搭配FX5-CCL-MS模块可实现无需编程即完成CC-Link通信的功能，极大...
三菱 PLC Q系列 通讯协议
02-24
三菱 PLC Q系列 通讯协议参考手册，里面有报文说明以及详细范例
三菱FX5U系列PLC进行UDP以太网通信的具体方法示例（二）.docx
10-13
总的来说，通过精心设计的GX-WORKS3程序和正确配置的UDP通信指令，两个三菱FX5U系列PLC可以高效地进行以太网通信，实现数据的双向传输。在实际应用中，用户应根据具体需求调整程序参数，确保通信的稳定性和效率。
三菱q系列plc 和电脑socket_三菱Q系列串口和台达变频器RTU通信
weixin_39611820的博客
11-17 744
一：硬件准备PLC：三菱Q系列PLC+QJ71C24N-R4模块变频器：台达VFD-B终端电阻：110欧姆，主要目的就是为了防止干扰。接线图如下：二：台达变频器参数设置1.00-02；设置成09或者是10，先进行参数初始化。2.02-00第一频率指令来源设定:设定为04/05都可以，频率由RS-485通信界面操作(RJ-11)3.02-01第一运转指令来源设定：设定为03/04都可以，运转指令由通...
QT+C++与PLC进行以太网通讯
热门推荐
angelsha417的博客
11-22 1万+
这里写自定义目录标题前言通讯测试QT+OpenCV使用ACT控件的问题功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 ...
Qt5工业上位机自动扫码数据追溯实现：链接PLC，使用无线扫码枪SR1000，存储于Sqlserver，轻松导出Excel
GBBcuRIPGmUq的博客
05-20 674
总结一下，Qt5与C++开发语言的结合，可以实现工业上位机自动扫码数据追溯的功能。我们可以使用Qt5提供的库函数和组件来快速构建工业上位机应用程序，并且通过与工业设备的连接，实现自动扫码功能。我们可以通过编写C++代码，将从数据库中查询到的数据导出到Excel表格中，从而方便进行数据分析和报表生成。一套完整工程，链接PLC，工业无人值守自动扫码使用，无线扫码枪SR1000的使用，使用qt5.14，用qtcreator加载工程后，编译，运行，可调试可扩展，目的是学习qt开发方式。工业上位机与MES开发。
qt socket/modbus 简单又好用的交互库 以及与PLC 多地址交互示例以及信息统计 附加软件最小化到托盘
zhaojo的博客
04-26 265
【代码】qt socket/modbus 简单又好用的交互库 以及与PLC 多地址交互示例以及信息统计 附加软件最小化到托盘。
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值