Hologram Python SDK v0.8.0 release

Author: rbalik

CHANGELOG.md

@@ -1,5 +1,14 @@
 # What's New in Hologram Python SDK
 
+## v0.8.0
+
+2018-07-19 Hologram <[email protected]>
+    * Add support for Nova R410 Cat-M modem
+    * Drivers for R410 and R404 are loaded automatically
+    * Revamp error handling on AT command connect so we don't keep
+        moving the process forward if we've already failed
+    * Fixes to the repeated message send feature
+
 ## v0.7.6
 
 2018-04-04 Hologram <[email protected]>

Exceptions/HologramError.py

@@ -19,6 +19,9 @@ class AuthenticationError(HologramError):
 class NetworkError(HologramError):
     pass
 
+class ModemError(HologramError):
+    pass
+
 class PPPError(NetworkError):
     pass
 

Hologram/Cloud.py

@@ -13,7 +13,7 @@
 from Network import NetworkManager
 from Authentication import *
 
-__version__ = '0.7.6'
+__version__ = '0.8.0'
 
 class Cloud(object):
 

Hologram/CustomCloud.py

@@ -99,25 +99,22 @@ def open_send_socket(self, timeout=SEND_TIMEOUT):
         if self._is_send_socket_open:
             return
 
-        try:
-            self.__enforce_send_host_and_port()
-            self.logger.info("Connecting to: %s", self.send_host)
-            self.logger.info("Port: %s", self.send_port)
+        self.__enforce_send_host_and_port()
+        self.logger.info("Connecting to: %s", self.send_host)
+        self.logger.info("Port: %s", self.send_port)
 
-            # Check if we're going to use the AT command version of sockets or the
-            # native Python socket lib.
-            if self.__to_use_at_sockets():
-                self.network.create_socket()
-                self.network.connect_socket(self.send_host, self.send_port)
-            else:
-                self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                self.sock.settimeout(timeout)
-                self.sock.connect((self.send_host, self.send_port))
+        # Check if we're going to use the AT command version of sockets or the
+        # native Python socket lib.
+        if self.__to_use_at_sockets():
+            self.network.create_socket()
+            self.network.connect_socket(self.send_host, self.send_port)
+        else:
+            self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.sock.settimeout(timeout)
+            self.sock.connect((self.send_host, self.send_port))
+
+        self._is_send_socket_open = True
 
-            self._is_send_socket_open = True
-        except (IOError):
-            self.logger.error('An error occurred while attempting to send the message to the cloud')
-            self.logger.error('Please try again.')
 
     def close_send_socket(self):
         try:
@@ -177,7 +174,6 @@ def sendPeriodicMessage(self, interval, message, topics=None, timeout=5):
         self._periodic_msg = threading.Thread(target=self._periodic_job_thread,
                                               args=[interval, self.sendMessage,
                                                     message, topics, timeout])
-        self._periodic_msg.daemon = True
         self._periodic_msg.start()
 
     def sendSMS(self, destination_number, message):
@@ -190,7 +186,6 @@ def __to_use_at_sockets(self):
     # EFFECTS: This threaded infinite loop shoud keep sending messages with the specified
     #          interval.
     def _periodic_job_thread(self, interval, function, *args):
-
         while True:
             self._periodic_msg_lock.acquire()
 
@@ -199,8 +194,17 @@ def _periodic_job_thread(self, interval, function, *args):
                 break
 
             self.logger.info('Sending another periodic message...')
-            response = function(*args)
-            self.logger.info('DATA RECEIVED: %s', str(response))
+            try:
+                response = function(*args)
+            except Exception as e:
+                self.logger.info('Message function threw an exception: %s', str(e))
+                self._periodic_msg_lock.release()
+                break
+            else:
+                self.logger.info('RESPONSE MESSAGE: %s', self.getResultString(response))
+                if not self.resultWasSuccess(response):
+                    self._periodic_msg_lock.release()
+                    break
 
             self._periodic_msg_lock.release()
             time.sleep(interval)
@@ -215,6 +219,9 @@ def stopPeriodicMessage(self):
         self._periodic_msg.join()
         self.logger.info('Periodic job stopped')
 
+    def periodicMessageRunning(self):
+        return self._periodic_msg and self._periodic_msg.isAlive()
+
     def initializeReceiveSocket(self):
         return self.openReceiveSocket()
 
@@ -386,3 +393,9 @@ def _enforce_minimum_periodic_interval(self, interval):
     def __enforce_network_disconnected(self):
         if self.network_type == 'Cellular':
             self.network.disconnect()
+
+    def getResultString(self, result_code):
+        return str(response)
+
+    def resultWasSuccess(self, result_code):
+        return True

