C 列出具有特定ID的串行USB设备'；s

您好，我是xCode和Mac OS编程新手，对使用USB和串行设备有点迷茫

实际上，我尝试编写一个max/msp外部程序，列出与特定产品ID、供应商ID和名称匹配的USB设备的串行BSD路径

就我而言，我得到了这个程序，它列出了串行BSD路径：

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <errno.h>
#include <paths.h>
#include <termios.h>
#include <sysexits.h>
#include <sys/param.h>
#include <sys/select.h>
#include <sys/time.h>
#include <time.h>
#include <CoreFoundation/CoreFoundation.h>
#include <IOKit/IOKitLib.h>
#include <IOKit/serial/IOSerialKeys.h>
#include <IOKit/serial/ioss.h>
#include <IOKit/IOBSD.h>


// Function prototypes
static kern_return_t findModems(io_iterator_t *matchingServices);
static kern_return_t getModemPath(io_iterator_t serialPortIterator, char *bsdPath, CFIndex maxPathSize);

// Returns an iterator across all known modems. Caller is responsible for
// releasing the iterator when iteration is complete.
static kern_return_t findModems(io_iterator_t *matchingServices)
{
    kern_return_t           kernResult;
    CFMutableDictionaryRef  classesToMatch;

    // Serial devices are instances of class IOSerialBSDClient.
    // Create a matching dictionary to find those instances.
    classesToMatch = IOServiceMatching(kIOSerialBSDServiceValue);
    if (classesToMatch == NULL) {
        printf("IOServiceMatching returned a NULL dictionary.\n");
    }
    else {
        // Look for devices that claim to be modems.
        CFDictionarySetValue(classesToMatch,
                             CFSTR(kIOSerialBSDTypeKey),
                             CFSTR(kIOSerialBSDAllTypes));
    }

    // Get an iterator across all matching devices.
    kernResult = IOServiceGetMatchingServices(kIOMasterPortDefault, classesToMatch, matchingServices);
    if (KERN_SUCCESS != kernResult) {
        printf("IOServiceGetMatchingServices returned %d\n", kernResult);
        goto exit;
    }

exit:
    return kernResult;
}

static kern_return_t getModemPath(io_iterator_t serialPortIterator, char *bsdPath, CFIndex maxPathSize)
{
    io_object_t     modemService;
    kern_return_t   kernResult = KERN_FAILURE;
    Boolean         modemFound = false;

    // Initialize the returned path
    *bsdPath = '\0';

    // Iterate across all modems found. In this example, we bail after finding the first modem.

    while ((modemService = IOIteratorNext(serialPortIterator))) {
        CFTypeRef   bsdPathAsCFString;

        bsdPathAsCFString = IORegistryEntryCreateCFProperty(modemService,
                                                            CFSTR(kIOCalloutDeviceKey),
                                                            kCFAllocatorDefault,
                                                            0);
        if (bsdPathAsCFString) {
            Boolean result;
            result = CFStringGetCString(bsdPathAsCFString,
                                        bsdPath,
                                        maxPathSize,
                                        kCFStringEncodingUTF8);
            CFRelease(bsdPathAsCFString);

            if (result) {
                printf("Modem found with BSD path: %s", bsdPath);
                modemFound = true;
                kernResult = KERN_SUCCESS;
            }
        }

        printf("\n");

        // Release the io_service_t now that we are done with it.
        (void) IOObjectRelease(modemService);
    }

    return kernResult;
}

