I04_1-150: showing message for duplicate puck barcode

Author: IsabellaRey

dls_barcode/camera/__init__.py

@@ -1,2 +1,3 @@
 from .camera_switch import CameraSwitch
 from .camera_scanner import CameraScanner
+from .scanner_message import NoNewBarcodeMessage, ScanErrorMessage

dls_barcode/camera/scanner_message.py

@@ -0,0 +1,9 @@
+class NoNewBarcodeMessage:
+    pass
+
+class ScanErrorMessage:
+    def __init__(self, content):
+        self._content = content
+
+    def content(self):
+        return self._content

dls_barcode/camera/scanner_worker.py

@@ -7,6 +7,7 @@
 from dls_barcode.datamatrix import DataMatrix
 from .camera_position import CameraPosition
 from .plate_overlay import PlateOverlay
+from .scanner_message import NoNewBarcodeMessage, ScanErrorMessage
 
 NO_PUCK_TIME = 2
 
@@ -20,7 +21,7 @@ class ScannerWorker:
     """
     def run(self, task_queue, overlay_queue, result_queue, message_queue, kill_queue, config, cam_position):
         print("SCANNER start")
-        self._last_plate_time = time.time()
+        self._last_puck_time = time.time()
 
         SlotScanner.DEBUG = config.slot_images.value()
         SlotScanner.DEBUG_DIR = config.slot_image_directory.value()
@@ -54,8 +55,8 @@ def _process_frame(self, frame, config, overlay_queue, result_queue, message_que
             scan_result.print_summary()
 
         if scan_result.success():
-            # Record the time so we can see how long its been since we last saw a plate
-            self._last_plate_time = time.time()
+            # Record the time so we can see how long its been since we last saw a puck
+            self._last_puck_time = time.time()
 
             plate = scan_result.plate()
             if scan_result.any_valid_barcodes():
@@ -64,8 +65,12 @@ def _process_frame(self, frame, config, overlay_queue, result_queue, message_que
 
             if scan_result.any_new_barcodes():
                 result_queue.put((plate, image))
-        elif scan_result.error() is not None and (time.time() - self._last_plate_time > NO_PUCK_TIME):
-            message_queue.put(Message(MessageType.WARNING, scan_result.error(), lifetime=1))
+        elif scan_result.any_valid_barcodes():
+            # We have read valid barcodes but they are not new
+            self._last_puck_time = time.time()
+            message_queue.put(NoNewBarcodeMessage())
+        elif scan_result.error() is not None and (time.time() - self._last_puck_time > NO_PUCK_TIME):
+            message_queue.put(ScanErrorMessage(scan_result.error()))
 
     def _create_scanner(self, cam_position, config):
         if cam_position == CameraPosition.SIDE:

dls_barcode/gui/main_window.py

@@ -1,10 +1,11 @@
 import multiprocessing
 import queue
+import time
 
 from PyQt4 import QtGui, QtCore
 
 from dls_barcode.config import BarcodeConfig, BarcodeConfigDialog
-from dls_barcode.camera import CameraScanner, CameraSwitch
+from dls_barcode.camera import CameraScanner, CameraSwitch, NoNewBarcodeMessage
 from dls_util import Beeper
 from dls_util.file import FileManager
 from dls_util.message import MessageType, Message
@@ -14,6 +15,11 @@
 from .message_display import MessageDisplay
 
 
+RESULT_TIMER_PERIOD = 1000 # ms
+VIEW_TIMER_PERIOD = 1 # ms
+MESSAGE_TIMER_PERIOD = 1 # ms
+
+
 class DiamondBarcodeMainWindow(QtGui.QMainWindow):
     """ Main GUI window for the Barcode Scanner App.
     """
@@ -39,19 +45,20 @@ def __init__(self, config_file):
         self._view_queue = multiprocessing.Queue()
         self._message_queue = multiprocessing.Queue()
         self._initialise_scanner()
+        self._reset_test_timer()
 
         # Timer that controls how often new scan results are looked for
         self._result_timer = QtCore.QTimer()
         self._result_timer.timeout.connect(self._read_result_queue)
-        self._result_timer.start(1000)
+        self._result_timer.start(RESULT_TIMER_PERIOD)
 
         self._view_timer = QtCore.QTimer()
         self._view_timer.timeout.connect(self._read_view_queue)
-        self._view_timer.start(1)
+        self._view_timer.start(VIEW_TIMER_PERIOD)
 
         self._message_timer = QtCore.QTimer()
         self._message_timer.timeout.connect(self._read_message_queue)
-        self._message_timer.start(1)
+        self._message_timer.start(MESSAGE_TIMER_PERIOD)
 
         self._camera_switch.restart_live_capture_from_side()
 
@@ -195,11 +202,45 @@ def _read_view_queue(self):
     def _read_message_queue(self):
         if not self._message_queue.empty():
             try:
-                message = self._message_queue.get(False)
-                self._message_display.display_message(message)
+                scanner_msg = self._message_queue.get(False)
+                if self._camera_switch.is_side() and isinstance(scanner_msg, NoNewBarcodeMessage):
+                    if not self._test_timer_is_running():
+                        self._start_test_timer()
+                    elif self._has_test_timer_timeout():
+                        self._message_display.display_message(self._get_duplicate_barcode_message())
+                else:
+                    self._reset_test_timer()
+                    self._message_display.display_message(self._get_message_from_scanner_msg(scanner_msg))
             except queue.Empty:
                 return
 
+    def _get_duplicate_barcode_message(self):
+        return Message(MessageType.WARNING, "Puck barcode already in database")
+
+    def _get_message_from_scanner_msg(self, scanner_msg):
+        return Message(MessageType.WARNING, scanner_msg.content())
+
+    def _get_puck_recorded_message(self):
+        return Message(MessageType.INFO, "Puck barcode recorded")
+
+    def _get_scan_timeout_message(self):
+        return Message(MessageType.WARNING, "Scan timeout")
+
+    def _get_scan_completed_message(self):
+        return Message(MessageType.INFO, "Scan completed")
+
+    def _reset_test_timer(self):
+        self._test_timer = None
+
+    def _start_test_timer(self):
+        self._test_timer = time.time()
+
+    def _test_timer_is_running(self):
+        return self._test_timer is not None
+
+    def _has_test_timer_timeout(self):
+        return self._test_timer_is_running() and time.time() - self._test_timer > 2*RESULT_TIMER_PERIOD/1000
+
     def _read_result_queue(self):
         """ Called every second; read any new results from the scan results queue, store them and display them.
         """
@@ -222,17 +263,19 @@ def _read_side_scan(self):
 
         # Barcode successfully read
         Beeper.beep()
-        print("MAIN: holder barcode recorded")
+        print("MAIN: puck barcode recorded")
         if self._record_table.unique_side_barcode(plate): # if new side barcode
             self.original_plate = plate
             self._latest_holder_image = holder_image
-            self._message_display.display_message(Message(MessageType.INFO, "Plate barcode recorded"))
+            self._message_display.display_message(self._get_puck_recorded_message())
             self._camera_switch.restart_live_capture_from_top()
+        else:
+            self._message_display.display_message(self._get_duplicate_barcode_message())
 
     def _read_top_scan(self):
         if self._result_queue.empty():
             if self._camera_switch.is_top_scan_timeout():
-                self._message_display.display_message(Message(MessageType.INFO, "Scan timeout", lifetime=4))
+                self._message_display.display_message(self._get_scan_timeout_message())
                 print("\n*** Scan timeout ***")
                 self._camera_switch.restart_live_capture_from_side()
             return
@@ -248,6 +291,6 @@ def _read_top_scan(self):
         # Barcodes successfully read
         Beeper.beep()
         print("Scan Completed")
-        self._message_display.display_message(Message(MessageType.INFO, "Scan completed"))
+        self._message_display.display_message(self._get_scan_completed_message())
         self._camera_switch.restart_live_capture_from_side()
 

dls_util/object_with_lifetime.py

@@ -5,8 +5,12 @@ class ObjectWithLifetime:
     """ Abstract base class. Has a specified lifetime.
     """
     def __init__(self, lifetime):
+        """A lifetime of 0 indicates that the object does not expire"""
         self._lifetime = lifetime
         self._start_time = time.time()
 
     def has_expired(self):
+        if self._lifetime == 0:
+            return False
+
         return (time.time() - self._start_time) > self._lifetime

tests/unit_tests/test_dls_util/test_object_with_lifetime.py

@@ -24,3 +24,14 @@ def test_object_with_life_greater_than_lifetime_has_expired(self):
 
         # Assert
         self.assertTrue(obj.has_expired())
+
+    def test_zero_lifetime_does_not_expire(self):
+        # Arrange
+        lifetime = 0
+
+        # Act
+        obj = ObjectWithLifetime(lifetime)
+        time.sleep(lifetime)
+
+        # Assert
+        self.assertFalse(obj.has_expired())