Blocklyprop Solo Rest API compatibility

.gitignore

@@ -1,4 +1,12 @@
+####################
+## BlocklyPropClient
+####################
 access.txt
+venv/
+VPython/
+*.app
+*.pkg
+*.bak
 
 #################
 ## Eclipse

BlocklyHardware.py

@@ -0,0 +1,132 @@
+import os
+import logging
+from sys import platform
+from subprocess import Popen, PIPE, check_output, CalledProcessError
+
+# Platform constants
+PLATFORM_LINUX = 'linux2'
+PLATFORM_MACOS = 'darwin'
+PLATFORM_WINDOWS = 'win32'
+
+# Define error constants
+FTDI_DRIVER_NOT_INSTALLED = 201
+FTDI_DRIVER_NOT_LOADED = 202
+PLATFORM_UNKNOWN = 2
+
+
+# Enable logging
+__module_logger = logging.getLogger('blockly')
+
+
+def init():
+    result = is_module_installed()
+    if result != 0:
+        return result
+
+    result = is_module_loaded()
+    if result != 0:
+        return result
+
+
+def is_module_installed():
+    if platform == PLATFORM_MACOS:
+        return __is_module_installed_macos()
+    elif platform == PLATFORM_LINUX:
+        return __is_module_installed_linux()
+    elif platform == PLATFORM_WINDOWS:
+        return __is_module_installed_windows()
+    else:
+        return PLATFORM_UNKNOWN
+
+
+def is_module_loaded():
+    if platform == PLATFORM_MACOS:
+        return __is_module_loaded_macos()
+    elif platform == PLATFORM_LINUX:
+        return __is_module_loaded_linux()
+    else:
+        return PLATFORM_UNKNOWN
+
+
+# Ubuntu implementation
+def __is_module_installed_linux():
+    try:
+        process = Popen(['cat', '/proc/modules'], stdout=PIPE, stderr=PIPE)
+        output = check_output(('grep', 'ftdi'), stdin=process.stdout)
+        __module_logger.debug('FTDI module load state')
+        __module_logger.debug(output)
+        return 0
+    except CalledProcessError:
+        __module_logger.warning('No FTDI modules detected.')
+        return FTDI_DRIVER_NOT_INSTALLED
+
+
+def __is_module_loaded_linux():
+    try:
+        process = Popen(['dmesg', '-H', '-x'], stdout=PIPE, stderr=PIPE)
+        output = check_output(('grep', 'ftdi'), stdin=process.stdout)
+        process.wait()
+        __module_logger.debug(output)
+        return 0
+    except CalledProcessError:
+        __module_logger.warning('Serial port is not assigned.')
+        return FTDI_DRIVER_NOT_LOADED
+
+
+# MacOS implementation
+def __is_module_installed_macos():
+    try:
+        # Does the log directory exist
+        os.stat('/Library/Extensions/FTDIUSBSerialDriver.kext')
+        __module_logger.info('FTDI driver is installed')
+        return 0
+
+    except OSError:
+        __module_logger.error('Cannot find FTDI installation')
+        return FTDI_DRIVER_NOT_INSTALLED
+
+
+def __is_module_loaded_macos():
+    try:
+        process = Popen(['kextstat'], stdout=PIPE, stderr=PIPE)
+        output = check_output(('grep', 'FTDI'), stdin=process.stdout)
+        __module_logger.debug('FTDI module load state')
+        __module_logger.debug(output)
+        return 0
+    except CalledProcessError:
+        __module_logger.warning('No FTDI modules detected.')
+        return 1
+
+
+# Windows implementation
+def __is_module_installed_windows():
+    try:
+        out, err = Popen('driverquery.exe -v', stdout=PIPE, shell=True).communicate()
+        position = out.find('FT')
+        if position > 0:
+            __module_logger.debug('FTDI module load state')
+            __module_logger.debug(out[position:position+91])
+            return 0
+        else:
+            __module_logger.warning('No FTDI modules installed.')
+            return FTDI_DRIVER_NOT_INSTALLED
+    except CalledProcessError:
+        __module_logger.warning('No FTDI modules detected.')
+        return FTDI_DRIVER_NOT_INSTALLED
+
+
+def __is_module_loaded_windows():
+    try:
+        out, err = Popen('driverquery.exe -v', stdout=PIPE, shell=True).communicate()
+        position = out.find('FT')
+        if position > 0:
+            __module_logger.debug('FTDI module load state')
+            __module_logger.debug(out[position+84:position+91])
+            return 0
+        else:
+            __module_logger.warning('No FTDI modules loaded.')
+            return FTDI_DRIVER_NOT_INSTALLED
+    except CalledProcessError:
+        __module_logger.warning('No FTDI modules detected.')
+        return FTDI_DRIVER_NOT_INSTALLED
+

BlocklyLogger.py