int main(int argc, const char * argv[])
{
    kern_return_t   kernResult;
    io_iterator_t   serialPortIterator;
    char            bsdPath[MAXPATHLEN];

    kernResult = findModems(&serialPortIterator);
    if (KERN_SUCCESS != kernResult) {
        printf("No modems were found.\n");
    }

    kernResult = getModemPath(serialPortIterator, bsdPath, sizeof(bsdPath));
    if (KERN_SUCCESS != kernResult) {
        printf("Could not get path for modem.\n");
    }

    IOObjectRelease(serialPortIterator);

    return EX_OK;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
//功能原型
静态内核返回find模型（io迭代器匹配服务）；
静态kern_return_t getModemPath（io_迭代器_t serialPortIterator，char*bsdPath，CFIndex maxPathSize）；
//返回所有已知调制解调器的迭代器。来电者负责
//迭代完成后释放迭代器。
静态内核返回find模型（io迭代器匹配服务）
{
kern_返回kern_t结果；
cfmutableDictionaryRefClasseSToMatch；
//串行设备是IOSerialBSDClient类的实例。
//创建匹配的字典以查找这些实例。
classesToMatch=IOServiceMatch（KIOSerialBSDSServiceValue）；
if（classesToMatch==NULL）{
printf（“IOServiceMatch返回一个空字典。\n”）；
}
否则{
//寻找声称是调制解调器的设备。
CFDictionarySetValue（类匹配，
CFSTR（kIOSerialBSDTypeKey），
CFSTR（kIOSerialBSDAllTypes）；
}
//获取所有匹配设备的迭代器。
kernResult=IOServiceGetMatchingServices（kIOMasterPortDefault、classesToMatch、matchingServices）；
if（KERN_SUCCESS！=kernsult）{
printf（“IOServiceGetMatchingServices返回%d\n”，结果）；
转到出口；
}
出口：
返回结果；
}
静态kern\u return\u t getModemPath（io迭代器\u t serialPortIterator，char*bsdPath，CFIndex maxPathSize）
{
io对象模式服务；
kern_return_t kernResult=kern_失败；
布尔modemFound=false；
//初始化返回的路径
*bsdPath='\0'；
//迭代找到的所有调制解调器。在本例中，我们在找到第一个调制解调器后退出。
while（（modemService=IOIteratorNext（serialPortIterator）））{
CFTypeRef BSDPATHASSCFSTRING；
bsdPathAsCFString=IORegistryEntryCreateCProperty（modemService，
CFSTR（kIOCalloutDeviceKey），
KCO默认值，
0);
if（bsdPathAsCFString）{
布尔结果；
结果=CFStringGetCString（BSDPathasCstring，
bsdPath，
最大路径大小，
kCFStringEncodingUTF8）；
CFRelease（bsdpathasfstring）；
如果（结果）{
printf（“使用BSD路径找到的调制解调器：%s”，bsdPath）；
modemFound=true；
KERN结果=KERN_成功；
}
}
printf（“\n”）；
//现在我们已经完成io_服务，请释放它。
（无效）IOObjectRelease（modemService）；
}
返回结果；
}
int main（int argc，const char*argv[]
{
kern_返回kern_t结果；
io_迭代器\u t串行端口迭代器；
char bsdPath[MAXPATHLEN]；
kernResult=findModels（&serialPortIterator）；
if（KERN_SUCCESS！=kernsult）{
printf（“未找到调制解调器。\n”）；
}
kernResult=getModemPath（串行端口计数器，bsdPath，sizeof（bsdPath））；
if（KERN_SUCCESS！=kernsult）{
printf（“无法获取调制解调器的路径。\n”）；
}
IOObjectRelease（串行端口器）；
返回EX_OK；
}

以及搜索具有特定ID的USB的其他代码：

#include <CoreFoundation/CoreFoundation.h>
#include <IOKit/IOKitLib.h>
#include <IOKit/IOMessage.h>
#include <IOKit/IOCFPlugIn.h>
#include <IOKit/usb/IOUSBLib.h>

// Change these two constants to match your device's idVendor and idProduct.
// Or, just pass your idVendor and idProduct as command line arguments when running this sample.
#define kMyVendorID         0x04D8
#define kMyProductID        0x000A

typedef struct MyPrivateData {
    io_object_t             notification;
    IOUSBDeviceInterface    **deviceInterface;
    CFStringRef             deviceName;
    unsigned int            locationID;
} MyPrivateData;

static IONotificationPortRef    gNotifyPort;
static io_iterator_t            gAddedIter;
static CFRunLoopRef             gRunLoop;

