在 Unreal Engine 5（UE5）中，串口通讯并未像 Unity 那样直接有 System.IO.Ports 这样的内置支持。实现串口通讯需要通过 C++ 的串口接口或者第三方库（如 boost::asio 或 libserial）来完成。以下将从基础到高级，逐步讲解如何在 UE5 中实现串口通讯。

---

1. 基础：UE5 串口通讯的环境准备

1.1 环境需求

在 UE5 中实现串口通讯需要：

1. C++ 项目：串口通讯需要编写 C++ 代码，蓝图本身无法直接操作串口。
2. 第三方库（可选）：如使用 boost::asio 或者 libserial，可以简化串口通讯的实现。

---

1.2 创建 C++ 类

1. 打开 UE5 项目，确保项目是 C++ 项目（或者将蓝图项目转换为 C++ 项目）。
2. 右键 Content Browser，选择 Add New > C++ Class。
3. 选择继承自 Actor 或 Object 的类，例如创建一个名为 SerialCommunication 的类。

---

2. 基础串口通讯实现

以下是使用标准 C++ 的串口通讯代码直接集成到 UE5 中的基础实现。

2.1 添加串口头文件

在 SerialCommunication.h 中，添加串口通讯所需的头文件：

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include <string>
#include <windows.h> // Windows 串口通讯的核心头文件
#include "SerialCommunication.generated.h"

UCLASS()
class YOURPROJECTNAME_API ASerialCommunication : public AActor
{
    GENERATED_BODY()

public:
    ASerialCommunication();

protected:
    virtual void BeginPlay() override;

public:
    virtual void Tick(float DeltaTime) override;

private:
    HANDLE SerialHandle; // 串口句柄
    DCB SerialParams;    // 串口参数
    COMMTIMEOUTS Timeouts; // 串口超时设置

    bool OpenSerialPort(const std::string& PortName, int BaudRate);
    void CloseSerialPort();
    bool WriteToSerial(const std::string& Data);
    std::string ReadFromSerial();
};

---

2.2 添加串口通讯逻辑

在 SerialCommunication.cpp 中实现串口通讯的逻辑：

#include "SerialCommunication.h"
#include <iostream> // 用于调试输出
#include <string>
#include <windows.h>

ASerialCommunication::ASerialCommunication()
{
    PrimaryActorTick.bCanEverTick = true;
    SerialHandle = INVALID_HANDLE_VALUE; // 初始化句柄
}

void ASerialCommunication::BeginPlay()
{
    Super::BeginPlay();

    // 打开串口 (修改为实际的端口号和波特率)
    if (OpenSerialPort("COM3", 9600))
    {
        UE_LOG(LogTemp, Warning, TEXT("串口已成功打开"));
    }
    else
    {
        UE_LOG(LogTemp, Error, TEXT("无法打开串口"));
    }
}

void ASerialCommunication::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

    // 从串口读取数据
    std::string ReceivedData = ReadFromSerial();
    if (!ReceivedData.empty())
    {
        UE_LOG(LogTemp, Warning, TEXT("接收到的数据: %s"), *FString(ReceivedData.c_str()));
    }

    // 示例：发送数据
    if (WriteToSerial("Hello from Unreal!"))
    {
        UE_LOG(LogTemp, Warning, TEXT("已发送数据"));
    }
}

bool ASerialCommunication::OpenSerialPort(const std::string& PortName, int BaudRate)
{
    // 打开串口
    SerialHandle = CreateFileA(PortName.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
    if (SerialHandle == INVALID_HANDLE_VALUE)
    {
        return false;
    }

    // 设置串口参数
    SerialParams = {0};
    SerialParams.DCBlength = sizeof(SerialParams);

    if (!GetCommState(SerialHandle, &SerialParams))
    {
        CloseSerialPort();
        return false;
    }

    SerialParams.BaudRate = BaudRate;
    SerialParams.ByteSize = 8; // 数据位
    SerialParams.StopBits = ONESTOPBIT; // 停止位
    SerialParams.Parity = NOPARITY; // 无校验位

    if (!SetCommState(SerialHandle, &SerialParams))
    {
        CloseSerialPort();
        return false;
    }

    // 设置超时时间
    Timeouts = {0};
    Timeouts.ReadIntervalTimeout = 50; // 每次读取的间隔
    Timeouts.ReadTotalTimeoutConstant = 50;
    Timeouts.ReadTotalTimeoutMultiplier = 10;
    Timeouts.WriteTotalTimeoutConstant = 50;
    Timeouts.WriteTotalTimeoutMultiplier = 10;

    if (!SetCommTimeouts(SerialHandle, &Timeouts))
    {
        CloseSerialPort();
        return false;
    }

    return true;
}

void ASerialCommunication::CloseSerialPort()
{
    if (SerialHandle != INVALID_HANDLE_VALUE)
    {
        CloseHandle(SerialHandle);
        SerialHandle = INVALID_HANDLE_VALUE;
    }
}

bool ASerialCommunication::WriteToSerial(const std::string& Data)
{
    if (SerialHandle == INVALID_HANDLE_VALUE)
    {
        return false;
    }

    DWORD BytesWritten;
    return WriteFile(SerialHandle, Data.c_str(), Data.length(), &BytesWritten, NULL);
}

std::string ASerialCommunication::ReadFromSerial()
{
    if (SerialHandle == INVALID_HANDLE_VALUE)
    {
        return "";
    }

    char Buffer[256];
    DWORD BytesRead;
    if (ReadFile(SerialHandle, Buffer, sizeof(Buffer) - 1, &BytesRead, NULL))
    {
        Buffer[BytesRead] = '\0'; // 确保字符串以 '\0' 结束
        return std::string(Buffer);
    }

    return "";
}

void ASerialCommunication::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    Super::EndPlay(EndPlayReason);
    CloseSerialPort();
}

