用qt写一段代码实现两个上位机通过代理连接两个下位机，两个下位机收到命令后会发送的数据，发送的数据会在两台上位机上同时显示出来

下面是一个简单的示例代码，用于实现两个上位机通过代理连接两个下位机，并在两台上位机上同时显示接收到的数据。这里假设下位机使用TCP协议进行通信。

#include <QTcpSocket>
#include <QTcpServer>
#include <QHostAddress>

// 定义代理服务器的地址和端口
const QString proxyHost = "192.168.0.1";
const int proxyPort = 8888;

// 定义下位机的地址和端口
const QString device1Host = "192.168.0.2";
const int device1Port = 8001;
const QString device2Host = "192.168.0.3";
const int device2Port = 8002;

class ProxyServer : public QTcpServer
{
public:
    ProxyServer(QObject *parent = nullptr) : QTcpServer(parent) {}

protected:
    void incomingConnection(qintptr socketDescriptor) override
    {
        // 建立与代理服务器的连接
        QTcpSocket *proxySocket = new QTcpSocket(this);
        proxySocket->connectToHost(proxyHost, proxyPort);
        if (!proxySocket->waitForConnected()) {
            qDebug() << "Failed to connect to proxy server!";
            return;
        }

        // 建立与下位机的连接
        QTcpSocket *deviceSocket = new QTcpSocket(this);
        if (!deviceSocket->setSocketDescriptor(socketDescriptor)) {
            qDebug() << "Failed to create device socket!";
            return;
        }

        // 将代理服务器和下位机的连接进行转发
        connect(proxySocket, &QTcpSocket::readyRead, [=](){
            deviceSocket->write(proxySocket->readAll());
        });
        connect(deviceSocket, &QTcpSocket::readyRead, [=](){
            proxySocket->write(deviceSocket->readAll());
        });
    }
};

class UpperComputer : public QObject
{
    Q_OBJECT
public:
    UpperComputer(QObject *parent = nullptr) : QObject(parent) {}

public slots:
    void connectToDevice(const QString &host, int port)
    {
        // 建立与代理服务器的连接
        proxySocket = new QTcpSocket(this);
        proxySocket->connectToHost(proxyHost, proxyPort);
        if (!proxySocket->waitForConnected()) {
            qDebug() << "Failed to connect to proxy server!";
            return;
        }

        // 建立与下位机的连接
        deviceSocket = new QTcpSocket(this);
        connect(deviceSocket, &QTcpSocket::connected, [=](){
            qDebug() << "Connected to device!";
        });
        connect(deviceSocket, &QTcpSocket::readyRead, [=](){
            qDebug() << "Received data from device:" << deviceSocket->readAll();
        });
        deviceSocket->connectToHost(host, port);
    }

    void sendDataToDevice(const QByteArray &data)
    {
        if (proxySocket && proxySocket->state() == QAbstractSocket::ConnectedState) {
            proxySocket->write(data);
        }
    }

private:
    QTcpSocket *proxySocket = nullptr;
    QTcpSocket *deviceSocket = nullptr;
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 创建代理服务器并监听端口
    ProxyServer proxyServer;
    proxyServer.listen(QHostAddress::Any, 8888);

    // 创建两个上位机
    UpperComputer upperComputer1;
    UpperComputer upperComputer2;

    // 连接两个上位机到下位机
    upperComputer1.connectToDevice(device1Host, device1Port);
    upperComputer2.connectToDevice(device2Host, device2Port);

    // 发送数据到下位机
    upperComputer1.sendDataToDevice("Hello, device 1!");
    upperComputer2.sendDataToDevice("Hello, device 2!");

    return a.exec();
}

#include "main.moc"

在这个示例代码中，我们创建了一个`ProxyServer`类用于建立代理服务器，并在其中实现了`incomingConnection`函数以便在有新连接时建立与代理服务器的连接，并将代理服务器和下位机的连接进行转发。

另外，我们创建了一个`UpperComputer`类用于实现上位机的功能，其中包括连接到下位机和向下位机发送数据的功能。在`main`函数中，我们创建了两个`UpperComputer`对象，并分别连接到了两个下位机。然后我们向两个下位机发送了一条消息，并在两台上位机上同时显示接收到的数据。