hardwarelibrary 0.0.0__py3-none-any.whl

hardwarelibrary/.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

hardwarelibrary/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
+  </component>
+</project>

hardwarelibrary/.idea/workspace.xml

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ChangeListManager">
+    <list default="true" id="90ca4116-5fad-4c16-b2e5-e7165d36af6f" name="Default Changelist" comment="">
+      <change beforePath="$PROJECT_DIR$/../.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/../.idea/workspace.xml" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/communication/serialport.py" beforeDir="false" afterPath="$PROJECT_DIR$/communication/serialport.py" afterDir="false" />
+    </list>
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="Git.Settings">
+    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$/.." />
+  </component>
+  <component name="ProjectId" id="1uLsLaSQEOdaPgWc7Tr7BFMizJv" />
+  <component name="ProjectLevelVcsManager" settingsEditedManually="true" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent">
+    <property name="RunOnceActivity.OpenProjectViewOnStart" value="true" />
+    <property name="RunOnceActivity.ShowReadmeOnStart" value="true" />
+    <property name="last_opened_file_path" value="$PROJECT_DIR$" />
+    <property name="settings.editor.selected.configurable" value="com.jetbrains.python.configuration.PyActiveSdkModuleConfigurable" />
+  </component>
+  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="90ca4116-5fad-4c16-b2e5-e7165d36af6f" name="Default Changelist" comment="" />
+      <created>1624456151873</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1624456151873</updated>
+    </task>
+    <servers />
+  </component>
+</project>

hardwarelibrary/__init__.py

@@ -0,0 +1,19 @@
+__version__ = "1.0.5"
+__author__ = "Daniel Cote <dccote@cervo.ulaval.ca>"
+
+__all__ = ["communication","motion","oscilloscope","powermeters","spectrometers"]
+
+# We want the modules at the top level
+from .devicemanager import *
+
+from hardwarelibrary.physicaldevice import *
+from hardwarelibrary.notificationcenter import *
+from hardwarelibrary.communication import *
+
+# We want these modules in their namespace
+import hardwarelibrary.spectrometers
+import hardwarelibrary.oscilloscope
+import hardwarelibrary.motion
+# import hardwarelibrary.cameras
+
+#import sources #TODO: Not much to see here yet

hardwarelibrary/__main__.py

@@ -0,0 +1,76 @@
+import os 
+import sys
+import argparse
+import re
+import subprocess
+from pathlib import Path
+import platform
+import hardwarelibrary.spectrometers as spectro
+from hardwarelibrary import DeviceManager, connectedUSBDevices
+
+import signal
+import sys
+
+def signal_handler(sig, frame):
+    dm = DeviceManager()
+    if dm.isMonitoring and not dm.quitMonitoring:
+        print('Quitting nicely')
+        dm.stopMonitoring()
+
+signal.signal(signal.SIGINT, signal_handler)
+
+ # We start by figuring out what the user really wants. If they don't know,
+# we offer some help
+ap = argparse.ArgumentParser(prog='python -m hardwarelibrary')
+ap.add_argument("-stellar", "--stellarnet", required=False, action='store_const',
+                const=True, help="Decrypt the StellarnNet driver.  Contact StellarNet for info.")
+ap.add_argument("-s", "--spectrometer", required=False, action='store_const',
+                const=True, help="Display any spectrometer")
+ap.add_argument("-l", "--list", required=False, action='store_const',
+                const=True, help="List all USB devices")
+ap.add_argument("-dm", "--devicemanager", required=False, action='store_const',
+                const=True, help="Show notifications from DeviceManager")
+ap.add_argument("-d", "--debugusb", required=False, action='store_const',
+                const=True, help="Help debugging USB libraries issues")
+
+args = vars(ap.parse_args())
+decrypt = args['stellarnet']
+displaySpectrum = args['spectrometer']
+deviceManager = args['devicemanager']
+debugUSB = args['debugusb']
+listAll = args['list']
+
+if listAll == True:
+    devices = connectedUSBDevices()
+    for device in devices:
+        print(device)
+
+if decrypt == True:
+    rootHardwareLibrary = Path(os.path.abspath(__file__)).parents[1]
+    spectrometersDirectory = rootHardwareLibrary.joinpath('hardwarelibrary/spectrometers')
+    zipFile =spectrometersDirectory.joinpath('stellarnet.zip')
+
+    if platform.system() == 'Windows':
+        os.startfile(zipFile)
+    elif platform.system() == 'Darwin':
+        completedProcess = subprocess.run(["unzip", zipFile, "-d", spectrometersDirectory])
+        if completedProcess.returncode != 0:
+            print("There was an error when unzipping and decrypting the stellarnet.zip file")
+    else:
+        print('Cannot unzip stellarnet file, you must unzip it manually : {0}'.format(zipFile))
+
+if displaySpectrum == True:
+    spectro.displayAny()
+
+if deviceManager == True:
+    dm = DeviceManager()
+    dm.showNotifications()
+    dm.startMonitoring()
+
+if debugUSB == True:
+    from hardwarelibrary.communication import validateUSBBackend
+    backend = validateUSBBackend(verbose=True)
+    if backend is not None:
+        print("PyUSB found and uses backend from: {0}".format(backend.lib))
+    else:
+        print("PyUSB has not found a backend to operate.")