---

2.3 测试串口通讯

1. 在 UE5 中，将 ASerialCommunication 放置到关卡中。
2. 确保外部设备（如 Arduino）已正确连接到电脑，并通过串口发送数据。
3. 在 BeginPlay 中打开串口，Tick 中完成数据收发。
4. 示例外部设备代码（Arduino）：

   void setup() {
       Serial.begin(9600);
   }
   
   void loop() {
       Serial.println("Hello Unreal!");
       delay(1000);
   }
   

运行项目后，在 UE5 的输出日志中可以看到串口传输的数据。

---

3. 中级：多线程串口通讯

在实际应用中，串口操作可能会阻塞主线程，导致 UE5 的帧率下降。为了解决这个问题，可以使用多线程处理串口数据。

3.1 使用 UE5 的多线程机制

UE5 提供简单的多线程支持，可以通过 AsyncTask 或 FRunnable 实现。

在串口通讯中添加多线程支持

修改 SerialCommunication 类，使用 UE5 的 AsyncTask 处理串口数据读取：

#include "Async/Async.h"

void ASerialCommunication::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

    // 异步读取串口数据
    AsyncTask(ENamedThreads::AnyBackgroundThreadNormalTask, [this]()
    {
        std::string ReceivedData = ReadFromSerial();
        if (!ReceivedData.empty())
        {
            // 回到主线程处理数据
            AsyncTask(ENamedThreads::GameThread, [ReceivedData]()
            {
                UE_LOG(LogTemp, Warning, TEXT("接收到的数据: %s"), *FString(ReceivedData.c_str()));
            });
        }
    });

    // 发送数据（可选）
    if (WriteToSerial("Hello from Unreal!"))
    {
        UE_LOG(LogTemp, Warning, TEXT("已发送数据"));
    }
}

---

4. 高级：与蓝图集成的串口通讯

为了方便开发者无需直接操作 C++ 代码，可以将串口通讯功能封装为 Blueprint Callable 的函数。

4.1 将功能暴露给蓝图

在 SerialCommunication.h 中添加以下代码：

UFUNCTION(BlueprintCallable, Category = "Serial")
bool OpenSerialPort(const FString& PortName, int BaudRate);

UFUNCTION(BlueprintCallable, Category = "Serial")
void CloseSerialPort();

UFUNCTION(BlueprintCallable, Category = "Serial")
bool WriteToSerial(const FString& Data);

UFUNCTION(BlueprintCallable, Category = "Serial")
FString ReadFromSerial();

在 SerialCommunication.cpp 中修改对应实现，将 std::string 替换为 Blueprint 支持的 FString：

bool ASerialCommunication::OpenSerialPort(const FString& PortName, int BaudRate)
{
    return OpenSerialPort(TCHAR_TO_UTF8(*PortName), BaudRate);
}

bool ASerialCommunication::WriteToSerial(const FString& Data)
{
    return WriteToSerial(TCHAR_TO_UTF8(*Data));
}

FString ASerialCommunication::ReadFromSerial()
{
    return FString(ReadFromSerial().c_str());
}

---

5. 总结与展望

通过上述步骤，您可以实现 UE5 中的串口通讯功能，从基础的串口操作到多线程优化以及与蓝图集成，全面支持实际项目开发。

关键点总结：

1. 基础串口通讯：使用 Windows API 或第三方库实现串口读写功能。
2. 多线程优化：异步处理串口数据避免阻塞主线程。
3. 蓝图集成：将功能封装为蓝图函数，方便非程序开发者调用。
4. 扩展与优化：
   • 支持多设备串口管理。
   • 使用无线串口（如蓝牙或 Wi-Fi）扩展功能。
   • 与 UE5 的实时系统集成（如 UI、动画和物理）。

