Implementation of selecting network carrier (WIFI, LTE).

Author: tomekmalek

1_send_data.py

@@ -7,7 +7,7 @@
 import time
 import LiveObjects
 
-board = LiveObjects.BoardsFactory()
+board = LiveObjects.BoardsFactory(net_type=LiveObjects.BoardsInterface.WIFI)
 
 apikey = board.get_apikey()
 client_id = board.get_client_id()
@@ -16,7 +16,7 @@
 # Create LiveObjects with parameters:  Board - ClientID - Security - APIKEY
 lo = LiveObjects.Connection(board, client_id, security_level, apikey)
 
-messageRate = 5
+MESSAGE_RATE = 5
 
 # Main program
 board.network_connect()
@@ -25,7 +25,7 @@
 uptime = time.time()
 
 while True:
-	if time.time() >= last+messageRate:
+	if time.time() >= last + MESSAGE_RATE:
 		lo.addToPayload("uptime", int(time.time() - uptime))		# Add value to payload: name - value
 		lo.sendData()												# Sending data to cloud
 		lo.loop() 						# Check for incoming messages and if connection is still active

LiveObjects/credentials.py

@@ -9,20 +9,22 @@
 class Credentials:
 
     def __init__(self, net_type):
+
         self._apikey = <APIKEY>
+        self._net_type = net_type
 
         if net_type == LiveObjects.BoardsInterface.WIFI:
             self._wifi_ssid = <WIFI_SSID>
-            self._wifi_password = <WIFI PASS>
+            self._wifi_password = <WIFI_PASS>
         elif net_type == LiveObjects.BoardsInterface.LTE:
             self._pin = <PIN>
             self._apn = <APN_NAME>
 
     def get_apikey(self):
         return self._apikey
 
-    def get_wifi_creds(self):
-        return {'ssid': self._wifi_ssid, 'password': self._wifi_password}
-
-    def get_lte_creds(self):
-        return {'pin': self._pin, 'apn_name': self._apn}
+    def get_creds(self):
+        if self._net_type == LiveObjects.BoardsInterface.WIFI:
+            return {'ssid': self._wifi_ssid, 'password': self._wifi_password}
+        elif self._net_type == LiveObjects.BoardsInterface.LTE:
+            return {'pin': self._pin, 'apn_name': self._apn}

LiveObjects/hal.py

@@ -12,13 +12,13 @@
 
 class BoardsInterface:
 
-    EXISTING = 1
-    WIFI = 2
-    LTE = 3
+    EXISTING_NETWORK = 2
+    WIFI = 3
+    LTE = 4
 
     @staticmethod
-    def create_credentials(mode):
-        return LiveObjects.Credentials(mode)
+    def create_credentials(net_type):
+        return LiveObjects.Credentials(net_type)
 
     def get_apikey(self):
         return self._credentials.get_apikey()
@@ -35,7 +35,7 @@ def mqtt_lib_import_str(lang):
         return import_strings[lang]
 
     def get_security_level(self):
-        return LiveObjects.SSL if self._wifi_tls_capability else LiveObjects.NONE
+        pass
 
     def network_connect(self):
         pass
@@ -49,63 +49,91 @@ class LoPy(BoardsInterface):
 
 
 class GPy(BoardsInterface):
-    def __init__(self):
+    def __init__(self, net_type):
         self._lang = 'microPython'
+        self._net_type = net_type
         self._wifi_tls_capability = True
-        self._lte_tls_capability = True
+        self._lte_tls_capability = False
         self._mqtt_lib = super().mqtt_lib_import_str(self._lang)
-        self._credentials = super().create_credentials(BoardsInterface.WIFI)
+        self._credentials = super().create_credentials(net_type)
 
     def network_connect(self):
