拍照机smartshooter

python/api.py

@@ -549,12 +549,6 @@ def get_photo_records(page: int = 1, size: int = 5):
         }
     ]
     for item in result:
-        print(item)
-        # list_item = photos.read_all(
-        #     session,
-        #     conditions={"goods_art_no": item.goods_art_no},
-        #     join_conditions=join_conditions,
-        # )
         query = (
             select(PhotoRecord, DeviceConfig.action_name)
             .where(PhotoRecord.goods_art_no == item.goods_art_no)
@@ -652,10 +646,21 @@ def update_left_right_config(params: LeftRightParams):
     save_device_config = sysConfig.updateConditions(
         session, conditions={"key": "action_configs"}, **kwargs
     )
-    # return {"code": 0, "msg": "操作成功", "data": save_device_config}
     return {"code": 0, "msg": "操作成功", "data": None}
 
 
+@app.post("/update_record", description="更新拍照记录")
+def update_record(params: RecordUpdate):
+    session = SqlQuery()
+    photoRecord = CRUD(PhotoRecord)
+    model = photoRecord.read(session, conditions={"id": params.id})
+    if model == None:
+        return {"code": 1, "msg": "记录不存在", "data": None}
+    kwargs = params.__dict__
+    save_device_config = photoRecord.update(session, obj_id=params.id, **kwargs)
+    return {"code": 0, "msg": "操作成功", "data": save_device_config}
+
+
 @app.post("/update_sys_configs", description="创建或修改系统配置")
 def save_sys_configs(params: SysConfigParams):
     session = SqlQuery()
@@ -673,16 +678,6 @@ def save_sys_configs(params: SysConfigParams):
 def create_main_image(params: MaineImageTest):
     file_path = params.file_path
     onePic = OnePicTest(pic_path=file_path)
-    # session = SqlQuery()
-    # sysConfig = CRUD(SysConfigs)
-    # model = sysConfig.read(session, conditions={"key": params.key})
-    # if model == None:
-    #     return {"code": 1, "msg": "配置不存在", "data": None}
-    # # 走编辑逻辑
-    # kwargs = params.__dict__
-    # save_device_config = sysConfig.updateConditions(
-    #     session, conditions={"key": params.key}, **kwargs
-    # )
     main_out_path = onePic.HandlerMainImage()
     return {"code": 0, "msg": "操作成功", "data": {"main_out_path": main_out_path}}
 

python/databases.py

@@ -79,8 +79,9 @@ def insert_photo_records(
     device_config = PhotoRecord(**data)
     session.add(device_config)
     session.commit()
+    inserted_id = device_config.id
     session.close()
-    return True
+    return True, inserted_id
 
 
 # 创建一个通用的 CRUD 类

python/mcu/BaseClass.py

@@ -1,11 +1,15 @@
 import asyncio
 from sockets import ConnectionManager
 from utils.common import message_queue
+from mcu.capture.smart_shooter_class import SmartShooter
 
 class BaseClass:
 
-    def __init__(self, websocket_manager: ConnectionManager):
+    def __init__(
+        self, websocket_manager: ConnectionManager, smart_shooter: SmartShooter = None
+    ):
         self.websocket_manager = websocket_manager
+        self.smart_shooter = smart_shooter
         self.msg_type = ""
         # -1连接失败  0未连接 1连接中  2连接成功  3端口占用
         # self.device_status = 2
@@ -94,4 +98,4 @@ class BaseClass:
             except:
                 serial_handle = None
                 _recv_data = b""
-                return False
+                return False

python/mcu/BlueToothMode.py

@@ -9,13 +9,17 @@ from utils.SingletonType import SingletonType
 from .RemoteControlV2 import RemoteControlV2
 from .BaseClass import BaseClass
 from sockets.connect_manager import ConnectionManager
+from mcu.capture.smart_shooter_class import SmartShooter
 
-class BlueToothMode(BaseClass,metaclass=SingletonType):
+
+class BlueToothMode(BaseClass, metaclass=SingletonType):
     instance = None
     init_flag = None
 
-    def __init__(self, websocket_manager: ConnectionManager):
-        super().__init__(websocket_manager)
+    def __init__(
+        self, websocket_manager: ConnectionManager, smart_shooter: SmartShooter = None
+    ):
+        super().__init__(websocket_manager, smart_shooter)
         """此处设计为，如果已经存在实例时，不再执行初始化"""
         if self.init_flag:
             return
@@ -149,8 +153,8 @@ class BlueToothMode(BaseClass,metaclass=SingletonType):
                     self.print_error("Failed to connect to the device.")
                     self.devices[address]["connect_state"] = False
                     self.disconnect_device(
-                            address=address, name=self.devices[address]["name"]
-                        )
+                        address=address, name=self.devices[address]["name"]
+                    )
                     continue
                 if len(self.devices) == 0:
                     break
@@ -162,32 +166,28 @@ class BlueToothMode(BaseClass,metaclass=SingletonType):
                     for char in service.characteristics:
                         if "notify" in char.properties:
                             self.print_error(
-                                    f"Subscribing to characteristic: {char.uuid}"
-                                )
+                                f"Subscribing to characteristic: {char.uuid}"
+                            )
                             await client.start_notify(
-                                    char,
-                                    lambda char, data: asyncio.create_task(
-                                        self.notification_handler(address, char, data)
-                                    ),
-                                )
+                                char,
+                                lambda char, data: asyncio.create_task(
+                                    self.notification_handler(address, char, data)
+                                ),
+                            )
 
                 # 进入一个简单的循环，保持连接
                 self.print_error(
-                        "进入一个简单的循环  保持连接", self.devices[address]["name"]
-                    )
-                self.connect_device(
-                        address=address, name=self.devices[address]["name"]
-                    )
+                    "进入一个简单的循环  保持连接", self.devices[address]["name"]
+                )
+                self.connect_device(address=address, name=self.devices[address]["name"])
                 self.retry_num += 1
                 while True:
                     if not client.is_connected:
-                        self.print_error(
-                                f"Device {address} disconnected unexpectedly."
-                            )
+                        self.print_error(f"Device {address} disconnected unexpectedly.")
                         with self._lock:
                             self.disconnect_device(
-                                    address=address, name=self.devices[address]["name"]
-                                )
+                                address=address, name=self.devices[address]["name"]
+                            )
                             if len(self.devices) == 0:
                                 break
                             self.devices[address]["connect_state"] = False
@@ -196,13 +196,9 @@ class BlueToothMode(BaseClass,metaclass=SingletonType):
                         break
                     if self.devices[address]["send_queue"]:
                         with self._lock:
-                            send_data = self.devices[address][
-                                    "send_queue"
-                                ].popleft()
+                            send_data = self.devices[address]["send_queue"].popleft()
                             # print("-----------> send_data:", self.change_hex_to_10_int(send_data))
-                        await self.write_characteristic(
-                                client, char.uuid, send_data
-                            )
+                        await self.write_characteristic(client, char.uuid, send_data)
                         await asyncio.sleep(0.01)
 
                     await asyncio.sleep(0.02)
@@ -229,7 +225,7 @@ class BlueToothMode(BaseClass,metaclass=SingletonType):
         # self.devices_name[_name] = address
         # asyncio.create_task(self.connect_and_listen(address))
         if self.connect_state == True:
-            print('蓝牙已连接，不可重新连接')
+            print("蓝牙已连接，不可重新连接")
             message = {
                 "_type": "show_info",
                 "plugins_mode": "remote_control",
@@ -251,6 +247,7 @@ class BlueToothMode(BaseClass,metaclass=SingletonType):
                 await asyncio.sleep(3)
             await self.scan_for_esp32()
         print("蓝牙断开连接，已释放")
+
     def run(self):
         self.print_error("开启蓝牙扫描")
         asyncio.run(self.main_func())

python/mcu/DeviceControl.py

@@ -16,13 +16,15 @@ from .McuDeviationSet import McuDeviationSet
 from .OtherSet import OtherSet
 from .DebugUart import DebugUart
 import copy
-
+from mcu.capture.smart_shooter_class import SmartShooter
 # mcu命令
 class DeviceControl(BaseClass, metaclass=SingletonType):
     lock = threading.Lock()
 
-    def __init__(self, websocket_manager: ConnectionManager):
-        super().__init__(websocket_manager)
+    def __init__(
+        self, websocket_manager: ConnectionManager, smart_shooter: SmartShooter = None
+    ):
+        super().__init__(websocket_manager=websocket_manager,smart_shooter=smart_shooter)
         self.msg_type = "mcu"
         self.mcu_deviation_set = McuDeviationSet(self)
         self.mcu_other_set = OtherSet(self)
@@ -114,6 +116,7 @@ class DeviceControl(BaseClass, metaclass=SingletonType):
             92: self.get_from_mcu_move_respond_data,  # 获取MCU响应
             100: self.print_mcu_error_data,  # 打印下位机的错误内容
         }
+
     async def sendCommand(self,command):
         await asyncio.sleep(0.01)
         loop = asyncio.get_event_loop()
@@ -1331,18 +1334,19 @@ class DeviceControl(BaseClass, metaclass=SingletonType):
                     device_name="laser_position", value=0 if int(value) <= 0 else 1
                 )
             case "take_picture":
-                capture_one = DigiCam()
-                try:
-                    # camera_is_connect = capture_one.checkCameraConnect()
-                    # if camera_is_connect is not True:
-                    #     self.sendSocketMessage(1,"相机未连接,请检查",device_status=-1)
-                    #     return
-                    capture_one.getCaptureFolderPath()
-                    if value > 0:
-                        capture_one.auto_focus()
-                    capture_one.run_capture_action("Capture")
-                except:
-                    self.sendSocketMessage(1,"digicam未初始化,请检查",device_status=-1)
+                loop = asyncio.get_event_loop()
+                if value>0:
+                    # 指定自动对焦
+                    loop.create_task(
+                        self.smart_shooter.CameraAutofocus(),
+                        name="CameraAutofocus",
+                    )
+                # 拍照
+                print("smart shooter 拍照")
+                loop.create_task(
+                    self.smart_shooter.CameraShooter(msg_type="run_mcu"),
+                    name="CameraShooter",
+                )
             case "to_deal_device":
                 self.to_deal_device(device_name, value=value, _type=0, times=1)
             case _:
@@ -1366,12 +1370,15 @@ class DeviceControl(BaseClass, metaclass=SingletonType):
             )
             return False
 
-    async def run_mcu_config(self, config_list, goods_art_no, action_info):
+    async def run_mcu_config(
+        self, config_list, goods_art_no, action_info, smart_shooter
+    ):
         if self.checkDevice() == False:
             return
         image_counts = 0
         if config_list:
             action_names = []
+            record_ids = []
             if len(config_list) > 1:
                 if config_list[-1]["take_picture"] is True:
                     new_init_config = copy.copy(config_list[0])
@@ -1390,16 +1397,17 @@ class DeviceControl(BaseClass, metaclass=SingletonType):
                 is_take_picture = item["take_picture"]
                 action_id = item["id"]
                 if is_take_picture:
-                    action_names.append(item["action_name"])
                     image_counts += 1
                     # 批量插入
                     image_deal_mode = 0 if action_info == "执行左脚程序" else 1
-                    insert_photo_records(
+                    status,record_id = insert_photo_records(
                         image_deal_mode=image_deal_mode,
                         goods_art_no=goods_art_no,
                         image_index=idx,
                         action_id=action_id,
                     )
+                    action_names.append(item["action_name"])
+                    record_ids.append(record_id)
             total_len = len(config_list)
             self.action_state = 1
             self.msg_type = "image_process"
@@ -1425,6 +1433,7 @@ class DeviceControl(BaseClass, metaclass=SingletonType):
                     self.is_stop_action = False
                     break
                 action_is_take_picture = action["take_picture"]
+                action_id = action["id"]
                 image_index = -1
                 if action_is_take_picture:
                     image_index = index
@@ -1434,8 +1443,8 @@ class DeviceControl(BaseClass, metaclass=SingletonType):
                     mcu=self,
                     goods_art_no=goods_art_no,
                     image_index=image_index,
+                    smart_shooter=smart_shooter,
                 )
-                print("self.action_state===>", self.action_state)
                 if self.action_state != 1:
                     # 异常终止
                     print("action异常终止")
@@ -1445,33 +1454,23 @@ class DeviceControl(BaseClass, metaclass=SingletonType):
                     self.sendSocketMessage(
                         code=1,
                         msg="{} 执行失败~".format(program_item.action_name),
+                        data={"goods_art_no": goods_art_no, "id": action_id},
                         device_status=0,
                     )
                     self.to_deal_device(device_name="buzzer", times=3)
                     break
                 else:
-                    # self.show_info("{}执行完成~".format(action.action_name))
+                    if program_item.action_name == "移动到初始位":
+                        self.msg_type = "mcu"
+                        break
                     self.sendSocketMessage(
                         code=0,
                         msg="{} 执行完成~".format(program_item.action_name),
-                        data={"goods_art_no": goods_art_no},
+                        data={"goods_art_no": goods_art_no, "id": record_ids[index]},
                         device_status=2,
                     )
                 self.msg_type = "mcu"
                 # 在第三张图时检查是否有对应图片生成
-                # if index == 3:
-                #     # if not self.image_process_data.check_photo_is_get():
-                #     self.sendSocketMessage(
-                #             code=1,
-                #             msg="未获取到图片数据",
-                #             device_status=0,
-                #         )
-                #     self.action_state = 2
-                #     return
-                if index == total_len - 1:
-                    #  最后一个初始化处理
-                    pass
-                # self.action_state = 2
             self.action_state = 2
             self.is_runn_action = False
             self.msg_type = "photo_take_finish"
@@ -1483,7 +1482,7 @@ class DeviceControl(BaseClass, metaclass=SingletonType):
             self.msg_type = "mcu"
             self.controlDevice("laser_position", 1)
 
-    async def run_mcu_config_single(self, config_info, goods_art_no,msg_type="run_mcu_single_finish",image_index=-1):
+    async def run_mcu_config_single(self, config_info, goods_art_no,msg_type="run_mcu_single_finish",image_index=-1,smart_shooter=None,action_id=-1):
         '''独立拍照  仅作测试用'''
         if self.checkDevice() == False:
             return
@@ -1497,30 +1496,20 @@ class DeviceControl(BaseClass, metaclass=SingletonType):
                     mcu=self,
                     goods_art_no=goods_art_no,
                     image_index=image_index,
+                    smart_shooter=smart_shooter
                 )
-            print("self.action_state===>", self.action_state)
             if self.action_state != 1:
                 # 异常终止
                 print("action异常终止")
                 return
             self.msg_type = "photo_take"