hardwarelibrary/cameras/__init__.py

@@ -0,0 +1,2 @@
+
+from .camera import OpenCVCamera, CameraDeviceNotification

hardwarelibrary/cameras/camera.py

@@ -0,0 +1,181 @@
+import time
+from enum import Enum
+from hardwarelibrary.physicaldevice import PhysicalDevice
+from hardwarelibrary.notificationcenter import NotificationCenter, Notification
+from threading import Thread, RLock
+try:
+    import cv2
+except Exception as err:
+    print("No support for OpenCVcameras")
+    pass
+    
+import re
+
+class CameraDeviceNotification(Enum):
+    willStartCapture    = "willStartCapture"
+    didStartCapture     = "didStartCapture"
+    willStopCapture     = "willStopCapture"
+    didStopCapture      = "didStopCapture"
+    imageCaptured       = "imageCaptured"
+
+class CameraDevice(PhysicalDevice):
+    def __init__(self, serialNumber:str = None, idProduct:int = None, idVendor:int = None):
+        super().__init__(serialNumber, idProduct, idVendor)
+        self.version = ""
+        self.quitLoop = False
+        self.lock = RLock()
+        self.mainLoop = None
+
+    def doInitializeDevice(self):
+        pass # nothing to do, but incuded by symmetry with doShutdown
+
+    def doShutdownDevice(self):
+        with self.lock:
+            if self.isCapturing:
+                self.stop()
+
+    def livePreview(self):
+        NotificationCenter().postNotification(notificationName=CameraDeviceNotification.willStartCapture,
+                                              notifyingObject=self)
+        self.captureLoopSynchronous()
+
+    def start(self):
+        with self.lock:
+            if not self.isCapturing:
+                self.quitLoop = False
+                self.mainLoop = Thread(target=self.captureLoop, name="Camera-CaptureLoop")
+                NotificationCenter().postNotification(notificationName=CameraDeviceNotification.willStartCapture, notifyingObject=self)
+                self.mainLoop.start()
+            else:
+                raise RuntimeError("Capture loop already running")
+
+    @property
+    def isCapturing(self):
+        return self.mainLoop is not None
+
+    def stop(self):
+        if self.isCapturing:
+            NotificationCenter().postNotification(CameraDeviceNotification.willStopCapture, notifyingObject=self)
+            with self.lock:
+                self.quitLoop = True
+            self.mainLoop.join()
+            self.mainLoop = None
+            NotificationCenter().postNotification(CameraDeviceNotification.didStopCapture, notifyingObject=self)
+        else:
+            raise RuntimeError("No monitoring loop running")
+
+    def captureLoopSynchronous(self):
+        frame = None
+        NotificationCenter().postNotification(notificationName=CameraDeviceNotification.didStartCapture,
+                                              notifyingObject=self)
+        while (True):
+            frame = self.doCaptureFrame()
+            NotificationCenter().postNotification(CameraDeviceNotification.imageCaptured, self, frame)
+
+            cv2.imshow('Preview (Q to quit)', frame)
+            if cv2.waitKey(1) & 0xFF == ord('q'):
+                NotificationCenter().postNotification(CameraDeviceNotification.willStopCapture, notifyingObject=self)
+                break
+
+        cv2.destroyAllWindows()
+        NotificationCenter().postNotification(CameraDeviceNotification.didStopCapture, notifyingObject=self)
+
+    def captureFrames(self, n=1):
+        frames = []
+        for i in range(n):
+            frames.append(self.doCaptureFrame())
+        return frames
+
+    def captureLoopThread(self):
+        frame = None
+        NotificationCenter().postNotification(notificationName=CameraDeviceNotification.didStartCapture,
+                                              notifyingObject=self)
+        while (True):
+            frame = self.doCaptureFrame()
+            NotificationCenter().postNotification(CameraDeviceNotification.imageCaptured, self, frame)
+
+            if self.quitLoop:
+                return
+
+class OpenCVCamera(CameraDevice):
+
+    def __init__(self, serialNumber:str = None, idProduct:int = None, idVendor:int = None):
+        super().__init__(serialNumber, idProduct, idVendor)
+        self.version = ""
+        self.cameraHandler = None
+        self.cvCameraIndex = 0
+        if serialNumber is not None:
+            self.cvCameraIndex = int(serialNumber)
+
+    def openCVProperties(self):
+        properties = {}
+        for property in dir(cv2):
+            if re.search('CAP_', property) is not None:
+                indexProp = getattr(cv2, property)
+                value = cam.get(indexProp)
+                if value != 0:
+                    properties[property] = value
+        return properties
+
+    @classmethod
+    def isCompatibleWith(cls, serialNumber, idProduct, idVendor):
+        return False
+
+        try:
+            cameraIndex = int(serialNumber)
+        except Exception as err:
+            cameraIndex = 0
+
+        cam = cv2.VideoCapture(cameraIndex)
+        wasAcquired, frame = cam.read()
+        cam.release()
+
+        return wasAcquired
+
+    def doInitializeDevice(self):
+        super().doInitializeDevice()
+        with self.lock:
+            # FIXME: Open the first camera we find
+            self.cameraHandler = cv2.VideoCapture(self.cvCameraIndex)
+
+            if self.cameraHandler is None:
+                raise Exception("Could not open video device")
+
+            if not (self.cameraHandler.isOpened()):
+                raise Exception("Could not open video device")
+
+    def doShutdownDevice(self):
+        super().doShutdownDevice()
+        with self.lock:
+            self.cameraHandler.release()
+            self.cameraHandler = None
+
+    def doCaptureFrame(self):
+        with self.lock:
+            # Capture frame-by-frame
+            ret, frame = self.cameraHandler.read()
+            return frame
+
+    @classmethod
+    def availableCameras(cls):
+        return 0
+
+        numberOfCameras = 0
+        for i in range(10):
+            cam = cv2.VideoCapture(i)
+            wasAcquired, frame = cam.read()
+            cam.release()
+
+            if not wasAcquired:
+                break
+
+            numberOfCameras += 1
+
+        return numberOfCameras
+
+if __name__ == "__main__":
+    print(OpenCVCamera.availableCameras())
+    cam = OpenCVCamera()
+    cam.initializeDevice()
+    cam.livePreview()
+    cam.shutdownDevice()

