From 503678df16d0192421dad0f6ddd1df770873ad22 Mon Sep 17 00:00:00 2001
From: wu_xinjun <bent20140204@outlook.com>
Date: 星期四, 16 六月 2022 10:34:53 +0800
Subject: [PATCH] dust cleaner installed!

---
 src/engine/MessageThreads.py  |   50 ++++++++++
 src/engine/AcquisitionMain.py |   35 +++++-
 src/engine/devices.py         |  181 ++++++++++++++++++-----------------
 3 files changed, 169 insertions(+), 97 deletions(-)

diff --git a/src/engine/AcquisitionMain.py b/src/engine/AcquisitionMain.py
index 17d80ed..4c98a0f 100644
--- a/src/engine/AcquisitionMain.py
+++ b/src/engine/AcquisitionMain.py
@@ -7,7 +7,7 @@
 # from .ControllThread import ControllThread
 # from .MicroWaveUDPThread import MicroWaveUDPThread
 from . import MessageThreads as ths
-from .devices import cameraController, dustCleanerController
+from .devices import cameraController, dustCleanerController,microwaveController
 
 # # add python path of src to sys.path
 # src_path = os.path.join(__file__, *(['..'] * 2))
@@ -75,11 +75,17 @@
         self.MQpassword = MQpassword
         self.parameters = None
         # camera
-        self.IMAGE_WIDTH = 3840
-        self.IMAGE_HEIGHT = 2880
-        self.CAMERA_COUNT = 4
+        self.IMAGE_WIDTH = IMAGE_WIDTH
+        self.IMAGE_HEIGHT = IMAGE_HEIGHT
+        self.CAMERA_COUNT = CAMERA_COUNT
         # microwave
         self.MICROWAVEhost = MICROWAVEhost
+
+        # dust cleaner
+        self.com = "COM11"
+        self.bps = "115200"
+        self.timeout = 1
+        
         # threads
         self.threads = []
 
@@ -182,9 +188,9 @@
     def _connect_device(self):
         # connect to cameras
         self.cc = cameraController(
-                        IMAGE_WIDTH=IMAGE_WIDTH,
-                        IMAGE_HEIGHT=IMAGE_HEIGHT,
-                        CAMERA_COUNT=CAMERA_COUNT,
+                        IMAGE_WIDTH=self.IMAGE_WIDTH,
+                        IMAGE_HEIGHT=self.IMAGE_HEIGHT,
+                        CAMERA_COUNT=self.CAMERA_COUNT,
                         device_id=self.device_id,
                         logs_queue=self.LogsSender_queue,
                         images_queue=self.ImagesSender_queue,
@@ -192,7 +198,20 @@
                         init_routing_key="server"
 
         )
-        # self.dc = dustCleanerController()
+        self.dc = dustCleanerController(
+                    com = self.com,
+                    bps = self.bps,
+                    timeout=self.timeout,
+                    logs_queue=self.LogsSender_queue,
+                    device_id=self.device_id,
+                    routing_key="server"
+                    )
+
+        self.mc = microwaveController()
+
+
+
+        
 
     def run_rabbitmq(self):
         self._connect_to_MQ()
diff --git a/src/engine/MessageThreads.py b/src/engine/MessageThreads.py
index 98e7cc0..d66975a 100644
--- a/src/engine/MessageThreads.py
+++ b/src/engine/MessageThreads.py
@@ -8,6 +8,7 @@
 from datetime import datetime
 from typing import List
 import numpy as np
+import cv2
 
 # # add python path of src to sys.path
 # src_path = os.path.join(__file__, *(['..'] * 2))
@@ -327,6 +328,55 @@
     def decode_CommandsMsg(self,queue):
 
         raise NotImplementedError("NOT IMPLEMENT!")
