Add support for G&G JJ100B scale

trickler/main.py

@@ -162,7 +162,7 @@ def main(config, args, pidtune_logger):
     parser.add_argument('--verbose', action='store_true')
     parser.add_argument('--auto_mode', action='store_true')
     parser.add_argument('--pid_tune', action='store_true')
-    parser.add_argument('--target_weight', type=decimal.Decimal, default=0)
+    parser.add_argument('--target_weight', type=decimal.Decimal, default=10)   # default=0
     parser.add_argument('--target_unit', choices=scales.UNIT_MAP.keys(), default='GN')
     args = parser.parse_args()
 

trickler/scales.py

@@ -25,13 +25,13 @@ class Units(enum.Enum):
 
 UNIT_MAP = {
     'GN': Units.GRAINS,
-    'g': Units.GRAMS,
+    'G': Units.GRAMS,
 }
 
 
 UNIT_REVERSE_MAP = {
     Units.GRAINS: 'GN',
-    Units.GRAMS: 'g',
+    Units.GRAMS: 'G',
 }
 
 
@@ -40,6 +40,133 @@ def noop(*args, **kwargs):
     return
 
 
+class GGjj100b:
+    """Class for controlling a G&G JJ100B scale."""
+
+    class ScaleStatusV1(enum.Enum):
+        """Supports the first version of OpenTrickler software."""
+        STABLE = 0
+        UNSTABLE = 1
+        OVERLOAD = 2
+        ERROR = 3
+        MODEL_NUMBER = 4
+        SERIAL_NUMBER = 5
+        ACKNOWLEDGE = 6
+
+    class ScaleStatusV2(enum.Enum):
+        """New version avoids zero (0) which can be confused with null/None."""
+        STABLE = 1
+        UNSTABLE = 2
+        OVERLOAD = 3
+        ERROR = 4
+        MODEL_NUMBER = 5
+        SERIAL_NUMBER = 6
+        ACKNOWLEDGE = 7
+
+    def __init__(self, memcache, port='/dev/ttyUSB0', baudrate=9600, timeout=0.1, _version=1, **kwargs):
+        """Controller."""
+        self._memcache = memcache
+        self._serial = serial.Serial(port=port, baudrate=baudrate, timeout=timeout, **kwargs)
+        # Set default values, which should be overwritten quickly.
+        self.raw = b''
+        self.unit = Units.GRAINS
+        self.resolution = decimal.Decimal(0.02)
+        self.weight = decimal.Decimal('0.00')
+
+        self.StatusMap = self.ScaleStatusV1
+        if _version == 2:
+            self.StatusMap = self.ScaleStatusV2
+
+        self.status = self.StatusMap.STABLE
+        self.model_number = None
+        self.serial_number = None
+        atexit.register(self._graceful_exit)
+
+    def _graceful_exit(self):
+        """Graceful exit, closes serial port."""
+        logging.debug('Closing serial port...')
+        self._serial.close()
+
+    def change_unit(self):
+        """Changes the unit of weight on the scale."""
+        logging.debug('changing weight unit on scale from: %r', self.unit)
+        # Send Mode button command.
+        self._serial.write(b'\x1B\x73')
+        # Sleep 1s and wait for change to take effect.
+        time.sleep(1)
+        # Run update fn to set latest values.
+        self.update()
+
+    @property
+    def is_stable(self):
+        """Returns True if the scale is stable, otherwise False."""
+        return self.status == self.StatusMap.STABLE
+        # returns 1 when previous weights match with current
+        # return len(set(self._previous_reads)) == 1
+
+    def update(self):
+        """Read from the serial port and update an instance of this class with the most recent values."""
+        handlers = {
+            ' GN': self._stable,
+            '   ': self._unstable,
+            'F---.-H': self._overload,
+            None: noop,
+        }
+
+        # Note: The input buffer can fill up, causing latency. Clear it before reading.
+        self._serial.reset_input_buffer()
+        self._serial.write(b'\x1B\x70')
+        raw = self._serial.readline()
+        self.raw = raw
+        logging.debug(raw)
+        try:
+            line = raw.strip().decode('utf-8')
+        except UnicodeDecodeError:
+            logging.debug('Could not decode bytes to unicode.')
+        else:
+            status = line[9:12].strip()
+            fault = line[2:9].strip()
+            handler = handlers.get(status, noop)
+            handler2 = handlers.get(fault, noop)
+            handler(line)
+            handler2(line)
+
+    def _stable_unstable(self, line):
+        """Update the scale when status is stable or unstable."""
+        weight = line[2:9].strip()
+        self.weight = decimal.Decimal(weight)
+
+        unit = line[9:12].strip()
+        self.unit = UNIT_MAP[unit]
+
+        resolution = {}
+        resolution[Units.GRAINS] = decimal.Decimal(0.02)
+        resolution[Units.GRAMS] = decimal.Decimal(0.001)
+
+        self.resolution = resolution[self.unit]
+        # Update memcache values.
+        self._memcache.set(constants.SCALE_STATUS, self.status)
+        self._memcache.set(constants.SCALE_WEIGHT, self.weight)
+        self._memcache.set(constants.SCALE_UNIT, self.unit)
+        self._memcache.set(constants.SCALE_RESOLUTION, self.resolution)
+        self._memcache.set(constants.SCALE_IS_STABLE, self.is_stable)
+
+    def _stable(self, line):
+        """Scale is stable."""
+        self.status = self.StatusMap.STABLE
+        self._stable_unstable(line)
+
+    def _unstable(self, line):
+        """Scale is unstable."""
+        self.status = self.StatusMap.UNSTABLE
+        self._stable_unstable(line)
+
+    def _overload(self, line):
+        """Scale is overloaded."""
+        self.status = self.StatusMap.OVERLOAD
+        self._memcache.set(constants.SCALE_STATUS, self.status)
+
+
 class ANDFx120:
     """Class for controlling an A&D FX120 scale."""
 
@@ -187,6 +314,7 @@ def _serial_number(self, line):
 
 SCALES = {
     'and-fx120': ANDFx120,
+    'jj100b': GGjj100b,
 }
 
 
@@ -196,9 +324,9 @@ def _serial_number(self, line):
     import helpers
 
     parser = argparse.ArgumentParser(description='Test scale.')
-    parser.add_argument('--scale', choices=SCALES.keys(), default='and-fx120')
+    parser.add_argument('--scale', choices=SCALES.keys(), default='jj100b')
     parser.add_argument('--scale_port', default='/dev/ttyUSB0')
-    parser.add_argument('--scale_baudrate', type=int, default='19200')
+    parser.add_argument('--scale_baudrate', type=int, default='9600')
     parser.add_argument('--scale_timeout', type=float, default='0.1')
     parser.add_argument('--scale_version', type=int, default='1')
     args = parser.parse_args()