dust cleaner installed!

wu_xinjun

2022-06-16 503678df16d0192421dad0f6ddd1df770873ad22

dust cleaner installed!

 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()

 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])


    



 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 转换为numpy数组
                        byte_array = np_array.tobytes()  # numpy数组转换为byte数组
                        # 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 转换为numpy数组
#                         byte_array = np_array.tobytes()  # numpy数组转换为byte数组
#                         # 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")
#                 self.next_time += self.interval
#             time.sleep(0.1)
#         for camera in self.cameras:
#             camera.release()
#         print("CaptureThread stopped")