+
+
+
+def send_logs_tool(logs:List[str],
+                logs_queue:queue.Queue,
+                source:str,
+                routing_key:str):
+
+    for i, log in enumerate(logs):
+        if log is not None:
+            # constract a logs message
+            logsMsg = pb.LogsMessage()
+            logsMsg.source = source
+            logsMsg.timestamp = f"{time.asctime()}"
+            logsMsg.context = log
+            # convert the proto object to string
+            logsMsg_bytes = logsMsg.SerializeToString()
+            # add logsmsg to queue
+            logs_queue.put([routing_key,logsMsg_bytes])
+
+
+def send_images_tool(images:List[np.array],
+                    images_queue:queue.Queue,
+                    source:str,
+                    routing_key:str):
+
+        # constract a images message
+        imagesMsg = pb.ImagesMessage()
+        imagesMsg.source = source
+        curr_time = datetime.now().strftime('%Y-%m-%d-%H-%M-%S')
+        imagesMsg.timestamp = curr_time
+
+        for img in images:
+            if img is not None:
+                success,image_encoded = cv2.imencode(".jpg",img)
+                if success:
+                    image_bytes = image_encoded.tobytes()
+                    image_length = len(image_bytes)
+                    # add the encoded image to msg
+                    image_item = imagesMsg.Image.add()
+                    image_item.length = image_length
+                    image_item.data = image_bytes
+
+        # converting the pb image msg to bytes
+        imageMsg_bytes = imagesMsg.SerializeToString()
+        # add the imageMsg to the queue
+        images_queue.put([routing_key,imageMsg_bytes])
+
+
     
 
 
diff --git a/src/engine/devices.py b/src/engine/devices.py
index 29f4340..07f5d32 100644
--- a/src/engine/devices.py
+++ b/src/engine/devices.py
@@ -14,7 +14,11 @@
 # sys.path.insert(0, src_path)
 
 from ..protos import aerial_pb2 as pb
+from .DustCleaner import DustCleaner
+from .MessageThreads import send_logs_tool, send_images_tool
 
+
+######################################### CAMERAS ############################################
 class cameraController(object):
 
     def __init__(self,
@@ -66,45 +70,15 @@
         
     def _generate_msg(self,logs:List[str],images:List):
 
-        # constract a images message
-        imagesMsg = pb.ImagesMessage()
-        imagesMsg.source = self.device_id
-        curr_time = datetime.now().strftime('%Y-%m-%d-%H-%M-%S')
-        imagesMsg.timestamp = curr_time 
-        log_rk = self.routing_key+".logs.test0"
-        image_rk = self.routing_key+".images.test0"
+        send_logs_tool(logs=logs,
+                        logs_queue=self.logs_queue,
+                        source=self.device_id,
+                        routing_key=self.routing_key+".logs.test0")
 
-        for log, img in zip(logs,images):
-
-            # encoding the images to the bytes
-            # encode_params = [int(cv2.IMWRITE_JPEG_QUALITY), self.image_quality]
-            # image_encoded = cv2.imencode(".jpg",single_img,encode_params)
-            if img is not None:
-                success,image_encoded = cv2.imencode(".jpg",img)
-                if success:
-                    image_bytes = image_encoded.tobytes()
-                    image_length = len(image_bytes)
-                    # add the encoded image to msg
-                    image_item = imagesMsg.Image.add()
-                    image_item.length = image_length
-                    image_item.data = image_bytes
-
-            if log is not None:
-                # constract a logs message
-                logsMsg = pb.LogsMessage()
-                logsMsg.source = self.device_id
-                logsMsg.timestamp = f"{time.asctime()}"
-                logsMsg.context = log
-                # convert the proto object to string
-                logsMsg_bytes = logsMsg.SerializeToString()
-                # add logsmsg to queue
-                self.logs_queue.put([log_rk,logsMsg_bytes])
-
-
-        # converting the pb image msg to bytes
-        imageMsg_bytes = imagesMsg.SerializeToString()
-        # add the imageMsg to the queue
-        self.images_queue.put([image_rk,imageMsg_bytes])
+        send_images_tool(images=images,
+                        images_queue=self.images_queue,
+                        source=self.device_id,
+                        routing_key=self.routing_key+".images.test0")
 
 
     def _capture_image(self,mode:str = "capture"):
@@ -168,68 +142,97 @@
         self.routing_key = self.init_routing_key
 
 
+
+######################################## MICROWAVE ###########################################
 class microwaveController(object):
     pass
 
-class dustCleanerController(object):
-    
-    pass 
 
+####################################### DUST CLEANER #########################################
+class dustCleanerController(DustCleaner):
+    def __init__(self, com, bps, timeout, logs_queue, device_id,routing_key):
+        super().__init__(com, bps, timeout)
 
-class CaptureThread(threading.Thread):
-    """
-    camera capture thread
-    """
-    def __init__(self, cameras, msg_queue, interval, device_id,image_quality = 95):
-        """init the thread"""
-        threading.Thread.__init__(self)
-        self.cameras = cameras
-        self.msg_queue = msg_queue
-        self.interval = interval
-        self.image_quality = image_quality
-        self.is_stop = False
+        self.logs_queue = logs_queue
         self.device_id = device_id
+        self.routing_key = routing_key
+        self._check_cleaner()
 
-    def stop(self):
-        """stop the thread"""
-        self.is_stop = True
 
-# TODO鏍规嵁鏂扮殑鏁版嵁缁撴瀯淇敼闃熸秷鎭槦鍒椼��
-    def run(self):
-        print("CaptureThread started")
-        encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), self.image_quality]
-        self.next_time = time.time() + self.interval
-        while not self.is_stop:
-            this_time = time.time()
-            if this_time > self.next_time:
-                for i in range(len(self.cameras)):
-                    _, frame = self.cameras[i].read()
-                    capture_time = time.time()
-                    _, encimg = cv2.imencode('.jpg', frame, encode_param)
-                    if frame is not None:
-                        np_array = np.asarray(encimg)  # frame 杞崲涓簄umpy鏁扮粍
-                        byte_array = np_array.tobytes()  # numpy鏁扮粍杞崲涓篵yte鏁扮粍
-                        # convert the image to pb.DataField
-                        imagedata = pb.DataField()
-                        imagedata.data = byte_array
-                        imagedata.length = len(byte_array)
+    def _check_cleaner(self):
 
