如何通过Qt GUI（非网页）实现WiFi控制NodeMCU与LED？

Got it, let's break this down. You've got a working web-based LED control setup, and now you want to swap the web interface for a Qt GUI that talks directly over WiFi without relying on URL redirects/HTTP. Here's how to pull this off:

Instead of using HTTP/URLs (the backbone of your web server setup), you’ll use direct network communication (TCP or UDP) between your Qt GUI and the LED controller (like an ESP32, Arduino with WiFi shield, etc.). This skips HTTP overhead and lets you send simple, custom commands to control the LED directly.

First, adjust the code on your LED device to listen for network commands instead of HTTP requests. Let’s use an ESP32 (super common for WiFi LED projects) as an example:

Replace your WebServer library code with a TCP server (or UDP if you prefer fire-and-forget communication). Here’s a stripped-down working example:

#include <WiFi.h>

const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";
WiFiServer server(1234); // Listen for connections on port 1234
WiFiClient client;

const int ledPin = 2; // ESP32 on-board LED pin

void setup() {
  pinMode(ledPin, OUTPUT);
  Serial.begin(115200);
  
  // Connect to WiFi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi connected!");
  Serial.print("Device IP: ");
  Serial.println(WiFi.localIP());
  
  server.begin(); // Start TCP server
}

void loop() {
  // Accept new client connections
  if (!client.connected()) {
    client = server.available();
    return;
  }

  // Read incoming commands from Qt GUI
  if (client.available() > 0) {
    String cmd = client.readStringUntil('\n');
    cmd.trim(); // Clean up whitespace/newlines

    if (cmd == "ON") {
      digitalWrite(ledPin, HIGH);
      client.println("LED ON"); // Send confirmation back to GUI
    } else if (cmd == "OFF") {
      digitalWrite(ledPin, LOW);
      client.println("LED OFF");
    }
  }
}

This sets up a TCP server that listens for "ON" or "OFF" commands (followed by a newline) and toggles the LED accordingly.

On the Qt side, use the QtNetwork module to connect to your device’s IP and port, then send commands when buttons are clicked.

First, add QtNetwork to your project file (.pro): #

QT += network

Then, the GUI code example (C++): #

#include <QMainWindow>
#include <QTcpSocket>
#include <QMessageBox>

QT_BEGIN_NAMESPACE
namespace Ui { class LEDControlWindow; }
QT_END_NAMESPACE

class LEDControlWindow : public QMainWindow
{
    Q_OBJECT

public:
    LEDControlWindow(QWidget *parent = nullptr)
        : QMainWindow(parent)
        , ui(new Ui::LEDControlWindow)
        , socket(new QTcpSocket(this))
    {
        ui->setupUi(this);
        
        // Link button clicks to command-sending functions
        connect(ui->btnTurnOn, &QPushButton::clicked, this, [this](){ sendCommand("ON"); });
        connect(ui->btnTurnOff, &QPushButton::clicked, this, [this](){ sendCommand("OFF"); });
        
        // Handle socket status updates
        connect(socket, &QTcpSocket::connected, this, [](){
            QMessageBox::information(nullptr, "Success", "Connected to LED controller!");
        });
        
        connect(socket, &QTcpSocket::disconnected, this, [](){
            QMessageBox::warning(nullptr, "Disconnected", "Lost connection to device.");
        });
        
        connect(socket, &QTcpSocket::readyRead, this, [this](){
            QString response = socket->readAll();
            ui->statusLabel->setText("Device: " + response.trimmed());
        });
        
        // Connect to your device (replace with your device's actual IP)
        socket->connectToHost("192.168.1.100", 1234);
    }

    ~LEDControlWindow()
    {
        delete ui;
    }

private:
    Ui::LEDControlWindow *ui;
    QTcpSocket *socket;
    
    void sendCommand(const QString &cmd)
    {
        if (socket->state() == QTcpSocket::ConnectedState) {
            // Send command with newline to match device's read logic
            socket->write(cmd.toUtf8() + "\n");
            socket->flush();
        } else {
            QMessageBox::critical(nullptr, "Error", "Not connected to the device!");
        }
    }
};

The UI (using Qt Designer): #

• Add two QPushButton widgets labeled "Turn LED On" and "Turn LED Off"
• Add a QLabel named statusLabel to display connection status and device responses

• Dynamic IP Input: Instead of hardcoding the device IP, add a QLineEdit to your GUI so users can enter the IP address manually (useful if the device’s IP changes).
• UDP Alternative: If you don’t need a persistent connection, use QUdpSocket instead of QTcpSocket—it’s simpler for one-way commands, though you won’t get confirmation unless the device sends a reply.
• Error Handling: Add more robust checks (e.g., handle connection timeouts, invalid commands, or WiFi drops).
• Security: For public networks, add basic authentication (e.g., require a password before sending commands) to prevent unauthorized access.

This approach is far more lightweight than HTTP/URL-based control, while keeping the exact same core functionality—you’re just replacing the web server’s HTTP parsing with direct, simple network command passing.

内容的提问来源于stack exchange，提问作者user8606643