libusbsio 2.1.13__tar.gz → 2.2.0__tar.gz

libusbsio-2.2.0/LICENSE.txt

@@ -0,0 +1,2 @@
+The libusbsio Python package and related binaries is released under BSD-3-Clause License.
+See the 'license' folder for related license files and SBOM-libusbsio.spdx.json.

libusbsio-2.2.0/MANIFEST.in

@@ -0,0 +1,8 @@
+recursive-include libusbsio/bin *
+ 
+include license/SBOM-libusbsio.spdx.json
+include license/BSD-3-clause.txt
+include license/LICENSE-hidapi-bsd.txt
+
+global-exclude *.py[cod]
+prune __pycache__

{libusbsio-2.1.13/libusbsio.egg-info → libusbsio-2.2.0}/PKG-INFO

@@ -1,28 +1,26 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: libusbsio
-Version: 2.1.13
+Version: 2.2.0
 Summary: Python wrapper around NXP LIBUSBSIO library
-Author: Michal Hanak
-Author-email: michal.hanak@nxp.com
-License: BSD-3-Clause
-Project-URL: NXP LIBUSBSIO Home, https://www.nxp.com/design/software/development-software/library-for-windows-macos-and-ubuntu-linux:LIBUSBSIO
-Project-URL: MCULink Pro, https://www.nxp.com/design/microcontrollers-developer-resources/mcu-link-pro-debug-probe:MCU-LINK-PRO
-Project-URL: LPCLink2, https://www.nxp.com/design/microcontrollers-developer-resources/lpc-microcontroller-utilities/lpc-link2:OM13054
+Author-email: Michal Hanak <michal.hanak@nxp.com>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://www.nxp.com/libusbsio
+Project-URL: NXP LIBUSBSIO Home, https://www.nxp.com/libusbsio
+Project-URL: MCU-Link Pro, https://www.nxp.com/mculink
+Project-URL: LPCLink2, https://www.nxp.com/lpclink2
 Keywords: LIBUSBSIO,USBSIO,SPI,I2C,GPIO
-Platform: Windows
-Platform: Linux
-Platform: Mac OSX
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: MacOS :: MacOS X
-Classifier: License :: OSI Approved :: BSD License
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development :: Embedded Systems
 Classifier: Topic :: System :: Hardware
 Classifier: Topic :: Utilities
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: license-file
 
 # Python wrapper for NXP libusbsio binary library
 
@@ -55,7 +53,7 @@ python -m pip install libusbsio
 Use the following `pip` command to install the libusbsio module from
 the local NXP LIBUSBSIO installation package available at www.nxp.com:
 ```
-python -m pip install dist/libusbsio-2.1.13-py3-none-any.whl
+python -m pip install dist/libusbsio-2.2.0-py3-none-any.whl
 ```
 
 ## Running example code
@@ -120,6 +118,10 @@ test\test_30_gpio.py ......s.
 ```
 
 ## History
+### v2.2.0 - October 2025
+- Add OpenBySerial and OpenByPath more robust calls, immune to index reordering upon re-enumeration.
+- Enumerated devices list remains valid after device close; GetNumPorts re-enumeration is no longer needed
+- Multiple LIBUSBSIO objects may be open and used simultaneously, one for each connected device.
 ### v2.1.13 - October 2024
 - Fix HID_API Windows enumeration to avoid accidental duplicate device enumeration.
 ### v2.1.12 - January 2023
@@ -141,4 +143,4 @@ test\test_30_gpio.py ......s.
 - The initial Python libusbsio library wrapper release supporting USBSIO library v2.1
 
 ____
-Copyright NXP 2021-2024
+Copyright NXP 2021-2025

{libusbsio-2.1.13 → libusbsio-2.2.0}/README.md

@@ -29,7 +29,7 @@ python -m pip install libusbsio
 Use the following `pip` command to install the libusbsio module from
 the local NXP LIBUSBSIO installation package available at www.nxp.com:
 ```
