update: 1. Timer Rebuild; 2. LED Rebuild; 3. Location add insernal gnns; 4. settings.py; 5. tracker.py; 6. delete selfcheck.py;

code/battery.py

@@ -1,7 +1,5 @@
 
 from misc import Power
-from machine import Timer
-import usr.settings as settings
 from usr.logging import getLogger
 
 log = getLogger(__name__)
@@ -56,20 +54,8 @@ def get_soc(temp, volt_arg, bat_type='nix_coy_mnzo2'):
 
 
 class Battery(object):
-    def __init__(self, battery_read_cb=None):
+    def __init__(self):
-        current_settings = settings.settings.get()
         self.now_energy = 100
-        self.battery_read_cb = battery_read_cb
-        if self.battery_read_cb:
-            self.battery_timer = Timer(current_settings['sys']['battery_timern'])
-            self.battery_timer.start(period=60 * 1000, mode=self.battery_timer.PERIODIC, callback=self.battery_cb)
-        else:
-            log.warn('Battery read callback is not defined.')
-
-    def battery_cb(self, args):
-        self.energy()
-        if self.battery_read_cb is not None:
-            self.battery_read_cb(self.now_energy)
 
     def indicate(self, low_power_threshold, low_power_cb):
         # TODO: This fun for what?

code/common.py

@@ -1,6 +1,11 @@
+import utime
 import _thread
+import osTimer
 
+from misc import USB
 from misc import Power
+
+import usr.settings as settings
 from usr.battery import Battery
 
 
@@ -39,18 +44,14 @@ class Controller(Singleton):
             self.tracker.remote.post_data(self.tracker.remote.DATA_NON_LOCA, {'power_switch': True})
         elif perm == 'w':
             if flag is True:
-                # TODO: Get other model info
+                self.tracker.machine_info_report()
-                model_info = {}
-                model_info['power_switch'] = flag
-                self.tracker.remote.post_data(self.tracker.remote.DATA_NON_LOCA, model_info)
             elif flag is False:
-                # TODO: Get other model info
+                self.tracker.machine_info_report(power_switch=flag)
-                model_info = {}
+                self.tracker.energy_led.period = None
-                model_info['power_switch'] = flag
+                self.tracker.energy_led.switch(0)
-                self.tracker.remote.post_data(self.tracker.remote.DATA_NON_LOCA, model_info)
+                self.tracker.running_led.period = None
+                self.tracker.running_led.switch(0)
                 Power.powerDown()
-            else:
-                pass
         else:
             raise ControllerError('Controller switch permission error %s.' % perm)
 
@@ -60,3 +61,88 @@ class Controller(Singleton):
             self.tracker.remote.post_data(self.tracker.remote.DATA_NON_LOCA, {'energy': battery_energy})
         else:
             raise ControllerError('Controller energy permission error %s.' % perm)