@@ -0,0 +1,198 @@
+""""
+BlocklyPropLogger manages the application logging process.
+
+
+"""
+
+import os
+import logging
+import platform
+
+
+__author__ = 'Jim Ewald'
+
+
+# Platform constants
+PLATFORM_POSIX = "posix"
+PLATFORM_LINUX = 'Linux'
+PLATFORM_MACOS = 'MacOS'
+PLATFORM_DARWIN = 'Darwin'
+PLATFORM_WINDOWS = 'Windows'
+
+# Default log path for each platform
+DEFAULT_PATH_MACOS = 'Library/Logs/Parallax'
+DEFAULT_PATH_WINDOWS = 'AppData/Local/Parallax'
+DEFAULT_PATH_LINUX = 'tmp'
+
+# Resulting path for log file
+path = None
+
+loglevel = logging.DEBUG
+
+
+def init(filename = 'BlocklyPropClient.log'):
+    global path
+
+    # Set NullHandler as a default
+    try:  # Python 2.7+
+        from logging import NullHandler
+    except ImportError:
+        class NullHandler(logging.Handler):
+            def emit(self, record):
+                pass
+
+    logging.getLogger(__name__).addHandler(NullHandler())
+
+    # Set a default log file name
+    logfile_name = filename
+    disable_filelogging = False
+
+    # Set correct log file location
+    system = platform.system()
+    print("Platform detected is: %", system)
+
+    # A posix system could be a MacOS or a Linux variety
+    if system == PLATFORM_POSIX:
+        # Asking for a MacOS version number only works on MacOS
+        is_mac = platform.mac_ver()
+        if is_mac[0] == "":
+            # This must be a Linux platform
+            system = PLATFORM_LINUX
+        else:
+            system = PLATFORM_MACOS
+
+    if (system == PLATFORM_MACOS) or (system == PLATFORM_DARWIN):
+        logfile_name = __set_macos_logpath(filename)
+    elif system == PLATFORM_WINDOWS:
+        logfile_name = __set_windows_logpath(filename)
+    elif system == PLATFORM_LINUX:
+        logfile_name = __set_linux_logpath(filename)
+
+    # Verify that we have a valid location
+    if logfile_name is None:
+        disable_filelogging = True
+    else:
+        # Set the module-level path
+        path = logfile_name
+        print("Sending file logging output to: ", path)
+
+    # Create a logger
+    logger = logging.getLogger('blockly')
+    logger.setLevel(loglevel)
+
+    # create a console handler for error-level events
+    console = logging.StreamHandler()
+    console.setLevel(loglevel)
+
+    # create a logging format
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    console.setFormatter(formatter)
+
+    # create a file handler to log events to the debug level if disk logging is active.
+    #  Log file is overwritten each time the app runs.
+    if not disable_filelogging:
+        handler = logging.FileHandler(logfile_name, mode='w')
+        handler.setLevel(loglevel)
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+
+    # add the handlers to the logger
+    logger.addHandler(console)
+    logger.info("Logger has been started.")
+
+
+# Set the default log file location on a Linux system
+def __set_linux_logpath(filename):
+    user_home = os.path.expanduser('~')
+    print("User home directory is: %s", user_home)
+    log_path = user_home + "/" + DEFAULT_PATH_LINUX
+    print("Logfile path is %s", log_path)
+
+    # Does the log directory exist
+    try:
+        result = __verify_logpath(log_path)
+        if result is None or result == False:
+            # Path does not exist. Create it
+            if __create_logpath(log_path) is None:
+                return None
+        else:
+            return log_path + '/' + filename
+
+    except OSError:
+        return None
+
+
+# Set the default log file location on a MacOS system
+def __set_macos_logpath(filename):
+    user_home = os.path.expanduser('~')
+    print("User home directory is: %s", user_home)
+    log_path = user_home + "/" + DEFAULT_PATH_MACOS
+    print("Logfile path is %s", log_path)
+
+    # Does the log directory exist
+    try:
+        result = __verify_logpath(log_path)
+        if result is None or result == False:
+            # Path does not exist. Let's create it
+            if __create_logpath(log_path) is None:
+                # Try to create the directory in the tmp directory
+                log_path = '/tmp'
+                result = __verify_logpath(log_path)
+                if result is None:
+                    return None
+
+        return log_path + '/' + filename
+    except OSError:
+        return None
+
+
+# Set the default log file location on a Windows system
+def __set_windows_logpath(filename):
+    user_home = os.path.expanduser('~')
+    print("User home directory is: %s", user_home)
+    log_path = user_home + "/" + DEFAULT_PATH_WINDOWS
+    print("Log file path is: %s", log_path)
+
+    # Does the log directory exist
+    try:
+        result = __verify_logpath(log_path)
+
+        if result is None or result == False:
+            # Path does not exist. Create it
+            if __create_logpath(log_path) is None:
+                # try to create the log file in the user's home directory
+                log_path = user_home
+                result = __verify_logpath(log_path)
+
+                if result is None:
+                    return None
+
+        return log_path + '/' + filename
+    except OSError:
+        return None
+
+
+# Create a file path for the log file
+def __create_logpath(file_path):
+    try:
+        os.makedirs(file_path)
+        return True
+
+    except OSError as ex:
+        print ex.message
+        return None
+
+
+# Verify that the file for the log file exists
+def __verify_logpath(file_path):
+    try:
+        print("Testing access to: %s", file_path)
+        return os.access(file_path, os.W_OK)
+
+    except OSError as ex:
+        print ex.message
+        return None
+
+    except Exception as ex:
+        print ex.message
+        return None