-python -m pip install dist/libusbsio-2.1.13-py3-none-any.whl
+python -m pip install dist/libusbsio-2.2.0-py3-none-any.whl
 ```
 
 ## Running example code
@@ -94,6 +94,10 @@ test\test_30_gpio.py ......s.
 ```
 
 ## History
+### v2.2.0 - October 2025
+- Add OpenBySerial and OpenByPath more robust calls, immune to index reordering upon re-enumeration.
+- Enumerated devices list remains valid after device close; GetNumPorts re-enumeration is no longer needed
+- Multiple LIBUSBSIO objects may be open and used simultaneously, one for each connected device.
 ### v2.1.13 - October 2024
 - Fix HID_API Windows enumeration to avoid accidental duplicate device enumeration.
 ### v2.1.12 - January 2023
@@ -115,4 +119,4 @@ test\test_30_gpio.py ......s.
 - The initial Python libusbsio library wrapper release supporting USBSIO library v2.1
 
 ____
-Copyright NXP 2021-2024
+Copyright NXP 2021-2025

{libusbsio-2.1.13 → libusbsio-2.2.0}/examples/hid.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 #
-# Copyright 2021 NXP
+# Copyright 2021,2025 NXP
 # SPDX-License-Identifier: BSD-3-Clause
 #
 # NXP USBSIO Library - HID devices enumeration example

{libusbsio-2.1.13 → libusbsio-2.2.0}/examples/i2c.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 #
-# Copyright 2021 NXP
+# Copyright 2021, 2025 NXP
 # SPDX-License-Identifier: BSD-3-Clause
 #
 # NXP USBSIO Library - I2C example code

{libusbsio-2.1.13 → libusbsio-2.2.0}/examples/ports.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 #
-# Copyright 2021-2022 NXP
+# Copyright 2021-2022,2025 NXP
 # SPDX-License-Identifier: BSD-3-Clause
 #
 # NXP USBSIO Library - I2C example code
@@ -21,10 +21,10 @@ from libusbsio import *
 logging.basicConfig()
 
 # example on how to load DLL from a specific directory
-#sio = LIBUSBSIO(r"..\..\bin_debug\x64", loglevel=logging.DEBUG)
+#sio = usbsio(r"..\..\bin_debug\x64", loglevel=logging.DEBUG)
 
 # load DLL from default directory
-sio = LIBUSBSIO()
+sio = usbsio()
 
 ############################################################################
 ############################################################################
@@ -34,6 +34,8 @@ sio = LIBUSBSIO()
 numports = sio.GetNumPorts()
 print("SIO ports = %d" % numports)
 
+all_devices=[]
+
 if not numports:
     print("No USBSIO device found")
 
@@ -46,11 +48,28 @@ for i in range(0, numports):
             print(f"    HID product: {info.manufacturer_string} {info.product_string}")
             print(f"    HID serial: {info.serial_number}")
             print(f"    HID path: {info.path}")
+            all_devices.insert(0, (i, info.serial_number, info.path) )
         print("    LIB version = '%s'" % sio.GetVersion())
         print("    I2C ports = %d" % sio.GetNumI2CPorts())
         print("    SPI ports = %d" % sio.GetNumSPIPorts())
         print("    Max data size = %d" % sio.GetMaxDataSize())
         sio.Close()
-        # re-enumerate after closing port
-        sio.GetNumPorts()
+
+print("\nTest re-open all devices using serial numbers:")
+for d in all_devices:
+    print(f"Opening serial_number {d[1]} (was device #{d[0]})")
+    if sio.OpenBySerial(d[1]):
+        print(f"  ...success: {sio.GetVersion()}")
+        sio.Close()
+    else:
+        print(f"  ...failed")
+
+print("\nTest re-open all devices using USB HID paths:")
+for d in all_devices:
+    print(f"Opening path {d[2]} (was device #{d[0]})")
+    if sio.OpenByPath(d[2]):
+        print(f"  ...success: {sio.GetVersion()}")
+        sio.Close()
+    else:
+        print(f"  ...failed")
 

{libusbsio-2.1.13 → libusbsio-2.2.0}/libusbsio/__init__.py

