Debugging..

[~andy/csm213a-hw] / vis / device.py

diff --git a/vis/device.py b/vis/device.py
index 82b8b4598b44e55757f79d1fbb543714fe92b875..3d19ab24f2af66245f85ac57b17b09ed249af1f0 100644 (file)
--- a/vis/device.py
+++ b/vis/device.py
@@ -18,34 +18,38 @@ class State:                                    #information stored
 
 class Frame:
        # Sensor types
-       ACC_SNS    = 0x00
-       MAG_SNS    = 0x01
-       LGT_SNS    = 0x02
-       TCH_SNS    = 0x03
-       A2D_SNS    = 0x04
+       SNS_ACC    = 0x00
+       SNS_MAG    = 0x01
+       SNS_LGT    = 0x02
+       SNS_TCH    = 0x03
+       SNS_A2D    = 0x04
 
        SNS_NUM    = 0x05
        SNS_SHIFT  = 4
        SNS_MASK   = 0xF0
 
        # Data types
-       INT        = 0
-       LONG       = 1
-       FLOAT      = 2
-       DOUBLE     = 3
-
-       TYP_NUM    = 4
+       TYP_S8     = 0
+       TYP_S16    = 1
+       TYP_S32    = 2
+       TYP_U8     = 3
+       TYP_U16    = 4
+       TYP_U32    = 5
+       TYP_F32    = 6
+       TYP_F64    = 7
+
+       TYP_NUM    = 8
        TYP_SHIFT  = 0
        TYP_MASK   = 0x0F
 
        # Command codes
-       STOP       = 0
-       START      = 1
-       RATE       = 2
+       CMD_STOP   = 0
+       CMD_START  = 1
+       CMD_RATE   = 2
 
-       OPER_NUM   = 3
-       OPER_SHIFT = 0
-       OPER_MASK  = 0x0F
+       CMD_NUM    = 3
+       CMD_SHIFT  = 0
+       CMD_MASK   = 0x0F
 
        # Frame information
        HEADER     = 0x02
@@ -57,25 +61,29 @@ class Frame:
        DATA_POS   = 3
 
        # Maps
-       snsMap   = {ACC_SNS: 'acc',
-                   MAG_SNS: 'mag',
-                   LGT_SNS: 'lgt',
-                   TCH_SNS: 'tch',
-                   A2D_SNS: 'a2d'}
-
-       cmdMap   = {START,   'start',
-                   STOP,    'stop',
-                   RATE,    'rate'}
-
-       sizeMap  = {INT:      2,
-                   LONG:     4,
-                   FLOAT:    4,
-                   DOUBLE:   8}
-
-       fmtMap   = {INT:     'h',
-                   LONG:    'i',
-                   FLOAT:   'f',
-                   DOUBLE:  'd'}
+       snsMap   = {SNS_ACC:   'acc',
+                   SNS_MAG:   'mag',
+                   SNS_LGT:   'lgt',
+                   SNS_TCH:   'tch',
+                   SNS_A2D:   'a2d'}
+
+       cmdMap   = {CMD_START, 'start',
+                   CMD_STOP,  'stop',
+                   CMD_RATE,  'rate'}
+
+       sizeMap  = {TYP_S8:   1,  TYP_S16:  2,  TYP_S32:  4,
+                   TYP_U8:   1,  TYP_U16:  2,  TYP_U32:  4,
+                   TYP_F32:  4,  TYP_F64:  8}
+
+       fmtMap   = {TYP_S8:  'b', TYP_S16: 'h', TYP_S32: 'i',
+                   TYP_U8:  'B', TYP_U16: 'H', TYP_U32: 'I',
+                   TYP_F32: 'f', TYP_F64: 'd'}
+
+        sampleNum= {SNS_ACC:   0,
+                   SNS_MAG:   0,
+                   SNS_LGT:   0,
+                   SNS_TCH:   0,
+                   SNS_A2D:   0}
 
        # Parser data
        index    = 0   # read index
@@ -151,8 +159,14 @@ class Frame:
                fmt = Frame.fmtMap[self.bits_typ] * self.count
                sns = Frame.snsMap[self.bits_sns]
                self.values = unpack('<'+fmt, self.binary)
-               print('convert: %3s = \'%3s\'%%[%s] -> [%s]' %
-                       (sns, fmt, hexDump(self.binary), fltDump(self.values)))
+
+               # Print debug output
+                self.sampleNum[self.bits_sns] += 1
+               #if self.sampleNum[self.bits_sns] == 1000:
+               if self.sampleNum[self.bits_sns] == 1000:
+                        print('convert: %3s = \'%3s\'%%[%s] -> [%s]' %
+                              (sns, fmt, hexDump(self.binary), fltDump(self.values)))
+                        self.sampleNum[self.bits_sns] = 0
 
                # Create state
                state = State()
@@ -201,44 +215,27 @@ class Device:
 
        def set_rate(self, sensor, interval):
                sns   = Frame.findCode(Frame.snsMap, sensor)
-               bits  = (sns        << Frame.SNS_SHIFT) | \
-                       (Frame.RATE << Frame.OPER_SHIFT)
+               bits  = (sns            << Frame.SNS_SHIFT) | \
+                       (Frame.CMD_RATE << Frame.CMD_SHIFT)
                self._write_binary('Bf', bits, interval)
 
        def set_enable(self, sensor, enabled):
                sns   = Frame.findCode(Frame.snsMap, sensor)
-               oper  = Frame.START if enabled else Frame.STOP
-               bits  = (sns  << Frame.SNS_SHIFT) | \
-                       (oper << Frame.OPER_SHIFT)
+               cmd   = Frame.CMD_START if enabled else Frame.CMD_STOP
+               bits  = (sns << Frame.SNS_SHIFT) | \
+                       (cmd << Frame.CMD_SHIFT)
                self._write_binary('B', bits)
 
        def process(self):
-               items = []
-               count = 0
-               limit = 1000
-
                if not self.running():
-                       return items
-
-               while self.serial.readable():
-                       try:
-                               byte  = self.serial.read()
-                       except Exception as ex:
-                               # Not sure why this is excepting
-                               # if it says it's readable
-                               break
-                       if len(byte) == 0:
-                               break
+                       return []
 
+               items = []
+               while self.serial.inWaiting():
+                       byte  = self.serial.read()
                        state = self.frame.parse(byte)
                        if state:
                                items.append(state)
-                       if count > limit:
-                               print('[ERROR] Exceeded Read Limit')
-                               break
-
-                       count += 1
-
                return items