hardwarelibrary/communication/.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

hardwarelibrary/communication/.idea/communication.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+  <component name="PyDocumentationSettings">
+    <option name="format" value="PLAIN" />
+    <option name="myDocStringFormat" value="Plain" />
+  </component>
+</module>

hardwarelibrary/communication/.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

hardwarelibrary/communication/.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.9" project-jdk-type="Python SDK" />
+</project>

hardwarelibrary/communication/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/communication.iml" filepath="$PROJECT_DIR$/.idea/communication.iml" />
+    </modules>
+  </component>
+</project>

hardwarelibrary/communication/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
+  </component>
+</project>

hardwarelibrary/communication/__init__.py

@@ -0,0 +1,53 @@
+from .communicationport import *
+from .serialport import SerialPort
+from .usbport import USBPort
+from .diagnostics import USBParameters, DeviceCommand, USBDeviceDescription
+from .debugport import DebugPort
+from .echoport import DebugEchoPort
+import usb.backend.libusb1
+import platform
+from pathlib import *
+import os
+
+def validateUSBBackend(verbose=False):
+    backend = usb.backend.libusb1.get_backend()
+    if backend is not None:
+        try:
+            usb.core.find(backend=backend)
+            return backend
+        except:
+            if verbose:
+                print("The default backend search of PyUSB does not find a libusb backend")
+
+    libusbPath = None
+    candidates = []
+    if platform.system() == 'Windows':
+        rootHardwareLibrary = PureWindowsPath(os.path.abspath(__file__)).parents[1]
+        candidates = [rootHardwareLibrary.joinpath('communication/libusb/MS64/libusb-1.0.dll'),
+                         rootHardwareLibrary.joinpath('communication/libusb/MS32/libusb-1.0.dll')]
+    elif platform.system() == 'Darwin':
+        rootHardwareLibrary = PurePosixPath(os.path.abspath(__file__)).parents[1]
+        candidates = [rootHardwareLibrary.joinpath('communication/libusb/Darwin/libusb-1.0.0.dylib')]
+    else:
+        if verbose:
+            otherDir = rootHardwareLibrary.joinpath('communication/libusb/other')
+            print("""Platform not recognized {1} and default PyUSB backend not found. You should try installing libusb.
+            If it does not work out of the box, you can try copying the library in the {0} directory""".format(otherDir, platform.system()))
+        candidates = os.listdir(otherDir)
+
+    for libpath in candidates:
+        if os.path.exists(libpath):
+            backend = usb.backend.libusb1.get_backend(find_library=lambda x: "{0}".format(libpath))
+            if backend is not None:
+                try:
+                    usb.core.find(backend=backend)
+                    return backend
+                except:
+                    pass
+        else:
+            if verbose:
+                print("Library candidate {0} does not exist".format(libpath))
+
+    return None
+
+validateUSBBackend()

