commit c4a347b28704169d417bdc120241d7a3eb41df40 Author: WIN-20230613SRA\Administrator <871066422@qq.com> Date: Thu Jul 2 16:07:26 2026 +0800 first commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..84b2419 --- /dev/null +++ b/.gitignore @@ -0,0 +1,16 @@ +# Ignore files +**/.DS_Store +**/__pycache__ +/.idea +/logFile +/logFile/* +/dataFile +/dataFile/* +/build +/dist +/env +/venv +/datas +*.db +*.log +.vscode \ No newline at end of file diff --git a/API_DOCUMENTATION.md b/API_DOCUMENTATION.md new file mode 100644 index 0000000..21688fb --- /dev/null +++ b/API_DOCUMENTATION.md @@ -0,0 +1,328 @@ +# Python Gateway HTTP API 接口文档 + +## 概述 + +Python Gateway HTTP Server 提供RESTful API接口,用于文件上传、计算处理、设备管理和状态查询。 + +**服务器地址**: `http://:` +**默认端口**: `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 | 初始版本,支持数据上传、计算和设备管理 | diff --git a/InStructTemplate.mat b/InStructTemplate.mat new file mode 100644 index 0000000..df880ec Binary files /dev/null and b/InStructTemplate.mat differ diff --git a/README_DEPLOY.md b/README_DEPLOY.md new file mode 100644 index 0000000..80b92fd --- /dev/null +++ b/README_DEPLOY.md @@ -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 diff --git a/__init__.py b/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/build.bat b/build.bat new file mode 100644 index 0000000..ee2c70a --- /dev/null +++ b/build.bat @@ -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 diff --git a/build.ps1 b/build.ps1 new file mode 100644 index 0000000..e93650a --- /dev/null +++ b/build.ps1 @@ -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" diff --git a/compute_service.py b/compute_service.py new file mode 100644 index 0000000..ecfcb60 --- /dev/null +++ b/compute_service.py @@ -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() diff --git a/config.py b/config.py new file mode 100644 index 0000000..b1728dd --- /dev/null +++ b/config.py @@ -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() diff --git a/config_template.json b/config_template.json new file mode 100644 index 0000000..6b6bca7 --- /dev/null +++ b/config_template.json @@ -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 + } +} \ No newline at end of file diff --git a/cpy_server.py b/cpy_server.py new file mode 100644 index 0000000..e3db3bd --- /dev/null +++ b/cpy_server.py @@ -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 diff --git a/file_handler.py b/file_handler.py new file mode 100644 index 0000000..1909514 --- /dev/null +++ b/file_handler.py @@ -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 diff --git a/main.py b/main.py new file mode 100644 index 0000000..b5d41e6 --- /dev/null +++ b/main.py @@ -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() diff --git a/mqtt_client.py b/mqtt_client.py new file mode 100644 index 0000000..75122c0 --- /dev/null +++ b/mqtt_client.py @@ -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 diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..e1c57fa Binary files /dev/null and b/requirements.txt differ diff --git a/udp_handler.py b/udp_handler.py new file mode 100644 index 0000000..2ce8766 --- /dev/null +++ b/udp_handler.py @@ -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() diff --git a/version.py b/version.py new file mode 100644 index 0000000..d43b809 --- /dev/null +++ b/version.py @@ -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__ + }