@@ -1,18 +1,18 @@
 #!/usr/bin/env python3
 #
-# Copyright 2021-2024 NXP
+# Copyright 2021-2025 NXP
 # SPDX-License-Identifier: BSD-3-Clause
 #
 # NXP USBSIO Library to control SPI, I2C and GPIO bus over USB
 #
-__version__ = '2.1.13'
+__version__ = '2.2.0'
 __title__ = 'usblibsio'
 __author__ = 'NXP Semiconductors'
-__copyright__ = 'Copyright NXP 2021-2024'
+__copyright__ = 'Copyright NXP 2021-2025'
 __license__ = 'BSD-3-Clause'
 __url__ = 'https://www.nxp.com/design/software/development-software/library-for-windows-macos-and-ubuntu-linux:LIBUSBSIO'
 __description__ = 'Python interface for the NXP USBSIO Library version %s' % __version__
-__long_description__ = '''LIBUSBSIO: The NXP USBSIO Library version %s 
+__long_description__ = '''LIBUSBSIO: The NXP USBSIO Library version %s.
 This module implements a Python wrapper around the NXP USBSIO Library enabling to access SPI or
 I2C bus and GPIO ports over a USB interface of the NXP LPC-link2 and MCU-Link devices.
 ''' % __version__

{libusbsio-2.1.13/license → libusbsio-2.2.0/libusbsio/bin}/BSD-3-clause.txt

@@ -1,4 +1,4 @@
-Copyright 2021 NXP
+Copyright 2021-2025 NXP
 
 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
 

libusbsio-2.2.0/libusbsio/bin/SBOM-libusbsio.spdx.json

@@ -0,0 +1,95 @@
+{
+  "SPDXID": "SPDXRef-DOCUMENT",
+  "spdxVersion": "SPDX-2.3",
+  "creationInfo": {
+    "created": "2025-10-31T10:12:29Z",
+    "creators": [
+      "Organization: NXP"
+    ],
+    "licenseListVersion": "3.20"
+  },
+  "name": "libusbsio-2.2.0",
+  "dataLicense": "CC0-1.0",
+  "documentNamespace": "https://nxp.com/spdx/79c03a43-7a2b-4947-b1c4-8d87e24adb43",
+  "packages": [
+    {
+      "SPDXID": "SPDXRef-package-16ddf628-ffe8-4a50-a37f-4ac21026fc7b",
+      "name": "hidapi",
+      "versionInfo": "0.11.2",
+      "licenseConcluded": "BSD-3-Clause",
+      "licenseDeclared": "(BSD-3-Clause OR GPL-3.0-or-later)",
+      "homepage": "http://www.signal11.us/oss/hidapi/",
+      "downloadLocation": "https://pypi.org/project/hidapi/0.11.2",
+      "originator": "Organization: pypi",
+      "supplier": "NOASSERTION",
+      "externalRefs": [
+        {
+          "referenceCategory": "PACKAGE-MANAGER",
+          "referenceLocator": "pkg:pypi/hidapi@0.11.2",
+          "referenceType": "purl"
+        },
+        {
+          "referenceCategory": "OTHER",
+          "referenceLocator": "c8918c0e-682f-457a-9eaa-4e38a17a5c10",
+          "referenceType": "BlackDuck-ComponentOrigin"
+        }
+      ],
+      "filesAnalyzed": false,
+      "licenseComments": "Multiple license: license chosen BSD-3-Clause"
+    },
+    {
+      "SPDXID": "SPDXRef-package-79c03a43-7a2b-4947-b1c4-8d87e24adb43",
+      "name": "libusbsio",
+      "versionInfo": "2.2.0",
+      "licenseConcluded": "(BSD-3-Clause)",
+      "licenseDeclared": "(BSD-3-Clause)",
+      "downloadLocation": "https://pypi.org/project/libusbsio/ https://www.nxp.com/design/design-center/software/development-software/libusbsio-host-library-for-usb-enabled-mcus:LIBUSBSIO",
+      "originator": "Organization: NXP",
+      "supplier": "NOASSERTION",
+      "externalRefs": [],
+      "filesAnalyzed": false
+    },
+    {
+      "SPDXID": "SPDXRef-package-8c673b9b-215e-40f5-bf01-40c6bfc02b03",
+      "name": "libhidapi-hidraw0",
+      "versionInfo": "0.11.2",
+      "licenseConcluded": "BSD-3-Clause",
+      "licenseDeclared": "(BSD-3-Clause OR GPL-3.0-or-later)",
+      "homepage": "http://www.signal11.us/oss/hidapi/",
+      "downloadLocation": "http://archive.ubuntu.com/ubuntu/ubuntu/pool/universe/h/hidapi",
+      "originator": "Organization: ubuntu",
+      "supplier": "NOASSERTION",
+      "externalRefs": [
+        {
+          "referenceCategory": "PACKAGE-MANAGER",
+          "referenceLocator": "pkg:deb/ubuntu/hidapi@0.11.2-1",
+          "referenceType": "purl"
+        },
+        {
+          "referenceCategory": "OTHER",
+          "referenceLocator": "ac0becc4-29d8-469d-a6fa-d42a0c88ae4b",
+          "referenceType": "BlackDuck-ComponentOrigin"
+        }
+      ],
+      "filesAnalyzed": false,
+      "licenseComments": "Multiple license: license chosen BSD-3-Clause"
+    }
+  ],
+  "relationships": [
+    {
+      "spdxElementId": "SPDXRef-package-79c03a43-7a2b-4947-b1c4-8d87e24adb43",
+      "relationshipType": "CONTAINS",
+      "relatedSpdxElement": "SPDXRef-package-16ddf628-ffe8-4a50-a37f-4ac21026fc7b"
+    },
+    {
+      "spdxElementId": "SPDXRef-DOCUMENT",
+      "relationshipType": "DESCRIBES",
+      "relatedSpdxElement": "SPDXRef-package-79c03a43-7a2b-4947-b1c4-8d87e24adb43"
+    },
+    {
+      "spdxElementId": "SPDXRef-package-79c03a43-7a2b-4947-b1c4-8d87e24adb43",
+      "relationshipType": "CONTAINS",
+      "relatedSpdxElement": "SPDXRef-package-8c673b9b-215e-40f5-bf01-40c6bfc02b03"
+    }
+  ]
+}

{libusbsio-2.1.13 → libusbsio-2.2.0}/libusbsio/libusbsio.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 #
-# Copyright 2021-2022 NXP
+# Copyright 2021-2022,2025 NXP
 # SPDX-License-Identifier: BSD-3-Clause
 #
 # NXP USBSIO Library to control SPI, I2C and GPIO bus over USB
@@ -15,6 +15,8 @@ from ctypes import (CDLL, POINTER, Structure, c_char_p, c_int32, c_uint8,
                     c_uint16, c_uint32, c_void_p, c_wchar_p)
 from typing import Generator, List, Tuple
 
+def _hex(n):
+    return hex(n) if n is not None else "None"
 
 class LibUsbStructure(Structure):
     @property
@@ -41,10 +43,89 @@ class LIBUSBSIO_Exception(Exception):
         message = "LIBUSBSIO: " + message
         super().__init__(message)
 
+class LIBUSBSIO_DllManager(object):
+    """# This object is used as a singleton by LIBUSBSIO instances, to manage DLLs.
+    This object counts references to DLLs used by LIBUSBSIO instances and unloads 
+    them when no more clients use it.
+    """
+    def __init__(self):
+        '''LIBUSBSIO_DLL class constructor'''
+        self._instances = {}
+
+    class Record:    
+        '''Data record managed for each instance
+        '''
+        def __init__(self, cdll:'CDLL'):
+            self.__dict__.update({ "cdll":cdll, "used":1 })
+
+    def __del__(self):
+        '''LIBUSBSIO_DLL class destructor.
+        Takes care about cleaning up remaining DLLs
+        '''
+        for i in self._instances:
+            self._cleanup_cdll(self._instances[i].cdll)
+
+    def LoadDLL(self, dllpath:str) -> 'CDLL|None':
+        '''Get DLL handle, either it was loaded earlier or it is the first time now'''
+        dll = None
+        if dllpath in self._instances:
+            # DLL already used, increment usage count
+            record = self._instances[dllpath]
+            record.used += 1
+            dll = record.cdll
+        else:
+            # DLL being loaded for the first time, create its record
+            dll = CDLL(dllpath)
+            if dll:
+                record = LIBUSBSIO_DllManager.Record(dll)
+                self._instances[dllpath] = record
+        # note that dll may be None if library load failed
+        return dll
+
+    def FreeDLL(self, cdll:'CDLL') -> bool:
+        '''Decrement usage counter on CDLL object and free library if zero'''
+        unloaded = False
+        # Find the DLL's record
+        for p in self._instances:
+            record = self._instances[p]
+            if cdll is record.cdll:
+                # Decrement usage count
+                record.used -= 1
+                if record.used == 0:
+                    # Free DLL if usage count reached zero
+                    self._cleanup_cdll(cdll)
+                    del self._instances[p]
+                    unloaded = 1
+                    break
+        return unloaded
+
+    def _cleanup_cdll(self, cdll:'CDLL'):
+        '''Physically unload the LIBUSBSIO DLL library'''
+        try:
+            # Versions v2.2 and later has a LibCleanup method
+            cleanup = cdll.LPCUSBSIO_LibCleanup
+            cleanup.argtypes = []
+            cleanup.restype = c_int32
+            cleanup()
+        except Exception as e:
+            # Ignore if LibCleanup does not exist or fails
+            pass
+        # Unload the library object
+        del cdll
+
+# the LIBUSBSIO_DllManager singleton object used by all LIBUSBSIO instances
+_the_libusbsio_dll = LIBUSBSIO_DllManager()
+
 class LIBUSBSIO(object):
-    """# Class encapsulating functionality of the NXP USBSIO binary library.
-       The library enables to access SPI or I2C bus and GPIO ports over a USB interface
-       of the NXP LPC-link2 and MCU-Link bridge devices.
+    """# Class encapsulating functionality of the NXP USBSIO device port.
+
+       The object enables to access SPI or I2C bus and GPIO ports over a USB interface
+       of the NXP LPC-link2 and MCU-Link bridge devices. Multiple object
+       can be created simultaneously to access different USBSIO devices.
+
+       Note: The USB devices are not open in exclusive mode, so using multiple 
+       LIBUSBSIO instances to access the same device is technically possible 
+       but not recommended.
     """
 
     # platforms
@@ -57,6 +138,7 @@ class LIBUSBSIO(object):
     ERR_SYNCHRONIZATION = -3     # Thread Synchronization error.
     ERR_MEM_ALLOC = -4           # Memory allocation error.
     ERR_MUTEX_CREATE = -5        # Mutex creation error.
+    ERR_FORCED_CLEANUP = -6      # Some objects might have been in use during cleanup.
 
     # I2C hardware interface errors
     ERR_FATAL = -0x11            # Fatal error occurred
@@ -170,7 +252,7 @@ class LIBUSBSIO(object):
 
     # search for the DLL
     def _lookup_dll_path(subdir: str, dllname: str):
-        ''' search for the DLL specified by a sub-directoruy and DLL name'''
+        ''' search for the DLL specified by a sub-directory and DLL name'''
         def probe(*parts):
             p = os.path.join(*parts)
             return p if os.path.isfile(p) else None
@@ -199,7 +281,6 @@ class LIBUSBSIO(object):
 
         self._dll = None
         self._dllpath:str = None
-        self._devIx:int = None
         self._ports_open:List[int] = []
         self._h = None
         self._vidpid = (0,0)
@@ -212,7 +293,7 @@ class LIBUSBSIO(object):
         if self._h:
             self.Close()
         if self._dll:
-            del self._dll
+            _the_libusbsio_dll.FreeDLL(self._dll)
             self._dll = None
             self._dllpath = None
             self.logger.info("SIO library unloaded")
@@ -269,7 +350,7 @@ class LIBUSBSIO(object):
             dllname = "libusbsio.dylib"
             packing = 8
         else:
-            ex = LIBUSBSIO_Exception("Unknown platform to load proper library.")
+            ex = LIBUSBSIO_Exception("Unknown platform, cannot load library.")
             if raiseOnError:
                 raise ex
             return ex
@@ -299,8 +380,7 @@ class LIBUSBSIO(object):
 
         self.logger.info("Loading SIO library: %s" % dllpath)
         self._dllpath = dllpath
-        self._dll = CDLL(dllpath)
-        self._devIx = None
+        self._dll = _the_libusbsio_dll.LoadDLL(dllpath)
         self._h = None
 
         if not self._dll:
@@ -441,6 +521,22 @@ class LIBUSBSIO(object):
         self._GPIO_ConfigIOPin.argtypes = [c_void_p, c_uint8, c_uint8, c_uint32]
         self._GPIO_ConfigIOPin.restype = c_int32
 
+        # methods added in LIBUSBSIO v2.2, gracefully ignore if missing
+        try:
+            self._OpenBySerial = self._dll.LPCUSBSIO_OpenBySerial
+            self._OpenBySerial.argtypes = [c_wchar_p]
+            self._OpenBySerial.restype = c_void_p
+        except:
+            self._OpenBySerial = lambda x: 0
+
+        try:
+            self._OpenByPath = self._dll.LPCUSBSIO_OpenByPath
+            self._OpenByPath.argtypes = [c_char_p]
+            self._OpenByPath.restype = c_void_p
+        except:
+            self._OpenByPath = lambda x: 0
+
+        # low-level HIDAPI interface
         if 1:
             self._HIDAPI_Enumerate = self._dll.HIDAPI_Enumerate
             self._HIDAPI_Enumerate.argtypes = [c_uint32,c_uint32,c_int32]
@@ -546,7 +642,7 @@ class LIBUSBSIO(object):
     @need_dll_loaded
     def GetNumPorts(self, vidpids:'list[tuple[int,int]]' = None) -> int:
         '''# Get number of USBSIO ports
