мульти-последовательный порт связи на windows

Question

Я работаю над проектом, в котором нужно одновременно использовать два последовательных порта на windows, но что бы я ни пытался, я могу открыть только один последовательный порт. Если не повторять открывать и закрывать, я могу управлять двумя портами, но это слишком медленно. Мне нужно написать и прочитать первый порт и формализовать его по протоколу и отправить его на другой порт, но я не могу инициализировать два порта. Я использовал открыть и закрыть два порта, чтобы сделать это раньше, но это было слишком медленно. Кто-нибудь знает, как открыть два порта одновременно; Спасибо !!!

вот мой код здесь:

#include <iostream>
#include <iomanip>
#include "udp.h"
#include "Serial.h"
#include "Formalized.h"
using namespace std;

bool sthread = false;
unsigned char status[6] = {};
HANDLE hMutex = NULL;

DWORD WINAPI ULTRAread(LPVOID lpParamter)
{
    Cserial ultra;
    unsigned char input0[7] = { 0x00,0x01,0x00,0x01,0x01,0xE5,0xAC };
    unsigned char input1[7] = { 0x00,0x02,0x00,0x01,0x01,0xE5,0xE8 };
    unsigned char input2[7] = { 0x00,0x03,0x00,0x01,0x01,0xE4,0x14 };
    unsigned char input3[7] = { 0x00,0x04,0x00,0x01,0x01,0xE5,0x60 };
    unsigned char input4[7] = { 0x00,0x05,0x00,0x01,0x01,0xE4,0x9C };
    unsigned char input5[7] = { 0x00,0x06,0x00,0x01,0x01,0xE4,0xD8 };
    unsigned char* input[6] = { input0,input1,input2,input3,input4,input5 };
    unsigned char pool[8] = {};

    if (!ultra.Initcom("COM10"))     //ultrasonic COM interface
    {
        cout << "Init ultrasonic failure \n";
        getchar();
        sthread = false;        
    }
    else
    {
        sthread = true;
        for (;;)
        {
            WaitForSingleObject(hMutex, INFINITE);
            for (int i = 0; i < 6; i++)
            {
                if (ultra.Write(input[i], 7))
                {
                    ultra.Read(pool, 8);
                }
                switch (pool[5])
                {
                case 0x01:
                    status[i] = 0x01;
                    break;
                case 0x00:
                    status[i] = 0x00;
                    break;
                }
            }
            Sleep(5000);
            ReleaseMutex(hMutex);
        }
    }

}

int main()
{
    HANDLE uThread = CreateThread(NULL, 0, ULTRAread, NULL, 0, NULL);
    hMutex = CreateMutex(NULL, FALSE, "ultrasonics status");
    Cserial zigbee;
    cUDP UWB;

    char buff[300];
    char data[256];

    if (!UWB.Initial(6685))             //latitude and longitude port
    {
        cout << "UWB Port connecting failure \n";
        getchar();
    }
    else
    {
        cout << "UWB Com connecting success \n";
    }
    if (!zigbee.Initcom("COM7"))       //zigbee  access port
    {
        cout << "Zigbee Initial Failure! \n";
        getchar();
    }
    else
    {
        cout << "Zigbee Initial Success! \n";
    }

    for (;;)
    {
        WaitForSingleObject(hMutex, INFINITE);
        switch (sthread)
        {
        case TRUE:  //ultrasonics trustful
            WaitForSingleObject(hMutex, INFINITE);
            cout << "1";
            ReleaseMutex(hMutex);
            break;
        case FALSE:
            cout << "2";
            break;
        }
        Sleep(5000);
    }
    CloseHandle(uThread);
    getchar();
    return 0;
}





#include"Serial.h"

Cserial::Cserial()
{
    hcom = INVALID_HANDLE_VALUE;
}
Cserial::~Cserial()
{

}
bool Cserial::Initcom(LPCSTR Port)
{
    hcom = CreateFile(Port, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING
        , FILE_ATTRIBUTE_NORMAL, 0);
    if (hcom == INVALID_HANDLE_VALUE)
    {

        fprintf(stderr, "fail serial1\n");
        return false;
    }
    SetupComm(hcom, 1024, 1024);
    DCB dcb;
    GetCommState(hcom, &dcb);
    dcb.BaudRate = 9600;
    dcb.ByteSize = 8;
    dcb.Parity = 0;
    dcb.StopBits = 1;
    SetCommState(hcom, &dcb);

    COMMTIMEOUTS CommTimeouts;
    GetCommTimeouts(hcom, &CommTimeouts);
    CommTimeouts.ReadIntervalTimeout = MAXDWORD;
    CommTimeouts.ReadTotalTimeoutMultiplier = 10;
    CommTimeouts.ReadTotalTimeoutConstant = 100;

    CommTimeouts.WriteTotalTimeoutMultiplier = 1;
    CommTimeouts.WriteTotalTimeoutConstant = 10;
    if (!SetCommTimeouts(hcom, &CommTimeouts))
    {
        fprintf(stderr, "fail serial2\n");
        return FALSE;

    }
    return true;
}
void Cserial::Uninitcom()
{
    CloseHandle(hcom);
    hcom = INVALID_HANDLE_VALUE;
}

bool Cserial::Clearcom()
{
    PurgeComm(hcom, PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR | PURGE_TXABORT);
    return TRUE;
}

bool Cserial::Write(unsigned char* buf, int len)
{
    if (hcom == INVALID_HANDLE_VALUE)
    {
        return FALSE;
    }
    DWORD dwWrittenLen = 0;
    if (!WriteFile(hcom, buf, len, &dwWrittenLen, NULL))
    {
        return FALSE;
    }
    else
    {
        return TRUE;
    }
}
bool Cserial::Read(unsigned char* buf, int len)
{
    DWORD dwReadLen = 0;
    if (hcom == INVALID_HANDLE_VALUE)
    {
        return FALSE;
    }
    if (!ReadFile(hcom, buf, len, &dwReadLen, NULL))
    {
        return FALSE;
    }
    else
    {
        return TRUE;
    }
}