//================================================================================================
//
//  DeviceNotification
//
//  This routine will get called whenever any kIOGeneralInterest notification happens.  We are
//  interested in the kIOMessageServiceIsTerminated message so that's what we look for.  Other
//  messages are defined in IOMessage.h.
//
//================================================================================================
void DeviceNotification(void *refCon, io_service_t service, natural_t messageType, void *messageArgument)
{
    kern_return_t   kr;
    MyPrivateData   *privateDataRef = (MyPrivateData *) refCon;

    if (messageType == kIOMessageServiceIsTerminated) {
        fprintf(stderr, "Device removed.\n");

        // Dump our private data to stderr just to see what it looks like.
        fprintf(stderr, "privateDataRef->deviceName: ");
        CFShow(privateDataRef->deviceName);
        fprintf(stderr, "privateDataRef->locationID: 0x%x.\n\n", privateDataRef->locationID);

        // Free the data we're no longer using now that the device is going away
        CFRelease(privateDataRef->deviceName);

        if (privateDataRef->deviceInterface) {
            kr = (*privateDataRef->deviceInterface)->Release(privateDataRef->deviceInterface);
        }

        kr = IOObjectRelease(privateDataRef->notification);

        free(privateDataRef);
    }
}

//================================================================================================
//
//  DeviceAdded
//
//  This routine is the callback for our IOServiceAddMatchingNotification.  When we get called
//  we will look at all the devices that were added and we will:
//
//  1.  Create some private data to relate to each device (in this case we use the service's name
//      and the location ID of the device
//  2.  Submit an IOServiceAddInterestNotification of type kIOGeneralInterest for this device,
//      using the refCon field to store a pointer to our private data.  When we get called with
//      this interest notification, we can grab the refCon and access our private data.
//
//================================================================================================
void DeviceAdded(void *refCon, io_iterator_t iterator)
{
    kern_return_t       kr;
    io_service_t        usbDevice;
    IOCFPlugInInterface **plugInInterface = NULL;
    SInt32              score;
    HRESULT             res;

    while ((usbDevice = IOIteratorNext(iterator))) {
        io_name_t       deviceName;
        CFStringRef     deviceNameAsCFString;   
        MyPrivateData   *privateDataRef = NULL;
        unsigned int    locationID;

        printf("Device added.\n");

        // Add some app-specific information about this device.
        // Create a buffer to hold the data.
        privateDataRef = malloc(sizeof(MyPrivateData));
        bzero(privateDataRef, sizeof(MyPrivateData));

        // Get the USB device's name.
        kr = IORegistryEntryGetName(usbDevice, deviceName);
        if (KERN_SUCCESS != kr) {
            deviceName[0] = '\0';
        }

        deviceNameAsCFString = CFStringCreateWithCString(kCFAllocatorDefault, deviceName, 
                                                         kCFStringEncodingASCII);

        // Dump our data to stderr just to see what it looks like.
        fprintf(stderr, "deviceName: ");
        CFShow(deviceNameAsCFString);

        // Save the device's name to our private data.        
        privateDataRef->deviceName = deviceNameAsCFString;

        // Now, get the locationID of this device. In order to do this, we need to create an IOUSBDeviceInterface 
        // for our device. This will create the necessary connections between our userland application and the 
        // kernel object for the USB Device.
        kr = IOCreatePlugInInterfaceForService(usbDevice, kIOUSBDeviceUserClientTypeID, kIOCFPlugInInterfaceID,
                                               &plugInInterface, &score);

        if ((kIOReturnSuccess != kr) || !plugInInterface) {
            fprintf(stderr, "IOCreatePlugInInterfaceForService returned 0x%08x.\n", kr);
            continue;
        }

        // Use the plugin interface to retrieve the device interface.
        res = (*plugInInterface)->QueryInterface(plugInInterface, CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID),
                                                 (LPVOID*) &privateDataRef->deviceInterface);

        // Now done with the plugin interface.
        (*plugInInterface)->Release(plugInInterface);

        if (res || privateDataRef->deviceInterface == NULL) {
            fprintf(stderr, "QueryInterface returned %d.\n", (int) res);
            continue;
        }

        // Now that we have the IOUSBDeviceInterface, we can call the routines in IOUSBLib.h.
        // In this case, fetch the locationID. The locationID uniquely identifies the device
        // and will remain the same, even across reboots, so long as the bus topology doesn't change.

        kr = (*privateDataRef->deviceInterface)->GetLocationID(privateDataRef->deviceInterface, &locationID);
        if (KERN_SUCCESS != kr) {
            fprintf(stderr, "GetLocationID returned 0x%08x.\n", kr);
            continue;
        }
        else {
            fprintf(stderr, "Location ID: 0x%x\n\n", locationID);
        }

        privateDataRef->locationID = locationID;

        // Register for an interest notification of this device being removed. Use a reference to our
        // private data as the refCon which will be passed to the notification callback.
        kr = IOServiceAddInterestNotification(gNotifyPort,                      // notifyPort
                                              usbDevice,                        // service
                                              kIOGeneralInterest,               // interestType
                                              DeviceNotification,               // callback
                                              privateDataRef,                   // refCon
                                              &(privateDataRef->notification)   // notification
                                              );

        if (KERN_SUCCESS != kr) {
            printf("IOServiceAddInterestNotification returned 0x%08x.\n", kr);
        }

        // Done with this USB device; release the reference added by IOIteratorNext
        kr = IOObjectRelease(usbDevice);
    }
}

