拍摄流程

python/databases.py

@@ -94,8 +94,8 @@ class CRUD:
         db_obj = self.model(**obj_in_data)
         session.add(db_obj)
         session.commit()
-        session.refresh(db_obj)
-        session.close()
+        # session.refresh(db_obj)
+        # session.close()
         return db_obj
 
     def read(

python/mcu/DeviceControl.py

@@ -264,12 +264,16 @@ class DeviceControl(BaseClass, metaclass=SingletonType):
 
     async def getDeviationInfo(self):
         await asyncio.sleep(0.01)
-        # 发送获取偏移量
-        data = [self.command["get_deviation"], 1]
-        self.add_send_data_queue(data)
-        # if self.serial_ins:
-        #     self.serial_ins.write_cmd(data)
-        print("发送获取偏移量")
+        try:
+            # 发送获取偏移量
+            data = [self.command["get_deviation"], 1]
+            self.add_send_data_queue(data)
+            # if self.serial_ins:
+            #     self.serial_ins.write_cmd(data)
+            print("发送获取偏移量")
+        except Exception as e:
+            print(e)
+            print("getDeviationInfo", "暂未获取到self.command")
 
     def set_deviation(self, device_name, _type=0, deviation=0):
         # turntable----0 angle_ratio   1 turntable_steering_deviation
@@ -1354,6 +1358,7 @@ class DeviceControl(BaseClass, metaclass=SingletonType):
             # case "photograph":
             #     self.photograph(goods_art_no=None)
     def checkDevice(self):
+        print("检查设备是否运行中")
         if not self.is_running:
             self.sendSocketMessage(
                 code=1, msg="mcu设备未连接,请先连接设备", device_status=0
@@ -1489,12 +1494,13 @@ class DeviceControl(BaseClass, metaclass=SingletonType):
 
     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):
         '''独立拍照  仅作测试用'''
+        await asyncio.sleep(0.1)
         if self.checkDevice() == False:
             return
+        print("检查完成", config_info)
         if config_info:
             self.action_state = 1
             self.msg_type = "mcu"
-            await asyncio.sleep(0.1)
             program_item = ProgramItem(
                     websocket_manager=self.websocket_manager,
                     action_data=config_info,
@@ -1509,6 +1515,7 @@ class DeviceControl(BaseClass, metaclass=SingletonType):
                 print("action异常终止")
                 return
             self.msg_type = "photo_take"
+            program_item.smart_shooter = smart_shooter
             program_item.run(3)
             self.sendSocketMessage(
                 code=0,
@@ -1525,6 +1532,10 @@ class DeviceControl(BaseClass, metaclass=SingletonType):
                     device_status=2,
                 )
             self.msg_type = "mcu"
+        else:
+            self.sendSocketMessage(
+                code=1, msg="未查询到重拍记录得配置信息，请确认", device_status=0
+            )
 
 
 async def checkMcuConnection(device_ctrl: DeviceControl):

python/mcu/McuDeviationSet.py

@@ -21,8 +21,8 @@ class McuDeviationSet:
         self.last_value = defaultdict(float)
         is_debug = True if settings.IS_DEBUG == "true" else False
         self.mcu_debug = McuDebug(mcu, is_debug=is_debug, is_deviation=False)
-        loop = asyncio.get_event_loop()
-        loop.create_task(self.get_mcu_deviation(), name="get_mcu_deviation")
+        # loop = asyncio.get_event_loop()
+        self.get_mcu_deviation()
         # # 运动到设定位
         # QTimer.singleShot(2500, self.init_pos)
 
@@ -235,9 +235,12 @@ class McuDeviationSet:
     def _to_init_all(self, *args):
         self.mcu.to_init_device_origin_point(device_name="mcu", is_force=True)
 
-    async def get_mcu_deviation(self):
-        await asyncio.sleep(0.01)
-        self.mcu.getDeviationInfo()
+    def get_mcu_deviation(self):
+        # await asyncio.sleep(0.01)
+        # await self.mcu.getDeviationInfo()
+        # loop = asyncio.get_event_loop()
+        # loop.create_task(self.mcu.getDeviationInfo(), name="get_mcu_deviation")
+        asyncio.run(self.mcu.getDeviationInfo())
 
     def get_mcu_deviation_info(self, data):
         if "_type" not in data:

python/mcu/ProgramItem.py

@@ -185,13 +185,13 @@ class ProgramItem(BaseClass):
         if settings.IS_TEST:
             self.do_run()
         else:
-            # try:
-            self.do_run()
-        # except BaseException as e:
-        #     self.sendSocketMessage(
-        #         msg="p_item 错误：{}".format(e), device_status=-1
-        #     )
-        #     self.set_state(state_value=99)
+            try:
+                self.do_run()
+            except BaseException as e:
+                self.sendSocketMessage(
+                    msg="p_item 错误：{}".format(e), device_status=-1
+                )
+                self.set_state(state_value=99)
 
         self.set_state(state_value=2)
         return True
@@ -287,28 +287,25 @@ class ProgramItem(BaseClass):
             self.mcu.to_deal_device(device_name="buzzer", times=1)
             # 用于临时拍照计数
             is_af = True if self.af_times > 0 else False
-            loop = asyncio.get_event_loop()
             if self.smart_shooter != None:
-                if is_af:
-                    # 指定自动对焦
-                    loop.create_task(
-                        self.smart_shooter.CameraAutofocus(),
-                        name="CameraAutofocus",
-                    )
+                loop = asyncio.get_event_loop()
                 # 拍照
                 print("smart shooter 拍照")
                 record_id = self.record_id
                 goods_art_no = self.goods_art_no
                 if record_id == -1:
                     goods_art_no = ""
+                print("smart shooter CameraShooter")
                 loop.create_task(
                     self.smart_shooter.CameraShooter(
                         msg_type="run_mcu",
                         goods_art_no=goods_art_no,
                         id=record_id,
+                        is_af=is_af,
                     ),
                     name="CameraShooter",
                 )
+                print("smart shooter CameraShooter end")
             else:
                 # 指定自动对焦
                 self.capture_one.photograph(is_af=is_af)
@@ -321,6 +318,15 @@ class ProgramItem(BaseClass):
             time.sleep(self.after_delay_time)
         return True
 
+    async def RunSmartShooter(self, goods_art_no,record_id):
+        await asyncio.gather(
+            self.smart_shooter.CameraShooter(
+                msg_type="run_mcu",
+                goods_art_no=goods_art_no,
+                id=record_id,
+            ),
+        )
+
     def rephotograph_one_pic(self, *args):
         """
         1、获取最近一张照片

python/mcu/capture/smart_shooter_class.py

@@ -45,9 +45,9 @@ class SmartShooter(metaclass=SingletonType):
         context = zmq.Context()
         req_socket = context.socket(zmq.REQ)
         # 设置发送超时为 5000 毫秒（5 秒）
-        req_socket.setsockopt(zmq.RCVTIMEO, 2000)
+        req_socket.setsockopt(zmq.RCVTIMEO, 4000)
         # 设置接收超时为 5000 毫秒（5 秒）
-        req_socket.setsockopt(zmq.SNDTIMEO, 2000)
+        req_socket.setsockopt(zmq.SNDTIMEO, 4000)
         req_socket.setsockopt(zmq.LINGER, 0)  # 设置为 0 表示不等待未完成的操作
         req_socket.connect(self.SET_REQ)
         return req_socket, context
@@ -57,9 +57,9 @@ class SmartShooter(metaclass=SingletonType):
         listen_socket = context.socket(zmq.SUB)
         listen_socket.setsockopt(zmq.SUBSCRIBE, b"")
         # 设置发送超时为 5000 毫秒（5 秒）
-        listen_socket.setsockopt(zmq.RCVTIMEO, 2000)
+        listen_socket.setsockopt(zmq.RCVTIMEO, 4000)
         # 设置接收超时为 5000 毫秒（5 秒）
-        listen_socket.setsockopt(zmq.SNDTIMEO, 2000)
+        listen_socket.setsockopt(zmq.SNDTIMEO, 4000)
         listen_socket.setsockopt(zmq.LINGER, 0)  # 设置为 0 表示不等待未完成的操作
         listen_socket.connect(self.LISTEN_REQ)
         return listen_socket, context
@@ -68,8 +68,8 @@ class SmartShooter(metaclass=SingletonType):
         await asyncio.sleep(0.01)
         self.msg_type = msg_type
         """
-        实时获取相机信息，是否连接、软件是否被打开
-        """
+            实时获取相机信息，是否连接、软件是否被打开
+            """
         try:
             socket, context = self.__create_req()
             req = {}
@@ -84,15 +84,15 @@ class SmartShooter(metaclass=SingletonType):
                 msg_send = "相机未连接或软件未打开"
                 if is_send:
                     message = {
-                        "code": 1,
-                        "msg": msg_send,
-                        "data": None,
-                        "msg_type": self.msg_type,
-                        "device_status": -1,
-                    }
+                            "code": 1,
+                            "msg": msg_send,
+                            "data": msg_result,
+                            "msg_type": self.msg_type,
+                            "device_status": -1,
+                        }
                     await self.websocket_manager.send_personal_message(
-                        message, self.websocket
-                    )
+                            message, self.websocket
+                        )
                 return False, msg_send
             cameraInfo = json_msg.get("CameraInfo")
             if cameraInfo == None or len(cameraInfo) == 0:
@@ -100,52 +100,55 @@ class SmartShooter(metaclass=SingletonType):
                 msg_send = "相机未连接"
                 if is_send:
                     message = {
-                        "code": 1,
-                        "msg": msg_send,
-                        "data": None,
-                        "msg_type": self.msg_type,
-                        "device_status": -1,
-                    }
+                            "code": 1,
+                            "msg": msg_send,
+                            "data": msg_result,
+                            "msg_type": self.msg_type,
+                            "device_status": -1,
+                        }
                     await self.websocket_manager.send_personal_message(
-                        message, self.websocket
-                    )
+                            message, self.websocket
+                        )
                 return False, "相机未连接"
             # 链接的相机
             # connect_camera = cameraInfo
             CameraStatus = any(
-                item.get("CameraStatus") in ["Ready", "Busy"] for item in cameraInfo
-            )
+                    item.get("CameraStatus") in ["Ready", "Busy"] for item in cameraInfo
+                )
             # CameraStatus = connect_camera.get("CameraStatus")
             if not CameraStatus:
                 self.connect_status = False
                 msg_send = "相机未连接"
                 if is_send:
                     message = {
-                        "code": 1,
-                        "msg": msg_send,
-                        "data": None,
-                        "msg_type": self.msg_type,
-                        "device_status": -1,
-                    }
+                            "code": 1,
+                            "msg": msg_send,
+                            "data": msg_result,
+                            "msg_type": self.msg_type,
+                            "device_status": -1,
+                        }
                     await self.websocket_manager.send_personal_message(
-                        message, self.websocket
-                    )
+                            message, self.websocket
+                        )
                 return False, msg_send
             self.connect_status = True
             msg_send = "相机已连接"
             if is_send:
                 message = {
-                    "code": 0,
-                    "msg": msg_send,
-                    "data": None,
-                    "msg_type": self.msg_type,
-                    "device_status": 2,
-                }
+                        "code": 0,
+                        "msg": msg_send,
+                        "data": msg_result,
+                        "msg_type": self.msg_type,
+                        "device_status": 2,
+                    }
                 await self.websocket_manager.send_personal_message(
-                    message, self.websocket
-                )
+                        message, self.websocket
+                    )
             return True, "相机已连接"