+
+
+class TrackerTimer(Singleton):
+
+    def __init__(self, tracker):
+        self.tracker = tracker
+        self.tracker_timer = osTimer()
+        self.tracker_timer.start(1000, 1, self.timer_callback)
+        self.loc_count = 0
+        self.barrery_count = 0
+        self.gnns_count = 0
+
+    def timer_callback(self, args):
+        current_settings = settings.settings.get()
+
+        self.loc_count += 1
+        self.barrery_count += 1
+        self.gnns_count += 1
+
+        if (current_settings['app']['loc_mode'] & settings.default_values_app._loc_mode.cycle) \
+                and current_settings['app']['loc_cycle_period'] \
+                and self.loc_count == current_settings['app']['loc_cycle_period']:
+            self.loc_count = 0
+            self.loc_timer()
+
+        if self.barrery_count == 60:
+            self.barrery_count = 0
+            self.barrery_timer()
+
+        if current_settings['app']['loc_method'] & settings.default_values_app._loc_method.gps and \
+                current_settings['app']['gps_mode'] & settings.default_values_app._gps_mode.internal:
+            self.gnns_count = 1
+            self.gnns_timer()
+
+    def loc_timer(self):
+        self.tracker.locator.trigger()
+
+    def barrery_timer(self):
+        current_settings = settings.settings.get()
+        energy = self.tracker.battery.energy()
+        is_charge = USB.getStatus()
+        if is_charge == 0:
+            self.tracker.energy_led_show(energy)
+            if current_settings['app']['sw_low_power_alert']:
+                if energy <= current_settings['app']['low_power_alert_threshold']:
+                    self.tracker.alert.post_alert(30002, {'local_time': utime.mktime(utime.localtime())})
+                    self.tracker.machine_info_report()
+            if energy <= current_settings['app']['low_power_shutdown_threshold']:
+                self.tracker.machine_info_report(power_switch=False)
+                self.tracker.energy_led.period = None
+                self.tracker.energy_led.switch(0)
+                self.tracker.running_led.period = None
+                self.tracker.running_led.switch(0)
+                Power.powerDown()
+        elif is_charge == 1:
+            self.tracker.energy_led_show(energy)
+
+    def gnns_timer(self):
+        self.tracker.locator.gps.quecgnns_read()
+
+
+class LEDTimer(object):
+    def __init__(self, tracker):
+        self.period = 500
+        self.tracker = tracker
+        self.energy_led_count = 0
+        self.running_led_count = 0
+        self.led_timer = osTimer(self.period, 1, self.led_callback)
+
+    def led_callback(self):
+        self.energy_led_count += 1
+        self.running_led_count += 1
+
+        if self.tracker.energy_led.period == 0 or \
+                (self.tracker.energy_led.period > 0 and int(self.tracker.energy_led.period / self.period) == self.energy_led_count):
+            self.led_timer(self.tracker.energy_led)
+
+        if self.tracker.running_led.period == 0 or \
+                (self.tracker.running_led.period > 0 and int(self.tracker.energy_led.period / self.period) == self.running_led_count):
+            self.led_timer(self.tracker.running_led)
+
+    def led_timer(self, led):
+        led.switch(1)
+        if led.period > 0:
+            led.switch()

code/led.py

@@ -1,74 +1,16 @@
-from machine import Timer
-
-import usr.settings as settings
-
 # from machine import Pin
-from usr.common import Singleton
 from usr.logging import getLogger
 
 log = getLogger(__name__)
 
 
-class LED(Singleton):
+class LED(object):
-    def __init__(self):
+    def __init__(self, period=None):
-        current_settings = settings.settings.get()
+        self.period = None
-        self.energy_led_timer = Timer(current_settings['sys']['energy_led_timern'])
-        self.operating_led_timer = Timer(current_settings['sys']['operating_led_timern'])
-        self.on_color = [None, None, None]
-        self.on_period = [None, None, None]
-        self.long_bright = False
-        self.led_type = None
 
-        # TODO: Three LED
+    def switch(self, flag=None):
-        self.energy_led = None
+        # TODO:
-        self.operating_led = None
+        # 1. flag is None Auto Check LED Status ON To OFF or OFF To ON.
-        self.third_led = None
+        # 2. flag is 1 LED ON.
-
+        # 3. flag is 0 LED OFF.
-    def on(self, led_type):
+        pass
-        if led_type == 'energy_led':
-            # color = self.on_color[0]
-            pass
-        elif led_type == 'operating_led':
-            pass
-        elif led_type == 'third_led':
-            pass
-
-    def off(self, led_type):
-        if led_type == 'energy_led':
-            pass
-        elif led_type == 'operating_led':
-            pass
-        elif led_type == 'third_led':
-            pass
-
-    def led_timer_cb(self, args):
-        if self.on_color:
-            self.on(self.led_type)
-        if self.long_bright is False:
-            self.off(self.led_type)
-
-    def flashing_mode(self, led_type, period, color=None):
-        self.led_type = led_type
-        self.long_bright = True if period == 0 else False
-        if period == 0:
-            mode = self.energy_led_timer.ONE_SHOT
-        else:
-            mode = self.energy_led_timer.PERIODIC
-
-        if led_type == 'energy_led':
-            if self.on_color[0] != color or self.on_period[0] != period:
-                self.on_color[0] = color
-                self.on_period[0] = period
-                self.energy_led_timer.stop()
-                self.energy_led_timer.start(period=period, mode=mode, callback=self.led_timer_cb)
-        elif led_type == 'operating_led':
-            if self.on_color[1] != color or self.on_period[1] != period:
-                self.on_color[1] = color
-                self.on_period[1] = period
-                self.operating_led_timer.stop()
-                self.operating_led_timer.start(period=period, mode=mode, callback=self.led_timer_cb)
-        elif led_type == 'third_led':
-            if self.on_color[2] != color or self.on_period[2] != period:
-                self.on_color[2] = color
-                self.on_period[2] = period
-                pass