//================================================================================================
//
//  SignalHandler
//
//  This routine will get called when we interrupt the program (usually with a Ctrl-C from the
//  command line).
//
//================================================================================================
void SignalHandler(int sigraised)
{
    fprintf(stderr, "\nInterrupted.\n");

    exit(0);
}

//================================================================================================
//  main
//================================================================================================
int main(int argc, const char *argv[])
{
    CFMutableDictionaryRef  matchingDict;
    CFRunLoopSourceRef      runLoopSource;
    CFNumberRef             numberRef;
    kern_return_t           kr;
    long                    usbVendor = kMyVendorID;
    long                    usbProduct = kMyProductID;
    sig_t                   oldHandler;

    // Set up a signal handler so we can clean up when we're interrupted from the command line
    // Otherwise we stay in our run loop forever.
    oldHandler = signal(SIGINT, SignalHandler);
    if (oldHandler == SIG_ERR) {
        fprintf(stderr, "Could not establish new signal handler.");
    }

    fprintf(stderr, "Looking for devices matching vendor ID=%ld and product ID=%ld.\n", usbVendor, usbProduct);

    // Set up the matching criteria for the devices we're interested in. The matching criteria needs to follow
    // the same rules as kernel drivers: mainly it needs to follow the USB Common Class Specification, pp. 6-7.
    // See also Technical Q&A QA1076 "Tips on USB driver matching on Mac OS X" 
    // <http://developer.apple.com/qa/qa2001/qa1076.html>.
    // One exception is that you can use the matching dictionary "as is", i.e. without adding any matching 
    // criteria to it and it will match every IOUSBDevice in the system. IOServiceAddMatchingNotification will 
    // consume this dictionary reference, so there is no need to release it later on.

    matchingDict = IOServiceMatching(kIOUSBDeviceClassName);    // Interested in instances of class
                                                                // IOUSBDevice and its subclasses
    if (matchingDict == NULL) {
        fprintf(stderr, "IOServiceMatching returned NULL.\n");
        return -1;
    }

    // We are interested in all USB devices (as opposed to USB interfaces).  The Common Class Specification
    // tells us that we need to specify the idVendor, idProduct, and bcdDevice fields, or, if we're not interested
    // in particular bcdDevices, just the idVendor and idProduct.  Note that if we were trying to match an 
    // IOUSBInterface, we would need to set more values in the matching dictionary (e.g. idVendor, idProduct, 
    // bInterfaceNumber and bConfigurationValue.

    // Create a CFNumber for the idVendor and set the value in the dictionary
    numberRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &usbVendor);
    CFDictionarySetValue(matchingDict, 
                         CFSTR(kUSBVendorID), 
                         numberRef);
    CFRelease(numberRef);

    // Create a CFNumber for the idProduct and set the value in the dictionary
    numberRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &usbProduct);
    CFDictionarySetValue(matchingDict, 
                         CFSTR(kUSBProductID), 
                         numberRef);
    CFRelease(numberRef);
    numberRef = NULL;

    // Create a notification port and add its run loop event source to our run loop
    // This is how async notifications get set up.

    gNotifyPort = IONotificationPortCreate(kIOMasterPortDefault);
    runLoopSource = IONotificationPortGetRunLoopSource(gNotifyPort);

    gRunLoop = CFRunLoopGetCurrent();
    CFRunLoopAddSource(gRunLoop, runLoopSource, kCFRunLoopDefaultMode);

    // Now set up a notification to be called when a device is first matched by I/O Kit.
    kr = IOServiceAddMatchingNotification(gNotifyPort,                  // notifyPort
                                          kIOFirstMatchNotification,    // notificationType
                                          matchingDict,                 // matching
                                          DeviceAdded,                  // callback
                                          NULL,                         // refCon
                                          &gAddedIter                   // notification
                                          );        

    // Iterate once to get already-present devices and arm the notification    
    DeviceAdded(NULL, gAddedIter);  

    // Start the run loop. Now we'll receive notifications.
    fprintf(stderr, "Starting run loop.\n\n");
    CFRunLoopRun();

    // We should never get here
    fprintf(stderr, "Unexpectedly back from CFRunLoopRun()!\n");
    return 0;
}