-            # if not program_item.run_only_mcu(1):
-            #     self.sendSocketMessage(
-            #             code=1,
-            #             msg="{} 执行失败~".format(program_item.action_name),
-            #             device_status=0,
-            #         )
-            #     self.to_deal_device(device_name="buzzer", times=3)
-            #     return
-            # else:
             program_item.run(3)
-            # self.show_info("{}执行完成~".format(action.action_name))
             self.sendSocketMessage(
-                        code=0,
-                        msg="{} 执行完成~".format(program_item.action_name),
-                        data={"goods_art_no": goods_art_no},
-                        device_status=2,
-                    )
+                code=0,
+                msg="{} 执行完成~".format(program_item.action_name),
+                data={"goods_art_no": goods_art_no, "id": action_id},
+                device_status=2,
+            )
             self.msg_type = "mcu"
             self.action_state = 2
             self.msg_type = msg_type

python/mcu/ProgramItem.py

@@ -1,3 +1,4 @@
+import asyncio
 import json
 import os
 
@@ -7,24 +8,38 @@ import time
 from .capture.module_digicam import DigiCam
 from .capture.module_watch_dog import FileEventHandler
 
+
 class ProgramItem(BaseClass):
     # program_sign = Signal(dict)
     # program_refresh_photo_list_sign = Signal()
 
-    def __init__(self,websocket_manager, action_data:any, mcu, goods_art_no:str=None,image_index:int=-1):
+    def __init__(
+        self,
+        websocket_manager,
+        action_data: any,
+        mcu,
+        goods_art_no: str = None,
+        image_index: int = -1,
+        smart_shooter=None,
+    ):
         super().__init__(BaseClass)
         # 1 表示等待中，2表示没有等待
         self.wait_state = 2
         self.msg_type = "mcu"
         print("action_data====>", action_data)
         self.data = action_data
-        self.capture_one = DigiCam()
-        captrure_folder_path = self.capture_one.getCaptureFolderPath()
-        self.watch_dog = FileEventHandler()
-        self.watch_dog.goods_art_no = goods_art_no
-        self.watch_dog.image_index = image_index
-        self.watch_dog.mcu = mcu
-        self.watch_dog.start_observer(captrure_folder_path)
+        print("ProgramItem smart_shooter", smart_shooter)
+        self.smart_shooter = smart_shooter
+        if smart_shooter == None:
+            self.capture_one = DigiCam()
+            captrure_folder_path = self.capture_one.getCaptureFolderPath()
+            self.watch_dog = FileEventHandler()
+            self.watch_dog.goods_art_no = goods_art_no
+            self.watch_dog.image_index = image_index
+            self.watch_dog.mcu = mcu
+            self.watch_dog.start_observer(captrure_folder_path)
+        else:
+            print("使用smart_shooter")
         print("21 =========ProgramItem=======action_data=====")
         print(action_data)
         self.action_id = self.get_value(action_data, "id")
@@ -93,7 +108,7 @@ class ProgramItem(BaseClass):
         }
         if self.is_wait:
             msg = "{}--等待".format(self.action_name)
-            self.sendSocketMessage(msg=msg,device_status=0)
+            self.sendSocketMessage(msg=msg, device_status=0)
         else:
             msg = "{}".format(self.action_name)
             self.sendSocketMessage(msg=msg, device_status=2)
@@ -137,12 +152,12 @@ class ProgramItem(BaseClass):
                 # 外部终止，停止运行
                 return False
             cr_time = time.time()
-            print(cr_time - _s, cr_time,_s)
+            print(cr_time - _s, cr_time, _s)
             if cr_time - _s > 8:
                 self.error_info_text = "MCU检测运动未停止，自动退出"
                 self.set_state(state_value=99)  # 标记异常
                 print("MCU检测运动未停止，自动退出")
-                self.sendSocketMessage(msg=self.error_info_text,device_status=-1)
+                self.sendSocketMessage(msg=self.error_info_text, device_status=-1)
                 return False
                 # return True
             # 存在时间间隙，导致误认为所有设备已完成运动
@@ -171,7 +186,6 @@ class ProgramItem(BaseClass):
             try:
                 self.do_run()
             except BaseException as e:
-                # print("p_item 错误：{}".format(e))
                 self.sendSocketMessage(
                     msg="p_item 错误：{}".format(e), device_status=-1
                 )
@@ -218,7 +232,11 @@ class ProgramItem(BaseClass):
             if self.mode_type != "其他配置" and self.check_mcu_move_is_stop() is False:
                 # MCU运动是否有停止检查，设定超时时间
                 return
-            print("{} 检查停止时间1：{}".format(self.action_name, time.time() - start_time))
+            print(
+                "{} 检查停止时间1：{}".format(
+                    self.action_name, time.time() - start_time
+                )
+            )
             if self.is_led:
                 self.mcu.to_deal_device(device_name="laser_position", value=1)
             else:
@@ -261,16 +279,29 @@ class ProgramItem(BaseClass):
                     return
 
         if self.delay_time:
-            # print("拍照前延时：{}".format(self.delay_time))
             time.sleep(self.delay_time)
-
         if self.is_photograph:
-            print("拍照==>", time.time())
             # print("photograph==================")
             self.mcu.to_deal_device(device_name="buzzer", times=1)
             # 用于临时拍照计数
             is_af = True if self.af_times > 0 else False
-            self.capture_one.photograph(is_af=is_af)
+            loop = asyncio.get_event_loop()
+            if self.smart_shooter != None:
+                if is_af:
+                    # 指定自动对焦
+                    loop.create_task(
+                        self.smart_shooter.CameraAutofocus(),
+                        name="CameraAutofocus",
+                    )
+                # 拍照
+                print("smart shooter 拍照")
+                loop.create_task(
+                    self.smart_shooter.CameraShooter(msg_type="run_mcu"),
+                    name="CameraShooter",
+                )
+            else:
+                # 指定自动对焦
+                self.capture_one.photograph(is_af=is_af)
             self.last_photograph_time = time.time()  # 记录最近一次拍照时间
         # print("{} 拍照时间：{}".format(self.action_name, time.time() - start_time))
         print("{}-{}已完成".format(self.mode_type, self.action_name))

python/mcu/RemoteControlV2.py

@@ -234,7 +234,7 @@ class RemoteControlV2(BaseClass):
         self.msg_type = "blue_tooth"
         self.photo_take_state = 2
 
-    async def handlerTakePhoto(self):
+    async def handlerTakePhoto(self, smart_shooter=None):
         """处理单独拍照"""
         await asyncio.sleep(0.1)
         print("开始单拍0")
@@ -264,28 +264,33 @@ class RemoteControlV2(BaseClass):
                 return
             image_index = record.image_index + 1
             self.photo_take_state = 1
-            insert_photo_records(
+            _,record_id_single = insert_photo_records(
                 record.image_deal_mode,
                 record.goods_art_no,
                 image_index,
                 record.action_id,
             )
             print("开始单拍1-插入数据")
-            capture_one = DigiCam()
             try:
-                watch_dog = FileEventHandler()
-                if watch_dog.observer is None:
-                    captrure_folder_path = capture_one.getCaptureFolderPath()
-                    watch_dog.start_observer(captrure_folder_path)
-                watch_dog.goods_art_no = record.goods_art_no
-                watch_dog.image_index = image_index
-                print("开始单拍1-检查相机")
-                # camera_is_connect = capture_one.checkCameraConnect()
-                # if camera_is_connect is not True:
-                #     self.sendSocketMessage(1, "相机未连接,请检查", device_status=-1)
-                #     return
-                capture_one.run_capture_action("Capture")
-                print("开始单拍1-完成拍照")
+                if smart_shooter == None:
+                    capture_one = DigiCam()
+                    watch_dog = FileEventHandler()
+                    if watch_dog.observer is None:
+                        captrure_folder_path = capture_one.getCaptureFolderPath()
+                        watch_dog.start_observer(captrure_folder_path)
+                    watch_dog.goods_art_no = record.goods_art_no
+                    watch_dog.image_index = image_index
+                    print("开始单拍1-检查相机")
+                    capture_one.run_capture_action("Capture")
+                    print("开始单拍1-完成拍照")
+                else:
+                    loop = asyncio.get_event_loop()
+                    loop.create_task(
+                        self.smart_shooter.CameraShooter(
+                            msg_type="handler_take_picture"
+                        ),
+                        name="CameraShooter",
+                    )
                 time.sleep(1)
                 self.msg_type = "photo_take"
                 self.sendSocketMessage(
@@ -295,12 +300,12 @@ class RemoteControlV2(BaseClass):
                         if record.image_deal_mode == 1
                         else "执行左脚程序"
                     ),
-                    data={"goods_art_no": record.goods_art_no},
+                    data={"goods_art_no": record.goods_art_no, "id": record_id_single},
                     device_status=2,
                 )
                 self.msg_type = "blue_tooth"
             except Exception as e:
-                self.sendSocketMessage(1, "digicam未初始化,请检查", device_status=-1)
+                self.sendSocketMessage(1, "处理失败,请重试", device_status=-1)
         self.photo_take_state = 0
 
     async def analysis_received_data(self):
@@ -311,11 +316,8 @@ class RemoteControlV2(BaseClass):
             receive_data = self.bluetooth_ins.read_cmd_one(
                 address=self.bluetooth_address
             )
-            # print("received data", 1)
         else:
             receive_data = self.serial_ins.read_cmd(out_time=1, check=None)
-        # print("received data", 2)
-        # print("self.bluetooth_ins", receive_data)
         if receive_data is False:
             self.connect_state = False
             return False

python/mcu/capture/smart_shooter_class.py

@@ -8,16 +8,14 @@ from io import BytesIO
 import base64
 import zmq, sys
 from utils.SingletonType import SingletonType
-from mcu.BaseClass import BaseClass
 
 
 # 定义为单例模式,避免被重复实例化
-class SmartShooter(BaseClass,metaclass=SingletonType):
+class SmartShooter(metaclass=SingletonType):
     SET_REQ = "tcp://127.0.0.1:54544"
     LISTEN_REQ = "tcp://127.0.0.1:54543"
 
     def __init__(self, websocket_manager):
