{"id":388,"date":"2009-05-01T10:23:32","date_gmt":"2009-05-01T10:23:32","guid":{"rendered":"https:\/\/driverentry.com.br\/en\/2009\/05\/01\/enumerating-devices\/"},"modified":"2026-07-30T19:55:22","modified_gmt":"2026-07-30T19:55:22","slug":"enumerating-devices","status":"publish","type":"post","link":"https:\/\/driverentry.com.br\/en\/2009\/05\/01\/enumerating-devices\/","title":{"rendered":"Enumerating devices"},"content":{"rendered":"
\"\"<\/a><\/div>\n

Among my current tasks was reading the samples from a gyroscope using a serial port and generating a file with them. This file would be read by a driver similar to the one demonstrated in the post before this one<\/a>. In the gyroscope’s datasheet<\/a> there is a description of the protocol, not to mention the example made in Visual Basic that exists on the manufacturer’s site<\/a>, which demonstrates the angular acceleration<\/a> on each axis as well as their linear accelerations<\/a> as shown below.<\/p>\n

\"\"<\/div>\n


<\/p>\n

The entire interface for configuring and obtaining the gyroscope’s data is done through the serial port. Even without a dedicated application you can use any program, like HyperTerminal, to access the menus offered by the device. Using a serial port, any microcontroller kit that has no display and not even a keyboard can offer a quite friendly interface.<\/p>\n

Writing serial protocols is not something that scares me. What is hard is having to remember how to program a User-Mode<\/span> application that has windows, buttons and other controls, but nothing that a little MSDN<\/a> does not solve. Driver programmers usually test everything they can using console applications, so I developed a small terminal software to deal directly with the device. Its source follows below and is a bonus for anyone who needs to play with serial ports some day.<\/p>\n

\n
\/****<\/span><\/pre>\n
***     main<\/span><\/pre>\n
**<\/span><\/pre>\n
**      And off we go...<\/span><\/pre>\n
*\/<\/span><\/pre>\n
int<\/span> _tmain(int<\/span> argc, _TCHAR* argv[])<\/pre>\n
{<\/pre>\n
    DWORD           dwBytes,<\/pre>\n
                    dwError = ERROR_SUCCESS;<\/pre>\n
    HANDLE          hCom;<\/pre>\n
    ULONG           i;<\/pre>\n
    UCHAR           ucByteIn[512<\/span>], ucByteOut;<\/pre>\n
    DCB             dcb;<\/pre>\n
    COMMTIMEOUTS    CommTimeouts;<\/pre>\n
 <\/pre>\n
    \/\/-f--> Here we open the desired serial port<\/span><\/pre>\n
    hCom = CreateFile(L\"COM3\"<\/span>,<\/pre>\n
                      GENERIC_READ | GENERIC_WRITE,<\/pre>\n
                      0<\/span>,<\/pre>\n
                      NULL,<\/pre>\n
                      OPEN_EXISTING,<\/pre>\n
                      0<\/span>,<\/pre>\n
                      NULL);<\/pre>\n
 <\/pre>\n
    \/\/-f--> Checks whether we succeeded<\/span><\/pre>\n
    if<\/span> (hCom == INVALID_HANDLE_VALUE) <\/pre>\n
    {<\/pre>\n
        \/\/-f--> Oops!<\/span><\/pre>\n
        dwError = GetLastError();<\/pre>\n
        printf(\"CreateFile failed with error %d.\\n\"<\/span>,<\/pre>\n
                dwError);<\/pre>\n
        return<\/span> dwError;<\/pre>\n
    }<\/pre>\n
 <\/pre>\n
    \/\/-f--> There are 7 kilos of serial port settings.<\/span><\/pre>\n
    \/\/      Instead of configuring each one of them, we will just<\/span><\/pre>\n
    \/\/      get the system default settings and modify<\/span><\/pre>\n
    \/\/      only the ones we care about.<\/span><\/pre>\n
    if<\/span> (!GetCommState(hCom, &dcb))<\/pre>\n
    {<\/pre>\n
        \/\/-f--> Oops!<\/span><\/pre>\n
        dwError = GetLastError();<\/pre>\n
        printf (\"GetCommState failed with error %d.\\n\"<\/span>,<\/pre>\n
                dwError);<\/pre>\n
        CloseHandle(hCom);<\/pre>\n
        return<\/span> dwError;<\/pre>\n
    }<\/pre>\n
 <\/pre>\n
    \/\/-f--> Here we modify the settings to set the<\/span><\/pre>\n
    \/\/      settings required by the gyroscope.<\/span><\/pre>\n
    \/\/      57600, 8 N 1 (no flow control)<\/span><\/pre>\n
    dcb.DCBlength = sizeof<\/span>(DCB);<\/pre>\n
    dcb.BaudRate = CBR_57600;<\/pre>\n
    dcb.ByteSize = 8<\/span>;<\/pre>\n
    dcb.Parity = NOPARITY;<\/pre>\n
    dcb.StopBits = ONESTOPBIT;<\/pre>\n
    dcb.fDtrControl = DTR_CONTROL_DISABLE;<\/pre>\n
    dcb.fRtsControl = RTS_CONTROL_DISABLE;<\/pre>\n
 <\/pre>\n
    \/\/-f--> Here we apply the settings we modified<\/span><\/pre>\n
    if<\/span> (!SetCommState(hCom, &dcb))<\/pre>\n
    {<\/pre>\n
        \/\/-f--> Oops!<\/span><\/pre>\n
        dwError = GetLastError();<\/pre>\n
        printf (\"SetCommState failed with error %d.\\n\"<\/span>,<\/pre>\n
                dwError);<\/pre>\n
        CloseHandle(hCom);<\/pre>\n
        return<\/span> dwError;<\/pre>\n
    }<\/pre>\n
 <\/pre>\n
    \/\/-f--> I am going to configure the timeouts so that a<\/span><\/pre>\n
    \/\/      read is completed after 100ms even if<\/span><\/pre>\n
    \/\/      no character is received by the application.<\/span><\/pre>\n
    \/\/      This prevents the application from getting stuck in ReadFile<\/span><\/pre>\n
    \/\/      until a byte is received by the serial port<\/span><\/pre>\n
    CommTimeouts.ReadIntervalTimeout = 0<\/span>;<\/pre>\n
    CommTimeouts.ReadTotalTimeoutMultiplier = 0<\/span>;<\/pre>\n
    CommTimeouts.ReadTotalTimeoutConstant = 100<\/span>;<\/pre>\n
    CommTimeouts.WriteTotalTimeoutConstant = 0<\/span>;<\/pre>\n
    CommTimeouts.WriteTotalTimeoutMultiplier = 0<\/span>;<\/pre>\n
 <\/pre>\n
    \/\/-f--> Applies the timeout settings<\/span><\/pre>\n
    if<\/span> (!SetCommTimeouts(hCom, &CommTimeouts))<\/pre>\n
    {<\/pre>\n
        \/\/-f--> Oops!<\/span><\/pre>\n
        dwError = GetLastError();<\/pre>\n
        printf (\"SetCommTimeouts failed with error %d.\\n\"<\/span>,<\/pre>\n
                dwError);<\/pre>\n
        CloseHandle(hCom);<\/pre>\n
        return<\/span> dwError;<\/pre>\n
    }<\/pre>\n
 <\/pre>\n
    \/\/-f--> Here begins the infinite loop that will run<\/span><\/pre>\n
    \/\/      forever and ever until the end of days.<\/span><\/pre>\n
    \/\/      Actually, if you press [ESC] it ends.<\/span><\/pre>\n
    while<\/span>(1<\/span>)<\/pre>\n
    {<\/pre>\n
        \/\/-f--> Checks whether there is a byte to be received by the<\/span><\/pre>\n
        \/\/      application in the keyboard buffer.<\/span><\/pre>\n
        if<\/span> (_kbhit())<\/pre>\n
        {<\/pre>\n
            \/\/-f--> Gets the key<\/span><\/pre>\n
            ucByteOut = _getch();<\/pre>\n
 <\/pre>\n
            \/\/-f--> Checks whether the received key is [ESC]<\/span><\/pre>\n
            if<\/span> (ucByteOut == 27<\/span>)<\/pre>\n
                break<\/span>;<\/pre>\n
 <\/pre>\n
            \/\/-f--> Sends the received byte to the serial port<\/span><\/pre>\n
            if<\/span> (!WriteFile(hCom,<\/pre>\n
                           &ucByteOut,<\/pre>\n
                           1<\/span>,<\/pre>\n
                           &dwBytes,<\/pre>\n
                           NULL))<\/pre>\n
            {<\/pre>\n
                \/\/--> Oops!<\/span><\/pre>\n
                dwError = GetLastError();<\/pre>\n
                break<\/span>;<\/pre>\n
            }<\/pre>\n
        }<\/pre>\n
 <\/pre>\n
        \/\/-f--> Checks whether any byte was received by the<\/span><\/pre>\n
        \/\/      serial port. Note that in this loop there is no<\/span><\/pre>\n
        \/\/      typical Sleep() to keep from driving the CPU<\/span><\/pre>\n
        \/\/      to 100%. This wait is performed inside the<\/span><\/pre>\n
        \/\/      call to ReadFile(). The function waits for a<\/span><\/pre>\n
        \/\/      byte for up to 100ms, as configured in the<\/span><\/pre>\n
        \/\/      timeouts.<\/span><\/pre>\n
        if<\/span> (!ReadFile(hCom,<\/pre>\n
                      ucByteIn,<\/pre>\n
                      sizeof<\/span>(ucByteIn),<\/pre>\n
                      &dwBytes,<\/pre>\n
                      NULL))<\/pre>\n
        {<\/pre>\n
            \/\/-f--> Oops!<\/span><\/pre>\n
            dwError = GetLastError();<\/pre>\n
            break<\/span>;<\/pre>\n
        }<\/pre>\n
 <\/pre>\n
        \/\/-f--> Prints the received character sequence on the screen<\/span><\/pre>\n
        for<\/span> (i=0<\/span>; i<dwBytes; i++)<\/pre>\n
        {<\/pre>\n
            if<\/span> (ucByteIn[i] == 0x0d<\/span>)<\/pre>\n
                puts(\"\"<\/span>);<\/pre>\n
            else<\/span><\/pre>\n
                printf(\"%c\"<\/span>, ucByteIn[i]);<\/pre>\n
        }<\/pre>\n
    }<\/pre>\n
 <\/pre>\n
    \/\/-f--> Well, if we got to this point it is because we reached<\/span><\/pre>\n
    \/\/      the end of days or the ESC key was pressed.<\/span><\/pre>\n
    \/\/      Let us close the serial port and run away.<\/span><\/pre>\n
    CloseHandle(hCom);<\/pre>\n
    return<\/span> dwError;<\/pre>\n
}<\/pre>\n<\/div>\n
Opening a serial port is the simplest part of this story; the problem is deciding which port to open. Like any decent program, there should be a combo list with the serial ports available on the computer, where the user would choose one and that is it. From there it is just a matter of getting the port selected by the user and building a call to the CreateFile()<\/a> routine as illustrated in the code above.<\/p>\n
All right, I dragged the control onto the window I was programming and now I just have to fill it in. So I thought: “There must be some function like EnumerateCommPorts() in the API”<\/span>, but that is not what the reference page<\/a> showed me. – What do you mean there is not one? Google<\/a> must know something about it. – I ended up finding out that this is a pretty common question out there. Some solve this problem by making a loop that tries to open the serial ports in sequence (COM1, COM2,… ), others use the QueryDosDevice()<\/a> function and filter the Symbolic Links<\/span> that start with “COM(n)”, but the method I am going to show here is capable of enumerating any type of interface using the SetupAPI<\/a>.<\/p>\n
Setup who?<\/h3>\n
The SetupAPI is a part of Plug-And-Play<\/span> that provides services to User-Mode<\/span> applications. One of the objectives of Plug-And-Play<\/span> is to unify the configuration, use and enumeration of similar devices and services. This way all manufacturers of boards that offer serial port services can have their devices configured in a single way. Devices that offer serial port services must implement a predefined interface, that is, they must show themselves willing to receive IOCTLs<\/span> and respond to them in a manner foreseen in the documentation<\/a>.<\/p>\n
The driver that wants to create devices that implement the serial port interface must declare this through the call to the IoRegisterDeviceInterface()<\/a> routine. Here a device is associated with a device interface class, which is identified by a GUID<\/span>. There are several predefined device interface classes in the system, as listed here<\/a>, and the serial ports class<\/a> is one of them. From there, your device will be enumerated by Plug-and-Play<\/span> routines as a provider of a given interface.<\/p>\n
All right then. What we have to do is use these interface enumeration functions to find out which devices implement the serial port interface. The SetupAPI<\/span> is going to help us with that task. But before we take a look at the source, let us settle one little thing. I have seen different ways of using GUID_DEVINTERFACE_COMPORT<\/span>, some include the Kernel-Mode<\/span> header Ntddser.h<\/span>, others define the GUID<\/span> by hand, but what would be the correct way?<\/p>\n
Defining the interface GUID<\/h3>\n
It all starts with the call to the SetupDiGetClassDevs()<\/a> routine that will gather information about the group of devices that match the search criteria adopted in the parameters. We are going to want devices that implement the interface identified by GUID_DEVINTERFACE_COMPORT, but if we simply make the call as shown below…<\/p>\n
\n
hDevInfoSet = SetupDiGetClassDevs(&GUID_DEVINTERFACE_COMPORT,<\/pre>\n
                                  NULL,<\/pre>\n
                                  NULL,<\/pre>\n
                                  DIGCF_PRESENT | DIGCF_INTERFACEDEVICE);<\/pre>\n<\/div>\n
…we will get the error shown next.<\/p>\n
\n
1>z:\\sources\\samples\\enumserialport.obj : error LNK2001: unresolved external<\/pre>\n
 symbol _GUID_DEVINTERFACE_COMPORT<\/pre>\n<\/div>\n
This happens because GUID_DEVINTERFACE_COMPORT is declared in WinIoCtl.h<\/span>. Remember that this header is indirectly included by Windows.h<\/span> when the WIN32_LEAN_AND_MEAN symbol is not defined, as I already commented on in this other post<\/a>. But even including this header we still have the same problem. Let us look at this a little more closely.<\/p>\n
In the WinIoCtl.h<\/span> header we have:<\/p>\n
\n
DEFINE_GUID(GUID_DEVINTERFACE_COMPORT, 0x86e0d1e0L<\/span>, 0x8089<\/span>, 0x11d0<\/span>,<\/pre>\n
            0x9c<\/span>, 0xe4<\/span>, 0x08<\/span>, 0x00<\/span>, 0x3e<\/span>, 0x30<\/span>, 0x1f<\/span>, 0x73<\/span>);<\/pre>\n<\/div>\n
But what is DEFINE_GUID anyway?<\/p>\n
In GuidDef.h we have:<\/p>\n
\n
#ifdef<\/span> INITGUID<\/pre>\n
#define<\/span> DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \\<\/pre>\n
        EXTERN_C const<\/span> GUID DECLSPEC_SELECTANY name \\<\/pre>\n
                = { l, w1, w2, { b1, b2,  b3,  b4,  b5,  b6,  b7,  b8 } }<\/pre>\n
#else<\/span><\/pre>\n
#define<\/span> DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \\<\/pre>\n
    EXTERN_C const<\/span> GUID FAR name<\/pre>\n
#endif<\/span> \/\/ INITGUID<\/span><\/pre>\n<\/div>\n
So now comes the resounding “Aaaah, right!”. GUID_DEVINTERFACE_COMPORT is a constant that is defined when the INITGUID symbol is defined; otherwise, this constant is only declared. The INITGUID symbol is defined in the InitGuid.h<\/span> header. So, when you want to use the GUIDs declared with DEFINE_GUID, you will have to, in one of your modules, include the Initguid.h<\/span> header before Windows.h<\/span>. Since our example has only one module, it is easy. As usual, all the source code is contained in an example available for download.<\/p>\n
\n
\/\/-f--> We will have to put these includes in the right order<\/span><\/pre>\n
\/\/      so that the GUID that identifies the<\/span><\/pre>\n
\/\/      GUID_DEVINTERFACE_COMPORT interface gets defined.<\/span><\/pre>\n
#include<\/span> <InitGuid.h><\/span><\/pre>\n
#include<\/span> <Windows.h><\/span><\/pre>\n
#include<\/span> <SetupApi.h><\/span><\/pre>\n<\/div>\n
Enumerating interfaces<\/h3>\n
\n
\/****<\/span><\/pre>\n
***     EnumSerialInterfaces<\/span><\/pre>\n
**<\/span><\/pre>\n
**      Routine that enumerates devices that<\/span><\/pre>\n
**      implement the serial port interface<\/span><\/pre>\n
*\/<\/span><\/pre>\n
 <\/pre>\n
DWORD EnumSerialInterfaces(void<\/span>)<\/pre>\n
{<\/pre>\n
    CHAR                        szFriendlyName[100<\/span>];<\/pre>\n
    HDEVINFO                    hDevInfoSet = NULL;<\/pre>\n
    SP_DEVICE_INTERFACE_DATA    DevInterfaceData;<\/pre>\n
    SP_DEVINFO_DATA             DevInfoData;<\/pre>\n
    DWORD                       dwReturn,<\/pre>\n
                                dwInterfaceIndex = 0<\/span>;<\/pre>\n
    try<\/span><\/pre>\n
    {<\/pre>\n
        \/\/-f--> Gathering information about devices that implement<\/span><\/pre>\n
        \/\/      the desired interface that are present at the<\/span><\/pre>\n
        \/\/      moment this routine is called.<\/span><\/pre>\n
        hDevInfoSet = SetupDiGetClassDevs(&GUID_DEVINTERFACE_COMPORT,<\/pre>\n
                                          NULL,<\/pre>\n
                                          NULL,<\/pre>\n
                                          DIGCF_PRESENT | DIGCF_INTERFACEDEVICE);<\/pre>\n
 <\/pre>\n
        if<\/span> (hDevInfoSet == INVALID_HANDLE_VALUE)<\/pre>\n
            throw<\/span> GetLastError();<\/pre>\n
 <\/pre>\n
        DevInterfaceData.cbSize = sizeof<\/span>(SP_DEVICE_INTERFACE_DATA);<\/pre>\n
 <\/pre>\n
        \/\/-f--> Now enumerates each of the interfaces<\/span><\/pre>\n
        while<\/span> (SetupDiEnumDeviceInterfaces(hDevInfoSet,<\/pre>\n
                                           0<\/span>,<\/pre>\n
                                           &GUID_DEVINTERFACE_COMPORT,<\/pre>\n
                                           dwInterfaceIndex++,<\/pre>\n
                                           &DevInterfaceData))<\/pre>\n
        {<\/pre>\n
            DevInfoData.cbSize = sizeof<\/span>(SP_DEVINFO_DATA);<\/pre>\n
 <\/pre>\n
            \/\/-f--> For each of the interfaces, we get the<\/span><\/pre>\n
            \/\/      device that implements it.<\/span><\/pre>\n
            if<\/span> (SetupDiGetDeviceInterfaceDetail(hDevInfoSet,<\/pre>\n
                                                &DevInterfaceData,<\/pre>\n
                                                NULL,<\/pre>\n
                                                0<\/span>,<\/pre>\n
                                                NULL,<\/pre>\n
                                                &DevInfoData))<\/pre>\n
                throw<\/span> GetLastError();<\/pre>\n
 <\/pre>\n
            \/\/-f--> Now we just get the friendly name of the device<\/span><\/pre>\n
            if<\/span> (!SetupDiGetDeviceRegistryProperty(hDevInfoSet,<\/pre>\n
                                                  &DevInfoData,<\/pre>\n
                                                  SPDRP_FRIENDLYNAME,<\/pre>\n
                                                  NULL,<\/pre>\n
                                                  (PBYTE)szFriendlyName,<\/pre>\n
                                                  sizeof<\/span>(szFriendlyName),<\/pre>\n
                                                  NULL))<\/pre>\n
                throw<\/span> GetLastError();<\/pre>\n
 <\/pre>\n
            \/\/-f--> Printf them...<\/span><\/pre>\n
            printf(\"%d) %s\\n\"<\/span>,<\/pre>\n
                   dwInterfaceIndex,<\/pre>\n
                   szFriendlyName);<\/pre>\n
        }<\/pre>\n
    }<\/pre>\n
    catch<\/span>(DWORD dwError)<\/pre>\n
    {<\/pre>\n
        \/\/-f--> Oops!<\/span><\/pre>\n
 <\/pre>\n
        printf(\"Error %d on trying enumerate device interfaces.\\n\"<\/span>,<\/pre>\n
               dwError);<\/pre>\n
 <\/pre>\n
        dwReturn = dwError;<\/pre>\n
    }<\/pre>\n
 <\/pre>\n
    \/\/-f--> Frees the obtained information<\/span><\/pre>\n
    if<\/span> (hDevInfoSet)<\/pre>\n
        SetupDiDestroyDeviceInfoList(hDevInfoSet);<\/pre>\n
 <\/pre>\n
    return<\/span> dwReturn;<\/pre>\n
}<\/pre>\n<\/div>\n
With this implementation, we will have the following output.<\/p>\n
\"\"<\/div>\n

<\/p>\n
Cool, but that was not quite it…<\/h3>\n
Very well. The ports were enumerated, but how would I pass a string like that to the CreateFile()<\/a> function? Will I have to keep interpreting that string to get the “COM1” part that is between parentheses?<\/p>\n
Actually there are ways for you to obtain the Symbolic Link<\/span> of the devices also using SetupAPI<\/span> functions, but I imagine that what you wanted is the same as what I want. To fill a Combo Box<\/span> with the simple name of the serial ports, like any normal program.<\/p>\n
The port name, which is the “COMx” string we are looking for, is written as a registry value in the device’s key. Every serial port driver has to have this value as shown on this page<\/a>. To obtain the registry key regarding the device, we will use another SetupAPI<\/span> routine. The source below will enumerate the serial ports the way we want.<\/p>\n
\n
\/****<\/span><\/pre>\n
***     EnumSerialPorts<\/span><\/pre>\n
**<\/span><\/pre>\n
**      Routine that enumerates devices that<\/span><\/pre>\n
**      implement the serial port interface and<\/span><\/pre>\n
**      prints a name that is not friendly but that<\/span><\/pre>\n
**      still serves some purpose.<\/span><\/pre>\n
*\/<\/span><\/pre>\n
 <\/pre>\n
DWORD EnumSerialPorts(void<\/span>)<\/pre>\n
{<\/pre>\n
    CHAR                        szPortName[10<\/span>];<\/pre>\n
    HDEVINFO                    hDevInfoSet = NULL;<\/pre>\n
    SP_DEVICE_INTERFACE_DATA    DevInterfaceData;<\/pre>\n
    SP_DEVINFO_DATA             DevInfoData;<\/pre>\n
    DWORD                       dwReturn,<\/pre>\n
                                dwSize,<\/pre>\n
                                dwInterfaceIndex = 0<\/span>;<\/pre>\n
    HKEY                        hKey;<\/pre>\n
 <\/pre>\n
    try<\/span><\/pre>\n
    {<\/pre>\n
        \/\/-f--> Gathering information about devices that implement<\/span><\/pre>\n
        \/\/      the desired interface that are present at the<\/span><\/pre>\n
        \/\/      moment this routine is called.<\/span><\/pre>\n
 <\/pre>\n
        hDevInfoSet = SetupDiGetClassDevs(&GUID_DEVINTERFACE_COMPORT,<\/pre>\n
                                          NULL,<\/pre>\n
                                          NULL,<\/pre>\n
                                          DIGCF_PRESENT | DIGCF_INTERFACEDEVICE);<\/pre>\n
 <\/pre>\n
        if<\/span> (hDevInfoSet == INVALID_HANDLE_VALUE)<\/pre>\n
            throw<\/span> GetLastError();<\/pre>\n
 <\/pre>\n
        DevInterfaceData.cbSize = sizeof<\/span>(SP_DEVICE_INTERFACE_DATA);<\/pre>\n
 <\/pre>\n
        \/\/-f--> Now enumerates each of the interfaces<\/span><\/pre>\n
        while<\/span> (SetupDiEnumDeviceInterfaces(hDevInfoSet,<\/pre>\n
                                           0<\/span>,<\/pre>\n
                                           &GUID_DEVINTERFACE_COMPORT,<\/pre>\n
                                           dwInterfaceIndex++,<\/pre>\n
                                           &DevInterfaceData))<\/pre>\n
        {<\/pre>\n
            DevInfoData.cbSize = sizeof<\/span>(SP_DEVINFO_DATA);<\/pre>\n
 <\/pre>\n
            \/\/-f--> For each of the interfaces, we get the<\/span><\/pre>\n
            \/\/      device that implements it.<\/span><\/pre>\n
            if<\/span> (SetupDiGetDeviceInterfaceDetail(hDevInfoSet,<\/pre>\n
                                                &DevInterfaceData,<\/pre>\n
                                                NULL,<\/pre>\n
                                                0<\/span>,<\/pre>\n
                                                NULL,<\/pre>\n
                                                &DevInfoData))<\/pre>\n
                throw<\/span> GetLastError();<\/pre>\n
 <\/pre>\n
            \/\/-f--> Here we get the registry key of the<\/span><\/pre>\n
            \/\/      device that implements the interface.<\/span><\/pre>\n
            hKey = SetupDiOpenDevRegKey(hDevInfoSet,<\/pre>\n
                                        &DevInfoData,<\/pre>\n
                                        DICS_FLAG_GLOBAL,<\/pre>\n
                                        0<\/span>,<\/pre>\n
                                        DIREG_DEV,<\/pre>\n
                                        KEY_QUERY_VALUE);<\/pre>\n
 <\/pre>\n
            if<\/span> (hKey == INVALID_HANDLE_VALUE)<\/pre>\n
                throw<\/span> GetLastError();<\/pre>\n
 <\/pre>\n
            \/\/-f--> Here we get the PortName value from the Registry<\/span><\/pre>\n
            dwSize = sizeof<\/span>(szPortName);<\/pre>\n
            dwReturn = RegQueryValueEx(hKey,<\/pre>\n
                                       \"PortName\"<\/span>,<\/pre>\n
                                       NULL,<\/pre>\n
                                       NULL,<\/pre>\n
                                       (LPBYTE)szPortName,<\/pre>\n
                                       &dwSize);<\/pre>\n
            RegCloseKey(hKey);<\/pre>\n
 <\/pre>\n
            if<\/span> (dwReturn != ERROR_SUCCESS)<\/pre>\n
                throw<\/span> dwReturn;<\/pre>\n
 <\/pre>\n
            \/\/-f--> Printf them...<\/span><\/pre>\n
            printf(\"%d) %s\\n\"<\/span>,<\/pre>\n
                   dwInterfaceIndex,<\/pre>\n
                   szPortName);<\/pre>\n
        }<\/pre>\n
    }<\/pre>\n
    catch<\/span>(DWORD dwError)<\/pre>\n
    {<\/pre>\n
        \/\/-f--> Oops!<\/span><\/pre>\n
        printf(\"Error %d on trying enumerate device interfaces.\\n\"<\/span>,<\/pre>\n
               dwError);<\/pre>\n
 <\/pre>\n
        dwReturn = dwError;<\/pre>\n
    }<\/pre>\n
 <\/pre>\n
    \/\/-f--> Frees the obtained information<\/span><\/pre>\n
    if<\/span> (hDevInfoSet)<\/pre>\n
        SetupDiDestroyDeviceInfoList(hDevInfoSet);<\/pre>\n
 <\/pre>\n
    return<\/span> dwReturn;<\/pre>\n
}<\/pre>\n<\/div>\n
Now yes…<\/p>\n
\"\"<\/div>\n

<\/p>\n
Putting this in a combo box is already a subject for another blog. For a driver developer, the window below is not so bad after all.<\/p>\n
\"\"<\/div>\n

<\/p>\n
See you! \ud83d\ude09<\/p>\n
EnumSerialPort.zip<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
Among my current tasks was reading the samples from a gyroscope using a serial port and generating a file with them. This file would be read by a driver similar to the one demonstrated in the post before this one. In the gyroscope’s datasheet there is a description of the protocol, not to mention the […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"pagelayer_contact_templates":[],"_pagelayer_content":"","footnotes":""},"categories":[1],"tags":[],"class_list":["post-388","post","type-post","status-publish","format-standard","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/driverentry.com.br\/en\/wp-json\/wp\/v2\/posts\/388","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/driverentry.com.br\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/driverentry.com.br\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/driverentry.com.br\/en\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/driverentry.com.br\/en\/wp-json\/wp\/v2\/comments?post=388"}],"version-history":[{"count":2,"href":"https:\/\/driverentry.com.br\/en\/wp-json\/wp\/v2\/posts\/388\/revisions"}],"predecessor-version":[{"id":390,"href":"https:\/\/driverentry.com.br\/en\/wp-json\/wp\/v2\/posts\/388\/revisions\/390"}],"wp:attachment":[{"href":"https:\/\/driverentry.com.br\/en\/wp-json\/wp\/v2\/media?parent=388"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/driverentry.com.br\/en\/wp-json\/wp\/v2\/categories?post=388"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/driverentry.com.br\/en\/wp-json\/wp\/v2\/tags?post=388"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}