#包括
#包括
#包括
#包括
#包括
//更改这两个常量以匹配设备的idVendor和idProduct。
//或者，运行此示例时，只需将idVendor和idProduct作为命令行参数传递。
#定义kMyVendorID 0x04D8
#定义kMyProductID 0x000A
类型定义结构MyPrivateData{
io_对象通知；
恶意接口**设备接口；
CFStringRef设备名称；
无符号int-locationID；
}MyPrivateData；
静态离子化端口REF gNotifyPort；
静态io迭代器；
静态CFRunLoopRef-gRunLoop；
//================================================================================================
//
//设备化
//
//每当发生任何kIOGeneralInterest通知时，都会调用此例程。我们是
//对KiomeMessageServiceInterminated消息感兴趣，这就是我们要寻找的。其他
//消息在IOMessage.h中定义。
//
//================================================================================================
无效设备化（void*refCon、io_服务\u t服务、自然消息类型、void*messageArgument）
{
kern_return_t kr；
MyPrivateData*privateDataRef=（MyPrivateData*）refCon；
if（messageType==kiomessageserviceceistered）{
fprintf（stderr，“设备已删除”。\n”）；
//将我们的私有数据转储到stderr，看看它是什么样子。
fprintf（标准，“privateDataRef->deviceName:”；
CFShow（privateDataRef->deviceName）；
fprintf（stderr，“privateDataRef->locationID:0x%x.\n\n”，privateDataRef->locationID）；
//释放我们不再使用的数据，因为设备正在消失
CFRelease（privateDataRef->deviceName）；
if（privateDataRef->deviceInterface）{
kr=（*privateDataRef->deviceInterface）->发布（privateDataRef->deviceInterface）；
}
kr=IOObjectRelease（privateDataRef->notification）；
// Variable declaration
int pid, vid;
CFTypeRef cf_vendor, cf_product;    

// Search properties among parents of the current modemService
cf_vendor = IORegistryEntrySearchCFProperty(modemService, kIOServicePlane,
                                            CFSTR("idVendor"),
                                            kCFAllocatorDefault,
                                            kIORegistryIterateRecursively
                                            | kIORegistryIterateParents);

cf_product = IORegistryEntrySearchCFProperty(modemService, kIOServicePlane,
                                             CFSTR("idProduct"),
                                             kCFAllocatorDefault,
                                             kIORegistryIterateRecursively
                                             | kIORegistryIterateParents);

// Decode & print VID & PID
if (cf_vendor && cf_product &&
    CFNumberGetValue(cf_vendor , kCFNumberIntType, &vid) &&
    CFNumberGetValue(cf_product, kCFNumberIntType, &pid)) {
    printf("\nFound matching USB VID: %04X PID: %04X", vid, pid);
}

// Release CFTypeRef
if (cf_vendor)  CFRelease(cf_vendor);
if (cf_product) CFRelease(cf_product);