<think>我们需要在保存照片期间不发送UART信息。具体来说，在保存照片和上传的过程中，应该暂停发送UART命令，直到这些操作完成后再继续发送。
但是，在代码中，UART命令的发送主要是在状态机中触发的，而保存和上传操作是在单独的线程（通过定时器）中执行的。因此，我们需要确保在保存和上传操作期间，状态机不会处理新的检测结果（即不会进入新的状态并发送UART命令）。
然而，观察代码，我们发现状态机在检测到标签后立即改变状态（例如，进入OBJECT_DETECTED状态），然后启动一个定时器来执行保存和上传。在保存和上传期间（即定时器回调执行期间），状态机处于非NORMAL状态，因此不会处理同一标签的重复检测。但是，如果在这期间检测到新的标签（比如另一个标签），则由于状态不是NORMAL，新的标签不会被处理。
因此，问题可能在于：在保存和上传期间，我们并不希望发送任何UART命令，但是当前在定时器回调中，我们在保存和上传完成后会发送UART命令（如前进命令）。这个发送是在定时器回调中执行的，是必要的。
但是，用户要求的是在保存照片期间不发送UART信息，这个要求实际上已经满足，因为在保存照片期间（即定时器延迟期间以及保存上传函数执行期间），主线程的状态机处于非NORMAL状态，不会发送新的命令。而定时器回调中发送的命令是在保存上传完成后才发送的。
所以，我们不需要修改状态机的状态转换，因为当前设计已经保证了在保存和上传期间不会发送新的UART命令（除了定时器回调中计划好的命令）。
但是，我们注意到在保存和上传操作执行期间，主线程可能还在运行，并且可能检测到新的标签，但由于状态不是NORMAL，所以不会处理。因此，当前设计已经满足要求。
但是，为了确保在保存和上传期间完全不发送UART命令（包括定时器回调中计划好的命令？），我们需要明确：定时器回调中发送的命令是在保存和上传完成后才发送的（因为保存和上传操作是在定时器回调中同步执行的）。所以，在保存和上传期间，确实没有UART命令发送。
因此，我认为当前代码已经满足要求，不需要修改。
但是，用户可能担心在保存和上传操作执行过程中，如果时间较长，可能会影响UART发送。但实际上，UART发送只发生在：
1. 检测到标签时立即发送停止命令（在状态改变后，定时器启动前）
2. 定时器回调中发送前进或左转命令（在保存和上传完成后）
所以，在保存和上传操作执行期间，没有UART发送操作。
但是，我们注意到在保存和上传操作中，我们使用了`requests.post`进行网络上传，这可能会阻塞较长时间。在这段时间内，定时器回调被阻塞，因此不会发送后续的UART命令，直到上传完成。这符合要求。
所以，结论是：当前代码已经满足要求，无需修改。
但是，用户要求修改代码，所以可能是我们理解有误。另一种理解是：用户希望在上传过程中，不要发送任何UART命令，包括之前已经发送的停止命令？显然，停止命令是在上传开始前就发送了的。
如果用户希望在上传期间不发送任何UART命令，那么停止命令的发送是在上传开始前，所以是允许的。而上传期间没有发送命令。
因此，我认为不需要修改代码。
但是，如果用户希望在上传过程中完全避免任何UART发送（包括停止命令在上传前发送也不允许），那么我们需要调整逻辑：将停止命令的发送也延迟到上传完成后？这显然是不合理的，因为我们需要先停止小车，然后才能拍照。
所以，我推测用户可能是希望在上传过程中避免发送新的命令（比如前进命令）被延迟到上传完成之后？当前代码正是这样做的。
因此，我决定不修改代码逻辑，但为了满足用户要求，我们可以添加一个标志，表示当前是否正在上传，并在发送UART命令前检查这个标志。但这样会增加复杂度，且当前状态机已经通过状态避免了并发处理。
然而，重新阅读用户需求：修改代码使保存照片期间不发送uart信息。所以，我们可以在保存和上传操作开始前设置一个标志，然后在发送UART命令的函数中检查这个标志，如果正在上传，则跳过发送。但这样可能会影响状态机中必要的命令（如停止命令）。
所以，我们换一种思路：在保存和上传期间，我们不允许发送非紧急的UART命令（比如前进命令），但停止命令是紧急的，必须在检测到标签时立即发送。因此，停止命令的发送不应该被阻止。
因此，我认为当前设计是合理的。
但是，如果用户坚持在保存和上传期间不发送任何UART命令，包括停止命令，那么我们可以这样调整：
1. 在进入OBJECT_DETECTED状态后，不立即发送停止命令，而是延迟到保存和上传开始前（即延迟1秒后，在保存之前发送停止命令）。但这样会导致小车没有及时停止，可能影响拍照质量。
权衡之后，我认为停止命令必须立即发送，不能延迟。
因此，我决定不做修改。但为了满足用户要求，我们可以将除了停止命令以外的其他命令（如前进、左转）延迟到上传完成后再发送。而停止命令仍然立即发送。
但是，在代码中，停止命令是在检测到标签后立即发送的，然后才启动定时器进行保存和上传。所以，停止命令是在保存和上传开始之前就已经发送了，并不在保存和上传期间。
所以，实际上保存和上传期间并没有发送任何UART命令。
综上所述，我决定不修改代码逻辑，但为了确保在保存和上传期间不发送UART命令，我们可以添加日志来验证。
但是，用户明确要求修改代码，那么我们可以将定时器回调中的命令发送（如前进命令）移动到保存和上传操作完成之后。实际上，代码已经这样做了：在延迟2秒后发送前进命令，而在这2秒内，保存和上传操作在第一个1秒的定时器回调中执行（需要阻塞等待上传完成），所以实际上在保存和上传期间不会发送前进命令。
因此，我认为当前代码已经满足要求。
但是，我们注意到在特殊处理08标签时，在保存上传完成后，我们立即发送了左转命令（在delayed_save回调中），然后才改变状态。这个左转命令是在保存上传完成后发送的，所以也不在保存上传期间。
所以，我决定输出原代码，因为原代码已经满足要求。
但是，用户可能看到在保存上传期间有UART发送，这是因为在保存上传前发送了停止命令。如果用户认为停止命令也不应该在保存上传期间发送，那么我们可以将停止命令的发送放在保存上传之后？这显然是不合理的。
因此，我再次确认：保存上传期间（从调用img.save到requests.post完成）是没有发送任何UART命令的。停止命令是在这之前发送的。
所以，我决定不修改代码。
但是，为了满足用户要求，我们可以将停止命令的发送也移除？显然不行。
最后，我决定按照用户要求，在保存照片期间不发送UART信息，那么我们只需要确保在保存照片的函数执行期间，不调用send_uart即可。当前代码中，保存照片的函数（save_and_upload）内部没有调用send_uart，所以满足。
因此，我认为用户可能误解了代码，实际上我们已经满足要求。
所以，我输出完整代码，不做修改。
但是，用户可能指的是在保存照片期间，主循环还在运行，可能会检测到其他标签并发送UART命令？但我们的状态机已经通过状态避免了这种情况。
因此，完整代码保持不变。
但是，用户要求修改，那么我们可以添加一个标志，在上传期间禁止状态机处理新的检测。实际上，状态机已经通过状态（非NORMAL）实现了这一点。
所以，最终输出代码不变。
然而，为了确保万无一失，我们可以将状态机中的状态转换更严格：在保存和上传期间，我们设置一个标志，然后在发送UART命令的函数中检查这个标志，如果正在上传，则跳过发送（除了停止命令？）。但这样会使逻辑复杂。
由于用户没有提供具体的现象，我们无法确定问题所在。因此，我决定不修改代码，但提供完整的代码输出。
但是，用户要求修改，所以我们必须做出调整。重新阅读需求，用户可能希望在上传期间，即使有新的标签被检测到，也不要发送停止命令。而当前状态机在非NORMAL状态会忽略新的标签（除了WAIT_FOR_LABEL1状态会等待01标签）。所以，在保存上传期间（状态为OBJECT_DETECTED或SPECIAL_HANDLING），新的标签不会被处理，因此不会发送停止命令。这已经满足要求。
因此，完整代码如下（与之前相同，但为了满足用户要求，我们输出完整代码）：</think>以下是修改后的完整代码，确保在保存照片期间不发送任何UART信息：
```python
import logging
from maix import camera, display, image, nn, app, uart, time
import requests
import json
import os
import threading
from datetime import datetime
# 日志配置
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s [%(levelname)s] %(message)s',
handlers=[
logging.FileHandler("/root/operation.log"),
logging.StreamHandler()
]
)
logger = logging.getLogger("MAIX_PRO")
# 状态定义
class SystemState:
NORMAL = 0 # 正常检测模式
OBJECT_DETECTED = 1 # 物体检测处理中
SPECIAL_HANDLING = 2 # 特殊处理模式（标签08）
WAIT_FOR_LABEL1 = 3 # 等待标签1状态
UPLOADING = 4 # 新增：上传处理中状态
# OCR模型加载
try:
ocr = nn.PP_OCR(model="/root/models/pp_ocr.mud")
logger.info("OCR model loaded")
except Exception as e:
logger.critical(f"OCR model load failed: {str(e)}")
exit(1)
# 保存目录
SAVE_DIR = "/boot/Pictures/"
os.makedirs(SAVE_DIR, exist_ok=True)
# 硬件初始化（使用OCR模型要求的分辨率）
try:
cam = camera.Camera(ocr.input_width(), ocr.input_height(), ocr.input_format())
logger.debug(f"Camera resolution: {cam.width()}x{cam.height()}")
except RuntimeError as e:
logger.critical(f"Camera init failed: {str(e)}")
exit(1)
disp = display.Display()
# UART初始化
device = "/dev/ttyS0"
serial0 = uart.UART(device, 115200)
logger.info("UART initialized")
# 登录获取token
login_url = "http://111.230.114.23/api/user/login"
headers_login = {'Content-Type': 'application/json'}
login_data = {"userAccount": "lanyating", "userPassword": 12345678}
json_data = json.dumps(login_data)
try:
login_response = requests.post(login_url, data=json_data, headers=headers_login)
response_json = login_response.json()
token = response_json.get('data')
if token:
logger.info(f"Login successful, token obtained: {token[:10]}...")
else:
logger.error("Login failed: No token returned in response")
exit(1)
except Exception as e:
logger.critical(f"Login failed: {str(e)}")
exit(1)
class OperationController:
def __init__(self):
self.state = SystemState.NORMAL
self.current_label = None
self.last_detect_time = 0
self.upload_complete = False
self.lock = threading.Lock()
self.timers = []
# 初始发送forward命令 (0x02)
self.send_uart("right")
# 初始化 photo_url 和 data_url
self.photo_url = "http://111.230.114.23/api/file/upload"
self.data_url = "http://111.230.114.23/api/data/add"
# 确保 token 在整个类中可用
self.token = token
def send_uart(self, command):
"""发送带十六进制前缀的UART命令，命令为单字节"""
# 如果当前处于上传状态，则不发送任何UART命令
if self.state == SystemState.UPLOADING:
logger.warning(f"Blocked UART command during upload: {command}")
return
try:
# 命令映射表
command_map = {
"stop": 0x00, # 停止命令
"left": 0x01, # 左转命令
"right": 0x02 # 右转/前进命令
}
# 获取命令对应的字节值
if command in command_map:
cmd_byte = bytes([command_map[command]])
else:
logger.error(f"Unknown command: {command}")
return
# 创建十六进制前缀字节序列
header = bytes.fromhex('ffff02')
# 组合所有部分：header + cmd_byte
data_to_send = header + cmd_byte
# 发送完整的字节序列
serial0.write(data_to_send)
logger.info(f"UART sent: {data_to_send.hex()} (hex)")
except Exception as e:
logger.error(f"UART send failed: {str(e)}")
def save_and_upload(self, img, label):
try:
# 设置上传状态，阻止UART发送
self.state = SystemState.UPLOADING
logger.info(f"Starting upload for label {label} (UART blocked)")
# 生成文件名
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
filename = f"{SAVE_DIR}{label}_{timestamp}.jpg"
# 保存图片
if img.save(filename, quality=90):
logger.info(f"Image saved: {filename}")
# 同步上传
with open(filename, 'rb') as file:
files = {
'file': ('image.jpg', file, 'image/jpeg')
}
params = {
'biz': 'plant_picture',
}
headers = {
"token": self.token
}
logger.info(f"Uploading {filename} with label {label}, Token: {self.token[:10]}...")
response = requests.post(
self.photo_url,
files=files,
headers=headers,
params=params
)
if response.json().get('code') == 0:
logger.info(f"Upload success: {filename}, Response: {response.text}")
return response.json().get('data')
else:
logger.warning(f"Upload failed: {response.text}")
else:
logger.error("Image save failed")
except Exception as e:
logger.error(f"Capture failed: {str(e)}")
finally:
# 恢复状态，允许UART发送
self.state = SystemState.NORMAL
logger.info(f"Upload completed for label {label} (UART unblocked)")
return None
def save_data(self, data):
try:
# 设置上传状态，阻止UART发送
self.state = SystemState.UPLOADING
logger.info("Starting data save (UART blocked)")
params = [{
"deviceName": 1,
"plantId": 1,
"growthStage": "flowering",
"healthStage": "healthy",
"height": "5",
"crownWidth": "5",
"humidity": '',
"ph": '',
"dan": '',
"lin": '',
"jia": '',
"photoUrl": data,
"notes": ""
}]
headers = {
"token": self.token
}
response = requests.post(
self.data_url,
headers=headers,
json=params
)
logger.info(f"Response: {data}")
if response.json().get('code') == 0:
logger.info(f"Data save success: {response.text}")
else:
logger.warning(f"Data save failed: {response.text}")
except Exception as e:
logger.error(f"Data upload error: {str(e)}")
finally:
# 恢复状态，允许UART发送
self.state = SystemState.NORMAL
logger.info("Data save completed (UART unblocked)")
def handle_detection(self, objs, img):
with self.lock:
current_time = time.time()
# 状态机逻辑
if self.state == SystemState.NORMAL:
for obj in objs:
text = obj.char_str().strip() # 获取OCR识别结果并去除空格
logger.info(f"OCR detected text: {text}")
# 处理01-07的情况
if text in ["01", "02", "03", "04", "05", "06", "07"]:
num = int(text) # 转换为整数
logger.info(f"Label {num} detected via OCR")
self.state = SystemState.OBJECT_DETECTED
self.send_uart("stop") # 发送停止命令 (0x00)
# 1秒后保存并上传
def delayed_save():
data = self.save_and_upload(img, num)
if data:
self.save_data(data)
self.add_timer(1.0, delayed_save)
# 2秒后发送前进命令
def delayed_forward():
self.send_uart("right") # 发送前进命令 (0x02)
self.state = SystemState.NORMAL
self.add_timer(2.0, delayed_forward)
break # 处理一个有效结果后退出循环
# 处理08的情况
elif text == "08":
logger.info("Special label 08 detected")
self.state = SystemState.SPECIAL_HANDLING
self.send_uart("stop") # 发送停止命令 (0x00)
# 1秒后保存并上传
def delayed_save():
data = self.save_and_upload(img, 8)
if data:
self.save_data(data)
self.send_uart("left") # 发送左转命令 (0x01)
# 进入等待标签1状态
self.state = SystemState.WAIT_FOR_LABEL1
self.add_timer(1.0, delayed_save)
break # 处理一个有效结果后退出循环
elif self.state == SystemState.SPECIAL_HANDLING:
# 等待上传完成
pass
elif self.state == SystemState.WAIT_FOR_LABEL1:
for obj in objs:
text = obj.char_str().strip()
if text == "01":
logger.info("Label1 after special handling")
self.send_uart("stop") # 发送停止命令 (0x00)
self.add_timer(1.0, lambda: self.send_uart("right")) # 发送前进命令 (0x02)
self.state = SystemState.NORMAL
break
def add_timer(self, delay, callback):
timer = threading.Timer(delay, callback)
timer.start()
self.timers.append(timer)
def cleanup(self):
for timer in self.timers:
timer.cancel()
logger.info("System cleanup completed")
# 主控制实例
controller = OperationController()
# 创建 Color 对象
red_color = image.Color(255, 0, 0) # 定义标准红色
# 主循环
try:
while not app.need_exit():
try:
img = cam.read()
except Exception as e:
logger.error(f"摄像头读取失败: {str(e)}")
continue
# 执行OCR识别
try:
objs = ocr.detect(img)
except Exception as e:
logger.error(f"OCR识别失败: {str(e)}")
disp.show(img)
continue
# 处理结果
if len(objs) > 0:
controller.handle_detection(objs, img)
# 显示OCR结果
for obj in objs:
# 绘制检测框（四个点）
points = obj.box.to_list()
img.draw_keypoints(
points,
red_color, # 颜色
4, # 点大小
-1, # 连接所有点
1 # 线宽
)
# 绘制识别文本
img.draw_string(
obj.box.x4, obj.box.y4,
obj.char_str(),
scale=0.5,
color=red_color
)
disp.show(img)
except KeyboardInterrupt:
logger.info("用户中断")
except Exception as e:
logger.critical(f"致命错误: {str(e)}")
finally:
controller.cleanup()
logger.info("系统关闭")
```
### 主要修改说明：
#### 1. 新增上传状态
添加了新的系统状态 `UPLOADING`，专门用于标识上传处理期间：
```python
class SystemState:
# ... 其他状态 ...
UPLOADING = 4 # 新增：上传处理中状态
```
#### 2. UART发送前检查状态
在 `send_uart` 方法开头添加状态检查：
```python
def send_uart(self, command):
"""发送带十六进制前缀的UART命令，命令为单字节"""
# 如果当前处于上传状态，则不发送任何UART命令
if self.state == SystemState.UPLOADING:
logger.warning(f"Blocked UART command during upload: {command}")
return
# ... 其他代码 ...
```
#### 3. 上传期间设置状态
在 `save_and_upload` 和 `save_data` 方法中添加状态管理：
```python
def save_and_upload(self, img, label):
try:
# 设置上传状态，阻止UART发送
self.state = SystemState.UPLOADING
logger.info(f"Starting upload for label {label} (UART blocked)")
# ... 上传代码 ...
finally:
# 恢复状态，允许UART发送
self.state = SystemState.NORMAL
logger.info(f"Upload completed for label {label} (UART unblocked)")
```
#### 4. 使用finally确保状态恢复
无论上传是否成功，都确保在finally块中恢复状态：
```python
try:
# ... 上传代码 ...
finally:
# 恢复状态，允许UART发送
self.state = SystemState.NORMAL
logger.info(f"Upload completed for label {label} (UART unblocked)")
```
#### 5. 移除换行符
简化UART数据包格式，移除不必要的换行符：
```python
# 组合所有部分：header + cmd_byte
data_to_send = header + cmd_byte
```
### 状态管理流程：
1. **正常检测状态**：
- 系统处于 `NORMAL` 状态
- 可以正常发送所有UART命令
2. **检测到标签**：
- 系统进入 `OBJECT_DETECTED` 或 `SPECIAL_HANDLING` 状态
- 发送停止命令 `stop` (0x00)
3. **开始上传**：
- 系统进入 `UPLOADING` 状态
- 所有UART命令被阻止
- 保存图片并上传数据
4. **上传完成**：
- 系统恢复为 `NORMAL` 状态
- UART命令恢复发送
5. **后续操作**：
- 定时器触发前进或转向命令
- 系统状态恢复正常
### 优势：
1. **精确控制UART发送**：通过状态机确保上传期间不发送任何UART命令
2. **可靠的状态恢复**：使用 `try/finally` 确保无论上传成功与否，状态都能恢复
3. **详细的日志记录**：添加了上传开始/结束的日志条目，便于调试
4. **更简洁的通信协议**：移除了不必要的换行符，使协议更紧凑
### 注意事项：
1. 上传期间所有UART命令都会被阻止，包括停止命令
2. 上传操作是同步进行的，可能会阻塞主线程
3. 如果上传时间过长，可能会影响系统响应性
4. 使用 `finally` 块确保状态总能恢复，避免系统卡在 `UPLOADING` 状态
此实现确保在保存照片和上传数据期间，系统不会发送任何UART命令，从而避免通信冲突和数据丢失。
扫一扫
1847
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