-        except:
+        except zmq.Again:
+            print("获取相机信息超时，继续监听...")
+        except Exception as e:
+            print("拍照异常",e)
             self.connect_status = False
             socket.close()
             context.term()
@@ -200,6 +203,8 @@ class SmartShooter(metaclass=SingletonType):
             }
             await self.websocket_manager.send_personal_message(message, self.websocket)
             return True, "预览启用成功" if enable_status else "预览关闭成功"
+        except zmq.Again:
+            print("启动预览超时，继续监听...")
         except:
             self.perview_state = False
             socket.close()
@@ -220,6 +225,7 @@ class SmartShooter(metaclass=SingletonType):
         相机自动对焦
         """
         camera_states, _ = await self.GetCameraInfo(is_send=False)
+        print("CameraAutofocus 执行对焦")
         if not camera_states:
             return False, "请先连接相机"
         try:
@@ -235,19 +241,26 @@ class SmartShooter(metaclass=SingletonType):
             if not msg_result:
                 return False, "对焦失败"
             return True, "对焦成功"
+        except zmq.Again:
+            print("对焦超时，继续监听...")
         except:
             socket.close()
             context.term()
             return False, "相机未连接或软件未打开"
 
-    async def CameraShooter(self, msg_type="", goods_art_no="", id=0):
+    async def CameraShooter(self, msg_type="", goods_art_no="", id=0,is_af=False):
+        # 对焦混用
+        if is_af:
+            await self.CameraAutofocus()
         self.msg_type = msg_type
+        print("camera_states", msg_type)
         """
         执行拍照
         """
-        camera_states, _ = await self.GetCameraInfo(is_send=False)
-        if not camera_states:
-            return False, "请先连接相机"
+        # camera_states, _ = await self.GetCameraInfo(is_send=False)
+        # print("camera_states CameraShooter", camera_states)
+        # if not camera_states:
+        #     return False, "请先连接相机"
         try:
             socket, context = self.__create_req()
             req = {}
@@ -286,6 +299,8 @@ class SmartShooter(metaclass=SingletonType):
             }
             await self.websocket_manager.send_personal_message(message, self.websocket)
             return True, "拍照成功"
+        except zmq.Again:
+            print("拍照超时，继续监听...")
         except:
             socket.close()
             context.term()

python/sockets/message_handler.py

@@ -55,7 +55,7 @@ async def handlerSend(
                     # temp_photo_name = PhotoFilename
                     # 更新拍照记录
                     print("PhotoFilename", PhotoFilename, PhotoOrigin)
-                    if PhotoOrigin != "":
+                    if PhotoOrigin != "" and PhotoOrigin != "external":
                         goods_art_no, id = PhotoOrigin.split(",")
                         loop.create_task(
                             updateDataRecord(PhotoFilename, id), name="PhotoFilename"
@@ -238,6 +238,7 @@ async def handlerSend(
                 data = manager.jsonMessage(code=1, msg="当前没有可用配置")
                 await manager.send_personal_message(data, websocket, msg_type=msg_type)
                 return
+            print("device_action", device_action)
             # 清除图片记录,执行重拍
             reset_data = {"image_path": None}
             photoRecord.update(session, record_id, **reset_data)