Hologram/HologramCloud.py

@@ -28,7 +28,8 @@
 
 # Hologram error codes
 ERR_OK = 0
-ERR_CONNCLOSED = 1 # Connection was closed so we couldn't read enough
+ERR_CONNCLOSED = 1 # Connection was closed before a terminating character
+                   # but message might be fine
 ERR_MSGINVALID = 2 # Couldn't parse the message
 ERR_AUTHINVALID = 3 # Auth section of message was invalid
 ERR_PAYLOADINVALID = 4 # Payload type was invalid
@@ -232,3 +233,6 @@ def getResultString(self, result_code):
         if result_code not in self._errorCodeDescription:
             return 'Unknown response code'
         return self._errorCodeDescription[result_code]
+
+    def resultWasSuccess(self, result_code):
+        return result_code in (ERR_OK, ERR_CONNCLOSED)

Hologram/Network/Cellular.py

@@ -15,7 +15,8 @@
 from Modem import E303
 from Modem import MS2131
 from Modem import Nova_U201
-from Modem import NovaM_R404
+from Modem import NovaM
+from Modem import DriverLoader
 from Network import Network, NetworkScope
 import time
 from serial.tools import list_ports
@@ -35,7 +36,7 @@ class Cellular(Network):
         'e303': E303.E303,
         'ms2131': MS2131.MS2131,
         'nova': Nova_U201.Nova_U201,
-        'r404': NovaM_R404.NovaM_R404,
+        'novam': NovaM.NovaM,
         '': Modem
     }
 
@@ -46,13 +47,17 @@ def __init__(self, event=Event()):
         self._route = Route()
         self.__receive_port = None
 
+
     def autodetect_modem(self):
         # scan for a modem and set it if found
         dev_devices = self._scan_for_modems()
         if dev_devices is None:
             raise NetworkError('Modem not detected')
         self.modem = dev_devices[0]
 
+    def load_modem_drivers(self):
+        self._load_modem_drivers()
+
 
     def getConnectionStatus(self):
         return self._connection_status
@@ -173,6 +178,22 @@ def __configure_routing(self):
             self.logger.info('Adding system-wide default route to cellular interface')
             self._route.add_default(self.localIPAddress)
 
+    def _load_modem_drivers(self):
+        dl = DriverLoader.DriverLoader()
+        for (modemName, modemHandler) in self._modemHandlers.iteritems():
+            module = modemHandler.module
+            if module:
+                if not dl.is_module_loaded(module):
+                    self.logger.info('Loading module %s for %s', module, modemName)
+                    dl.load_module(module)
+                    syspath = modemHandler.syspath
+                    if syspath:
+                        usb_ids = modemHandler.usb_ids
+                        for vid_pid in usb_ids:
+                            dl.force_driver_for_device(syspath, vid_pid[0], vid_pid[1])
+
+
+
     def _scan_for_modems(self):
         res = None
         for (modemName, modemHandler) in self._modemHandlers.iteritems():

Hologram/Network/Modem/DriverLoader.py

@@ -0,0 +1,44 @@
+# DriverLoader.py - Class that wraps around different module loading
+# operations that are used for the R410 and maybe other modems in the
+# future
+# Author: Hologram <[email protected]>
+#
+#
+# Copyright 2018 - Hologram (Konekt, Inc.)
+#
+#
+# LICENSE: Distributed under the terms of the MIT License
+#
+
+import subprocess
+
+
+class DriverLoader(object):
+    # I would much rather use python-kmod for all this
+    # but it doesn't seem to build properly on the Pi and
+    # hasn't been updated in years. It's possible we need to update
+    # to python 3 for it to work correctly
+
+
+    def is_module_loaded(self, module):
+        output = subprocess.check_output(['lsmod'])
+        lines = output.splitlines()
+        for line in lines:
+            splitline = line.split()
+            if splitline[0] == "option":
+                return True
+        return False
+
+
+    def load_module(self, module):
+        subprocess.call(['sudo', 'modprobe', module])
+
+
+    def force_driver_for_device(self, syspath, vid, pid):
+        with open(syspath, "w") as f:
+            f.write("%s %s"%(vid, pid))
+
+
+
+
+

Hologram/Network/Modem/IModem.py

@@ -20,6 +20,10 @@
 class IModem(object):
 
     usb_ids = []