-        super().__init__(websocket_manager)
         self.msg_type = "smart_shooter"
         self.websocket_manager = websocket_manager
         # 是否停止监听
@@ -64,12 +62,12 @@ class SmartShooter(BaseClass,metaclass=SingletonType):
         listen_socket.connect(self.LISTEN_REQ)
         return listen_socket, context
 
-    async def GetCameraInfo(self,is_send=True,msg_type=""):
+    async def GetCameraInfo(self, is_send=True, msg_type=""):
         await asyncio.sleep(0.01)
         self.msg_type = msg_type
-        '''
+        """
         实时获取相机信息，是否连接、软件是否被打开
-        '''
+        """
         try:
             socket, context = self.__create_req()
             req = {}
@@ -82,46 +80,60 @@ class SmartShooter(BaseClass,metaclass=SingletonType):
             if not msg_result:
                 self.connect_status = False
                 msg_send = "相机未连接或软件未打开"
-                # self.websocket_manager
                 if is_send:
-                    self.sendSocketMessage(
-                        code=0,
-                        msg=msg_send,
-                        device_status=-1,
-                    )
+                    message = {
+                        "code": 1,
+                        "msg": msg_send,
+                        "data": None,
+                        "msg_type": self.msg_type,
+                        "device_status": -1,
+                    }
+                    await self.websocket_manager.broadcast(message)
                 return False, msg_send
             cameraInfo = json_msg.get("CameraInfo")
             if cameraInfo == None or len(cameraInfo) == 0:
                 self.connect_status = False
                 msg_send = "相机未连接"
                 if is_send:
-                    self.sendSocketMessage(
-                        code=0,
-                        msg=msg_send,
-                        device_status=-1,
-                    )
+                    message = {
+                        "code": 1,
+                        "msg": msg_send,
+                        "data": None,
+                        "msg_type": self.msg_type,
+                        "device_status": -1,
+                    }
+                    await self.websocket_manager.broadcast(message)
                 return False, "相机未连接"
             # 链接的相机
-            connect_camera = cameraInfo[0]
-            CameraStatus = connect_camera.get("CameraStatus")
-            if CameraStatus != "Ready":
+            # connect_camera = cameraInfo
+            CameraStatus = any(
+                item.get("CameraStatus") == "Ready" for item in cameraInfo
+            )
+            # CameraStatus = connect_camera.get("CameraStatus")
+            if not CameraStatus:
                 self.connect_status = False
                 msg_send = "相机未连接"
                 if is_send:
-                    self.sendSocketMessage(
-                        code=0,
-                        msg=msg_send,
-                        device_status=-1,
-                    )
+                    message = {
+                        "code": 1,
+                        "msg": msg_send,
+                        "data": None,
+                        "msg_type": self.msg_type,
+                        "device_status": -1,
+                    }
+                    await self.websocket_manager.broadcast(message)
                 return False, msg_send
             self.connect_status = True
             msg_send = "相机已连接"
             if is_send:
-                self.sendSocketMessage(
-                        code=0,
-                        msg=msg_send,
-                        device_status=2,
-                    )
+                message = {
+                    "code": 0,
+                    "msg": msg_send,
+                    "data": None,
+                    "msg_type": self.msg_type,
+                    "device_status": 2,
+                }
+                await self.websocket_manager.broadcast(message)
             return True, "相机已连接"
         except:
             self.connect_status = False
@@ -129,11 +141,14 @@ class SmartShooter(BaseClass,metaclass=SingletonType):
             context.term()
             msg_send = "相机未连接或软件未打开"
             if is_send:
-                self.sendSocketMessage(
-                    code=0,
-                    msg=msg_send,
-                    device_status=-1,
-                )
+                message = {
+                    "code": 1,
+                    "msg": msg_send,
+                    "data": None,
+                    "msg_type": self.msg_type,
+                    "device_status": -1,
+                }
+                await self.websocket_manager.broadcast(message)
             return False, msg_send
 
     async def EnableCameraPreview(self, enable_status=True, msg_type=""):
@@ -164,22 +179,28 @@ class SmartShooter(BaseClass,metaclass=SingletonType):
                 )
                 return False, "预览启用失败"
             msg_send = "预览启用成功" if enable_status else "预览关闭成功"
-            self.sendSocketMessage(
-                    code=0,
-                    msg=msg_send,
-                    device_status=2,
-                )
+            message = {
+                "code": 0,
+                "msg": msg_send,
+                "data": None,
+                "msg_type": self.msg_type,
+                "device_status": 2,
+            }
+            await self.websocket_manager.broadcast(message)
             return True, "预览启用成功" if enable_status else "预览关闭成功"
         except:
             self.perview_state = False
             socket.close()
             context.term()
             msg_send = "相机未连接或软件未打开"
-            self.sendSocketMessage(
-                code=0,
-                msg=msg_send,
-                device_status=2,
-            )
+            message = {
+                "code": 1,
+                "msg": msg_send,
+                "data": None,
+                "msg_type": self.msg_type,
+                "device_status": -1,
+            }
+            await self.websocket_manager.broadcast(message)
             return False, "相机未连接或软件未打开"
 
     async def CameraAutofocus(self):
@@ -220,34 +241,44 @@ class SmartShooter(BaseClass,metaclass=SingletonType):
             req = {}
             req["msg_type"] = "Request"
             req["msg_id"] = "Shoot"
-            req["msg_seq_num"] = 0
+            req["msg_seq_num"] = 1
             req["CameraSelection"] = "All"
             json_msg = self.__send_tcp_message(socket, req)
+            print("CameraShooter", json_msg)
             msg_result = json_msg.get("msg_result")
             if not msg_result:
                 msg_send = "拍照失败"
-                self.sendSocketMessage(
-                    code=0,
-                    msg=msg_send,
-                    device_status=2,
-                )
+                message = {
+                    "code": 1,
+                    "msg": msg_send,
+                    "data": None,
+                    "msg_type": self.msg_type,
+                    "device_status": -1,
+                }
+                await self.websocket_manager.broadcast(message)
                 return False, msg_send
             msg_send = "拍照成功"
-            self.sendSocketMessage(
-                    code=0,
-                    msg=msg_send,
-                    device_status=2,
-                )
+            message = {
+                "code": 0,
+                "msg": msg_send,
+                "data": None,
+                "msg_type": self.msg_type,
+                "device_status": 2,
+            }
+            await self.websocket_manager.broadcast(message)
             return True, "拍照成功"
         except:
             socket.close()
             context.term()
             msg_send = "相机未连接或软件未打开"
-            self.sendSocketMessage(
-                code=0,
-                msg=msg_send,
-                device_status=2,
-            )
+            message = {
+                "code": 1,
+                "msg": msg_send,
+                "data": None,
+                "msg_type": self.msg_type,
+                "device_status": -1,
+            }
+            await self.websocket_manager.broadcast(message)
             return False, msg_send
 
     async def connect_listen(self):

python/models.py

@@ -110,3 +110,10 @@ class LogoParamsupdate(BaseModel):
 class DeviceConfigTabsReq(BaseModel):
     id: int = Field(default=None, primary_key=True)
     mode_name: str = Field(default="", description="Tab名称")
+
+
+class RecordUpdate(BaseModel):
+    """系统配置"""
+
+    id: int = Field(default=0, description="记录id")
+    image_path: str = Field(default=None, description="图片地址")

python/sockets/message_handler.py

@@ -21,15 +21,17 @@ async def handlerSend(
     code = receiveData.get("code")
     msg = receiveData.get("msg")
     data = receiveData.get("data")
-    print("receiveData", receiveData)
-    print("jsonType", jsonType)
     async def MsgCallback(msg):
         msg_id = msg.get("msg_id")
         match msg_id:
             case "PhotoUpdated":
                 PhotoFilename = msg.get("PhotoFilename")
-                if PhotoFilename != "" and PhotoFilename != None:
-                    print("PhotoFilename", PhotoFilename)
+                PhotoLocation = msg.get("PhotoLocation")
+                if (PhotoFilename != "" and PhotoFilename != None) and (
+                    PhotoLocation == "Local Disk"
+                ):
+                    # print("PhotoFilename", temp_photo_name, PhotoFilename)
+                    # temp_photo_name = PhotoFilename
                     data = manager.jsonMessage(
                         code=1,
                         msg=f"照片获取成功",
@@ -48,6 +50,7 @@ async def handlerSend(
                     msg_type="smart_shooter_enable_preview",
                 )
                 await manager.send_personal_message(data, websocket)
+
     # 构建监听条件
     smart_shooter.callback_listen = MsgCallback
     loop.create_task(
@@ -67,7 +70,9 @@ async def handlerSend(
             dictMsg = {"code":code,"msg":msg,"data":data}
             await manager.broadcast(dictMsg)
         case "connect_mcu":
-            device_ctrl = DeviceControl(websocket_manager=manager)
+            device_ctrl = DeviceControl(
+                websocket_manager=manager, smart_shooter=smart_shooter
+            )
             device_ctrl.mcu_exit = False
             # if device_ctrl.serial_ins.check_connect():
             #     print("未连接")
@@ -80,7 +85,9 @@ async def handlerSend(
             loop.create_task(blue_tooth.main_func(), name="blue_tooth")
             # loop.close()
         case "init_mcu":
-            device_ctrl = DeviceControl(websocket_manager=manager)
+            device_ctrl = DeviceControl(
+                websocket_manager=manager, smart_shooter=smart_shooter
+            )
             # 是否强制初始化
             is_force_init = data.get("value",False)
             loop.create_task(device_ctrl.initDevice(is_force_init), name="init_mcu")
@@ -95,10 +102,14 @@ async def handlerSend(
                 )
                 await manager.send_personal_message(data, websocket)
                 return
-            device_ctrl = DeviceControl(websocket_manager=manager)
+            device_ctrl = DeviceControl(
+                websocket_manager=manager, smart_shooter=smart_shooter
+            )
             device_ctrl.controlDevice(device_name, value)
         case "stop_action":
-            device_ctrl = DeviceControl(websocket_manager=manager)
+            device_ctrl = DeviceControl(
+                websocket_manager=manager, smart_shooter=smart_shooter
+            )
             if device_ctrl.is_runn_action == True:
                 print("动作执行中，停止")
                 device_ctrl.is_stop_action = True
@@ -146,22 +157,32 @@ async def handlerSend(
                 await manager.send_personal_message(data, websocket, msg_type=msg_type)
                 return
             action_list = [device.model_dump() for device in all_devices]
-            print("action_list", action_list)
-            device_ctrl = DeviceControl(websocket_manager=manager)
+            print("handl send smart_shooter", smart_shooter)
+            device_ctrl = DeviceControl(
+                websocket_manager=manager, smart_shooter=smart_shooter
+            )
             loop.create_task(
-                device_ctrl.run_mcu_config(action_list, goods_art_no, action_info),
+                device_ctrl.run_mcu_config(
+                    action_list, goods_art_no, action_info, smart_shooter
+                ),
                 name="run_mcu_config",
             )
         case "run_mcu_single":
-            device_ctrl = DeviceControl(websocket_manager=manager)
+            device_ctrl = DeviceControl(
+                websocket_manager=manager, smart_shooter=smart_shooter
+            )
             loop.create_task(
-                device_ctrl.run_mcu_config_single(data, None, "run_mcu_single"),
+                device_ctrl.run_mcu_config_single(
+                    data, None, "run_mcu_single", -1, smart_shooter
+                ),
                 name="run_mcu_single",
             )
         case "handler_take_picture":
-            blue_tooth = BlueToothMode(websocket_manager=manager)
+            blue_tooth = BlueToothMode(
+                websocket_manager=manager, smart_shooter=smart_shooter
+            )
             loop.create_task(
-                blue_tooth.remote_control_v2.handlerTakePhoto(),
+                blue_tooth.remote_control_v2.handlerTakePhoto(smart_shooter),
                 name="run_mcu_config",
             )
         case "re_take_picture":#重拍
@@ -194,21 +215,32 @@ async def handlerSend(
             # 清除图片记录,执行重拍
             reset_data = {"image_path": None}
             photoRecord.update(session, record_id, **reset_data)
-            device_ctrl = DeviceControl(websocket_manager=manager)
+            device_ctrl = DeviceControl(
+                websocket_manager=manager, smart_shooter=smart_shooter
+            )
             loop.create_task(
                 device_ctrl.run_mcu_config_single(
-                    device_action.model_dump(), goods_art_no, msg_type=msg_type,image_index=image_index
+                    device_action.model_dump(),
+                    goods_art_no,
+                    msg_type=msg_type,
+                    image_index=image_index,
+                    smart_shooter=smart_shooter,
+                    action_id=action_id,
                 ),
                 name="run_mcu_config_single",
             )
         case "get_deviation":
-            device_ctrl = DeviceControl(websocket_manager=manager)
+            device_ctrl = DeviceControl(
+                websocket_manager=manager, smart_shooter=smart_shooter
+            )
             loop.create_task(
                 device_ctrl.getDeviationInfo(),
                 name="get_deviation",
             )
         case "set_deviation":
-            device_ctrl = DeviceControl(websocket_manager=manager)
+            device_ctrl = DeviceControl(
+                websocket_manager=manager, smart_shooter=smart_shooter
+            )
             value = data.get("value", None)
             action_name = data.get("action_name", None)
             loop.create_task(
@@ -216,7 +248,9 @@ async def handlerSend(
                 name="set_deviation",
             )
         case "move_deviation":
-            device_ctrl = DeviceControl(websocket_manager=manager)
+            device_ctrl = DeviceControl(
+                websocket_manager=manager, smart_shooter=smart_shooter
+            )
             value = data.get("value", None)
             action_name = data.get("action_name", None)
             loop.create_task(
@@ -224,19 +258,25 @@ async def handlerSend(
                 name="move_deviation",
             )
         case "get_mcu_other_info":
-            device_ctrl = DeviceControl(websocket_manager=manager)
+            device_ctrl = DeviceControl(
+                websocket_manager=manager, smart_shooter=smart_shooter
+            )
             loop.create_task(
                 device_ctrl.getMcuOtherInfo(),
                 name="mcu_other_set_get",
             )
         case "set_mcu_other_info":
-            device_ctrl = DeviceControl(websocket_manager=manager)
+            device_ctrl = DeviceControl(
+                websocket_manager=manager, smart_shooter=smart_shooter
+            )
             loop.create_task(
                 device_ctrl.setMcuOtherInfo(data),
                 name="setMcuOtherInfo",
             )
         case "send_command":
-            device_ctrl = DeviceControl(websocket_manager=manager)
+            device_ctrl = DeviceControl(
+                websocket_manager=manager, smart_shooter=smart_shooter
+            )
             loop.create_task(
                 device_ctrl.sendCommand(data.get("command", None)),
                 name="sendCommand",