通过串口通讯，UE5 可以与外部硬件无缝交互，为游戏开发、物联网和硬件项目提供强大支持。

---

6. 高级扩展：UE5 串口通讯的实际项目应用与优化

在更复杂的项目中，UE5 的串口通讯可以扩展到多设备支持、实时数据可视化、硬件反馈控制以及与其他系统的集成。以下将从实际应用的角度，深入探讨串口通讯在 UE5 中的高级用法和优化策略。

---

6.1 多设备支持

在许多场景中，可能需要同时与多个串口设备通信，例如多个传感器、控制器或外部模块。通过动态管理串口连接，可以实现多设备支持。

6.1.1 多设备串口管理器

以下代码实现了一个多设备串口管理器，支持动态添加和管理多个串口设备。

多设备串口类

在 SerialCommunication.h 中添加设备管理逻辑：

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include <map>
#include <string>
#include <windows.h>
#include "SerialCommunication.generated.h"

UCLASS()
class YOURPROJECTNAME_API ASerialCommunicationManager : public AActor
{
    GENERATED_BODY()

public:
    ASerialCommunicationManager();

protected:
    virtual void BeginPlay() override;
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;

public:
    UFUNCTION(BlueprintCallable, Category = "Serial")
    bool AddDevice(const FString& PortName, int BaudRate);

    UFUNCTION(BlueprintCallable, Category = "Serial")
    void RemoveDevice(const FString& PortName);

    UFUNCTION(BlueprintCallable, Category = "Serial")
    bool WriteToDevice(const FString& PortName, const FString& Data);

    UFUNCTION(BlueprintCallable, Category = "Serial")
    FString ReadFromDevice(const FString& PortName);

private:
    struct SerialDevice
    {
        HANDLE SerialHandle;
        DCB SerialParams;
        COMMTIMEOUTS Timeouts;
        FString Buffer;
    };

    std::map<std::string, SerialDevice> Devices;

    bool OpenSerialPort(SerialDevice& Device, const std::string& PortName, int BaudRate);
    void CloseSerialPort(SerialDevice& Device);
};

实现多设备支持

在 SerialCommunication.cpp 中实现设备管理逻辑：

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

// 添加设备
bool ASerialCommunicationManager::AddDevice(const FString& PortName, int BaudRate)
{
    std::string PortNameStd = TCHAR_TO_UTF8(*PortName);

    if (Devices.find(PortNameStd) != Devices.end())
    {
        UE_LOG(LogTemp, Warning, TEXT("设备已存在: %s"), *PortName);
        return false;
    }

    SerialDevice NewDevice = {};
    if (OpenSerialPort(NewDevice, PortNameStd, BaudRate))
    {
        Devices[PortNameStd] = NewDevice;
        UE_LOG(LogTemp, Warning, TEXT("成功添加设备: %s"), *PortName);
        return true;
    }

    UE_LOG(LogTemp, Error, TEXT("无法添加设备: %s"), *PortName);
    return false;
}

// 移除设备
void ASerialCommunicationManager::RemoveDevice(const FString& PortName)
{
    std::string PortNameStd = TCHAR_TO_UTF8(*PortName);

    auto It = Devices.find(PortNameStd);
    if (It != Devices.end())
    {
        CloseSerialPort(It->second);
        Devices.erase(It);
        UE_LOG(LogTemp, Warning, TEXT("设备已移除: %s"), *PortName);
    }
    else
    {
        UE_LOG(LogTemp, Warning, TEXT("设备不存在: %s"), *PortName);
    }
}

// 写入数据到设备
bool ASerialCommunicationManager::WriteToDevice(const FString& PortName, const FString& Data)
{
    std::string PortNameStd = TCHAR_TO_UTF8(*PortName);

    auto It = Devices.find(PortNameStd);
    if (It != Devices.end())
    {
        SerialDevice& Device = It->second;
        DWORD BytesWritten;
        std::string DataStd = TCHAR_TO_UTF8(*Data);

        if (WriteFile(Device.SerialHandle, DataStd.c_str(), DataStd.length(), &BytesWritten, NULL))
        {
            return true;
        }
    }

    return false;
}