-                        data_str = imagedata.SerializeToString()
+        success = self.Open()
 
-                        # create protobuf message
-                        data_msg = pb.CapturedData()
-                        data_msg.generate_time = capture_time
-                        data_msg.generate_device = self.device_id
-                        data_msg.camera_port = i
-                        data_msg.image_data = data_str
+        log = "Unknown log."
+        if success:
+            log = f"The port [{self.port}] refered to the dust cleaner is open."
+        else:
+            log = f"The port [{self.port}] refered to the dust cleaner can not open."
+
+        # display
+        print(f"{time.asctime()} | {log}")
+        
+        send_logs_tool(logs=[log],
+                        logs_queue=self.logs_queue,
+                        source = self.device_id,
+                        routing_key=self.routing_key+".logs.test0")
+
+
+
+# class CaptureThread(threading.Thread):
+#     """
+#     camera capture thread
+#     """
+#     def __init__(self, cameras, msg_queue, interval, device_id,image_quality = 95):
+#         """init the thread"""
+#         threading.Thread.__init__(self)
+#         self.cameras = cameras
+#         self.msg_queue = msg_queue
+#         self.interval = interval
+#         self.image_quality = image_quality
+#         self.is_stop = False
+#         self.device_id = device_id
+
+#     def stop(self):
+#         """stop the thread"""
+#         self.is_stop = True
+
+# # TODO鏍规嵁鏂扮殑鏁版嵁缁撴瀯淇敼闃熸秷鎭槦鍒椼��
+#     def run(self):
+#         print("CaptureThread started")
+#         encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), self.image_quality]
+#         self.next_time = time.time() + self.interval
+#         while not self.is_stop:
+#             this_time = time.time()
+#             if this_time > self.next_time:
+#                 for i in range(len(self.cameras)):
+#                     _, frame = self.cameras[i].read()
+#                     capture_time = time.time()
+#                     _, encimg = cv2.imencode('.jpg', frame, encode_param)
+#                     if frame is not None:
+#                         np_array = np.asarray(encimg)  # frame 杞崲涓簄umpy鏁扮粍
+#                         byte_array = np_array.tobytes()  # numpy鏁扮粍杞崲涓篵yte鏁扮粍
+#                         # convert the image to pb.DataField
+#                         imagedata = pb.DataField()
+#                         imagedata.data = byte_array
+#                         imagedata.length = len(byte_array)
+
+#                         data_str = imagedata.SerializeToString()
+
+#                         # create protobuf message
+#                         data_msg = pb.CapturedData()
+#                         data_msg.generate_time = capture_time
+#                         data_msg.generate_device = self.device_id
+#                         data_msg.camera_port = i
+#                         data_msg.image_data = data_str
 
                         
 
-                        # add message to queue
-                        self.msg_queue.put(data_msg)
+#                         # add message to queue
+#                         self.msg_queue.put(data_msg)
 
-                self.next_time += self.interval
-            time.sleep(0.1)
-        for camera in self.cameras:
-            camera.release()
-        print("CaptureThread stopped")
\ No newline at end of file
+#                 self.next_time += self.interval
+#             time.sleep(0.1)
+#         for camera in self.cameras:
+#             camera.release()
+#         print("CaptureThread stopped")
\ No newline at end of file

--
Gitblit v1.9.1