first commit

This commit is contained in:
WIN-20230613SRA\Administrator
2026-07-02 16:07:26 +08:00
commit c4a347b287
17 changed files with 2924 additions and 0 deletions
+16
View File
@@ -0,0 +1,16 @@
# Ignore files
**/.DS_Store
**/__pycache__
/.idea
/logFile
/logFile/*
/dataFile
/dataFile/*
/build
/dist
/env
/venv
/datas
*.db
*.log
.vscode
+328
View File
@@ -0,0 +1,328 @@
# Python Gateway HTTP API 接口文档
## 概述
Python Gateway HTTP Server 提供RESTful API接口,用于文件上传、计算处理、设备管理和状态查询。
**服务器地址**: `http://<host>:<port>`
**默认端口**: `5000`
**当前版本**: `1.0.0` (在version.py中管理)
**Content-Type**: `application/json` 或 `multipart/form-data`
---
## API 接口列表
### 1. 上传数据并计算
**接口地址**: `/api/data`
**请求方法**: `POST`
**Content-Type**: `multipart/form-data`
#### 请求参数
| 参数名 | 类型 | 必填 | 说明 |
|--------|------|------|------|
| file | File | 是 | 要上传的文件(CSV格式) |
| dev_id | String | 否 | 设备ID,默认为'default' |
| init | Integer | 否 | 初始化标志(0或1),默认为0 |
| device_name | String | 否 | 设备名称,用于设置文件根目录 |
| file_type | String | 否 | 文件类型,默认为'raw' |
| compress | String | 否 | 压缩类型('none'或'gz'),默认为'none' |
| scale | Float | 否 | 数据缩放因子,默认为1.0 |
| offset | Float | 否 | 数据偏移量,默认为0.0 |
| row_count | Integer | 否 | 行数限制,默认为0(不限制) |
#### 请求示例
```bash
curl -X POST http://localhost:5000/api/data \
-F "file=@data.csv" \
-F "dev_id=device1" \
-F "init=0" \
-F "device_name=TGX-08-0005"
```
#### 响应格式
成功响应(200 OK):
```json
{
"WtOSC": [1.234, 2.345, 3.456, 4.567, 5.678, 6.789, 7.890, 8.901],
"WtINS": [2.345, 3.456, 4.567, 5.678, 6.789, 7.890, 8.901, 9.012],
"WtISC": [3.456, 4.567, 5.678, 6.789, 7.890, 8.901, 9.012, 10.123],
"WtALL": [4.567, 5.678, 6.789, 7.890, 8.901, 9.012, 10.123, 11.234],
"AngOSC": [95.5, 185.3, 275.1],
"AngINS": [105.2, 195.0, 284.8],
"AngISC": [115.1, 204.9, 294.7],
"AngALL": [125.0, 214.8, 304.6],
"DmCORE": [100.5, 101.2, 102.3],
"DmALL": [120.5, 121.2, 122.3],
"EccentricityINS": 2.5,
"EccentricityOSC": 3.2,
"EccentricityISC": 1.8,
"Volatility": [0.05, 0.08, 0.12],
"EdgesA": [10.5, 20.3, 30.1, 40.9, 50.7, 60.5, 70.3, 80.1],
"EdgesB": [15.5, 25.3, 35.1, 45.9, 55.7, 65.5, 75.3, 85.1]
}
```
错误响应(400 Bad Request):
```json
{
"error": "No file provided"
}
```
或
```json
{
"error": "Failed to process file"
}
```
或
```json
{
"error": "ComputeService not initialized for dev_id device1"
}
```
#### 响应字段说明
| 字段名 | 类型 | 说明 |
|--------|------|------|
| WtOSC | Array[Float] | 外屏层壁厚(8个测量点) |
| WtINS | Array[Float] | 绝缘层壁厚(8个测量点) |
| WtISC | Array[Float] | 内屏层壁厚(8个测量点) |
| WtALL | Array[Float] | 总壁厚(8个测量点) |
| AngOSC | Array[Float] | 外屏层角度(3个角度值) |
| AngINS | Array[Float] | 绝缘层角度(3个角度值) |
| AngISC | Array[Float] | 内屏层角度(3个角度值) |
| AngALL | Array[Float] | 总壁厚角度(3个角度值) |
| DmCORE | Array[Float] | 核心直径(3个测量值) |
| DmALL | Array[Float] | 总直径(3个测量值) |
| EccentricityINS | Float | 绝缘层偏心率(百分比) |
| EccentricityOSC | Float | 外屏层偏心率(百分比) |
| EccentricityISC | Float | 内屏层偏心率(百分比) |
| Volatility | Array[Float] | 波动性[设备1标准差, 设备2标准差, 总体标准差] |
| EdgesA | Array[Float] | A边边缘位置(8个点) |
| EdgesB | Array[Float] | B边边缘位置(8个点) |
---
### 2. 获取服务器状态
**接口地址**: `/api/status`
**请求方法**: `GET`
#### 请求参数
| 参数名 | 类型 | 必填 | 说明 |
|--------|------|------|------|
| dev_id | String | 否 | 设备ID,如果不提供则返回服务器基本状态 |
#### 请求示例
示例1:获取服务器基本状态
```bash
curl -X GET http://localhost:5000/api/status
```
示例2:获取特定设备状态
```bash
curl -X GET "http://localhost:5000/api/status?dev_id=device1"
```
#### 响应格式
成功响应 - 基本状态(200 OK):
```json
{
"running": "true",
"mqtt_connected": true,
"version": "1.0.0"
}
```
或
```json
{
"running": "false",
"mqtt_connected": false,
"version": "1.0.0"
}
```
成功响应 - 设备状态(200 OK):
```json
{
"running": true,
"mqtt_connected": true,
"compute_status": true,
"version": "1.0.0"
}
```
或
```json
{
"running": true,
"mqtt_connected": true,
"compute_status": false,
"version": "1.0.0"
}
```
#### 响应字段说明
| 字段名 | 类型 | 说明 |
|--------|------|------|
| running | String/Boolean | 服务器运行状态(不带dev_id时为字符串"true"/"false",带dev_id时为布尔值) |
| mqtt_connected | Boolean | MQTT连接状态 |
| compute_status | Boolean | 计算服务可用状态(仅当提供dev_id时返回) |
| version | String | 软件版本号 |
---
### 3. 注册设备
**接口地址**: `/api/register`
**请求方法**: `POST`
**Content-Type**: `application/json`
#### 请求参数
| 参数名 | 类型 | 必填 | 说明 |
|--------|------|------|------|
| dev_id | String | 是 | 设备ID |
#### 请求示例
```bash
curl -X POST http://localhost:5000/api/register \
-H "Content-Type: application/json" \
-d '{"dev_id": "device1"}'
```
#### 响应格式
成功响应(200 OK):
```json
{
"message": "Device registered successfully"
}
```
错误响应(400 Bad Request):
```json
{
"error": "dev_id is required"
}
```
或
```json
{
"error": "Failed to initialize ComputeService: ..."
}
```
---
## 错误码说明
| HTTP状态码 | 说明 |
|-----------|------|
| 200 | 请求成功 |
| 400 | 请求参数错误 |
| 500 | 服务器内部错误 |
---
## 使用场景示例
### 场景1:首次上传数据并计算
```bash
# 上传CSV文件并计算
curl -X POST http://localhost:5000/api/data \
-F "file=@measurement_data.csv" \
-F "dev_id=device1" \
-F "init=1" \
-F "device_name=TGX-08-0005"
```
### 场景2:连续上传数据
```bash
# 后续上传,init=0
curl -X POST http://localhost:5000/api/data \
-F "file=@measurement_data_002.csv" \
-F "dev_id=device1" \
-F "init=0"
```
### 场景3:检查服务器状态
```bash
# 查询服务器状态
curl -X GET http://localhost:5000/api/status
```
### 场景4:注册新设备
```bash
# 注册新设备
curl -X POST http://localhost:5000/api/register \
-H "Content-Type: application/json" \
-d '{"dev_id": "device2"}'
```
---
## 注意事项
1. **文件格式**: 上传的文件应为CSV格式,包含CH1和CH2两列数据
2. **设备ID**: 每个设备需要先通过`/api/register`接口注册,才能进行计算
3. **初始化**: 首次上传数据时建议设置`init=1`,后续上传设置`init=0`
4. **文件大小**: 建议单次上传文件不超过10MB
5. **并发处理**: 服务器支持多线程并发处理请求
6. **MQTT发布**: 计算结果会自动发布到MQTT主题(如果MQTT已启用)
---
## 配置说明
服务器配置存储在`config.json`文件中,主要配置项:
```json
{
"http": {
"host": "0.0.0.0",
"port": 5000
},
"mqtt": {
"enable": true,
"broker": "123.57.81.127",
"port": 1883,
"username": "test",
"password": "test"
},
"file_root": "D:\\CPY_DTAT",
"template_path": "D:\\Python\\CPY_Server\\InStructTemplate.mat"
}
```
---
## 版本历史
| 版本 | 日期 | 说明 |
|------|------|------|
| 1.0.0 | 2026-01-05 | 初始版本,支持数据上传、计算和设备管理 |
Binary file not shown.
+229
View File
@@ -0,0 +1,229 @@
# CpyGateway 打包和部署指南
## 环境要求
### 开发环境(打包机器)
- Python 3.8 或更高版本
- Windows 操作系统
- 管理员权限(可选,但建议)
### 目标环境(运行机器)
- Windows 7 或更高版本
- 无需安装Python
- 无需安装依赖库
## 打包步骤
### 方法1:使用批处理脚本(推荐)
1. 打开命令提示符,进入项目目录:
```cmd
cd d:\Qt\CpyAlgorithmServerQt\PythonGateway
```
2. 运行打包脚本:
```cmd
build.bat
```
3. 等待打包完成,生成的exe文件位于 `dist\CpyGateway_v1.0.0.exe`(版本号会根据version.py自动更新)
### 方法2:手动打包
1. 安装PyInstaller:
```cmd
pip install pyinstaller
```
2. 安装项目依赖:
```cmd
pip install -r requirements.txt
```
3. 执行打包命令:
```cmd
pyinstaller CpyGateway.spec
```
4. 打包完成后,exe文件位于 `dist\CpyGateway_v1.0.0.exe`(版本号会根据version.py自动更新)
## 部署步骤
### 1. 准备部署包
将以下文件/文件夹复制到目标电脑:
```
CpyGateway/
├── dist/
│ └── CpyGateway.exe # 主程序
├── config.json # 配置文件(可选,程序会自动生成默认配置)
└── README_DEPLOY.md # 部署说明
```
### 2. 修改配置文件(可选)
根据目标环境修改 `config.json`:
```json
{
"device_id": "1",
"file_root": "D:\\CPY_DTAT",
"template_path": "D:\\Python\\CPY_Server\\InStructTemplate.mat",
"http": {
"host": "0.0.0.0",
"port": 5000
},
"mqtt": {
"enable": true,
"broker": "123.57.81.127",
"port": 1883,
"username": "test",
"password": "test",
"keepalive": 60,
"topic_prefix": "v1/cpycal/"
},
"udp": {
"udp_map": {}
},
"logging": {
"level": "INFO",
"file": "cpy_server.log"
}
}
```
**重要配置项说明**:
- `file_root`: 数据文件存储根目录,确保该目录存在且有写入权限
- `template_path`: MATLAB模板文件路径,确保文件存在
- `mqtt.broker`: MQTT服务器地址,根据实际环境修改
- `http.port`: HTTP服务端口,确保端口未被占用
### 3. 创建必要的目录
在目标电脑上创建数据存储目录:
```cmd
mkdir D:\CPY_DTAT
```
如果使用MATLAB计算,还需要:
```cmd
mkdir D:\Python\CPY_Server
```
并将 `InStructTemplate.mat` 文件复制到该目录。
### 4. 运行程序
双击 `CpyGateway.exe` 运行程序,或在命令行中运行:
```cmd
cd dist
CpyGateway.exe
```
### 5. 验证运行
打开浏览器访问:`http://localhost:5000/api/status`
应该看到类似以下响应:
```json
{
"running": "true",
"mqtt_connected": true
}
```
## 常见问题
### 1. 防火墙提示
首次运行时,Windows防火墙可能会提示是否允许程序访问网络,请选择"允许"。
### 2. 端口被占用
如果提示端口5000被占用,可以修改 `config.json` 中的端口号:
```json
"http": {
"host": "0.0.0.0",
"port": 5001 // 修改为其他端口
}
```
### 3. 文件权限错误
确保程序有权限读写 `file_root` 指定的目录。可以右键目录 -> 属性 -> 安全,添加用户权限。
### 4. MATLAB相关错误
如果程序需要与MATLAB网关通信:
- 确保MATLAB网关程序正在运行
- 确保UDP端口配置正确
- 检查防火墙是否阻止了UDP通信
### 5. MQTT连接失败
检查 `config.json` 中的MQTT配置:
- 确认broker地址正确
- 确认端口正确(默认1883)
- 确认用户名和密码正确
- 确认网络可以访问MQTT服务器
## 日志查看
程序运行日志保存在 `cpy_server.log` 文件中,位于exe文件同级目录。
如果遇到问题,请查看日志文件获取详细错误信息。
## 卸载
要卸载程序:
1. 停止程序(如果正在运行)
2. 删除程序文件夹
3. 删除数据目录(如果需要)
## 更新
要更新程序:
1. 停止旧版本程序
2. 备份 `config.json` 文件
3. 用新版本的 `CpyGateway.exe` 替换旧版本
4. 恢复 `config.json` 文件
5. 启动新版本程序
## 性能优化建议
1. **关闭控制台窗口**:如果不需要看到控制台输出,可以修改 `CpyGateway.spec` 文件:
```python
console=False, # 改为False
```
然后重新打包。
2. **启用UPX压缩**:spec文件中已启用UPX压缩,可以减小exe文件大小。
3. **日志级别调整**:在生产环境中,可以将日志级别改为 `WARNING` 或 `ERROR`:
```json
"logging": {
"level": "WARNING",
"file": "cpy_server.log"
}
```
## 技术支持
如遇到问题,请:
1. 查看日志文件 `cpy_server.log`
2. 检查配置文件 `config.json`
3. 参考API文档 `API_DOCUMENTATION.md`
4. 联系技术支持
## 版本信息
- 版本:1.0.0
- 打包日期:2026-01-05
- Python版本:3.11
View File
+76
View File
@@ -0,0 +1,76 @@
@echo off
chcp 65001 >nul
echo ========================================
echo CpyGateway 打包脚本
echo ========================================
echo.
REM 检查Python环境
python --version >nul 2>&1
if errorlevel 1 (
echo [错误] 未找到Python,请先安装Python
pause
exit /b 1
)
echo [1/5] 检查Python环境...
python --version
echo.
REM 检查pip
pip --version >nul 2>&1
if errorlevel 1 (
echo [错误] 未找到pip
pause
exit /b 1
)
echo [2/5] 安装/更新PyInstaller...
pip install --upgrade pyinstaller -i https://pypi.tuna.tsinghua.edu.cn/simple
if errorlevel 1 (
echo [错误] PyInstaller安装失败
pause
exit /b 1
)
echo.
echo [3/5] 安装项目依赖...
pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
if errorlevel 1 (
echo [错误] 依赖安装失败
pause
exit /b 1
)
echo.
echo [4/5] 清理旧的构建文件...
if exist "build" rmdir /s /q "build"
if exist "dist" rmdir /s /q "dist"
echo 清理完成
echo.
echo [5/5] 开始打包...
pyinstaller CpyGateway.spec
if errorlevel 1 (
echo [错误] 打包失败
pause
exit /b 1
)
echo.
REM 获取版本号
for /f "delims=" %%i in ('python -c "from version import get_version; print(get_version())"') do set VERSION=%%i
echo ========================================
echo 打包完成!
echo ========================================
echo.
echo 可执行文件位置: dist\CpyGateway_v%VERSION%.exe
echo.
echo 部署说明:
echo 1. 将 dist 文件夹复制到目标电脑
echo 2. 确保目标电脑已安装MATLAB Runtime (如果需要)
echo 3. 根据需要修改 config.json 配置文件
echo 4. 双击运行 CpyGateway_v%VERSION%.exe
echo.
pause
+97
View File
@@ -0,0 +1,97 @@
# CpyGateway PowerShell Build Script
$ErrorActionPreference = "Stop"
Write-Host "========================================" -ForegroundColor Cyan
Write-Host "CpyGateway Build Script" -ForegroundColor Cyan
Write-Host "========================================" -ForegroundColor Cyan
Write-Host ""
# Check Python
Write-Host "[1/6] Checking Python..." -ForegroundColor Yellow
try {
$pythonVersion = python --version 2>&1
Write-Host "Python version: $pythonVersion" -ForegroundColor Green
} catch {
Write-Host "[ERROR] Python not found. Please install Python first." -ForegroundColor Red
Read-Host "Press Enter to exit"
exit 1
}
Write-Host ""
# Check pip
Write-Host "[2/6] Checking pip..." -ForegroundColor Yellow
try {
$pipVersion = pip --version 2>&1
Write-Host "pip version: $pipVersion" -ForegroundColor Green
} catch {
Write-Host "[ERROR] pip not found" -ForegroundColor Red
Read-Host "Press Enter to exit"
exit 1
}
Write-Host ""
# Install/Update PyInstaller
Write-Host "[3/6] Installing/Updating PyInstaller..." -ForegroundColor Yellow
try {
pip install --upgrade pyinstaller -i https://pypi.tuna.tsinghua.edu.cn/simple
Write-Host "PyInstaller installed/updated successfully" -ForegroundColor Green
} catch {
Write-Host "[ERROR] Failed to install PyInstaller" -ForegroundColor Red
Read-Host "Press Enter to exit"
exit 1
}
Write-Host ""
# Install dependencies
Write-Host "[4/6] Installing dependencies..." -ForegroundColor Yellow
try {
pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
Write-Host "Dependencies installed successfully" -ForegroundColor Green
} catch {
Write-Host "[ERROR] Failed to install dependencies" -ForegroundColor Red
Read-Host "Press Enter to exit"
exit 1
}
Write-Host ""
# Clean old build files
Write-Host "[5/6] Cleaning old build files..." -ForegroundColor Yellow
if (Test-Path "build") {
Remove-Item -Path "build" -Recurse -Force
Write-Host "Removed build directory" -ForegroundColor Gray
}
if (Test-Path "dist") {
Remove-Item -Path "dist" -Recurse -Force
Write-Host "Removed dist directory" -ForegroundColor Gray
}
Write-Host "Cleanup completed" -ForegroundColor Green
Write-Host ""
# Build
Write-Host "[6/6] Building..." -ForegroundColor Yellow
try {
# 读取版本号
$version = python -c "from version import get_version; print(get_version())"
pyinstaller CpyGateway.spec
Write-Host "Build successful" -ForegroundColor Green
} catch {
Write-Host "[ERROR] Build failed" -ForegroundColor Red
Read-Host "Press Enter to exit"
exit 1
}
Write-Host ""
Write-Host "========================================" -ForegroundColor Cyan
Write-Host "Build completed!" -ForegroundColor Green
Write-Host "========================================" -ForegroundColor Cyan
Write-Host ""
Write-Host "Executable location: dist\CpyGateway_v$version.exe" -ForegroundColor White
Write-Host ""
Write-Host "Deployment instructions:" -ForegroundColor Yellow
Write-Host "1. Copy dist folder to target computer" -ForegroundColor White
Write-Host "2. Ensure MATLAB Runtime is installed (if needed)" -ForegroundColor White
Write-Host "3. Modify config.json as needed" -ForegroundColor White
Write-Host "4. Double-click CpyGateway_v$version.exe to run" -ForegroundColor White
Write-Host ""
Read-Host "Press Enter to exit"
+542
View File
@@ -0,0 +1,542 @@
import os
import json
import logging
from unittest import result
import pandas as pd
import numpy as np
from scipy.io import savemat, loadmat
from typing import Dict, Any, Optional, Tuple
from datetime import datetime
from werkzeug.wrappers import response
from udp_handler import UdpHandler
from config import config_manager
logger = logging.getLogger(__name__)
class CustomFloatEncoder(json.JSONEncoder):
"""自定义浮点数编码器"""
def encode(self, o):
if isinstance(o, float):
return format(o, '.3f')
if isinstance(o, dict):
return "{" + ", ".join(f"{json.dumps(k)}: {self.encode(v)}" for k, v in o.items()) + "}"
if isinstance(o, list):
return "[" + ", ".join(self.encode(v) for v in o) + "]"
return super().encode(o)
class ComputeService:
"""计算服务"""
def __init__(self, dev_id: str):
"""初始化计算服务
Args:
udp_handler: UDP处理器实例
template_path: MAT模板文件路径
"""
self.template_path = config_manager.get('template_path',
r'D:\Python\CPY_Server\InStructTemplate.mat')
port = config_manager.get('udp_map', {}).get(dev_id, None)
if port is None:
logger.error(f"UDP port not found for dev_id: {dev_id}")
port = 15000
self.udp_handler = UdpHandler(port,
config_manager.get('udp.host', '127.0.0.1'))
if not self.udp_handler.search_for_available_udp_port():
logger.error("ComputeService is not available")
self.available = False
raise Exception("ComputeService is not available")
self.available = True
self.dev_id = dev_id
# 数据缓冲区
self.dm_buffer = {
'X': [],
'Y': [],
'X_std': 0,
'Y_std': 0,
'dev1': [],
'dev2': [],
'dev1_std': 0,
'dev2_std': 0,
'all_std': 0
}
# 服务状态
self.available = False
# 统计信息
self.cal_count = 0
self.last_result = None
logger.info(f"ComputeService initialized with template: {self.template_path}")
def reset_buffer(self):
"""重置数据缓冲区"""
self.dm_buffer = {
'X': [],
'Y': [],
'X_std': 0,
'Y_std': 0,
'dev1': [],
'dev2': [],
'dev1_std': 0,
'dev2_std': 0,
'all_std': 0
}
logger.info("Data buffer reset")
def csv_to_mat(self, csv_path: str, init: int = 0) -> Optional[str]:
"""将CSV文件转换为MAT文件
Args:
csv_path: CSV文件路径
init: 是否初始化(1表示初始化)
Returns:
str: MAT文件路径,失败返回None
"""
try:
# 读取CSV文件
df = pd.read_csv(csv_path, nrows=8000)
# 取CH1和CH2两列的数据
df = df[['CH1', 'CH2']]
# 交换CH1和CH2
df = df[['CH2', 'CH1']]
# 检查df['CH1']每一行,如果有小于0的,就置为0
df['CH1'] = df['CH1'].apply(lambda x: x if x > 0 else 0)
# 检查df['CH2']每一行,如果有小于0的,就置为0
df['CH2'] = df['CH2'].apply(lambda x: x if x > 0 else 0)
# 判断最大值,如果最大值大于100000,则除以5,小于10000,则乘以5
max_val = df['CH1'].max()
if max_val > 100000:
df['CH1'] = df['CH1'].divide(5)
df['CH2'] = df['CH2'].divide(5)
elif max_val > 60000:
df['CH1'] = df['CH1'].divide(3)
df['CH2'] = df['CH2'].divide(3)
elif max_val < 10000:
df['CH1'] = df['CH1'].multiply(3)
df['CH2'] = df['CH2'].multiply(3)
# 舍弃小数位,只保留整数
df = df.astype(int)
# 如果是direction_1,逆序
if 'direction_1' in csv_path or 'UP' in csv_path:
df = df.iloc[::-1]
# 读取模板MAT文件
mat_data = loadmat(self.template_path)
# 替换InStruct.iIntensX和InStruct.iIntensY的值
mat_data['InStruct']['iIntensX'][0, 0] = df['CH1'].values.astype(np.uint16)
mat_data['InStruct']['iIntensY'][0, 0] = df['CH2'].values.astype(np.uint16)
# 设置设备类型
if 'device1' in csv_path or 'Scanner1' in csv_path :
mat_data['InStruct']['Settings'][0, 0][0, 0] = 5
elif 'device2' in csv_path or 'Scanner2' in csv_path:
mat_data['InStruct']['Settings'][0, 0][0, 0] = 4
# 设置其他参数
mat_data['InStruct']['Settings'][0, 0][0, 2] = 1.1
mat_data['InStruct']['Settings'][0, 0][0, 3] = 10.5
mat_data['InStruct']['Settings'][0, 0][0, 4] = 1.1
mat_data['InStruct']['Settings'][0, 0][0, 5] = 46
mat_data['InStruct']['Settings'][0, 0][0, 6] = 20.5
# 设置初始化标志
if init:
mat_data['InStruct']['Settings'][0, 0][0, 9] = 1
else:
mat_data['InStruct']['Settings'][0, 0][0, 9] = 0
# 删除不需要的字段
try:
del mat_data['OutStruct']
del mat_data['MatlabGateway_TimeStamp']
del mat_data['mem']
del mat_data['__globals__']
except:
pass
# 生成输出文件名
mat_path = csv_path.replace('.csv', '_in.mat')
# 保存MAT文件
savemat(mat_path, mat_data, appendmat=False)
logger.info(f"Converted CSV to MAT: {csv_path} -> {mat_path}")
return mat_path
except Exception as e:
logger.error(f"Failed to convert CSV to MAT: {e}")
return None
def _update_buffer(self, result_data: Dict[str, Any], out_path: str):
"""更新数据缓冲区
Args:
result_data: 结果数据
out_path: 输出文件路径
"""
try:
XEdgeLeft = result_data['XEdgeLeft']
XEdgeRight = result_data['XEdgeRight']
YEdgeLeft = result_data['YEdgeLeft']
YEdgeRight = result_data['YEdgeRight']
# 更新X缓冲区
if XEdgeRight[0] > 0.1 and XEdgeLeft[0] > 0.1:
XEdgeDist = XEdgeRight[0] - XEdgeLeft[0]
self.dm_buffer['X'].append(XEdgeDist)
if len(self.dm_buffer['X']) > 10:
self.dm_buffer['X'].pop(0)
self.dm_buffer['X_std'] = np.std(self.dm_buffer['X'])
# 更新Y缓冲区
if YEdgeRight[0] > 0.1 and YEdgeLeft[0] > 0.1:
YEdgeDist = YEdgeRight[0] - YEdgeLeft[0]
self.dm_buffer['Y'].append(YEdgeDist)
if len(self.dm_buffer['Y']) > 10:
self.dm_buffer['Y'].pop(0)
self.dm_buffer['Y_std'] = np.std(self.dm_buffer['Y'])
# 更新设备1缓冲区
if 'device1' in out_path or 'Scanner1' in out_path:
if XEdgeRight[0] > 0.1 and XEdgeLeft[0] > 0.1:
XEdgeDist = XEdgeRight[0] - XEdgeLeft[0]
self.dm_buffer['dev1'].append(XEdgeDist)
if len(self.dm_buffer['dev1']) > 10:
self.dm_buffer['dev1'].pop(0)
self.dm_buffer['dev1_std'] = np.std(self.dm_buffer['dev1'])
if YEdgeRight[0] > 0.1 and YEdgeLeft[0] > 0.1:
YEdgeDist = YEdgeRight[0] - YEdgeLeft[0]
self.dm_buffer['dev1'].append(YEdgeDist)
if len(self.dm_buffer['dev1']) > 10:
self.dm_buffer['dev1'].pop(0)
self.dm_buffer['dev1_std'] = np.std(self.dm_buffer['dev1'])
# 更新设备2缓冲区
elif 'device2' in out_path or 'Scanner2' in out_path:
if XEdgeRight[0] > 0.1 and XEdgeLeft[0] > 0.1:
XEdgeDist = XEdgeRight[0] - XEdgeLeft[0]
self.dm_buffer['dev2'].append(XEdgeDist)
if len(self.dm_buffer['dev2']) > 10:
self.dm_buffer['dev2'].pop(0)
self.dm_buffer['dev2_std'] = np.std(self.dm_buffer['dev2'])
if YEdgeRight[0] > 0.1 and YEdgeLeft[0] > 0.1:
YEdgeDist = YEdgeRight[0] - YEdgeLeft[0]
self.dm_buffer['dev2'].append(YEdgeDist)
if len(self.dm_buffer['dev2']) > 10:
self.dm_buffer['dev2'].pop(0)
self.dm_buffer['dev2_std'] = np.std(self.dm_buffer['dev2'])
# 更新总体标准差
if len(self.dm_buffer['dev1']) >= 10 or len(self.dm_buffer['dev2']) >= 10:
self.dm_buffer['all_std'] = np.std(self.dm_buffer['dev1'] + self.dm_buffer['dev2'])
except Exception as e:
logger.error(f"Failed to update buffer: {e}")
def _process_result(self, mat_data: Dict[str, Any], out_path: str) -> Dict[str, Any]:
"""处理计算结果
Args:
mat_data: MAT文件数据
out_path: 输出文件路径
Returns:
dict: 处理后的结果
"""
try:
ret = {}
# 提取边缘数据
XEdgeLeft = mat_data['OutStruct']['EdgesLeftX'][0, 0].flatten().tolist()
XEdgeRight = mat_data['OutStruct']['EdgesRightX'][0, 0].flatten().tolist()
YEdgeLeft = mat_data['OutStruct']['EdgesLeftY'][0, 0].flatten().tolist()
YEdgeRight = mat_data['OutStruct']['EdgesRightY'][0, 0].flatten().tolist()
# 更新缓冲区
self._update_buffer({
'XEdgeLeft': XEdgeLeft,
'XEdgeRight': XEdgeRight,
'YEdgeLeft': YEdgeLeft,
'YEdgeRight': YEdgeRight
}, out_path)
# 提取重量数据
WtISC = mat_data['OutStruct']['WtISC'][0, 0].flatten().tolist()
WtOSC = mat_data['OutStruct']['WtOSC'][0, 0].flatten().tolist()
WtINS = mat_data['OutStruct']['WtINS'][0, 0].flatten().tolist()
WtALL = mat_data['OutStruct']['WtALL'][0, 0].flatten().tolist()
vals = mat_data['OutStruct']['WtBis'][0, 0].flatten().tolist()
# 外屏层
ret['WtOSC'] = [0 for _ in range(8)]
ret['WtOSC'][0] = vals[2]
ret['WtOSC'][1] = WtOSC[0]
ret['WtOSC'][2] = vals[3]
ret['WtOSC'][3] = WtOSC[2]
ret['WtOSC'][4] = vals[0]
ret['WtOSC'][5] = WtOSC[1]
ret['WtOSC'][6] = vals[1]
ret['WtOSC'][7] = WtOSC[3]
# 绝缘层
ret['WtINS'] = [0 for _ in range(8)]
ret['WtINS'][0] = vals[6]
ret['WtINS'][1] = WtINS[0]
ret['WtINS'][2] = vals[7]
ret['WtINS'][3] = WtINS[2]
ret['WtINS'][4] = vals[4]
ret['WtINS'][5] = WtINS[1]
ret['WtINS'][6] = vals[5]
ret['WtINS'][7] = WtINS[3]
# 内屏层
ret['WtISC'] = [0 for _ in range(8)]
ret['WtISC'][0] = vals[10]
ret['WtISC'][1] = WtISC[0]
ret['WtISC'][2] = vals[11]
ret['WtISC'][3] = WtISC[2]
ret['WtISC'][4] = vals[8]
ret['WtISC'][5] = WtISC[1]
ret['WtISC'][6] = vals[9]
ret['WtISC'][7] = WtISC[3]
# 总壁厚
ret['WtALL'] = [0 for _ in range(8)]
ret['WtALL'][0] = vals[14]
ret['WtALL'][1] = WtALL[0]
ret['WtALL'][2] = vals[15]
ret['WtALL'][3] = WtALL[2]
ret['WtALL'][4] = vals[12]
ret['WtALL'][5] = WtALL[1]
ret['WtALL'][6] = vals[13]
ret['WtALL'][7] = WtALL[3]
# 提取角度数据
mmang = mat_data['OutStruct']['MMAng'][0, 0].flatten().tolist()
ret['AngOSC'] = [90 + val for val in mmang[0:2]]
ret['AngOSC'].append(90 + WtOSC[10])
for i in range(len(ret['AngOSC'])):
if ret['AngOSC'][i] >= 360:
ret['AngOSC'][i] = ret['AngOSC'][i] - 360
ret['AngINS'] = [90 + val for val in mmang[2:4]]
ret['AngINS'].append(90 + WtINS[10])
for i in range(len(ret['AngINS'])):
if ret['AngINS'][i] >= 360:
ret['AngINS'][i] = ret['AngINS'][i] - 360
ret['AngISC'] = [90 + val for val in mmang[4:6]]
ret['AngISC'].append(90 + WtISC[10])
for i in range(len(ret['AngISC'])):
if ret['AngISC'][i] >= 360:
ret['AngISC'][i] = ret['AngISC'][i] - 360
ret['AngALL'] = [90 + val for val in mmang[6:8]]
ret['AngALL'].append(90 + WtALL[10])
for i in range(len(ret['AngALL'])):
if ret['AngALL'][i] >= 360:
ret['AngALL'][i] = ret['AngALL'][i] - 360
# 提取直径数据
ret['DmCORE'] = mat_data['OutStruct']['DmCORE'][0, 0].flatten().tolist()[0:3]
ret['DmCORE'] = [val - 0.2 for val in ret['DmCORE']]
ret['DmALL'] = mat_data['OutStruct']['DmALL'][0, 0].flatten().tolist()[0:3]
ret['DmALL'] = [val - 0.2 for val in ret['DmALL']]
# 计算偏心率
err = max(ret['WtINS']) - min(ret['WtINS'])
if max(ret['WtINS']) < 0.1:
ret['EccentricityINS'] = 0
else:
ret['EccentricityINS'] = err * 100.0 / max(ret['WtINS'])
err = max(ret['WtOSC']) - min(ret['WtOSC'])
if max(ret['WtOSC']) < 0.1:
ret['EccentricityOSC'] = 0
else:
ret['EccentricityOSC'] = err * 100.0 / max(ret['WtOSC'])
err = max(ret['WtISC']) - min(ret['WtISC'])
if max(ret['WtISC']) < 0.1:
ret['EccentricityISC'] = 0
else:
ret['EccentricityISC'] = err * 100.0 / max(ret['WtISC'])
# 波动性
ret['Volatility'] = [self.dm_buffer['dev1_std'], self.dm_buffer['dev2_std'], self.dm_buffer['all_std']]
# 边缘数据
ret['EdgesB'] = XEdgeLeft[0:4] + XEdgeRight[0:4][::-1]
ret['EdgesA'] = YEdgeLeft[0:4] + YEdgeRight[0:4][::-1]
ret['EdgesA'].sort()
ret['EdgesB'].sort()
# 如果是direction_1,需要反转边缘数据
if 'direction_1' in out_path:
rawDataLen = len(mat_data['OutStruct']['NormVideoX'][0, 0].flatten().tolist())
width = rawDataLen * 0.04
for i in range(len(ret['EdgesB'])):
if ret['EdgesB'][i] > 0.1:
ret['EdgesB'][i] = width - ret['EdgesB'][i]
if ret['EdgesA'][i] > 0.1:
ret['EdgesA'][i] = width - ret['EdgesA'][i]
return ret
except Exception as e:
logger.error(f"Failed to process result: {e}")
return {}
def compute(self, mat_path: str, timeout: float = 2.0) -> Tuple[Optional[str], Optional[Dict[str, Any]]]:
"""执行计算
Args:
mat_path: MAT文件路径
timeout: 超时时间(秒)
Returns:
tuple: (输出文件路径, 结果字典)
"""
try:
# 通过UDP发送计算命令
start_time = datetime.now()
out_path = self.udp_handler.compute(mat_path, timeout)
end_time = datetime.now()
logger.info(f"---------------Computing used time: {end_time - start_time}---------------")
if not out_path:
logger.error("Compute failed: no output path returned")
self.available = False
return None, None
# 检查输出文件是否存在
if not os.path.exists(out_path):
logger.error(f"Output file not found: {out_path}")
return None, None
# 读取结果文件
mat_data = loadmat(out_path)
# 处理结果
result = self._process_result(mat_data, out_path)
logger.info(f"Compute completed: {out_path}")
return out_path, result
except Exception as e:
logger.error(f"Compute failed: {e}")
return None, None
def compute_file(self, csv_path: str, init: int = 0) -> Optional[str]:
"""计算CSV文件
Args:
csv_path: CSV文件路径
init: 是否初始化
Returns:
str: JSON格式的结果,失败返回None
"""
try:
start_time = datetime.now()
# 如果是初始化,重置缓冲区
if init:
self.reset_buffer()
# 转换CSV到MAT
mat_path = self.csv_to_mat(csv_path, init)
if not mat_path:
return json.dumps({'error': 'Failed to convert CSV to MAT'})
# 执行计算
out_path, result = self.compute(mat_path)
if not out_path or not result:
return json.dumps({'error': 'Compute failed'})
# 删除输出文件
try:
os.remove(out_path)
except:
pass
# 转换为JSON
result_json = json.dumps(result, cls=CustomFloatEncoder)
# 更新统计
self.cal_count += 1
self.last_result = result_json
end_time = datetime.now()
logger.info(f"Compute completed in {end_time - start_time}")
return result_json
except Exception as e:
logger.error(f"Failed to compute file: {e}")
return json.dumps({'error': str(e)})
def get_status(self) -> Dict[str, Any]:
"""获取服务状态
Returns:
dict: 状态信息
"""
return {
'available': self.available,
'cal_count': self.cal_count,
'buffer_size': {
'X': len(self.dm_buffer['X']),
'Y': len(self.dm_buffer['Y']),
'dev1': len(self.dm_buffer['dev1']),
'dev2': len(self.dm_buffer['dev2'])
},
'buffer_std': {
'X_std': self.dm_buffer['X_std'],
'Y_std': self.dm_buffer['Y_std'],
'dev1_std': self.dm_buffer['dev1_std'],
'dev2_std': self.dm_buffer['dev2_std'],
'all_std': self.dm_buffer['all_std']
}
}
def is_available(self) -> bool:
"""检查服务是否可用
Returns:
bool: 是否可用
"""
return self.udp_handler.is_available()
def close(self):
"""关闭服务"""
self.udp_handler.close()
+165
View File
@@ -0,0 +1,165 @@
"""
配置管理模块
负责读取和管理配置文件
"""
import json
import os
import logging
logger = logging.getLogger(__name__)
# 配置文件路径
DEFAULT_CONFIG_PATH = r"C:\CPY\Config\config.json"
DEFAULT_FILE_ROOT = r'C:\CPY\DTAT'
DEFAULT_SERVER_ID = '1'
DEFAULT_MQTT_HOST = "172.16.0.126"
DEFAULT_MQTT_PORT = 8883
DEFAULT_MQTT_USERNAME = "cpy_algrithm_server"
DEFAULT_MQTT_PASSWORD = "Tgzz2026"
DEFAULT_MQTT_USE_SSL = True
DEFAULT_MQTT_USE_CA = False
DEFAULT_MQTT_CA_FILE = "./ca.cert"
DEFAULT_MQTT_ENABLE = False
DEFAULT_HTTP_HOST = "0.0.0.0"
DEFAULT_HTTP_PORT = 5000
DEFAULT_UDP_SERVER = ("127.0.0.1", 15000)
DEFAULT_UDP_PORT_NUM = 10
class ConfigManager:
"""配置管理器"""
def __init__(self, config_path=None):
"""
初始化配置管理器
Args:
config_path: 配置文件路径,默认为 DEFAULT_CONFIG_PATH
"""
self.config_path = config_path or DEFAULT_CONFIG_PATH
self.settings = {}
self._load_config()
def _load_config(self):
"""从文件加载配置"""
try:
if os.path.exists(self.config_path):
with open(self.config_path, 'r', encoding='utf-8') as f:
self.settings = json.load(f)
logger.info(f"Loaded configuration from {self.config_path}")
else:
logger.warning(f"Config file not found: {self.config_path}, using defaults")
self._set_defaults()
except Exception as e:
logger.error(f"Failed to load configuration: {e}")
self._set_defaults()
def _set_defaults(self):
"""设置默认配置"""
self.settings = {
'server_id' : DEFAULT_SERVER_ID,
'file_root': DEFAULT_FILE_ROOT,
'mqtt': {
'host': DEFAULT_MQTT_HOST,
'port': DEFAULT_MQTT_PORT,
'username': DEFAULT_MQTT_USERNAME,
'password': DEFAULT_MQTT_PASSWORD,
'use_ssl' : DEFAULT_MQTT_USE_SSL,
'use_ca' : DEFAULT_MQTT_USE_CA,
'ca_file' : DEFAULT_MQTT_CA_FILE,
'enable' : DEFAULT_MQTT_ENABLE
},
'http': {
'host': DEFAULT_HTTP_HOST,
'port': DEFAULT_HTTP_PORT
},
'udp': {
'host': DEFAULT_UDP_SERVER[0],
'port': DEFAULT_UDP_SERVER[1],
'num': DEFAULT_UDP_PORT_NUM
},
'udp_map': {
}
}
def get(self, key, default=None):
"""
获取配置值
Args:
key: 配置键
default: 默认值
Returns:
配置值
"""
keys = key.split('.')
value = self.settings
for k in keys:
if isinstance(value, dict) and k in value:
value = value[k]
else:
value = None
break
return value if value is not None else default
def set(self, key, value):
"""
设置配置值
Args:
key: 配置键
value: 配置值
"""
keys = key.split('.')
current = self.settings
for i, k in enumerate(keys[:-1]):
if k not in current:
current[k] = {}
current = current[k]
current[keys[-1]] = value
self._save_config()
def _save_config(self):
"""保存配置到文件"""
try:
os.makedirs(os.path.dirname(self.config_path), exist_ok=True)
with open(self.config_path, 'w', encoding='utf-8') as f:
json.dump(self.settings, f, indent=4, ensure_ascii=False)
logger.info(f"Saved configuration to {self.config_path}")
except Exception as e:
logger.error(f"Failed to save configuration: {e}")
def get_file_root(self):
"""获取文件根目录"""
return self.get('file_root', DEFAULT_FILE_ROOT)
def get_mqtt_config(self):
"""获取MQTT配置"""
return self.get('mqtt', {})
def get_http_config(self):
"""获取HTTP配置"""
return self.get('http', {})
def get_udp_config(self):
"""获取UDP配置"""
return self.get('udp', {})
def get_udp_map(self):
"""获取UDP映射配置"""
return self.get('udp_map', {})
def del_udp_map(self, key):
if key in self.get_udp_map():
try:
del self.settings['udp_map'][key]
self._save_config()
except:
pass
# 全局配置实例
config_manager = ConfigManager()
+31
View File
@@ -0,0 +1,31 @@
{
"server_id": "1",
"file_root": "C:\\CPY\\Data",
"template_path": "C:\\CPY\\Resource\\InStructTemplate.mat",
"http": {
"host": "0.0.0.0",
"port": 5000
},
"mqtt": {
"broker": "172.16.0.126",
"port": 8883,
"username": "cpy_algrithm_server",
"password": "TgCpyServer2026.",
"keepalive": 60,
"topic_prefix": "v1/cpy/server/",
"enable": true
},
"udp": {
"host": "127.0.0.1",
"port": 15000,
"num": 10
},
"logging": {
"level": "INFO",
"file": "cpy_server.log"
},
"udp_map": {
"TGX08-2601-0008-210836834": 15001,
"TGX08-2601-0009-058131800": 15000
}
}
+277
View File
@@ -0,0 +1,277 @@
import logging
import json
import threading
from typing import Dict, Any, Optional
import base64
from config import ConfigManager
from mqtt_client import MqttClient
from file_handler import FileHandler
from compute_service import ComputeService
from version import get_version
from config import config_manager
logger = logging.getLogger(__name__)
class CpyServer:
def __init__(self):
# 服务器状态
self.running = False
self.host = config_manager.get('http.host', '0.0.0.0')
self.port = config_manager.get('http.port', 5000)
self.server_thread = None
# 初始化各个模块
self._init_modules()
def _init_modules(self):
"""初始化各个功能模块"""
try:
# 初始化MQTT客户端
if config_manager.get('mqtt.enable', False):
self.mqtt_client = MqttClient()
self.mqtt_client.set_callbacks(on_message = self.mqtt_msg_handler)
else:
self.mqtt_client = None
# 初始化文件处理器
file_root = config_manager.get("file_root", r"C:\\CPY\\Data")
self.file_handler = FileHandler(file_root)
# 初始化计算服务
self.compute_services = {}
for dev_id in config_manager.get('udp.udp_map', {}).keys():
try:
compute_service = ComputeService(dev_id)
logger.info(f"ComputeService initialized for dev_id: {dev_id}, udp port {compute_service.udp_handler.port}")
if compute_service.udp_handler.port != config_manager.get(f'udp_map.{dev_id}', 0):
config_manager.set(f'udp_map.{dev_id}', compute_service.udp_handler.port)
self.compute_services[dev_id] = compute_service
except Exception as e:
logger.error(f"Failed to initialize ComputeService for dev_id {dev_id}: {e}")
logger.info("All modules initialized successfully")
except Exception as e:
logger.error(f"Failed to initialize modules: {e}")
raise
def mqtt_ack(self, cmd, dev_id, result, error = 200, uuid = None):
topic = f"v1/cpy/{dev_id}"
rsp = {
'ack' : cmd,
'error' : error,
'result' : result
}
if uuid:
rsp['uuid'] = uuid
self.mqtt_client.publish(topic, rsp, 1)
def mqtt_msg_handler(self, client, userdata, msg):
try:
payload = json.loads(msg.payload.decode())
logger.info(f"Received message on topic {msg.topic}: ")
cmd = payload.get("cmd", None)
if not cmd:
return
if cmd == 'status':
self.get_status(payload)
elif cmd == 'register':
self.register_device(payload)
elif cmd == 'calculate':
self.handle_data(payload)
except json.JSONDecodeError:
logger.error(f"Failed to decode JSON from message on topic {msg.topic}")
def handle_data(self, metadata):
"""处理数据上传请求"""
try:
dev_id = metadata.get('dev_id', None)
msg_uuid = metadata.get('uuid', None)
file_name = metadata.get('file_name', None)
file_content = metadata.get('data', None)
scanner = metadata.get('scanner', None)
if file_name is None or \
file_content is None or\
dev_id is None or\
msg_uuid is None:
return
try:
file_content = base64.b64decode(file_content)
except:
self.mqtt_ack('calculate', dev_id, "failed to decode data", 400, msg_uuid)
return
# 处理文件上传
processed_filename = self.file_handler.process_file_upload(
file_name, file_content, metadata
)
if not processed_filename:
self.mqtt_ack('calculate', dev_id, 'Failed to process file', 400, msg_uuid)
return
# 获取计算参数
init = int(metadata.get('init', 0))
# 执行计算
file_path = processed_filename
compute_service = self.compute_services.get(dev_id)
if not compute_service:
self.mqtt_ack('calculate', dev_id, f'ComputeService not initialized for dev_id {dev_id}', 400, msg_uuid)
return
try:
result_json = compute_service.compute_file(file_path, init)
except Exception as e:
self.mqtt_ack('calculate', dev_id, f'ComputeService error: {e}', 400, msg_uuid)
return
# 返回结果
try:
rsp = json.loads(result_json)
except:
rsp = result_json
self.mqtt_ack('calculate', dev_id, rsp, uuid = msg_uuid)
except Exception as e:
logger.error(f"Error handling data request: {e}")
return json.dumps({'error': str(e)})
def get_status(self, data):
"""获取服务器状态"""
try:
# 获取MQTT连接状态
mqtt_connected = self.mqtt_client.is_connected() if self.mqtt_client else False
# 获取版本号
version = get_version()
#检查是否传入dev_id
dev_id = data.get('dev_id', None)
if not dev_id:
rsp = json.dumps({
'running': 'true' if self.running else 'false',
'mqtt_connected': mqtt_connected,
'version': version
})
return
try:
compute_status = self.compute_services.get(dev_id).is_available()
except:
compute_status = False
rsp = {
'running': self.running,
'mqtt_connected': mqtt_connected,
'compute_status': compute_status,
'version': version
}
self.mqtt_ack('status', dev_id, rsp)
except Exception as e:
logger.error(f"Error getting status: {e}")
return json.dumps({'error': str(e)})
def register_device(self, data):
"""注册设备"""
try:
dev_id = data.get('dev_id')
print('register msg from', dev_id)
if not dev_id:
return json.dumps({'error': 'dev_id is required'})
if dev_id in self.compute_services:
try:
if self.compute_services[dev_id].is_available():
self.mqtt_ack('register', \
dev_id, \
{'message': 'Device registered successfully'},\
200)
return
except:
pass
try:
self.compute_services[dev_id].close()
del self.compute_services[dev_id]
except:
pass
# 初始化计算服务
try:
compute_service = ComputeService(dev_id)
except Exception as e:
logger.error(f"Failed to initialize ComputeService for dev_id {dev_id}: {e}")
self.mqtt_ack('register', dev_id, {'error': f'Failed to initialize ComputeService: {e}'}, 500)
return
self.compute_services[dev_id] = compute_service
if compute_service.udp_handler.port != config_manager.get(f'udp_map.{dev_id}', 0):
config_manager.set(f'udp_map.{dev_id}', compute_service.udp_handler.port)
self.mqtt_ack('register', dev_id, {'message': 'Device registered successfully'})
except Exception as e:
logger.error(f"Error registering device: {e}")
return json.dumps({'error': str(e)})
def start(self):
"""启动HTTP服务器"""
if self.running:
logger.warning("Server is already running")
return
self.running = True
logger.info(f"Starting HTTP server on {self.host}:{self.port}")
# 启动MQTT客户端
if self.mqtt_client:
self.mqtt_client.connect()
logger.info("HTTP server started")
def stop(self):
"""停止HTTP服务器"""
if not self.running:
logger.warning("Server is not running")
return
self.running = False
logger.info("Stopping HTTP server")
# 断开MQTT连接
if self.mqtt_client:
self.mqtt_client.disconnect()
# 关闭所有计算服务
for dev_id in list(self.compute_services.keys()):
try:
self.compute_services[dev_id].close()
except:
pass
try:
del self.compute_services[dev_id]
except:
pass
# Flask会在新线程中运行,需要特殊处理
# 这里只是标记状态,实际停止需要更复杂的处理
logger.info("HTTP server stopped")
def is_running(self) -> bool:
"""检查服务器是否在运行"""
return self.running
+364
View File
@@ -0,0 +1,364 @@
import os
import gzip
import logging
import pandas as pd
import numpy as np
from typing import Optional, Dict, Any, Tuple
logger = logging.getLogger(__name__)
class FileHandler:
"""文件处理器"""
def __init__(self, file_root: str):
"""初始化文件处理器
Args:
file_root: 文件根目录
"""
self.file_root = file_root
logger.info(f"FileHandler initialized with root: {file_root}")
def set_file_root(self, file_root: str):
"""设置文件根目录
Args:
file_root: 新的文件根目录
"""
self.file_root = file_root
logger.info(f"File root changed to: {file_root}")
def get_file_path(self, filename: str) -> str:
"""获取文件的完整路径
Args:
filename: 文件名
Returns:
str: 文件完整路径
"""
# 解析文件名,获取日期和小时
dir_parts = filename.split('_')
if len(dir_parts) >= 2:
date = dir_parts[0]
hour = dir_parts[1][0:2]
dir_path = os.path.join(self.file_root, date, hour)
else:
dir_path = self.file_root
return os.path.join(dir_path, filename)
def ensure_directory(self, filename: str, dev_id: str = None) -> str:
"""确保文件目录存在,如果不存在则创建
Args:
filename: 文件名
dev_id: 设备ID
Returns:
str: 目录路径
"""
root_dir = self.file_root if dev_id is None else os.path.join(self.file_root, dev_id)
# 解析文件名,获取日期和小时
dir_parts = filename.split('_')
if len(dir_parts) >= 2:
date = dir_parts[0]
hour = dir_parts[1][0:2]
dir_path = os.path.join(root_dir, date, hour)
else:
dir_path = root_dir
# 创建目录
if not os.path.exists(dir_path):
os.makedirs(dir_path)
logger.info(f"Created directory: {dir_path}")
return dir_path
def file_exists(self, filename: str, dev_id: str = None) -> bool:
"""检查文件是否存在
Args:
filename: 文件名
dev_id: 设备ID
Returns:
bool: 文件是否存在
"""
file_path = self.get_file_path(filename, dev_id)
return os.path.exists(file_path)
def save_raw_data(self, filename: str, file_content: bytes,
scale: float = 1.0, offset: float = 0.0,
row_count: int = 0, dev_id: str = None) -> Optional[str]:
"""保存原始数据为CSV文件
Args:
filename: 文件名
file_content: 文件内容(字节数据)
scale: 缩放因子
offset: 偏移量
row_count: 行数限制(0表示不限制)
Returns:
str: 保存的文件名,失败返回None
"""
try:
# 确保目录存在
dir_path = self.ensure_directory(filename, dev_id)
file_path = os.path.join(dir_path, filename)
# 处理数据
data = np.frombuffer(file_content, dtype=np.float32)
# 应用缩放和偏移
if scale != 1.0:
data = data * scale
if offset != 0.0:
data = data + offset
# 限制行数
if row_count > 0 and len(data) > row_count:
data = data[:row_count]
# 保存为CSV文件
df = pd.DataFrame({
'CH1': data[::2], # 偶数索引
'CH2': data[1::2] # 奇数索引
})
df.to_csv(file_path, index=False)
logger.info(f"Saved raw data to {file_path}")
return file_path
except Exception as e:
logger.error(f"Failed to save raw data: {e}")
return None
def save_gz_data(self, filename: str, file_content: bytes, dev_id: str = None) -> Optional[str]:
"""解压并保存GZ压缩数据
Args:
filename: 文件名
file_content: GZ压缩的文件内容
dev_id: 设备ID
Returns:
str: 保存的文件名,失败返回None
"""
try:
# 解压数据
decompressed = gzip.decompress(file_content)
# 保存解压后的数据
filename = filename.replace('.gz', '')
return self.save_raw_data(filename, decompressed, scale=1.0, offset=0.0, row_count=0, dev_id=dev_id)
except Exception as e:
logger.error(f"Failed to save GZ data: {e}")
return None
def delete_file(self, filename: str, dev_id: str = None) -> bool:
"""删除文件
Args:
filename: 文件名
dev_id: 设备ID
Returns:
bool: 删除是否成功
"""
try:
file_path = self.get_file_path(filename, dev_id)
if os.path.exists(file_path):
os.remove(file_path)
logger.info(f"Deleted file: {file_path}")
return True
else:
logger.warning(f"File not found: {file_path}")
return False
except Exception as e:
logger.error(f"Failed to delete file {filename}: {e}")
return False
def get_file_info(self, filename: str, dev_id: str = None) -> Optional[Dict[str, Any]]:
"""获取文件信息
Args:
filename: 文件名
dev_id: 设备ID
Returns:
dict: 文件信息字典,失败返回None
"""
try:
file_path = self.get_file_path(filename, dev_id)
if not os.path.exists(file_path):
return None
stat = os.stat(file_path)
return {
'filename': filename,
'path': file_path,
'size': stat.st_size,
'created': stat.st_ctime,
'modified': stat.st_mtime,
'exists': True
}
except Exception as e:
logger.error(f"Failed to get file info for {filename}: {e}")
return None
def list_files(self, date: Optional[str] = None,
hour: Optional[str] = None, dev_id: str = None) -> list:
"""列出文件
Args:
date: 日期(可选)
hour: 小时(可选)
dev_id: 设备ID
Returns:
list: 文件列表
"""
try:
# 构建目录路径
if dev_id:
dir_path = os.path.join(self.file_root, dev_id)
else:
dir_path = self.file_root
if date and hour:
dir_path = os.path.join(dir_path, date, hour)
elif date:
dir_path = os.path.join(dir_path, date)
if not os.path.exists(dir_path):
return []
# 列出文件
files = []
for item in os.listdir(dir_path):
item_path = os.path.join(dir_path, item)
if os.path.isfile(item_path):
files.append(item)
logger.info(f"Found {len(files)} files in {dir_path}")
return files
except Exception as e:
logger.error(f"Failed to list files: {e}")
return []
def process_file_upload(self, filename: str, file_content: bytes,
metadata: Dict[str, Any]) -> Optional[str]:
"""处理文件上传
Args:
filename: 文件名
file_content: 文件内容
metadata: 元数据字典
Returns:
str: 处理后的文件名,失败返回None
"""
try:
# 获取参数
file_type = metadata.get('file_type', 'raw')
compress = metadata.get('compress', 'none')
scale = float(metadata.get('scale', 1.0))
offset = float(metadata.get('offset', 0.0))
row_count = int(metadata.get('row_count', 0))
dev_id = metadata.get('dev_id', None)
# 根据文件类型处理
if file_type == 'raw':
if compress == 'none':
return self.save_raw_data(filename, file_content, scale, offset, row_count, dev_id)
elif compress == 'gz':
return self.save_gz_data(filename, file_content, dev_id)
else:
logger.error(f"Unsupported compression type: {compress}")
return None
else:
logger.error(f"Unsupported file type: {file_type}")
return None
except Exception as e:
logger.error(f"Failed to process file upload: {e}")
return None
def read_csv(self, filename: str, dev_id: str = None, nrows: Optional[int] = None) -> Optional[pd.DataFrame]:
"""读取CSV文件
Args:
filename: 文件名
dev_id: 设备ID
nrows: 读取的行数(None表示全部)
Returns:
DataFrame: 数据框,失败返回None
"""
try:
file_path = self.get_file_path(filename, dev_id)
if not os.path.exists(file_path):
logger.error(f"File not found: {file_path}")
return None
if nrows:
df = pd.read_csv(file_path, nrows=nrows)
else:
df = pd.read_csv(file_path)
logger.info(f"Read CSV file: {file_path}, shape: {df.shape}")
return df
except Exception as e:
logger.error(f"Failed to read CSV file {filename}: {e}")
return None
def clean_old_files(self, days: int = 7) -> int:
"""清理旧文件
Args:
days: 保留天数
Returns:
int: 删除的文件数量
"""
try:
import time
current_time = time.time()
cutoff_time = current_time - (days * 24 * 60 * 60)
deleted_count = 0
# 遍历所有文件
for root, dirs, files in os.walk(self.file_root):
for file in files:
file_path = os.path.join(root, file)
file_mtime = os.path.getmtime(file_path)
if file_mtime < cutoff_time:
try:
os.remove(file_path)
deleted_count += 1
logger.info(f"Deleted old file: {file_path}")
except Exception as e:
logger.error(f"Failed to delete {file_path}: {e}")
logger.info(f"Cleaned {deleted_count} old files")
return deleted_count
except Exception as e:
logger.error(f"Failed to clean old files: {e}")
return 0
+85
View File
@@ -0,0 +1,85 @@
import logging
import signal
import sys
import time
from config import config_manager
from cpy_server import CpyServer
logging.basicConfig(
level=logging.INFO,
stream=sys.stdout # 输出到stdout,被nssm捕获写入日志文件
)
logger = logging.getLogger()
def setup_logging():
"""设置日志配置
Args:
config_manager: 配置管理器实例
"""
log_level = config_manager.get('logging.level', 'INFO')
log_file = config_manager.get('logging.file', 'cpy_server.log')
logging.basicConfig(
level=getattr(logging, log_level),
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
handlers=[
logging.FileHandler(log_file, encoding='utf-8'),
logging.StreamHandler(sys.stdout)
]
)
logger.info(f"Logging configured: level={log_level}, file={log_file}")
def signal_handler(signum, frame):
"""信号处理函数
Args:
signum: 信号编号
frame: 当前栈帧
"""
logger.info(f"Received signal {signum}, shutting down...")
sys.exit(0)
def main():
"""主函数"""
try:
# 设置日志
setup_logging()
logger.info("Starting Cpy Gateway Server...")
# 设置信号处理
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)
# 创建Cpy服务器
cpy_server = CpyServer()
# 启动服务器
cpy_server.start()
# 保持主线程运行
logger.info("Server is running. Press Ctrl+C to stop.")
try:
while cpy_server.is_running():
time.sleep(1)
except KeyboardInterrupt:
logger.info("Received keyboard interrupt")
finally:
# 清理资源
logger.info("Shutting down...")
cpy_server.stop()
logger.info("Server stopped")
except Exception as e:
logger.error(f"Fatal error: {e}", exc_info=True)
sys.exit(1)
if __name__ == '__main__':
main()
+341
View File
@@ -0,0 +1,341 @@
import paho.mqtt.client as mqtt
from paho.mqtt.enums import CallbackAPIVersion
import logging
import json
import ssl
from typing import Callable, Optional, Dict, Any
import threading
from config import config_manager
logger = logging.getLogger(__name__)
class MqttClient:
"""MQTT客户端封装类"""
def __init__(self):
"""初始化MQTT客户端
"""
self.client = None
self.connected = False
self.device_id = None
# 回调函数
self.on_connect_callback = None
self.on_message_callback = None
self.on_disconnect_callback = None
# 订阅的主题列表
self.subscribed_topics = set()
# 初始化客户端
self._init_client()
def _init_client(self):
"""初始化MQTT客户端"""
try:
# 获取配置
broker = config_manager.get('mqtt.broker', '127.0.0.1')
port = config_manager.get('mqtt.port', 1883)
username = config_manager.get('mqtt.username', '')
password = config_manager.get('mqtt.password', '')
use_ssl = config_manager.get('mqtt.use_ssl', True)
use_ca = config_manager.get('mqtt.use_ca', False)
logger.info(f"use_ssl {use_ssl}, use_ca {use_ca}")
server_id = config_manager.get('server_id', '3')
#读取本机ip地址
import socket
device_name = socket.gethostbyname(socket.gethostname())
# 创建客户端
self.client = mqtt.Client(client_id=f"cpy_gateway_{server_id}_{device_name}", \
callback_api_version=CallbackAPIVersion.VERSION2, clean_session=True)
logger.info(f"cpy_gateway_{server_id}_{device_name}")
# 设置用户名和密码
if username and password:
self.client.username_pw_set(username, password)
if use_ca:
ca_file = config_manager.get('mqtt.ca_file', '.ca.cert')
self.client.tls_set(cert_reqs=ca_file)
self.client.tls_insecure_set(False)
elif use_ssl:
# 使用默认系统CA证书
logger.info(f"use mqtts without ca")
self.client.tls_set(cert_reqs=ssl.CERT_NONE)
self.client.tls_insecure_set(True)
# 设置回调
self.client.on_connect = self._on_connect
self.client.on_message = self._on_message
self.client.on_disconnect = self._on_disconnect
logger.info(f"MQTT client initialized for broker {broker}:{port}")
except Exception as e:
logger.error(f"Failed to initialize MQTT client: {e}")
raise
def connect(self) -> bool:
"""连接到MQTT代理
Returns:
bool: 连接是否成功
"""
try:
broker = config_manager.get('mqtt.broker', '127.0.0.1')
port = config_manager.get('mqtt.port', 1883)
keepalive = config_manager.get('mqtt.keepalive', 60)
logger.info(f"Connecting to MQTT broker {broker}:{port}...")
self.client.connect(broker, port, keepalive)
self.client.loop_start()
return True
except Exception as e:
logger.error(f"Failed to connect to MQTT broker: {e}")
return False
def disconnect(self):
"""断开MQTT连接"""
try:
if self.client:
self.client.loop_stop()
self.client.disconnect()
self.connected = False
logger.info("Disconnected from MQTT broker")
except Exception as e:
logger.error(f"Error disconnecting from MQTT broker: {e}")
def publish(self, topic: str, payload: Any, qos: int = 0, retain: bool = False) -> bool:
"""发布消息到指定主题
Args:
topic: 主题名称
payload: 消息内容(可以是字符串、字典等)
qos: 服务质量等级(0, 1, 2)
retain: 是否保留消息
Returns:
bool: 发布是否成功
"""
try:
if not self.connected:
logger.warning("MQTT client not connected, cannot publish")
return False
# 如果payload是字典,转换为JSON字符串
if isinstance(payload, dict):
payload = json.dumps(payload)
result = self.client.publish(topic, payload, qos, retain)
if result.rc == mqtt.MQTT_ERR_SUCCESS:
logger.debug(f"Published to {topic}: {payload}")
return True
else:
logger.error(f"Failed to publish to {topic}, rc={result.rc}")
return False
except Exception as e:
logger.error(f"Error publishing to {topic}: {e}")
return False
def subscribe(self, topic: str, qos: int = 0) -> bool:
"""订阅主题
Args:
topic: 主题名称(支持通配符)
qos: 服务质量等级
Returns:
bool: 订阅是否成功
"""
try:
if not self.connected:
logger.warning("MQTT client not connected, cannot subscribe")
return False
result = self.client.subscribe(topic, qos)
if result[0] == mqtt.MQTT_ERR_SUCCESS:
self.subscribed_topics.add(topic)
logger.info(f"Subscribed to {topic}")
return True
else:
logger.error(f"Failed to subscribe to {topic}, rc={result[0]}")
return False
except Exception as e:
logger.error(f"Error subscribing to {topic}: {e}")
return False
def unsubscribe(self, topic: str) -> bool:
"""取消订阅主题
Args:
topic: 主题名称
Returns:
bool: 取消订阅是否成功
"""
try:
if not self.connected:
logger.warning("MQTT client not connected, cannot unsubscribe")
return False
result = self.client.unsubscribe(topic)
if result[0] == mqtt.MQTT_ERR_SUCCESS:
self.subscribed_topics.discard(topic)
logger.info(f"Unsubscribed from {topic}")
return True
else:
logger.error(f"Failed to unsubscribe from {topic}, rc={result[0]}")
return False
except Exception as e:
logger.error(f"Error unsubscribing from {topic}: {e}")
return False
def _on_connect(self, client, userdata, flags, rc, props):
"""连接回调函数"""
if rc == 0:
self.connected = True
logger.info(f"Connected to MQTT broker with result code {rc}")
# 订阅默认主题
self._subscribe_default_topics()
# 调用外部回调
if self.on_connect_callback:
self.on_connect_callback(client, userdata, flags, rc)
else:
self.connected = False
logger.error(f"Failed to connect to MQTT broker, result code {rc}")
def _on_message(self, client, userdata, msg):
"""消息接收回调函数"""
try:
topic = msg.topic
payload = msg.payload.decode()
logger.debug(f"Received message on {topic}: {payload}")
# 调用外部回调
if self.on_message_callback:
#在新线程中调用外部回调
thread = threading.Thread(target=self.on_message_callback, args=(client, userdata, msg))
thread.start()
except Exception as e:
logger.error(f"Error processing message: {e}")
def _on_disconnect(self, client, userdata, rc, props, flags):
"""断开连接回调函数"""
self.connected = False
logger.info(f"Disconnected from MQTT broker with result code {rc}")
# 调用外部回调
if self.on_disconnect_callback:
self.on_disconnect_callback(client, userdata, rc)
def _subscribe_default_topics(self):
"""订阅默认主题"""
try:
topic_prefix = config_manager.get('mqtt.topic_prefix', 'v1/cpycal/')
server_id = config_manager.get('server_id', '1')
# 订阅控制主题
control_topic = f"{topic_prefix}{server_id}"
self.subscribe(control_topic)
logger.info(f"Subscribed to default topics for device {server_id}")
except Exception as e:
logger.error(f"Error subscribing to default topics: {e}")
def get_status_topic(self) -> str:
"""获取状态主题
Returns:
str: 状态主题名称
"""
topic_prefix = config_manager.get('mqtt.topic_prefix', 'v1/cpycal/')
server_id = config_manager.get('server_id', '1')
return f"{topic_prefix}{server_id}/status"
def get_control_topic(self) -> str:
"""获取控制主题
Returns:
str: 控制主题名称
"""
topic_prefix = config_manager.get('mqtt.topic_prefix', 'v1/cpycal/')
server_id = config_manager.get('server_id', '1')
return f"{topic_prefix}{server_id}/control"
def get_data_topic(self) -> str:
"""获取数据主题
Returns:
str: 数据主题名称
"""
topic_prefix = config_manager.get('mqtt.topic_prefix', 'v1/cpycal/')
server_id = config_manager.get('server_id', '1')
return f"{topic_prefix}{server_id}/data"
def publish_status(self, status: Dict[str, Any]) -> bool:
"""发布状态消息
Args:
status: 状态字典
Returns:
bool: 发布是否成功
"""
topic = self.get_status_topic()
return self.publish(topic, status, qos=1, retain=True)
def publish_data(self, data: Dict[str, Any]) -> bool:
"""发布数据消息
Args:
data: 数据字典
Returns:
bool: 发布是否成功
"""
topic = self.get_data_topic()
return self.publish(topic, data, qos=0, retain=False)
def set_callbacks(self,
on_connect: Optional[Callable] = None,
on_message: Optional[Callable] = None,
on_disconnect: Optional[Callable] = None):
"""设置回调函数
Args:
on_connect: 连接回调函数
on_message: 消息回调函数
on_disconnect: 断开连接回调函数
"""
if on_connect:
self.on_connect_callback = on_connect
if on_message:
self.on_message_callback = on_message
if on_disconnect:
self.on_disconnect_callback = on_disconnect
def is_connected(self) -> bool:
"""检查是否已连接
Returns:
bool: 是否已连接
"""
return self.connected
BIN
View File
Binary file not shown.
+341
View File
@@ -0,0 +1,341 @@
import socket
import json
import logging
from typing import Optional, Dict, Any, Tuple
logger = logging.getLogger(__name__)
from config import config_manager
class UdpHandler:
"""UDP通信处理器"""
def __init__(self, remote_port: int, remote_host: str = 'localhost'):
"""初始化UDP处理器
Args:
remote_port: 远程端口号
"""
self.remote_address = (remote_host, remote_port)
self.sock = None
self.connected = False
# 初始化socket
self._init_socket()
def set_remote_port(self, remote_port: int):
"""设置远程端口号
Args:
remote_port: 远程端口号
"""
self.remote_address = (self.remote_address[0], remote_port)
# 重新初始化socket
self._init_socket()
@property
def port(self) -> int:
"""本地端口号"""
return self.remote_address[1]
def _init_socket(self):
"""初始化UDP socket"""
try:
# 关闭旧socket
if self.sock:
self.sock.close()
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# self.sock.bind((self.remote_address[0], self.remote_address[1] + 10000))
self.connected = True
logger.info(f"UDP socket initialized, local port: {self.remote_address[1] + 10000}, remote: {self.remote_address}")
except Exception as e:
logger.error(f"Failed to initialize UDP socket: {e}")
raise
def send_command(self, command: Dict[str, Any]) -> bool:
"""发送命令到MATLAB网关
Args:
command: 命令字典
Returns:
bool: 发送是否成功
"""
try:
if not self.sock:
logger.error("UDP socket not initialized")
return False
message = json.dumps(command)
self.sock.sendto(message.encode(), self.remote_address)
logger.debug(f"Sent command to {self.remote_address}: {command}")
return True
except Exception as e:
logger.error(f"Failed to send command: {e}")
return False
def send_status_cmd(self):
"""发送状态查询命令"""
command = {
'command': 'status'
}
return self.send_command(command)
def send_compute_cmd(self, file_path: str) -> bool:
"""发送计算命令
Args:
file_path: .mat文件路径
Returns:
bool: 发送是否成功
"""
command = {
'command': 'compute',
'file_path': file_path
}
return self.send_command(command)
def send_start_cmd(self, cfg_path: str) -> bool:
"""发送启动命令
Args:
cfg_path: 配置文件路径
Returns:
bool: 发送是否成功
"""
command = {
'command': 'start',
'cfg_path': cfg_path
}
return self.send_command(command)
def send_stop_cmd(self) -> bool:
"""发送停止命令
Returns:
bool: 发送是否成功
"""
command = {
'command': 'stop'
}
return self.send_command(command)
def receive_data(self, timeout: float = 2.0) -> Optional[Any]:
"""接收数据
Args:
timeout: 超时时间(秒)
Returns:
接收到的数据,如果失败或超时返回None
"""
try:
if not self.sock:
logger.error("UDP socket not initialized")
return None
self.sock.settimeout(timeout)
try:
data, addr = self.sock.recvfrom(10240)
self.sock.settimeout(None)
logger.debug(f"Received data from {addr}: {len(data)} bytes")
# 解码数据
if not isinstance(data, str):
data = data.decode()
# 解析JSON
msg = json.loads(data)
return msg
except socket.timeout:
logger.warning(f"Timeout waiting for response after {timeout} seconds")
return None
except json.JSONDecodeError as e:
logger.error(f"Failed to parse JSON response: {e}")
logger.debug(f"Raw data: {data}")
return None
except Exception as e:
logger.error(f"Failed to receive data: {e}")
return None
def compute(self, mat_file_path: str, timeout: float = 2.0) -> Optional[str]:
"""执行计算操作
Args:
mat_file_path: .mat文件路径
timeout: 超时时间(秒)
Returns:
输出文件路径,如果失败返回None
"""
try:
# 清空接收缓冲区
self.receive_data(timeout=0.001)
# 发送计算命令
if not self.send_compute_cmd(mat_file_path):
logger.error("Failed to send compute command")
return None
# 接收结果
result = self.receive_data(timeout=timeout)
if result is not None and 'result' in result:
result = result['result']
logger.info(f"Compute result: {result}")
return result
except Exception as e:
logger.error(f"Compute operation failed: {e}")
return None
def status(self, timeout: float = 2.0) -> Optional[Dict[str, Any]]:
"""查询状态
Args:
timeout: 超时时间(秒)
Returns:
状态信息字典,如果失败返回None
"""
try:
# 清空接收缓冲区
self.receive_data(timeout=0.001)
# 发送状态查询命令
if not self.send_status_cmd():
logger.error("Failed to send status command")
return None
# 接收结果
result = self.receive_data(timeout=timeout)
print()
print(result)
print()
logger.info(f"Status result: {result}")
return result
except Exception as e:
logger.error(f"Status query failed: {e}")
return None
def _udp_status_available(self, response) -> bool:
if not response:
return False
try:
status = response['result']
idle_time = response['idle_time']
run_time = response['run_time']
compute_count = response['compute_count']
if idle_time > 3600:
return True
if compute_count == 0:
return True
except Exception as e:
logger.error(f"Failed to parse UDP status response: {e}")
return False
return True
def is_udp_port_in_use(self, port):
maps = config_manager.get_udp_map()
if not maps:
return False
for dev_id, _port in maps.items():
if _port == port:
return True
return False
def search_for_available_udp_port(self) -> bool:
"""搜索可用的UDP端口
Returns:
bool: 是否找到可用端口
"""
#先检查当前端口是否可用
response = self.status()
logger.info(f"UDP port {self.port} status: {response}")
if self._udp_status_available(response):
logger.info(f"UDP port {self.port} is available")
self.available = True
return True
# 检查其他端口
self.available = False
port = config_manager.get('udp.port', 15000)
num = config_manager.get('udp.num', 10)
for i in range(num):
self.set_remote_port(port + i)
response = self.status()
logger.info(f"UDP port {self.port} status: {response}")
if self._udp_status_available(response) and not self.is_udp_port_in_use(port + i):
logger.info(f"UDP port {self.port} is available")
self.available = True
break
return self.available
def is_available(self) -> bool:
"""检查端口是否可用
Returns:
bool: 是否可用
"""
response = self.status()
logger.info(f"UDP port {self.port} status: {response}")
if self._udp_status_available(response):
logger.info(f"UDP port {self.port} is available")
self.available = True
else:
logger.info(f"UDP port {self.port} is not available")
self.available = False
return self.available
def remove_dev_by_port(self,port) -> bool:
maps = config_manager.get_udp_map()
for dev_id, _port in maps.items():
if _port == port:
config_manager.del_udp_map(dev_id)
return True
return False
def close(self):
"""关闭UDP socket"""
try:
if self.sock:
self.sock.close()
self.sock = None
self.connected = False
logger.info("UDP socket closed")
except Exception as e:
logger.error(f"Error closing UDP socket: {e}")
def is_connected(self) -> bool:
"""检查是否已连接
Returns:
bool: 是否已连接
"""
return self.connected
def __enter__(self):
"""上下文管理器入口"""
return self
def __exit__(self, exc_type, exc_val, exc_tb):
"""上下文管理器出口"""
self.close()
+32
View File
@@ -0,0 +1,32 @@
"""
版本信息模块
管理软件版本号
"""
__version__ = "1.0.3"
__author__ = "CpyGateway Team"
__date__ = "2026-01-14"
def get_version():
"""
获取当前版本号
Returns:
str: 版本号字符串
"""
return __version__
def get_version_info():
"""
获取完整的版本信息
Returns:
dict: 包含版本信息的字典
"""
return {
'version': __version__,
'author': __author__,
'date': __date__
}