// 从设备读取数据
FString ASerialCommunicationManager::ReadFromDevice(const FString& PortName)
{
    std::string PortNameStd = TCHAR_TO_UTF8(*PortName);

    auto It = Devices.find(PortNameStd);
    if (It != Devices.end())
    {
        SerialDevice& Device = It->second;
        char Buffer[256];
        DWORD BytesRead;

        if (ReadFile(Device.SerialHandle, Buffer, sizeof(Buffer) - 1, &BytesRead, NULL))
        {
            Buffer[BytesRead] = '\0';
            Device.Buffer += Buffer;

            // 提取完整数据帧（假设帧以 \n 结束）
            size_t FrameEnd = Device.Buffer.Find("\n");
            if (FrameEnd != FString::npos)
            {
                FString Frame = Device.Buffer.Left(FrameEnd);
                Device.Buffer.RemoveAt(0, FrameEnd + 1);
                return Frame;
            }
        }
    }

    return FString();
}

// 打开串口
bool ASerialCommunicationManager::OpenSerialPort(SerialDevice& Device, const std::string& PortName, int BaudRate)
{
    Device.SerialHandle = CreateFileA(PortName.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
    if (Device.SerialHandle == INVALID_HANDLE_VALUE)
    {
        return false;
    }

    Device.SerialParams = {0};
    Device.SerialParams.DCBlength = sizeof(Device.SerialParams);

    if (!GetCommState(Device.SerialHandle, &Device.SerialParams))
    {
        CloseSerialPort(Device);
        return false;
    }

    Device.SerialParams.BaudRate = BaudRate;
    Device.SerialParams.ByteSize = 8;
    Device.SerialParams.StopBits = ONESTOPBIT;
    Device.SerialParams.Parity = NOPARITY;

    if (!SetCommState(Device.SerialHandle, &Device.SerialParams))
    {
        CloseSerialPort(Device);
        return false;
    }

    Device.Timeouts = {0};
    Device.Timeouts.ReadIntervalTimeout = 50;
    Device.Timeouts.ReadTotalTimeoutConstant = 50;
    Device.Timeouts.ReadTotalTimeoutMultiplier = 10;
    Device.Timeouts.WriteTotalTimeoutConstant = 50;
    Device.Timeouts.WriteTotalTimeoutMultiplier = 10;

    if (!SetCommTimeouts(Device.SerialHandle, &Device.Timeouts))
    {
        CloseSerialPort(Device);
        return false;
    }

    return true;
}

// 关闭串口
void ASerialCommunicationManager::CloseSerialPort(SerialDevice& Device)
{
    if (Device.SerialHandle != INVALID_HANDLE_VALUE)
    {
        CloseHandle(Device.SerialHandle);
        Device.SerialHandle = INVALID_HANDLE_VALUE;
    }
}

---

6.1.2 使用多设备串口管理器

在 UE5 项目中，可以通过蓝图或 C++ 调用管理器的功能：

void AMyActor::TestSerialCommunication()
{
    ASerialCommunicationManager* SerialManager = GetWorld()->SpawnActor<ASerialCommunicationManager>();

    // 添加多个串口设备
    SerialManager->AddDevice(TEXT("COM3"), 9600);
    SerialManager->AddDevice(TEXT("COM4"), 115200);

    // 发送数据到设备
    SerialManager->WriteToDevice(TEXT("COM3"), TEXT("Hello COM3!"));
    SerialManager->WriteToDevice(TEXT("COM4"), TEXT("Hello COM4!"));

    // 读取设备数据
    FString COM3Data = SerialManager->ReadFromDevice(TEXT("COM3"));
    FString COM4Data = SerialManager->ReadFromDevice(TEXT("COM4"));

    UE_LOG(LogTemp, Warning, TEXT("COM3 数据: %s"), *COM3Data);
    UE_LOG(LogTemp, Warning, TEXT("COM4 数据: %s"), *COM4Data);

    // 移除设备
    SerialManager->RemoveDevice(TEXT("COM3"));
    SerialManager->RemoveDevice(TEXT("COM4"));
}

---

6.2 实时数据可视化

串口通讯常用于传感器数据采集，而实时将数据可视化是一个常见需求。

6.2.1 简单实时数据显示

1. 在 UI 中添加一个 TextBlock，用于显示传感器数据。
2. 在 C++ 或蓝图中更新串口接收到的数据。

示例：更新传感器数据到 UI

void AMyActor::UpdateSensorDataUI()
{
    FString SensorData = SerialManager->ReadFromDevice(TEXT("COM3"));
    if (!SensorData.IsEmpty())
    {
        UTextBlock* SensorText = Cast<UTextBlock>(YourWidget->GetWidgetFromName(TEXT("SensorTextBlock")));
        if (SensorText)
        {
            SensorText->SetText(FText::FromString(SensorData));
        }
    }
}

---

7. 总结与展望

UE5 的串口通讯可以实现从基础的单设备数据收发到多设备管理、多线程优化以及实时数据可视化等复杂应用。通过与蓝图集成，串口通讯功能可以更方便地应用于游戏开发、工业控制和物联网项目。

关键点回顾：

1. 基础实现：使用 Windows API 或第三方库实现串口数据收发。
2. 多设备支持：通过 map 或类似管理器支持多个串口设备。
3. 实时数据可视化：将传感器数据与 UE5 的 UI 系统结合，实现动态展示。
4. 优化与扩展：
   • 使用多线程处理串口数据，避免阻塞主线程。
   • 支持跨平台的串口实现（如蓝牙或 Wi-Fi）。

通过合理设计和优化，UE5 的串口通讯能力可以为智能硬件、机器人控制和实时监控等项目提供强大的技术支持。

---

8. 高级扩展：无线串口通讯与跨平台支持

在现代应用中，串口通讯不仅限于传统的有线串口（如 USB 串口），还包括无线串口（如蓝牙和 Wi-Fi 模块）。此外，UE5 的跨平台能力也要求串口通讯在不同设备（如 Windows、Linux、Mac、移动设备等）上运行。以下将继续探讨无线串口通讯的实现方式，以及如何支持跨平台开发。

---

8.1 无线串口通讯

无线串口通讯通过蓝牙或 Wi-Fi 模块模拟串口的功能，使设备可以远程通信。这在游戏开发、物联网设备控制、机器人交互等场景中非常重要。

8.1.1 蓝牙串口通讯

蓝牙串口（如 HC-05 模块）通过蓝牙技术模拟传统串口，支持标准的串口数据收发。

实现蓝牙串口通讯

在 UE5 中，蓝牙串口的实现需要借助第三方库或插件，例如：

• Windows 平台：使用 Windows 蓝牙 API（winrt::Windows::Devices::Bluetooth）。
• 跨平台解决方案：使用蓝牙插件（如 UE4Duino 或 BLE for UE4）。

以下是使用蓝牙插件的示例：

1. 安装蓝牙插件（如 BLE for UE4）。
2. 在蓝图或 C++ 中实现蓝牙设备的扫描和连接。

蓝图示例：扫描并连接蓝牙设备

• 使用插件节点：
  • Scan for Bluetooth Devices：扫描可用设备。
  • Connect to Device：连接到指定的蓝牙设备。
  • Send String Over Bluetooth 和 Receive String Over Bluetooth：发送和接收蓝牙数据。

---

8.1.2 Wi-Fi 串口通讯

Wi-Fi 串口（如 ESP8266 或 ESP32 模块）通过 TCP/UDP 协议与 UE5 通信，模拟串口数据的收发。

实现 Wi-Fi 通讯

1. 配置 Wi-Fi 模块：

   • 将 ESP8266/ESP32 配置为 TCP 服务器。
   • 例如，使用以下 Arduino 代码设置 Wi-Fi 模块：

     #include <ESP8266WiFi.h>
     
     const char* ssid = "YourSSID";
     const char* password = "YourPassword";
     
     WiFiServer server(12345);
     
     void setup() {
         Serial.begin(115200);
         WiFi.begin(ssid, password);
         while (WiFi.status() != WL_CONNECTED) {
             delay(1000);
             Serial.println("Connecting to WiFi...");
         }
         server.begin();
         Serial.println("Server started");
         Serial.print("IP Address: ");
         Serial.println(WiFi.localIP());
     }
     
     void loop() {
         WiFiClient client = server.available();
         if (client) {
             while (client.connected()) {
                 if (client.available()) {
                     String data = client.readStringUntil('\n');
                     Serial.println("Received: " + data);
                     client.println("Echo: " + data);
                 }
             }
         }
     }
     

2. UE5 实现 TCP 通讯：
   使用 UE5 的 FSocket 类实现 TCP 客户端，与 Wi-Fi 模块通信。

   示例代码：

   在 WiFiCommunication.h 中：

   #pragma once
   
   #include "CoreMinimal.h"
   #include "GameFramework/Actor.h"
   #include "Networking.h"
   #include "Sockets.h"
   #include "SocketSubsystem.h"
   #include "WiFiCommunication.generated.h"
   
   UCLASS()
   class YOURPROJECTNAME_API AWiFiCommunication : public AActor
   {
       GENERATED_BODY()
   
   public:
       AWiFiCommunication();
   
   protected:
       virtual void BeginPlay() override;
   
   public:
       virtual void Tick(float DeltaTime) override;
   
       UFUNCTION(BlueprintCallable, Category = "WiFi")
       bool ConnectToServer(const FString& IPAddress, int32 Port);
   
       UFUNCTION(BlueprintCallable, Category = "WiFi")
       void SendData(const FString& Message);
   
       UFUNCTION(BlueprintCallable, Category = "WiFi")
       FString ReceiveData();
   
   private:
       FSocket* ClientSocket;
   };
   

   在 WiFiCommunication.cpp 中：

   #include "WiFiCommunication.h"
   #include "Engine/Engine.h"
   
   AWiFiCommunication::AWiFiCommunication()
   {
       PrimaryActorTick.bCanEverTick = true;
       ClientSocket = nullptr;
   }
   
   void AWiFiCommunication::BeginPlay()
   {
       Super::BeginPlay();
   }
   
   void AWiFiCommunication::Tick(float DeltaTime)
   {
       Super::Tick(DeltaTime);
   }
   
   bool AWiFiCommunication::ConnectToServer(const FString& IPAddress, int32 Port)
   {
       ISocketSubsystem* SocketSubsystem = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM);
       ClientSocket = SocketSubsystem->CreateSocket(NAME_Stream, TEXT("WiFiClient"), false);
   
       FIPv4Address IP;
       FIPv4Address::Parse(IPAddress, IP);
   
       TSharedRef<FInternetAddr> Addr = SocketSubsystem->CreateInternetAddr();
       Addr->SetIp(IP.Value);
       Addr->SetPort(Port);
   
       bool bConnected = ClientSocket->Connect(*Addr);
       if (bConnected)
       {
           UE_LOG(LogTemp, Warning, TEXT("Successfully connected to server: %s:%d"), *IPAddress, Port);
       }
       else
       {
           UE_LOG(LogTemp, Error, TEXT("Failed to connect to server: %s:%d"), *IPAddress, Port);
       }
   
       return bConnected;
   }
   
   void AWiFiCommunication::SendData(const FString& Message)
   {
       if (ClientSocket)
       {
           TCHAR* Data = Message.GetCharArray().GetData();
           int32 Size = FCString::Strlen(Data);
           int32 Sent = 0;
   
           ClientSocket->Send((uint8*)TCHAR_TO_UTF8(Data), Size, Sent);
           UE_LOG(LogTemp, Warning, TEXT("Sent data: %s"), *Message);
       }
   }
   
   FString AWiFiCommunication::ReceiveData()
   {
       FString ReceivedData;
       if (ClientSocket)
       {
           uint32 Size;
           if (ClientSocket->HasPendingData(Size))
           {
               TArray<uint8> Data;
               Data.SetNumUninitialized(Size);
   
               int32 Read = 0;
               ClientSocket->Recv(Data.GetData(), Data.Num(), Read);
   
               ReceivedData = FString(ANSI_TO_TCHAR(reinterpret_cast<const char*>(Data.GetData())));
               UE_LOG(LogTemp, Warning, TEXT("Received data: %s"), *ReceivedData);
           }
       }
   
       return ReceivedData;
   }
   

