import time
import json
import fastapi
import uvicorn
import serial
import signal
# from fastapi import FastAPI, HTTPException
from fastapi import FastAPI, HTTPException, Request
from fastapi.staticfiles import StaticFiles
from pydantic import BaseModel
#from PLC_Siemens import UserControlReadWriteOp
from Modbus_TCP import Modbus_TCP
from PanasonicFPXHPLC import PanasonicFPXHPLC
import threading
import os
import sys
from pathlib import Path
from ScrewInfo import ScrewInfo
from ScannerInfo import ScannerInfo
from fastapi.responses import FileResponse
import glob
from HZG import HZG
import logging
from logging.handlers import RotatingFileHandler
from logging.handlers import TimedRotatingFileHandler
logging.basicConfig(filename='app.log', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
app = FastAPI()
# 新增全局退出控制
exit_flag = threading.Event()
main_pid = os.getpid()
app.mount("/static", StaticFiles(directory="static"), name="static")
sys.modules["fastapi.openapi.docs"].get_swagger_ui_html.__kwdefaults__["swagger_js_url"] = "/static/swagger-ui-bundle.js"
sys.modules["fastapi.openapi.docs"].get_swagger_ui_html.__kwdefaults__["swagger_css_url"] = "/static/swagger-ui.css"
# plc = PanasonicFPXHPLC("192.168.0.20")
plc = PanasonicFPXHPLC(port='COM16', baudrate=115200)
hzg = HZG()
SignalDi = None
lock_Barcode = threading.Lock()
lock_Plc = threading.Lock()
lock_Screw = threading.Lock()
############################################################
#根据路径下的json文件，创建螺钉机实例
base_dir = os.path.dirname(os.path.abspath(__file__))
# 使用Path对象处理路径
root_path = Path(base_dir)
# 递归遍历所有.json文件
#构造空的螺钉机字典
ScrewDeviceList ={}
#构造空的扫码枪机字典
ScannerDeviceList ={}
#遍历路径下 json文件
for json_file in root_path.rglob("*.json"):
with open(json_file, 'r', encoding='utf-8') as file:
data = json.load(file)
# 获取配置文件中的IP和Port
DeviceType = data["DeviceType"]
if DeviceType == "Screw":
# 将文件信息存入字典
# 获取配置文件中的IP和Port
ip = data["Ip"]
port = (data["Port"])
info = {json_file.stem: ScrewInfo(ip,port)}
ScrewDeviceList.update(info)
elif DeviceType == "Scanner":
#根据json配置内容，创建扫码枪对象实例
info = {json_file.stem: ScannerInfo(json_file.stem,data["Port"],data["Baudrate"])}
ScannerDeviceList.update(info)
############################################################
# 创建一个锁对象
lock = threading.Lock()
# # 绑定find_image文件夹路径
IMAGE_FOLDER3 = "D:\\YourImageFolder\\" # 替换为你的文件夹路径
##绑定左工位image文件夹路径
IMAGE_FOLDER = ("D:\\RawPicture1\\")
LastImageFile = None
CreateTime_LastImage = None
##绑定右工位image文件夹路径
IMAGE_FOLDER2 = ("D:\\RawPicture2\\")
LastImageFile2 = None
CreateTime_LastImage2 = None
# 新增监控线程
def shutdown_monitor():
while True:
if exit_flag.is_set():
print("检测到致命错误，触发系统关闭...")
hzg.SendMessageToHZG("检测到致命错误，触发系统关闭...")
os.kill(main_pid, signal.SIGINT) # 优雅关闭FastAPI
break
time.sleep(1)
def ScanBarcode():
try:
while not exit_flag.is_set():
try:
for key, scanner in ScannerDeviceList.items():
if not scanner.connected:
continue
try:
waiting = scanner.Device.in_waiting
if waiting > 0:
#time.sleep(0.1)
raw_data = scanner.Device.read(scanner.Device.in_waiting)
try:
decoded_data = raw_data.decode('utf-8').strip()
if decoded_data:
with lock_Barcode:
scanner.Data = decoded_data
print(decoded_data)
#扫到码后调用HZG 服务端指令 HZG完成业务逻辑处理
logging.info("扫码调用活字格文件")
print(hzg.BarcodeProcess(key,decoded_data))
logging.info("扫码调用活字格文件完成")
print(f"[扫码数据] {scanner.Data}")
except UnicodeDecodeError as e:
print(f"解码失败 @ {scanner.Port}: {raw_data.hex()}")
raise RuntimeError("连续解码错误") from e
except (serial.SerialException, OSError) as e:
print(f"硬件错误 @ {scanner.Port}: {str(e)}")
hzg.SendMessageToHZG(f"硬件错误 @ {scanner.Port}: {str(e)}")
raise # 向上抛出致命错误
except RuntimeError as e:
print(f"扫码系统关键错误: {str(e)}")
hzg.SendMessageToHZG(f"扫码系统关键错误: {str(e)}")
exit_flag.set() # 设置全局退出标志
break
time.sleep(0.1)
except Exception as e:
#print(f"扫码线程崩溃: {str(e)}")
exit_flag.set()
os.kill(main_pid, signal.SIGINT) # 直接发送终止信号
def ReadTorque ():
while True:
try:
for key, screw in ScrewDeviceList.items():
print(key)
print("TorqueData")
print(screw.Data)
time.sleep(0.5)
with lock_Screw:
rlt = screw.device.read_holding_register(0, 100)
#print(rlt)
#打螺钉结束信号
#print(rlt[32] )
if rlt[32] == 1:
screw.SetScrewFinish()
if rlt[32] !=1:
screw.ResetScrewFinish()
screw.ResetorqueFinish()
if screw.CheckIfNeedGetTorque() :
#计算扭矩
torque = rlt[24]/10 + rlt[25]/1000
# 计算角度
angle = rlt[26]*10000 + rlt[27]
#判断拧紧结果
if rlt[31] == 0:
data = {"Torque":torque,"Angle":angle,"Result":True,"ErrorCode":rlt[31]}
else:
data = {"Torque": torque, "Angle": angle, "Result": False,"ErrorCode":rlt[31]}
screw.Data.append(data)
screw.SetorqueFinish()
#保存扭矩
pass
except Exception as ex:
print(f"螺钉枪关键错误: {str(ex)}")
hzg.SendMessageToHZG(f"螺钉枪关键错误: {str(ex)}")
exit_flag.set() # 设置全局退出标志
break
time.sleep(0.1)
def ScrewLeftFinishProcess ():
while True:
try:
# R50 左打螺钉完成信号 R55 右侧打螺钉完成信号
# 判断完成信号是否从0跳转到1，发生跳转时调用或资格接口
with lock_Plc:
logging.info(f"RedaIsLeftScrew：...")
IsLeftScrewFinish = plc.read_r_register(50)
logging.info(f"IsLeftScrewFinish：{IsLeftScrewFinish}")
time.sleep(0.1)
logging.info(f"RedaIsLeftTorqu：...")
IsLeftReadTorqueFinish = plc.read_r_register(51)
logging.info(f"IsLeftReadTorqueFinish：{IsLeftReadTorqueFinish}")
if IsLeftScrewFinish and not IsLeftReadTorqueFinish:
logging.info(f"StartCallGettorqueByPython")
rlt = hzg.CallGettorqueByPython("Left")
logging.info(f"EndCallGettorqueByPython：{rlt}")
#延时三秒，防止重复调用
time.sleep(3)
except Exception as ex:
print(f"扫码系统关键错误: {str(ex)}")
hzg.SendMessageToHZG(f"扫码系统关键错误: {str(ex)}")
exit_flag.set() # 设置全局退出标志
break
time.sleep(0.1)
def ScrewRightFinishProcess ():
while True:
try:
# R50 左打螺钉完成信号 R55 右侧打螺钉完成信号
# 判断完成信号是否从0跳转到1，发生跳转时调用或资格接口
with lock_Plc:
logging.info(f"RedaIsRightScrew：...")
IsRightScrewFinish = plc.read_r_register(55)
logging.info(f"IsRightScrewFinish：{IsRightScrewFinish}")
time.sleep(0.1)
logging.info(f"RedaIsRightTorque：...")
IsRightReadTorqueFinish = plc.read_r_register(56)
logging.info(f"IsRightReadTorqueFinish：{IsRightReadTorqueFinish}")
if IsRightScrewFinish and not IsRightReadTorqueFinish:
logging.info(f"StartCallGettorqueByPython")
rlt = hzg.CallGettorqueByPython("Right")
logging.info(f"EndCallGettorqueByPython：{rlt}")
#延时三秒，防止重复调用
time.sleep(3)
except Exception as ex:
print(f"扫码系统关键错误: {str(ex)}")
hzg.SendMessageToHZG(f"扫码系统关键错误: {str(ex)}")
exit_flag.set() # 设置全局退出标志
break
time.sleep(0.1)
# def ScrewRightFinishProcess ():
#
#
# while True:
#
# try:
#
#
# # R50 左打螺钉完成信号 R55 右侧打螺钉完成信号
# # 判断完成信号是否从0跳转到1，发生跳转时调用或资格接口
# with lock_Plc:
# IsLeftScrewFinish = plc.read_r_register(50)
#
# if not IsLeftScrewFinish :
# time.sleep(0.5)
# with lock_Plc:
# IsLeftScrewFinish = plc.read_r_register(50)
# if IsLeftScrewFinish:
# hzg.CallGettorqueByPython("Left")
#
# with lock_Plc:
# IsRightScrewFinish = plc.read_r_register(55)
# if not IsRightScrewFinish :
# time.sleep(0.1)
# with lock_Plc:
# IsRightScrewFinish = plc.read_r_register(55)
# if IsRightScrewFinish:
# hzg.CallGettorqueByPython("Right")
#
#
# except Exception as ex:
# print(f"扫码系统关键错误: {str(ex)}")
# exit_flag.set() # 设置全局退出标志
# break
#
# time.sleep(0.1)
@app.get("/GetBarcode")
async def GetBarcode (Device:str):
try:
if Device in ScannerDeviceList:
device = ScannerDeviceList[Device]
with lock_Barcode:
barcode = device.Data
device.Data = ""
return {"status": 0, "msg": "success", "data": barcode}
else:
return {"status": -1, "msg": "该设备不存在", "data": None}
except Exception as ex:
return {"status": -1, "msg": str(ex), "data": None}
@app.get("/GetTorque")
async def GetTorque (Device:str):
try:
if Device in ScrewDeviceList:
device = ScrewDeviceList[Device]
return {"status": 0, "msg": "success", "data": device.Data}
else:
return {"status": -1, "msg": "该设备不存在", "data": None}
except Exception as ex:
return {"status": -1, "msg": str(ex), "data": None}
@app.post("/SetScrewparameter")
async def SetScrewparameter(Device: str, value: str, TorqueUpperLimit: str, TorqueLowerLimit: str, AngleUpperLimit: str, AngleLowerLimit: str):
"""
向指定设备的寄存器中写入地址和值，并设置扭矩上下限
:param Device: 设备名称
:param address: 寄存器地址
:param value: 要写入的值
:param TorqueUpperLimit: 扭矩上限，写入地址 58
:param TorqueLowerLimit: 扭矩下限，写入地址 60
:return: 返回操作状态和信息
"""
try:
Rlt = {
"status": 0,
"msg": "写入成功",
"data": {
"address": None,
"TorqueUpperLimit": None,
"TorqueLowerLimit": None
}
}
if Device in ScrewDeviceList:
device = ScrewDeviceList[Device]
with lock_Screw:
#写入任务数和参数
result_Task = device.device.write_holding_register(48, 1)
if result_Task != (48, 1):
Rlt["status"] = -1
Rlt["msg"] = "写入任务数失败"
return Rlt
print("写入任务数到地址 48 成功")
result_Parameter = device.device.write_holding_register(49, 1)
if result_Parameter != (49, 1):
Rlt["status"] = -1
Rlt["msg"] = "写入参数失败"
return Rlt
print("写入参数到地址 49 成功")
# 写入扭矩目标值到地址 56
result_StandardValue = device.device.write_holding_register(56, int(value))
if result_StandardValue != (56, int(value)):
Rlt["status"] = -1
Rlt["msg"] = "写入扭矩目标值失败"
return Rlt
print(f"写入目标值到地址 56 成功，值: {value}")
# 写入扭矩上限到地址 58
result_TorqueUpperLimit = device.device.write_holding_register(58, int(TorqueUpperLimit))
if result_TorqueUpperLimit != (58, int(TorqueUpperLimit)):
Rlt["status"] = -1
Rlt["msg"] = "写入扭矩上限失败"
return Rlt
print(f"写入扭矩上限到地址 58 成功，值: {TorqueUpperLimit}")
# 写入扭矩下限到地址 60
result_TorqueLowerLimit = device.device.write_holding_register(60, int(TorqueLowerLimit))
if result_TorqueLowerLimit != (60, int(TorqueLowerLimit)):
Rlt["status"] = -1
Rlt["msg"] = "写入扭矩下限失败"
return Rlt
print(f"写入扭矩下限到地址 60 成功，值: {TorqueLowerLimit}")
# 写入转角上限到地址 64
result_AngleUpperLimit = device.device.write_holding_register(64, int(AngleUpperLimit))
if result_AngleUpperLimit != (64, int(AngleUpperLimit)):
Rlt["status"] = -1
Rlt["msg"] = "写入转角上限失败"
return Rlt
print(f"写入转角上限到地址 64 成功，值: {AngleUpperLimit}")
# 写入转角下限到地址 66
result_AngleLowerLimit = device.device.write_holding_register(66, int(AngleLowerLimit))
if result_AngleLowerLimit != (66, int(AngleLowerLimit)):
Rlt["status"] = -1
Rlt["msg"] = "写入转角下限失败"
return Rlt
print(f"写入转角下限到地址 66 成功，值: {AngleLowerLimit}")
# 写入扭矩参数保存
result_ScrewSave = device.device.write_holding_register(50, 1)
if result_ScrewSave!= (50, 1):
Rlt["status"] = -1
Rlt["msg"] = "写入扭矩参数保存失败"
return Rlt
print("写入扭矩参数保存到地址 50 成功")
return {"status": 0, "msg": "写入成功", "data": None}
else:
return {"status": -1, "msg": "该设备不存在", "data": None}
except Exception as ex:
return {"status": -1, "msg": str(ex), "data": None}
@app.get("/ClearTorque")
async def ClearTorque (Device:str):
try:
if Device in ScrewDeviceList:
device = ScrewDeviceList[Device]
device.Data.clear()
return {"status": 0, "msg": "success", "data": None}
else:
return {"status": -1, "msg": "该设备不存在", "data": None}
except Exception as ex:
return {"status": -1, "msg": str(ex), "data": None}
@app.get("/SetData")
async def SetData (RegisterType:str,Address:str,Value:str,Type:str):
try:
with lock_Plc:
if RegisterType == "DT":
if Type == "U8":
logging.info("SetData:开始读取write_d_register_fineshed数据")
write_d_register_fineshed=plc.write_d_register(int(Address), int(Value), Type)
logging.info(f"write_d_register_fineshed:{write_d_register_fineshed}")
if write_d_register_fineshed:#plc.write_d_register(int(Address),int(Value),Type):
return {"status": 0, "msg": "写入成功", "data": None}
else:
return {"status": -1, "msg": "写入失败", "data": None}
if Type == "String":
logging.info("SetData:开始读取write_d_register_fineshed数据")
write_d_register_fineshed = plc.write_d_register(int(Address),Value,Type)
logging.info(f"write_d_register_fineshed:{write_d_register_fineshed}")
if write_d_register_fineshed: # plc.write_d_register(int(Address),Value,Type):
return {"status": 0, "msg": "写入成功", "data": None}
else:
return {"status": -1, "msg": "写入失败", "data": None}
elif RegisterType == "R":
logging.info("SetData:开始读取write_r_register_fineshed数据")
write_r_register_fineshed = plc.write_r_register(int(Address),int(Value))
logging.info(f"write_r_register_fineshed:{write_r_register_fineshed}")
if write_r_register_fineshed:#plc.write_r_register(int(Address),int(Value)):
return {"status": 0, "msg": "写入成功", "data": None}
else:
return {"status": -1, "msg": "写入失败", "data": None}
else:
return {"status": -1, "msg": "寄存器类型不存在", "data": None}
except Exception as ex:
print(f"读写PLC错误: {str(ex)}")
hzg.SendMessageToHZG(f"读写PLC错误: {str(ex)}")
exit_flag.set() # 设置全局退出标志
@app.get("/GetData")
async def GetData(RegisterType: str, Address: str,Type:str):
try:
logging.info("Start:开始读取PLC数据")
with lock_Plc:
if RegisterType == "DT":
if Type == "String":
logging.info(f"GetData:String...")
rlt = plc.Read_string(int(Address))
if rlt != None:
logging.info(f"End:DT/String{rlt}")
return {"status": 0, "msg": "读取成功", "data":rlt}
else:
return {"status": -1, "msg": "读取失败", "data": None}
else:
logging.info(f"GetData:U8...")
rlt = plc.read_dt_register(int(Address))
if rlt != None:
logging.info(f"End:DT/U8{rlt}")
return {"status": 0, "msg": "读取成功", "data": rlt}
else:
return {"status": -1, "msg": "读取失败", "data": None}
elif RegisterType == "R":
logging.info(f"GetData:R...")
rlt = plc.read_r_register(int(Address))
if rlt != None:
logging.info(f"End:R/Bool{rlt}")
return {"status": 0, "msg": "读取成功", "data": rlt}
else:
return {"status": -1, "msg": "读取失败", "data": None}
else:
return {"status": -1, "msg": "寄存器类型不存在", "data": None}
except Exception as ex:
print(f"读写PLC错误: {str(ex)}")
hzg.SendMessageToHZG(f"读写PLC错误: {str(ex)}")
exit_flag.set() # 设置全局退出标志
@app.get("/imagesLeft/{filename}")
async def get_image(filename: str):
# images = glob.glob(os.path.join((IMAGE_FOLDER+"*.bmp")))
images = glob.glob(os.path.join((IMAGE_FOLDER+"*.jpg")))
if not images:
return {"error": "File not found"}
images.sort(key=os.path.getmtime)
if os.path.isfile(images[-1]):
LastImageFile = images[-1]
return FileResponse(images[-1])
@app.get("/CheckIfHaveNewImage1/")
async def CheckIfHaveNewImage():
global LastImageFile,CreateTime_LastImage
images = glob.glob(os.path.join((IMAGE_FOLDER + "*.jpg")))
if not images:
return {"status": -1, "msg": "文件夹无照片", "data": None}
images.sort(key=os.path.getmtime)
if os.path.isfile(images[-1]):
if LastImageFile != None:
CreateTime_new = os.path.getmtime(images[-1])
if CreateTime_LastImage != CreateTime_new:
CreateTime_LastImage = CreateTime_new
LastImageFile = images[-1]
return {"status": 0, "msg": "照片已经更新", "data": None}
else:
CreateTime_new = os.path.getmtime(images[-1])
CreateTime_LastImage = CreateTime_new
LastImageFile = images[-1]
return {"status": 0, "msg": "照片已经更新", "data": None}
return {"status": -1, "msg": "照片未更新", "data": None}
@app.get("/imagesRight/{filename}")
async def get_image(filename: str):
# images = glob.glob(os.path.join((IMAGE_FOLDER2+"*.bmp")))
images = glob.glob(os.path.join((IMAGE_FOLDER2+"*.jpg")))
if not images:
return {"error": "File not found"}
images.sort(key=os.path.getmtime)
if os.path.isfile(images[-1]):
LastImageFile = images[-1]
return FileResponse(images[-1])
@app.get("/CheckIfHaveNewImage2/")
async def CheckIfHaveNewImage():
global LastImageFile2,CreateTime_LastImage2
images = glob.glob(os.path.join((IMAGE_FOLDER2 + "*.jpg")))
if not images:
return {"status": -1, "msg": "文件夹无照片", "data": None}
images.sort(key=os.path.getmtime)
if os.path.isfile(images[-1]):
if LastImageFile2 != None:
CreateTime_new = os.path.getmtime(images[-1])
if CreateTime_LastImage2 != CreateTime_new:
CreateTime_LastImage2 = CreateTime_new
LastImageFile2 = images[-1]
return {"status": 0, "msg": "照片已经更新", "data": None}
else:
CreateTime_new = os.path.getmtime(images[-1])
CreateTime_LastImage2 = CreateTime_new
LastImageFile2 = images[-1]
return {"status": 0, "msg": "照片已经更新", "data": None}
return {"status": -1, "msg": "照片未更新", "data": None}
@app.get("/find-image/{filename}")
async def find_image(filename: str):
try:
# 支持的图片扩展名
image_extensions = [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".JPG", ".JPEG", ".PNG", ".GIF", ".BMP"]
# 遍历文件夹，查找匹配的文件
for file in os.listdir(IMAGE_FOLDER3):
file_name, file_extension = os.path.splitext(file)
if file_name == filename and file_extension in image_extensions:
# 找到匹配的文件，返回图片
image_path = os.path.join(IMAGE_FOLDER3, file)
if os.path.isfile(image_path):
return FileResponse(image_path)
# 如果没有找到匹配的文件，返回错误信息
raise HTTPException(status_code=404, detail="Image not found")
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.on_event("startup")
async def startup_event():
hzg.SendMessageToHZG("系统初始化中...")
#遍历螺钉机,连接每一个螺钉机
for key, screw in ScrewDeviceList.items():
screw.Open()
#遍历扫码枪,扫码枪
for key, Scanner in ScannerDeviceList.items():
Scanner.connect()
# 启动监控线程
threading.Thread(target=shutdown_monitor, daemon=True).start()
# 启动数据读取线程
threading.Thread(target=ReadTorque, daemon=True).start()
threading.Thread(target=ScanBarcode, daemon=True).start()
#线程读取打螺钉完成信号
threading.Thread(target=ScrewLeftFinishProcess, daemon=True).start()
threading.Thread(target=ScrewRightFinishProcess, daemon=True).start()
print("系统初始化完成")
hzg.SendMessageToHZG("系统初始化完成")
print("PLC connected and FastAPI started.")
# 增强关闭事件
@app.on_event("shutdown")
def shutdown_event():
print("\n执行安全关闭...")
exit_flag.set()
# 释放所有硬件资源
for scanner in ScannerDeviceList.values():
scanner.stop()
for screw in ScrewDeviceList.values():
screw.Close()
print("所有设备连接已安全关闭")
if __name__ == "__main__":
uvicorn.run(app, host="0.0.0.0", port=39000, log_level="info")
#uvicorn.run(app, host="127.0.0.1", port=57000, log_level="info")
以上代码 告诉我哪些是关于hkcamera类的使用 帮我分开 我需要把它融入另一段层序 以上是hikcamera类
import datetime
import json
import socket
import threading
import time
import uuid
class AutoEvent:
def __init__(self):
self.Event = threading.Event()
def Wait(self, timeout: float):
Rlt = self.Event.wait(timeout=timeout)
self.Event.clear()
return Rlt
def Set(self):
self.Event.set()
class HikCamera:
__Socket = None
def __init__(self):
self.__TorqueResultList = []
self.__Lock = threading.Lock()
self.__ReceiveEvent = AutoEvent()
self.__ReceiveData = b""
self.__IsConnected = False
def SetConnect(self, Ip, Port, Timeout=10000):
self.__Port = Port
self.__IPAddress = Ip
self.__Timeout = Timeout
def Open(self):
if not self.__IsConnected:
self.Close()
self.__Socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.__Socket.settimeout(self.__Timeout / 1000.0)
self.__Socket.connect((self.__IPAddress, self.__Port))
self.__IsConnected = True
def Send(self, Data: bytes):
self.__Socket.send(Data)
def __SendAndReceive(self, data):
self.__Socket.send(data)
return self.__Socket.recv(1024)
def Close(self):
if self.__Socket:
self.__Socket.close()
self.__IsConnected = False
def Trigger(self,JobNo:str,Barcode: str):
str_cmd = "Start:" + JobNo + "," + Barcode
cmd = str_cmd.encode("utf-8")
data = self.__SendAndReceive(cmd)
str_data = data.decode("utf-8")
return str_data
def str_to_hex_array(self,input):
# 确保字符串长度为偶数
if len(input) % 2 != 0:
input = '0' + input
# 使用bytes.fromhex转换
return list(bytes.fromhex(input))
if __name__ == '__main__':
TimeStamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
dk = HikCamera()
dk.SetConnect("192.168.1.100", 7930)
dk.Open()
print(dk.Trigger("1","AAaAA"))
time.sleep(100000)
本文探讨了图片验证码响应错误的原因，并提供了将Response类型更正为HttpRequest的方法，帮助开发者解决前端开发中的常见问题。
扫一扫
1899
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