hardwarelibrary/communication/commands.py

@@ -0,0 +1,183 @@
+import re
+
+class Command:
+    def __init__(self, name:str, endPoints = (None, None)):
+        self.name = name
+        self.reply = None
+        self.matchGroups = None
+        self.endPoints = endPoints
+
+        self.isSent = False
+        self.isSentSuccessfully = False
+        self.exceptions = []
+
+        self.isReplyReceived = False
+        self.isReplyReceivedSuccessfully = False
+
+    @property
+    def payload(self):
+        return None
+
+    @property
+    def numberOfArguments(self):
+        return 0
+
+    def matchAsFloat(self, index=0):
+        if self.matchGroups is not None:
+            return float(self.matchGroups[index])
+        return None
+    
+    @property
+    def hasError(self):
+        return len(self.exceptions) != 0
+
+    def send(self, port) -> bool:
+        raise NotImplementedError("Subclasses must implement the send() command")
+
+class TextCommand(Command):
+    def __init__(self, name, text, replyPattern = None, 
+                                   alternatePattern = None, 
+                                   endPoints = (None, None)):
+        Command.__init__(self, name, endPoints=endPoints)
+        self.text : str = text
+        self.replyPattern: str = replyPattern
+        self.alternatePattern: str = alternatePattern
+
+    @property
+    def payload(self):
+        return self.text
+
+    @property
+    def numberOfArguments(self):
+        match = re.search(r"\{(.*?)\}", self.text)
+        if match is None:
+            return 0
+        return len(match.groups())
+
+    def send(self, port, params=None) -> bool:
+        try:
+            if params is not None:
+                textCommand = self.text.format(params)
+            else:
+                textCommand = self.text
+
+            if port is None:
+                raise RuntimeError("port cannot be None")
+
+            port.writeString(string=textCommand, endPoint=self.endPoints[0])
+            self.isSent = True
+
+            if self.replyPattern is not None:
+                self.reply, self.matchGroups = port.readMatchingGroups(
+                           replyPattern=self.replyPattern,
+                           alternatePattern=self.alternatePattern,
+                           endPoint=self.endPoints[1])
+            else:
+                pass
+            
+            self.isSentSuccessfully = True
+        except Exception as err:
+            self.exceptions.append(err)
+            self.isSentSuccessfully = False
+            return True
+
+        return False
+
+
+class MultilineTextCommand(Command):
+    def __init__(self, name, text,
+                 replyPattern=None,
+                 alternatePattern=None,
+                 lineCount=1,
+                 lastLinePattern=None,
+                 endPoints=(None, None)):
+        Command.__init__(self, name=name, endPoints=endPoints)
+        self.text: str = text
+        self.replyPattern: str = replyPattern
+        self.alternatePattern: str = alternatePattern
+        self.lineCount = lineCount
+        self.lastLinePattern = lastLinePattern
+
+    @property
+    def payload(self):
+        return self.text
+
+    def send(self, port, params=None) -> bool:
+        try:
+            if params is not None:
+                textCommand = self.text.format(params)
+            else:
+                textCommand = self.text
+
+            if port is None:
+                raise RuntimeError("port cannot be None")
+
+            port.writeString(string=textCommand, endPoint=self.endPoints[0])
+            self.isSent = True
+
+            if self.lineCount > 1:
+                self.reply = []
+                self.matchGroups = []
+
+                for i in range(self.lineCount):
+                    reply, matchGroups = port.readMatchingGroups(
+                        replyPattern=self.replyPattern,
+                        alternatePattern=self.alternatePattern,
+                        endPoint=self.endPoints[1])
+                    self.reply.append(reply)
+                    self.matchGroups.append(matchGroups)
+
+            elif self.lastLinePattern is not None:
+                self.reply = []
+                self.matchGroups = []
+
+                while True:
+                    reply, matchGroups = port.readMatchingGroups(
+                        replyPattern=self.replyPattern,
+                        alternatePattern=self.alternatePattern,
+                        endPoint=self.endPoints[1])
+                    self.reply.append(reply)
+                    self.matchGroups.append(matchGroups)
+
+                    if re.search(self.lastLinePattern, reply) is not None:
+                        break
+            else:
+                raise Exception("lineCount and lastLinePattern cannot both be None")
+
+            self.isSentSuccessfully = True
+        except Exception as err:
+            self.exceptions.append(err)
+            self.isSentSuccessfully = False
+            return True
+
+        return False
+
+
+class DataCommand(Command):
+    def __init__(self, name, data, replyHexRegex = None, replyDataLength = 0, unpackingMask = None, endPoints = (None, None)):
+        Command.__init__(self, name, endPoints=endPoints)
+        self.data : bytearray = data
+        self.replyHexRegex: str = replyHexRegex
+        self.replyDataLength: int = replyDataLength
+        self.unpackingMask:str = unpackingMask
+
+    @property
+    def payload(self):
+        return self.data
+
+    def send(self, port) -> bool:
+        try:
+            nBytes = port.writeData(data=self.data, endPoint=self.endPoints[0])
+            self.isSent = True
+            if self.replyDataLength > 0:
+                self.reply = port.readData(length=self.replyDataLength)
+            elif self.replyHexRegex is not None:
+                raise NotImplementedError("DataCommand reply pattern not implemented")
+                # self.reply = port.readData(length=self.replyDataLength)
+            self.isSentSuccessfully = True
+        except Exception as err:
+            self.exceptions.append(err)
+            self.isSentSuccessfully = False
+            raise(err)
+
+        return False