---

8.2 跨平台串口通讯

UE5 的跨平台能力使得项目可能需要在 Windows、Mac、Linux 和移动设备上运行。串口通讯在不同平台上的实现存在差异：

8.2.1 平台差异

1. Windows：

   • 使用 Windows API 完成串口操作。
   • 串口设备通常表示为 COMx 端口。

2. Linux/Mac：

   • 使用 POSIX 串口接口（termios）。
   • 串口设备通常表示为 /dev/ttyUSBx 或 /dev/ttySx。

3. 移动设备：

   • 使用蓝牙串口（BLE）或 Wi-Fi 模块。

---

8.2.2 跨平台实现方式

1. 条件编译：根据平台选择不同的串口实现。

   #if PLATFORM_WINDOWS
       // Windows 串口实现
   #elif PLATFORM_LINUX
       // Linux 串口实现
   #elif PLATFORM_MAC
       // Mac 串口实现
   #endif
   

2. 第三方库：

   • 使用跨平台库（如 boost::asio 或 serial），它们封装了串口操作的底层差异，提供统一的接口。

---

8.3 数据可视化与反馈

串口通讯的另一个重要应用是实时数据的可视化和硬件反馈控制。

8.3.1 实时数据可视化

使用 UE5 的 Slate 或 UMG 系统，将传感器数据以图表形式展示。