-        Gets the number of USBSIO ports that are available on the controller. Multiple PID+VID tuples
+        Gets the number of USBSIO ports that are available on the controller. Multiple VID+PID tuples
         may be specified to search multiple types of devices. The first device in the list which is detected
         is the one which will be used and which returns the number of its communication ports.
 
@@ -609,10 +705,60 @@ class LIBUSBSIO(object):
         ## Returns
         Boolean True if open was successful. False if not successful.
         '''
-        self.logger.info("Opening SIODevice%d" % dev)
+        self.Close()
+        self.logger.info("Opening SIODevice index %d" % dev)
         self._h = self._Open(dev)
-        self._devIx = dev
-        self.logger.debug("SIODevice%d Open returns %s" % (dev, self._h))
+        if self._h:
+            self.logger.info("Open(%d) returns %s" % (dev, _hex(self._h)))
+        else:
+            self.logger.error("Open(%d) failed." % dev)
+        self._ports_open = []
+        return bool(self._h)
+
+    @need_dll_loaded
+    def OpenBySerial(self, serial:str) -> bool:
+        '''# Open USBSIO port by looking for a device identified by serial number
+        This function looks for USBSIO device identified by serial number and opens this device.
+        User still needs to call GetNumPorts to perform device enumeration and VID/PID filtering. 
+        The port handle will be closed automatically in this object's destructor.
+
+        ## Args
+        - `serial` - Serial number device identifier.
+
+        ## Returns
+        Boolean True if open was successful. False if not successful.
+        '''
+        self.Close()
+        self.logger.info("Opening SIODevice serial number '%s'" % serial)
+        self._h = self._OpenBySerial(serial)
+        if self._h:
+            self.logger.info("OpenBySerial('%s') returns %s" % (serial, _hex(self._h)))
+        else:
+            self.logger.error("OpenBySerial('%s') failed." % serial)
+        self._ports_open = []
+        return bool(self._h)
+
+    @need_dll_loaded
+    def OpenByPath(self, hid_path:str) -> bool:
+        '''# Open USBSIO port from a device specified by USB HID device path. This is the 
+        only Open function which does not require the GetNumPorts device enumeration
+        to be called prior port opening. Note that USB device path is a platform 
+        specific string. You should not store the path value permanently. 
+        The port handle will be closed automatically in this object's destructor.
+
+        ## Args
+        - `hid_path` - USB HID device path.
+
+        ## Returns
+        Boolean True if open was successful. False if not successful.
+        '''
+        self.Close()
+        self.logger.info("Opening SIODevice at path '%s'" % hid_path)
+        self._h = self._OpenByPath(hid_path)
+        if self._h:
+            self.logger.info("OpenByPath('%s') returns %s" % (hid_path, _hex(self._h)))
+        else:
+            self.logger.error("OpenByPath('%s') failed." % hid_path)
         self._ports_open = []
         return bool(self._h)
 
@@ -627,9 +773,9 @@ class LIBUSBSIO(object):
         ret = 1
         if self._h:
             ret = self._Close(self._h)
-            self.logger.info("Closed SIODevice%d code=%d" % (self._devIx, ret))
+            self.logger.info("Closed SIODevice (handle=%s) code=%d" % (_hex(self._h), ret))
             self._h = None
-            self._devIx = None
+
         return ret
 
     @need_dll_open
@@ -1374,7 +1520,7 @@ class LIBUSBSIO(object):
             self.logger.info("Opening HID device at path: '%s'" % path)
             self._h = self._sio._HIDAPI_DeviceOpen(path)
             if self._h:
-                self.logger.info("HID device %d is now open" % self._h)
+                self.logger.info("HID device is now open as handle %s" % _hex(self._h))
             else:
                 self.logger.error("HID device '%s' opening failed." % path)
             return self._h != 0
@@ -1390,7 +1536,7 @@ class LIBUSBSIO(object):
             h = self._h
             self._h = None
             ret = self._sio._HIDAPI_DeviceClose(h)
-            self.logger.info("HID device %d closed" % h)
+            self.logger.info("HID device %s closed" % _hex(h))
             return ret == 0
 
         @need_device_open
@@ -1471,24 +1617,15 @@ class LIBUSBSIO(object):
         return dev
 
 
-# the LIBUSBSIO singleton object
-_LIBUSBSIO_SINGLETON:LIBUSBSIO = None
-
 def usbsio(dllpath:str=None, loglevel:int=logging.NOTSET, autoload=True) -> LIBUSBSIO:
-    '''# LIBUSBSIO singleton object
-    The returned instance acts as kind-of 'singleton' object, created
-    upon the first call of this function. All subsequent calls returns
-    the same instance.
+    '''# LIBUSBSIO object factory. Since v2.2 it is a simple object creator as we now
+    support multiple USBSIO devices to be open simultaneously. Older versions
+    of this factory were returning a singleton object, but this is no longer needed.
 
     ## Args
-    All arguments are passed to LIBUSBSIO constructor when the instance
-    is created for the first time. The arguments are ignored when the instance
-    already exists.
+    All arguments are passed to LIBUSBSIO constructor.
     - `dllpath`  Path to LIBUSBSIO dynamic library. Use None to autodetect based on operating system.
     - `loglevel` Internal logging level, defaults to logging.NOTSET.
     - `autoload` Set to load the DLL library automatically.
     '''
-    global _LIBUSBSIO_SINGLETON
-    if not _LIBUSBSIO_SINGLETON:
-        _LIBUSBSIO_SINGLETON = LIBUSBSIO(dllpath=dllpath, loglevel=loglevel, autoload=autoload)
-    return _LIBUSBSIO_SINGLETON
+    return LIBUSBSIO(dllpath=dllpath, loglevel=loglevel, autoload=autoload)