code/location.py

@@ -11,11 +11,24 @@ from usr.logging import getLogger
 from usr.common import Singleton
 from wifilocator import wifilocator
 
+try:
+    import quecgnns
+except ImportError:
+    quecgnns = None
+
 log = getLogger(__name__)
 
 gps_data_retrieve_queue = None
 
 
+class LocationError(Exception):
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return repr(self.value)
+
+
 def gps_data_retrieve_cb(para_list):
     '''
     GPS data retrieve callback from UART
@@ -46,19 +59,40 @@ def gps_data_retrieve_thread(argv):
 
 class GPS(Singleton):
     def __init__(self, gps_cfg):
+        self.gps_data = ''
+        self.gps_cfg = gps_cfg
+        current_settings = settings.settings.get()
+        if current_settings['app']['gps_mode'] & settings.default_values_app._gps_mode.external:
+            self.uart_init()
+        elif current_settings['app']['gps_mode'] & settings.default_values_app._gps_mode.internal:
+            if quecgnns:
+                quecgnns.init()
+            else:
+                raise LocationError('quecgnns import error.')
+            self.quecgnns_init()
+
+    def uart_init(self):
         global gps_data_retrieve_queue
         self.uart_obj = UART(
-            gps_cfg['UARTn'], gps_cfg['buadrate'], gps_cfg['databits'],
+            self.gps_cfg['UARTn'], self.gps_cfg['buadrate'], self.gps_cfg['databits'],
-            gps_cfg['parity'], gps_cfg['stopbits'], gps_cfg['flowctl']
+            self.gps_cfg['parity'], self.gps_cfg['stopbits'], self.gps_cfg['flowctl']
         )
         self.uart_obj.set_callback(gps_data_retrieve_cb)
-        self.gps_data = ''
         gps_data_retrieve_queue = Queue(maxsize=8)
         _thread.start_new_thread(gps_data_retrieve_thread, (self,))
 
     def uart_read(self, nread):
         return self.uart_obj.read(nread).decode()
 
+    def quecgnns_read(self):
+        if quecgnns.get_state() == 0:
+            quecgnns.gnssEnable(1)
+
+        data = quecgnns.read(4096)
+        self.gps_data = data[1].decode()
+
+        return self.gps_data
+
     def read(self):
         return self.gps_data
 
@@ -201,6 +235,10 @@ class Location(Singleton):
             if r:
                 data.append(r)
 
+            r = self.gps.read_location_GxVTG()
+            if r:
+                data.append(r)
+
             if len(data):
                 return (settings.default_values_app._loc_method.gps, data)
 

code/selfcheck.py

@@ -1,46 +0,0 @@
-
-'''
-check if network, gps, and all the sensors work normally
-'''
-
-import sim
-import net
-import utime
-import usr.settings as settings
-from usr.location import GPS
-
-
-def net_check():
-    # return True if OK
-    if sim.getStatus() == 1:
-        if net.getModemFun() == 1:
-            return True
-
-    return False
-
-
-def gps_check():
-    # return True if OK
-    gps = GPS(settings.default_values_sys._gps_cfg)
-
-    retry = 0
-    gps_data = None
-    sleep_time = 1
-    while retry < 5:
-        gps_data = gps.read()
-        if gps_data:
-            break
-        else:
-            retry += 1
-            utime.sleep(sleep_time)
-            sleep_time *= 2
-    if gps_data:
-        return True
-
-    return False
-
-
-def sensor_check():
-    # return True if OK
-    # TODO: How To Check Light & Movement Sensor?
-    return True

code/settings.py

@@ -6,7 +6,6 @@ import ure
 import _thread
 import quecIot
 from machine import UART
-from machine import Timer
 from usr.logging import getLogger
 from usr.common import Singleton
 
@@ -61,6 +60,11 @@ class default_values_app(object):
         onVoiceRecord = 0x8
         all = 0xF
 
+    class _gps_mode(object):
+        none = 0x0
+        internal = 0x1
+        external = 0x2
+
     class _drive_behavior(object):
         suddenly_start = 0
         suddenly_stop = 1
@@ -70,16 +74,14 @@ class default_values_app(object):
     '''
     variables of App default settings below MUST NOT start with '_'
     '''
-    loc_timern = Timer.Timer0
-    energy_led_timern = Timer.Timer1
-    operating_led_timern = Timer.Timer2
-    battery_timern = Timer.Timer3
 
     phone_num = ''
 
     loc_method = _loc_method.gps
 
-    loc_mode = _loc_mode.none
+    gps_mode = _gps_mode.external
+
+    loc_mode = _loc_mode.cycle
 
     loc_cycle_period = 1
 

code/tracker.py

@@ -1,9 +1,8 @@
-# import _thread
+import sim
+import net
+import utime
 
-# from queue import Queue
-from machine import Timer
 from misc import USB
-from misc import Power
 from misc import PowerKey
 
 import usr.settings as settings
@@ -12,40 +11,35 @@ from usr.led import LED
 from usr.sensor import Sensor
 from usr.remote import Remote
 from usr.battery import Battery
-from usr.common import Singleton, Controller
+from usr.common import Singleton, Controller, TrackerTimer, LEDTimer
-from usr.location import Location
+from usr.location import Location, GPS
 from usr.alert import AlertMonitor
 from usr.logging import getLogger
-from usr.selfcheck import net_check, gps_check, sensor_check
 
 log = getLogger(__name__)
 
 
 class Tracker(Singleton):
     def __init__(self, *args, **kwargs):
-        self.led = LED()
+        self.energy_led = LED()
+        self.running_led = LED()
         self.sensor = Sensor()
         self.locator = Location(self.loc_read_cb)
         self.alert = AlertMonitor(self.alert_read_cb)
         self.battery = Battery(self.batter_read_cb)
-        self.controller = Controller(self.remote)
+        self.controller = Controller(self)
         self.remote = Remote(self, self.remote_read_cb)
-
+        self.tracker_timer = TrackerTimer(self)
-        current_settings = settings.settings.get()
+        self.led_timer = LEDTimer(self)
-        self.loc_timer = Timer(current_settings['sys']['loc_timern'])
-        self.loc_timer_init()
 
         self.power_key = PowerKey()
         self.power_key.powerKeyEventRegister(self.pwk_callback)
         self.usb = USB()
         self.usb.setCallback(self.usb_callback)
+        self.check = SelfCheck()
 
     def remote_read_cb(self, *data):
-        if data:
+        pass
-            if data[0] == 'object_model':
-                for item in data[1]:
-                    if item[0] == 'loc_mode':
-                        self.loc_timer_init()
 
     def loc_read_cb(self, data):
         if data:
@@ -65,70 +59,46 @@ class Tracker(Singleton):
             alert_data = {data[0]: data[1]}
             self.remote.post_data(data_type, alert_data)
 
-    def batter_read_cb(self, *data):
+    def machine_info_report(self, power_switch=True):
         current_settings = settings.settings.get()
-        energy = data[0]
+        self.locator.trigger()
-        is_charge = USB.getStatus()
+        # TODO: Other Machine Info.
-        if is_charge == 0:
+        machine_info = {
-            self.energy_led_show(energy)
+            'power_switch': power_switch,
-            if current_settings['app']['sw_low_power_alert']:
+            'energy': self.battery.energy(),
-                if energy <= current_settings['app']['low_power_alert_threshold']:
+            'local_time': utime.mktime(utime.localtime()),
-                    # TODO: low_power_alert
+            'phone_num': current_settings['app']['phone_num'],
-                    pass
+        }
-            if energy <= current_settings['app']['low_power_shutdown_threshold']:
+        self.remote.post_data(self.remote.DATA_NON_LOCA, machine_info)
-                # TODO: low_power_shutdown
-                self.led.off()
-                Power.powerDown()
-        elif is_charge == 1:
-            if energy == 100:
-                self.led.flashing_mode('energy_led', 0, 'green')
-
-    def machine_info_report(self):
-        pass
 
     def energy_led_show(self, energy):
-        color = None
-        if energy <= 5:
-            self.led.off()
-        elif 5 < energy <= 20:
-            color = 'red'
-        elif 20 < energy <= 40:
-            color = 'orange'
-        elif 40 < energy <= 70:
-            color = 'yellow'
-        elif 70 < energy <= 100:
-            color = 'green'
-        if color:
-            self.led.flashing_mode('energy_led', 0, color)
-
-    def loc_timer_cb(self, args):
-        self.locator.trigger()
-
-    def loc_timer_init(self):
         current_settings = settings.settings.get()
-        if (current_settings['app']['loc_mode'] & settings.default_values_app._loc_mode.cycle) \
+        if energy <= current_settings['app']['low_power_shutdown_threshold']:
-                and current_settings['app']['loc_cycle_period']:
+            self.energy_led.period = None
-            log.debug('[.] loc_timer to restart.')
+            self.energy_led.switch(0)
-            self.loc_timer.stop()
+        elif current_settings['app']['low_power_shutdown_threshold'] < energy <= current_settings['app']['low_power_alert_threshold']:
-            log.debug('[.] loc_timer stop.')
+            self.energy_led.period = 1
-            self.loc_timer.start(period=current_settings['app']['loc_cycle_period'] * 1000, mode=self.loc_timer.PERIODIC, callback=self.loc_timer_cb)
+        elif current_settings['app']['low_power_alert_threshold'] < energy:
-            log.debug('[.] loc_timer start.')
+            self.energy_led.period = 0
-        else:
-            self.loc_timer.stop()
-            log.debug('[.] loc_timer stop forever.')
 
     def pwk_callback(self, status):
         if status == 0:
-            # TODO: Power On SelfCheck
             log.info('PowerKey Release.')
-            net_check_res = net_check()
+            net_check_res = self.check.net_check()
-            gps_check_res = gps_check()
+            gps_check_res = self.check.gps_check()
-            sensor_check_res = sensor_check()
+            sensor_check_res = self.check.sensor_check()
             if net_check_res and gps_check_res and sensor_check_res:
-                self.led.flashing_mode('operating_led', 2000)
+                self.running_led.period = 2
             else:
-                self.led.flashing_mode('operating_led', 500)
+                self.running_led.period = 0.5
-                # TODO: Post Fault Error Info
+                if not net_check_res:
+                    self.alert.post_alert(20000, {'fault_code': 20001})
+                if not gps_check_res:
+                    self.alert.post_alert(20000, {'fault_code': 20002})
+                if not sensor_check_res:
+                    # TODO: Need To Check What Sensor Error To Report.
+                    pass
+                self.machine_info_report()
         elif status == 1:
             log.info('PowerKey Press.')
         else:
@@ -141,11 +111,41 @@ class Tracker(Singleton):
             self.energy_led_show(energy)
         elif status == 1:
             log.info('USB is connected.')
-            if energy <= 5:
+            self.energy_led_show(energy)
-                self.led.flashing_mode('energy_led', 1000, 'red')
-            elif 5 < energy < 100:
-                self.led.flashing_mode('energy_led', 1000, 'yellow')
-            elif energy == 100:
-                self.led.flashing_mode('energy_led', 0, 'green')
         else:
             log.warn('Unknown USB Stauts:', status)
+
+
+class SelfCheck(object):
+    def net_check(self):
+        # return True if OK
+        if sim.getStatus() == 1:
+            if net.getModemFun() == 1:
+                return True
+
+        return False
+
+    def gps_check(self):
+        # return True if OK
+        gps = GPS(settings.default_values_sys._gps_cfg)
+
+        retry = 0
+        gps_data = None
+        sleep_time = 1
+        while retry < 5:
+            gps_data = gps.read()
+            if gps_data:
+                break
+            else:
+                retry += 1
+                utime.sleep(sleep_time)
+                sleep_time *= 2
+        if gps_data:
+            return True
+
+        return False
+
+    def sensor_check(self):
+        # return True if OK
+        # TODO: How To Check Light & Movement Sensor?
+        return True