• 曲线图：显示数据趋势（如温度变化）。
• 仪表盘：显示实时状态（如速度、压力）。

8.3.2 硬件反馈

通过串口控制外部硬件（如机器人、灯光）。

• 事件驱动：当游戏中发生特定事件时，通过串口发送控制信号。
• 实时交互：实现硬件与游戏的实时交互。

---

9. 总结与未来展望

通过无线串口通讯和跨平台支持，UE5 的串口通讯能力可以满足更多复杂的实际需求，为物联网、智能硬件、游戏互动等提供强大的技术支持。

关键点回顾：

1. 无线通讯：通过蓝牙和 Wi-Fi 模块实现远程串口通讯。
2. 跨平台支持：针对不同平台设计条件编译或使用跨平台库。
3. 实时可视化与硬件反馈：将串口数据与游戏逻辑深度结合。

未来扩展方向：

1. 边缘计算与 AI：将传感器数据结合 AI 模型进行实时分析。
2. 云端集成：通过串口将数据上传到云端，实现远程监控和控制。
3. 增强现实（AR）集成：结合 AR 技术实时展示串口数据。

通过灵活运用这些技术，UE5 的串口通讯可以成为开发智能交互系统、工业控制和实时监控项目的核心工具。

---

10. UE5 串口通讯应用示例：完整项目案例