-        pycom_wifi_connect(self._credentials.get_wifi_creds()['ssid'], self._credentials.get_wifi_creds()['password'])
+        if self._net_type == BoardsInterface.WIFI:
+            pycom_wifi_connect(self._credentials.get_creds()['ssid'], self._credentials.get_creds()['password'])
+        elif self._net_type == BoardsInterface.LTE:
+            lte_connect(self._credentials.get_creds()['pin'])
+
+    def get_security_level(self):
+        if self._net_type == BoardsInterface.WIFI:
+            return LiveObjects.SSL if self._wifi_tls_capability else LiveObjects.NONE
+        elif self._net_type == BoardsInterface.LTE:
+            return LiveObjects.SSL if self._lte_tls_capability else LiveObjects.NONE
 
 
 class Esp8266(BoardsInterface):
-    def __init__(self):
+    def __init__(self, net_type):
         self._lang = 'microPython'
+        self._net_type = net_type
         self._wifi_tls_capability = False
         self._wifi_lte_capability = False
         self._mqtt_lib = super().mqtt_lib_import_str(self._lang)
         self._credentials = super().create_credentials(BoardsInterface.WIFI)
 
     def network_connect(self):
-        wifi_connect(self._credentials.get_wifi_creds()['ssid'], self._credentials.get_wifi_creds()['password'])
+        if self._net_type == BoardsInterface.WIFI:
+            wifi_connect(self._credentials.get_creds()['ssid'], self._credentials.get_creds()['password'])
+
+    def get_security_level(self):
+        if self._net_type == BoardsInterface.WIFI:
+            return LiveObjects.SSL if self._wifi_tls_capability else LiveObjects.NONE
 
 
 class Win32(BoardsInterface):
     pass
 
 
 class Esp32(BoardsInterface):
-    def __init__(self):
+    def __init__(self, net_type):
         self._lang = 'microPython'
+        self._net_type = net_type
         self._wifi_tls_capability = True
         self._wifi_lte_capability = False
         self._mqtt_lib = super().mqtt_lib_import_str(self._lang)
         self._credentials = super().create_credentials(BoardsInterface.WIFI)
 
     def network_connect(self):
-        wifi_connect(self._credentials.get_wifi_creds()['ssid'], self._credentials.get_wifi_creds()['password'])
+        if self._net_type == BoardsInterface.WIFI:
+            wifi_connect(self._credentials.get_creds()['ssid'], self._credentials.get_creds()['password'])
+
+    def get_security_level(self):
+        if self._net_type == BoardsInterface.WIFI:
+            return LiveObjects.SSL if self._wifi_tls_capability else LiveObjects.NONE
 
 
 class Linux(BoardsInterface):
-    def __init__(self):
+    def __init__(self, net_type):
         self._lang = 'Python'
+        self._net_type = net_type
         self._wifi_tls_capability = True
         self._wifi_lte_capability = False
         self._mqtt_lib = super().mqtt_lib_import_str(self._lang)
-        self._credentials = super().create_credentials(BoardsInterface.EXISTING)
+        self._credentials = super().create_credentials(self._net_type)
 
     def network_connect(self):
-        use_existing_network_connection()
+        if self._net_type == BoardsInterface.EXISTING_NETWORK:
+            use_existing_network_connection()
+
+    def get_security_level(self):
+        if self._net_type == BoardsInterface.EXISTING_NETWORK:
+            return LiveObjects.SSL if self._wifi_tls_capability else LiveObjects.NONE
 
 
 class BoardsFactory:
 
-    def __new__(cls):
+    def __new__(cls, net_type):
         s = os.uname().sysname
         sn = s[0].upper() + s[1:]  # capitalize first letter
-        board = eval(sn)()  # instance of board
+        board = eval(sn)(net_type)  # instance of board w/ net type: WiFi, LTE, etc.
         return board
 
 
@@ -130,6 +158,7 @@ def wifi_connect(ssid, password):
 CONN_TIMEOUT = 20
 
 
+# noinspection PyUnresolvedReferences
 def pycom_wifi_connect(ssid, password):
     from network import WLAN
 
@@ -149,10 +178,10 @@ def pycom_wifi_connect(ssid, password):
             break
 
 
+# noinspection PyUnresolvedReferences
 def lte_connect(pin):
 
     from network import LTE
-    import socket
 
     lte = LTE()
     time.sleep(2)