smartshooter对接

python/docs/socket命令.md

@@ -553,4 +553,110 @@ _(该命令用于单独自定义配置中某一项的单独调整测试，不进
     "msg_type": "stop_action"
 }
 ```
+
+
+
+#### 使用smart shooter进行相机控制
+<mark>以下操作需要连接连接相机并拉起smartshooter5软件<mark>
+##### 获取相机是否连接
+* data：{}
+* type：
+    * 当该字段为smart_shooter_getinfo时,代表获取相机连接信息，是否连接成功
+##### 请求示例
+```python
+{
+    "data":{},
+    "type": "smart_shooter_getinfo"
+}
+```
+##### 响应示例-连接成功
+###### 发送后指令转换
+```python
+{
+    "code": 0,
+    "msg": "相机已连接",
+    "status": 2,
+    "data": null,
+    "msg_type": "smart_shooter_getinfo"
+}
+```
+##### 响应示例-连接失败
+###### 发送后指令转换
+```python
+{
+    "code": 0,
+    "msg": "相机未连接",
+    "status": -1,
+    "data": null,
+    "msg_type": "smart_shooter_getinfo"
+}
+```
+
+##### 启动/关闭预览
+* data：
+    * value：为true时代表打开预览,为false时代表关闭预览
+* type：
+    * 当该字段为smart_shooter_enable_preview时,代表操作预览启动关闭操作
+##### 请求示例
+```python
+{
+    "data":{"value":false},
+    "type": "smart_shooter_enable_preview"
+}
+```
+##### 响应示例-启动预览
+```python
+{
+    "code": 0,
+    "msg": "预览启用成功",
+    "status": 2,
+    "data": null,
+    "msg_type": ""
+}
+```
+##### 响应示例-关闭预览
+```python
+{
+    "code": 0,
+    "msg": "预览关闭成功",
+    "status": 2,
+    "data": null,
+    "msg_type": ""
+}
+```
+
+
+##### 拍照
+* data：{}
+* type：
+    * 当该字段为smart_shooter_photo_take时,代表操作拍照动作
+##### 请求示例
+```python
+{
+    "data":{},
+    "type": "smart_shooter_photo_take"
+}
+```
+##### 响应示例-拍照成功
+```python
+{
+    "code": 0,
+    "msg": "拍照成功",
+    "status": 2,
+    "data": null,
+    "msg_type": ""
+}
+```
+##### 响应示例-照片获取成功
+```python
+{
+    "code": 1,
+    "msg": "照片获取成功",
+    "data": {
+        "photo_file_name": "C:\\Users\\15001\\Pictures\\Smart Shooter 5\\SSP_45.JPG"
+    },
+    "msg_type": "smart_shooter_photo_take"
+}
+```
+
 ##### 未完待续.....

python/mcu/capture/smart_shooter_class.py

@@ -31,7 +31,7 @@ class SmartShooter(BaseClass,metaclass=SingletonType):
         # loop.create_task(
         #         self.connect_listen(),
         #         name="connect_listen",
-        #     )    
+        #     )
 
     def __send_tcp_message(self, socket, msg):
         # await asyncio.sleep(0.01)
@@ -64,8 +64,9 @@ class SmartShooter(BaseClass,metaclass=SingletonType):
         listen_socket.connect(self.LISTEN_REQ)
         return listen_socket, context
 
-    async def GetCameraInfo(self):
+    async def GetCameraInfo(self,is_send=True,msg_type=""):
         await asyncio.sleep(0.01)
+        self.msg_type = msg_type
         '''
         实时获取相机信息，是否连接、软件是否被打开
         '''
@@ -82,21 +83,23 @@ class SmartShooter(BaseClass,metaclass=SingletonType):
                 self.connect_status = False
                 msg_send = "相机未连接或软件未打开"
                 # self.websocket_manager
-                self.sendSocketMessage(
-                    code=0,
-                    msg=msg_send,
-                    device_status=-1,
-                )
+                if is_send:
+                    self.sendSocketMessage(
+                        code=0,
+                        msg=msg_send,
+                        device_status=-1,
+                    )
                 return False, msg_send
             cameraInfo = json_msg.get("CameraInfo")
             if cameraInfo == None or len(cameraInfo) == 0:
                 self.connect_status = False
                 msg_send = "相机未连接"
-                self.sendSocketMessage(
-                    code=0,
-                    msg=msg_send,
-                    device_status=-1,
-                )
+                if is_send:
+                    self.sendSocketMessage(
+                        code=0,
+                        msg=msg_send,
+                        device_status=-1,
+                    )
                 return False, "相机未连接"
             # 链接的相机
             connect_camera = cameraInfo[0]
@@ -104,37 +107,41 @@ class SmartShooter(BaseClass,metaclass=SingletonType):
             if CameraStatus != "Ready":
                 self.connect_status = False
                 msg_send = "相机未连接"
-                self.sendSocketMessage(
-                    code=0,
-                    msg=msg_send,
-                    device_status=-1,
-                )
+                if is_send:
+                    self.sendSocketMessage(
+                        code=0,
+                        msg=msg_send,
+                        device_status=-1,
+                    )
                 return False, msg_send
             self.connect_status = True
             msg_send = "相机已连接"
-            self.sendSocketMessage(
-                    code=0,
-                    msg=msg_send,
-                    device_status=2,
-                )
+            if is_send:
+                self.sendSocketMessage(
+                        code=0,
+                        msg=msg_send,
+                        device_status=2,
+                    )
             return True, "相机已连接"
         except:
             self.connect_status = False
             socket.close()
             context.term()
             msg_send = "相机未连接或软件未打开"
-            self.sendSocketMessage(
+            if is_send:
+                self.sendSocketMessage(
                     code=0,
                     msg=msg_send,
                     device_status=-1,
                 )
             return False, msg_send
 
-    async def EnableCameraPreview(self,enable_status=True):
+    async def EnableCameraPreview(self, enable_status=True, msg_type=""):
+        self.msg_type = msg_type
         """
         激活相机预览
         """
-        camera_states,_ = await self.GetCameraInfo()
+        camera_states, _ = await self.GetCameraInfo(is_send=False)
         if not camera_states:
             return False, "请先连接相机"
         try:
@@ -149,19 +156,37 @@ class SmartShooter(BaseClass,metaclass=SingletonType):
             msg_result = json_msg.get("msg_result")
             if not msg_result:
                 self.perview_state = False
+                msg_send = "预览启用失败"
+                self.sendSocketMessage(
+                    code=0,
+                    msg=msg_send,
+                    device_status=2,
+                )
                 return False, "预览启用失败"
+            msg_send = "预览启用成功" if enable_status else "预览关闭成功"
+            self.sendSocketMessage(
+                    code=0,
+                    msg=msg_send,
+                    device_status=2,
+                )
             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,
+            )
             return False, "相机未连接或软件未打开"
 
     async def CameraAutofocus(self):
         """
         相机自动对焦
         """
-        camera_states, _ = await self.GetCameraInfo()
+        camera_states, _ = await self.GetCameraInfo(is_send=False)
         if not camera_states:
             return False, "请先连接相机"
         try:
@@ -182,11 +207,12 @@ class SmartShooter(BaseClass,metaclass=SingletonType):
             context.term()
             return False, "相机未连接或软件未打开"
 
-    async def CameraShooter(self):
+    async def CameraShooter(self, msg_type=""):
+        self.msg_type = msg_type
         """
         执行拍照
         """
-        camera_states, _ = await self.GetCameraInfo()
+        camera_states, _ = await self.GetCameraInfo(is_send=False)
         if not camera_states:
             return False, "请先连接相机"
         try:
@@ -199,14 +225,34 @@ class SmartShooter(BaseClass,metaclass=SingletonType):
             json_msg = self.__send_tcp_message(socket, req)
             msg_result = json_msg.get("msg_result")
             if not msg_result:
-                return False, "拍照失败"
+                msg_send = "拍照失败"
+                self.sendSocketMessage(
+                    code=0,
+                    msg=msg_send,
+                    device_status=2,
+                )
+                return False, msg_send
+            msg_send = "拍照成功"
+            self.sendSocketMessage(
+                    code=0,
+                    msg=msg_send,
+                    device_status=2,
+                )
             return True, "拍照成功"
         except:
             socket.close()
             context.term()
-            return False, "相机未连接或软件未打开"
+            msg_send = "相机未连接或软件未打开"
+            self.sendSocketMessage(
+                code=0,
+                msg=msg_send,
+                device_status=2,
+            )
+            return False, msg_send
 
     async def connect_listen(self):
+        if self.connect_status == True:
+            return True
         # 发起监听
         sub_socket, context = self.__create_listen()
         print("构建监听")
@@ -214,7 +260,7 @@ class SmartShooter(BaseClass,metaclass=SingletonType):
             await asyncio.sleep(0.01)
             if self.callback_listen == None:
                 continue
-            camera_states, camera_msg = await self.GetCameraInfo()
+            camera_states, camera_msg = await self.GetCameraInfo(is_send=False)
             if not camera_states:
                 print("相机未连接")
                 await asyncio.sleep(5)  # 等待相机连接
@@ -228,7 +274,7 @@ class SmartShooter(BaseClass,metaclass=SingletonType):
                 json_msg = json.loads(str_msg)
                 if json_msg["msg_id"] == "NetworkPing":
                     continue
-                self.callback_listen(json_msg)
+                await self.callback_listen(json_msg)
             except zmq.Again:
                 print("接收超时，继续监听...")
                 continue

python/sockets/connect_manager.py

@@ -26,9 +26,7 @@ class ConnectionManager:
 
     async def send_personal_message(self, message: str, websocket: WebSocket):
         '''向用户发送消息'''
-        print("ready message successfully")
         await websocket.send_json(message)
-        print("sent message successfully")
 
     async def broadcast(self, message: str):
         """广播消息"""

python/sockets/message_handler.py

@@ -8,7 +8,10 @@ from mcu.capture.module_digicam import DigiCam
 from mcu.capture.smart_shooter_class import SmartShooter
 # socket消息发送逻辑处理方法
 async def handlerSend(
-    manager: ConnectionManager, receiveData: str, websocket: WebSocket
+    manager: ConnectionManager,
+    receiveData: str,
+    websocket: WebSocket,
+    smart_shooter: SmartShooter,
 ):
     loop = asyncio.get_event_loop()
     receiveData = json.loads(receiveData)
@@ -20,18 +23,37 @@ async def handlerSend(
     data = receiveData.get("data")
     print("receiveData", receiveData)
     print("jsonType", jsonType)
-    def MsgCallback(msg):
+    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("收到照片：", json.dumps(msg, ensure_ascii=False))
                     print("PhotoFilename", PhotoFilename)
+                    data = manager.jsonMessage(
+                        code=1,
+                        msg=f"照片获取成功",
+                        data={"photo_file_name": PhotoFilename},
+                        msg_type="smart_shooter_photo_take",
+                    )
+                    await manager.send_personal_message(data, websocket)
             case "LiveviewUpdated":
                 CameraLiveviewImage = msg.get("CameraLiveviewImage", None)
                 # base64_to_image(CameraLiveviewImage, "liveview.jpg")
-                # print("收到直播画面：", json.dumps(msg, ensure_ascii=False))
+                # print("收到直播画面：CameraLiveviewImage")
+                data = manager.jsonMessage(
+                    code=1,
+                    msg=f"预览数据发送",
+                    data={"smart_shooter_preview": CameraLiveviewImage},
+                    msg_type="smart_shooter_enable_preview",
+                )
+                await manager.send_personal_message(data, websocket)
+    # 构建监听条件
+    smart_shooter.callback_listen = MsgCallback
+    loop.create_task(
+        smart_shooter.connect_listen(),
+        name="smart_shooter_connect_listen",
+    )
     match jsonType:
         case "ping":
             """发送心跳"""
@@ -223,17 +245,28 @@ async def handlerSend(
             '''
             获取相机信息,是否连接
             '''
-            smart_shooter = SmartShooter(
-                websocket_manager=manager
-            )
-            smart_shooter.callback_listen = MsgCallback
             loop.create_task(
-                smart_shooter.GetCameraInfo(),
+                smart_shooter.GetCameraInfo(msg_type="smart_shooter_getinfo"),
                 name="smart_shooter_getinfo",
             )
+        case "smart_shooter_enable_preview":
+            """
+            启动相机或关闭实时预览
+            """
+            value = data.get("value", True)
+            loop.create_task(
+                smart_shooter.EnableCameraPreview(
+                    enable_status=value, msg_type="smart_shooter_enable_preview"
+                ),
+                name="smart_shooter_enable_preview",
+            )
+        case "smart_shooter_photo_take":
+            """
+            获取相机信息,是否连接
+            """
             loop.create_task(
-                smart_shooter.connect_listen(),
-                name="connect_listen",
+                smart_shooter.CameraShooter(msg_type="smart_shooter_photo_take"),
+                name="smart_shooter_photo_take",
             )
         case _:
             data = manager.jsonMessage(code=1, msg="未知消息")

python/sockets/socket_server.py

@@ -45,7 +45,9 @@ async def websocket_endpoint(websocket: WebSocket):
                         blue_tooth.clearMyInstance()
                         break
                     print("byteDats", byteDats)
-                    await handlerSend(conn_manager, json.dumps(byteDats), websocket)
+                    await handlerSend(
+                        conn_manager, json.dumps(byteDats), websocket, smart_shooter
+                    )
                 except Exception as e:
                     print(e)
                     break