为了更好地理解上述技术原理和实现方法，以下是一个完整的基于 Unreal Engine 5 串口通讯的项目案例：实时传感器数据可视化与硬件控制。本案例将结合串口数据采集、数据可视化和硬件反馈控制，展示如何在 UE5 中实现一个完整的串口通讯系统。

---

10.1 项目概述

目标

• 从传感器（如 Arduino 或 ESP8266）通过串口接收实时数据。
• 在 UE5 中将数据以图表形式动态可视化。
• 根据游戏事件通过串口发送信号控制硬件设备（如 LED、马达）。

硬件要求

• 一块 Arduino 或 ESP8266/ESP32。
• 一个连接传感器的模拟输入设备（如温度传感器、光敏传感器等）。
• 一个输出设备（如 LED 灯或马达）。

软件环境

• Unreal Engine 5。
• Arduino IDE（用于编写和上传硬件代码）。
• Windows 环境（串口通讯）。

---

10.2 Arduino 硬件代码

硬件功能

1. 将模拟传感器数据通过串口发送到电脑（例如温度数据）。
2. 通过串口接收控制信号（如 "LED_ON" 和 "LED_OFF"）控制设备。

const int sensorPin = A0; // 传感器连接的模拟引脚
const int ledPin = 13;    // LED 连接的数字引脚

void setup() {
    Serial.begin(9600); // 初始化串口
    pinMode(ledPin, OUTPUT);
}

void loop() {
    // 读取传感器数据
    int sensorValue = analogRead(sensorPin);
    float voltage = sensorValue * (5.0 / 1023.0); // 将模拟值转换为电压
    float temperature = (voltage - 0.5) * 100;   // 假设使用的是温度传感器

    // 发送数据到串口
    Serial.print("Temperature: ");
    Serial.println(temperature);

    // 检查是否有串口输入
    if (Serial.available()) {
        String command = Serial.readStringUntil('\n');
        if (command == "LED_ON") {
            digitalWrite(ledPin, HIGH);
        } else if (command == "LED_OFF") {
            digitalWrite(ledPin, LOW);
        }
    }

    delay(1000); // 每秒发送一次数据
}

---

10.3 UE5 项目实现

10.3.1 创建串口通讯类

在 UE5 中创建一个 C++ 类 ASerialController，用于处理串口通讯和数据交互。

头文件：SerialController.h

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include <string>
#include <windows.h>
#include "SerialController.generated.h"

UCLASS()
class YOURPROJECT_API ASerialController : public AActor
{
    GENERATED_BODY()

public:
    ASerialController();
    virtual void Tick(float DeltaTime) override;

    UFUNCTION(BlueprintCallable, Category = "Serial")
    bool OpenSerialPort(const FString& PortName, int BaudRate);

    UFUNCTION(BlueprintCallable, Category = "Serial")
    void CloseSerialPort();

    UFUNCTION(BlueprintCallable, Category = "Serial")
    FString ReadSerialData();

    UFUNCTION(BlueprintCallable, Category = "Serial")
    void WriteSerialData(const FString& Data);

protected:
    virtual void BeginPlay() override;
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;

private:
    HANDLE SerialHandle; // 串口句柄
    FString Buffer;      // 缓存串口接收的数据
};

---

实现文件：SerialController.cpp

#include "SerialController.h"
#include "Engine/Engine.h"

ASerialController::ASerialController()
{
    PrimaryActorTick.bCanEverTick = true;
    SerialHandle = INVALID_HANDLE_VALUE;
}

void ASerialController::BeginPlay()
{
    Super::BeginPlay();
}

void ASerialController::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    CloseSerialPort();
    Super::EndPlay(EndPlayReason);
}

void ASerialController::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
}