+    # module needed by modem
+    module = '' 
+    # system path to write usb IDs to to force use of a driver
+    syspath = ''
 
     _error_code_description = {
 

Hologram/Network/Modem/Modem.py

@@ -15,6 +15,7 @@
 from Hologram.Event import Event
 from Exceptions.HologramError import SerialError
 from Exceptions.HologramError import HologramError
+from Exceptions.HologramError import NetworkError
 
 from collections import deque
 import binascii
@@ -281,6 +282,7 @@ def connect_socket(self, host, port):
         ok, _ = self.set('+USOCO', at_command_val, timeout=20)
         if ok != ModemResult.OK:
             self.logger.error('Failed to connect socket')
+            raise NetworkError('Failed to connect socket')
         else:
             self.logger.info('Connect socket is successful')
 
@@ -291,6 +293,7 @@ def listen_socket(self, port):
         ok, _ = self.set('+USOLI', at_command_val, timeout=5)
         if ok != ModemResult.OK:
             self.logger.error('Failed to listen socket')
+            raise NetworkError('Failed to listen socket')
 
     def write_socket(self, data):
 
@@ -299,6 +302,7 @@ def write_socket(self, data):
         ok, _ = self.set('+USOWR', value, timeout=10)
         if ok != ModemResult.OK:
             self.logger.error('Failed to write to socket')
+            raise NetworkError('Failed to write socket')
         self.disable_hex_mode()
 
     def read_socket(self, socket_identifier=None, payload_length=None):
@@ -681,9 +685,10 @@ def _set_up_pdp_context(self):
         ok, _ = self.set('+UPSDA', '0,3', timeout=30)
         if ok != ModemResult.OK:
             self.logger.error('PDP Context setup failed')
+            raise NetworkError('Failed PDP context setup')
         else:
             self.logger.info('PDP context active')
-        return ok == ModemResult.OK
+
 
     def __enforce_serial_port_open(self):
         if not (self.serial_port and self.serial_port.isOpen()):

Hologram/Network/Modem/NovaM.py

@@ -0,0 +1,86 @@
+# NovaM.py - Hologram Python SDK Hologram Nova R404/R410 modem interface
+#
+# Author: Hologram <[email protected]>
+#
+# Copyright 2016-2018 - Hologram, Inc
+#
+#
+# LICENSE: Distributed under the terms of the MIT License
+#
+
+from Nova import Nova
+from Hologram.Event import Event
+from Exceptions.HologramError import NetworkError
+from UtilClasses import ModemResult
+
+DEFAULT_NOVAM_TIMEOUT = 200
+
+class NovaM(Nova):
+
+    usb_ids = [('05c6', '90b2')]
+    module = 'option'
+    syspath = '/sys/bus/usb-serial/drivers/option1/new_id'
+
+    def __init__(self, device_name=None, baud_rate='9600',
+                 chatscript_file=None, event=Event()):
+        super(NovaM, self).__init__(device_name=device_name, baud_rate=baud_rate,
+                                         chatscript_file=chatscript_file, event=event)
+        self._at_sockets_available = True
+        modem_id = self.modem_id
+        if("R404" in modem_id):
+            self.is_r410 = False
+        else:
+            self.is_r410 = True
+
+
+    def init_serial_commands(self):
+        self.command("E0") #echo off
+        self.command("+CMEE", "2") #set verbose error codes
+        self.command("+CPIN?")
+        self.command("+CPMS", "\"ME\",\"ME\",\"ME\"")
+        self.set_sms_configs()
+        self.set_network_registration_status()
+
+    def set_network_registration_status(self):
+        self.command("+CEREG", "2")
+
+    def is_registered(self):
+        return self.check_registered('+CEREG')
+
+    def close_socket(self, socket_identifier=None):
+
+        if socket_identifier is None:
+            socket_identifier = self.socket_identifier
+
+        ok, r = self.set('+USOCL', "%s" % socket_identifier, timeout=40)
+        if ok != ModemResult.OK:
+            self.logger.error('Failed to close socket')
+
+    @property
+    def description(self):
+        modemtype = '(R410)' if self.is_r410 else '(R404)'
+        return 'Hologram Nova US 4G LTE Cat-M1 Cellular USB Modem ' + modemtype
+
+    @property
+    def location(self):
+        raise NotImplementedError('The R404 and R410 do not support Cell Locate at this time')
+
+    @property
+    def operator(self):
+        # R4 series doesn't have UDOPN so need to override
+        ret = self._basic_command('+COPS?')
+        parts = ret.split(',')
+        if len(parts) >= 3:
+            return parts[2].strip('"')
+        return None
+
+
+    # same as Modem::connect_socket except with longer timeout
+    def connect_socket(self, host, port):
+        at_command_val = "%d,\"%s\",%s" % (self.socket_identifier, host, port)
+        ok, _ = self.set('+USOCO', at_command_val, timeout=122)
+        if ok != ModemResult.OK:
+            self.logger.error('Failed to connect socket')
+            raise NetworkError('Failed to connect socket')
+        else:
+            self.logger.info('Connect socket is successful')