bool ASerialController::OpenSerialPort(const FString& PortName, int BaudRate)
{
    std::string PortNameStd = TCHAR_TO_UTF8(*PortName);
    SerialHandle = CreateFileA(PortNameStd.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);

    if (SerialHandle == INVALID_HANDLE_VALUE)
    {
        UE_LOG(LogTemp, Error, TEXT("Failed to open serial port: %s"), *PortName);
        return false;
    }

    DCB SerialParams = {0};
    SerialParams.DCBlength = sizeof(SerialParams);

    if (!GetCommState(SerialHandle, &SerialParams))
    {
        CloseSerialPort();
        return false;
    }

    SerialParams.BaudRate = BaudRate;
    SerialParams.ByteSize = 8;
    SerialParams.StopBits = ONESTOPBIT;
    SerialParams.Parity = NOPARITY;

    if (!SetCommState(SerialHandle, &SerialParams))
    {
        CloseSerialPort();
        return false;
    }

    COMMTIMEOUTS Timeouts = {0};
    Timeouts.ReadIntervalTimeout = 50;
    Timeouts.ReadTotalTimeoutConstant = 50;

    if (!SetCommTimeouts(SerialHandle, &Timeouts))
    {
        CloseSerialPort();
        return false;
    }

    UE_LOG(LogTemp, Warning, TEXT("Serial port opened: %s"), *PortName);
    return true;
}

void ASerialController::CloseSerialPort()
{
    if (SerialHandle != INVALID_HANDLE_VALUE)
    {
        CloseHandle(SerialHandle);
        SerialHandle = INVALID_HANDLE_VALUE;
        UE_LOG(LogTemp, Warning, TEXT("Serial port closed"));
    }
}

FString ASerialController::ReadSerialData()
{
    if (SerialHandle == INVALID_HANDLE_VALUE)
    {
        return TEXT("");
    }

    char Buffer[256] = {0};
    DWORD BytesRead;

    if (ReadFile(SerialHandle, Buffer, sizeof(Buffer) - 1, &BytesRead, NULL))
    {
        Buffer[BytesRead] = '\0';
        return FString(ANSI_TO_TCHAR(Buffer));
    }

    return TEXT("");
}

void ASerialController::WriteSerialData(const FString& Data)
{
    if (SerialHandle == INVALID_HANDLE_VALUE)
    {
        return;
    }

    std::string DataStd = TCHAR_TO_UTF8(*Data);
    DWORD BytesWritten;

    WriteFile(SerialHandle, DataStd.c_str(), DataStd.length(), &BytesWritten, NULL);
}

---

10.3.2 数据可视化与硬件控制

步骤 1：创建蓝图并绑定串口功能

1. 在 UE5 中创建一个蓝图类（基于 ASerialController）。
2. 在蓝图中调用以下功能：
   • OpenSerialPort("COM3", 9600)：打开串口。
   • ReadSerialData()：每帧读取串口数据。
   • WriteSerialData("LED_ON") 和 WriteSerialData("LED_OFF")：发送信号控制硬件。

步骤 2：实时数据可视化

1. 在 UMG 中添加一个 TextBlock，用于显示温度数据。
2. 在蓝图中，定期更新 TextBlock 的文本：

   Event Tick -> ReadSerialData() -> SetText(TextBlock, Data)
   

步骤 3：游戏事件触发硬件控制

1. 在蓝图中创建一个按键事件（例如按下 Space 键）。
2. 在事件中调用 WriteSerialData("LED_ON") 或 WriteSerialData("LED_OFF")。

---

10.4 项目测试与运行

测试步骤

1. 上传 Arduino 代码到硬件设备，并确保设备连接到电脑的串口（如 COM3）。
2. 在 UE5 中运行项目：
   • 确认串口成功打开。
   • 观察温度数据在 UI 上实时更新。
   • 按下特定按键，观察硬件设备响应（如 LED 点亮）。

运行效果

• 在游戏界面中可以实时看到传感器数据的更新。
• 基于游戏事件可以控制硬件设备的状态（例如点亮或关闭 LED 灯）。

---

10.5 总结与优化

项目总结

本项目通过 UE5 和硬件设备的串口通讯，实现了实时数据采集、可视化和硬件控制，展示了 UE5 在物联网和硬件交互领域的强大能力。

优化方向

1. 多线程处理：
   • 使用 UE5 的 AsyncTask 或 C++ 多线程处理串口数据，避免阻塞主线程。
2. 数据过滤与校验：
   • 对接收到的传感器数据进行格式校验和异常处理。
3. 扩展无线通信：
   • 替换有线串口为蓝牙或 Wi-Fi 模块，扩展设备的物理范围。
4. 平台兼容性：
   • 在不同平台（如 Mac 或 Linux）上测试跨平台串口实现。

通过进一步优化和扩展，本项目可以应用于智能家居、工业控制、机器人系统等众多领域。