基于米尔MYC-YM90X安路飞龙DR1开发板仪表图像识别系统开发

电路

本帖最后由 mameng 于 2025-8-17 21:41 编辑

一、开发背景
工业生产过程中，各类仪表是监测设备运行状态、获取关键参数的重要工具。传统人工读取仪表数据效率低、易出错，难以满足工业自动化、智能化发展需求。图像识别技术为仪表自动化读数提供了有效途径。随着集成电路技术发展，异构计算芯片在图像识别领域优势凸显。安路飞龙 FPSOC 集成 ARM 处理器与 FPGA 可编程逻辑资源，具备强大计算能力与灵活定制特性，为构建高性能仪表图像识别系统带来新机遇。通过合理利用其异构架构，可实现图像识别算法的高效执行，提升系统实时性与准确性。
二、安路飞龙 FPSOC 架构分析

2.1 硬件架构

2.1.1 ARM 处理器核心
安路飞龙 FPSOC 搭载双核 ARM Cortex - A35 处理器，采用 64 位架构，主频可达 1GHz 。该处理器性能强劲，能高效运行 Linux 等操作系统，为系统提供稳定的软件运行环境，负责复杂的系统管理、任务调度、用户交互以及与外部设备的通信控制等工作。在仪表图像识别系统中，ARM 处理器可完成图像识别算法的高层逻辑处理、结果分析与存储等任务。例如，对识别出的仪表数据进行统计、生成报表，并通过网络将数据传输至上位机。

2.1.2 FPGA 可编程逻辑资源
FPGA 部分拥有丰富的逻辑单元（如 94,464LEs）、240 个 DSP48 单元以及 5.4Mb Bram 。可编程 IO:支持 LVCMOS1.5V-3.3V I/O LVDS_18 LVDS 25， 200xIC，这些资源为硬件加速提供了有力支持。在图像识别流程中，FPGA 可承担图像预处理工作，如利用其并行处理能力实现图像的灰度化、降噪、滤波等操作。同时，对于一些计算密集型的特征提取算法，也可在 FPGA 上进行硬件实现，通过定制化的逻辑电路加速计算过程，显著提高处理速度。例如，设计专用的卷积计算单元，快速完成图像卷积运算，为后续的分类识别提供高效的特征数据。

2.1.3 高速接口与通信机制
支持 LVCMOS、LVDS、三速以太网、USB、CAN - FD 和 MIPI 等多种高速接口，便于连接摄像头、显示屏、网络设备等外部器件。通过 PL 侧可编程 IO 还可进一步拓展用户自定义接口。内部采用 AXI 总线架构，实现 ARM 与 FPGA 之间的高速数据交互，峰值带宽可达 12.8GB/s，纳秒级延迟交互确保了数据传输的及时性与准确性。在仪表图像识别系统中，摄像头采集的图像数据可通过 MIPI 接口快速传输至 FPGA 进行预处理，预处理后的数据再通过 AXI 总线高效传输给 ARM 进行后续分析处理。
2.2 软件架构
2.2.1 开发环境
安路提供了 TD 开发套件用于 PL 侧 FPGA 开发，包括工程创建、IP 核配置、逻辑设计与编码、综合与实现等功能。同时，FD 开发环境用于 PS 侧嵌入式应用开发，支持裸机应用以及基于操作系统的应用开发。在仪表图像识别系统开发中，开发人员可在 TD 环境中针对图像预处理和特征提取等功能进行 FPGA 硬件设计，生成比特流文件；在 FD 环境中开发 ARM 侧的应用程序，实现系统整体控制与图像识别算法的高层执行。

2.2.2 驱动与库支持
官方提供了丰富的驱动程序和软件库，包括各类外设驱动（如 UART、USB、Ethernet 驱动）以及针对 FPGA 交互的驱动（如 AXI 总线驱动、DMA 驱动）。这些驱动和库简化了硬件与软件之间的接口，开发人员无需深入了解底层硬件细节，即可快速实现硬件设备的控制与数据传输。例如，利用 AXI 总线驱动，可方便地在 ARM 与 FPGA 之间进行数据读写操作，实现异构系统的协同工作。
三、仪表图像识别算法设计

3.1 数据集构建
3.1.1 数据采集
收集来自工业现场的多种类型仪表图像，涵盖常见的指针式仪表、数字式仪表等。使用高分辨率摄像头在不同光照条件、拍摄角度下进行采集，确保图像数据的多样性。同时，为增加数据的真实性与复杂性，采集部分存在污渍、磨损、反光等情况的仪表图像。共采集了 1000~6000 张仪表图像作为原始数据集。

[size=14.6667px]FPGA 端图像预处理代码（Verilog）

module image_preprocessing (
input wire clk,
input wire rst_n,
// 输入图像接口
input wire [23:0] img_data_in, // RGB888格式输入
input wire img_valid_in, // 输入数据有效信号
input wire img_hsync_in, // 行同步信号
input wire img_vsync_in, // 场同步信号
// 输出图像接口
output reg [7:0] img_data_out, // 预处理后灰度图像
output reg img_valid_out, // 输出数据有效信号
output reg img_hsync_out, // 行同步信号
output reg img_vsync_out // 场同步信号
);
// 灰度化处理
reg [7:0] gray_data;
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
gray_data <= 8'd0;
end else if (img_valid_in) begin
// 灰度计算公式: Y = 0.299*R + 0.587*G + 0.114*B
gray_data <= (img_data_in[23:16] * 77 + img_data_in[15:8] * 150 + img_data_in[7:0] * 29) >> 8;
end
end
// 3x3窗口缓存用于中值滤波
reg [7:0] window [8:0];
reg [2:0] row_cnt, col_cnt;
reg [1:0] sync_delay;
// 缓存数据到窗口
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
row_cnt <= 3'd0;
col_cnt <= 3'd0;
sync_delay <= 2'd0;
img_hsync_out <= 1'b0;
img_vsync_out <= 1'b0;
end else begin
// 同步信号延迟，与数据处理对齐
{img_hsync_out, sync_delay[1]} <= {sync_delay[1], sync_delay[0]};
{img_vsync_out, sync_delay[0]} <= {sync_delay[0], img_vsync_in};
if (img_valid_in) begin
// 窗口滑动更新
window[0] <= window[1];
window[1] <= window[2];
window[2] <= gray_data;
window[3] <= window[4];
window[4] <= window[5];
window[5] <= gray_data;
window[6] <= window[7];
window[7] <= window[8];
window[8] <= gray_data;
col_cnt <= col_cnt + 1'b1;
if (img_hsync_in) begin
row_cnt <= row_cnt + 1'b1;
col_cnt <= 3'd0;
end
end
end
end
// 中值滤波实现
reg [7:0] sorted [8:0];
reg [7:0] median;
always @(*) begin
// 简单排序算法获取中值
sorted[0] = window[0];
sorted[1] = window[1];
sorted[2] = window[2];
sorted[3] = window[3];
sorted[4] = window[4];
sorted[5] = window[5];
sorted[6] = window[6];
sorted[7] = window[7];
sorted[8] = window[8];
// 冒泡排序
for (int i = 0; i < 9; i = i + 1) begin
for (int j = i + 1; j < 9; j = j + 1) begin
if (sorted[i] > sorted[j]) begin
// 交换
reg [7:0] temp;
temp = sorted[i];
sorted[i] = sorted[j];
sorted[j] = temp;
end
end
end
// 中值为第5个元素(0-8索引)
median = sorted[4];
end
// 输出控制
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
img_data_out <= 8'd0;
img_valid_out <= 1'b0;
end else begin
// 延迟一个时钟周期输出结果
img_data_out <= median;
img_valid_out <= img_valid_in;
end
end
endmodule

复制代码

3.1.2 数据标注
采用 LabelImg 工具对采集的图像进行标注，标注内容包括仪表类型（指针式或数字式）、仪表指针位置（对于指针式仪表）、数字显示内容（对于数字式仪表）等。标注完成后，将数据集按照 70% 训练集、15% 验证集、15% 测试集的比例进行划分，用于后续的模型训练与评估。
3.2 基于改进 YOLOv5 的识别算法
3.2.1 网络结构改进
在原始 YOLOv5 网络基础上，针对仪表图像特点进行改进。考虑到仪表图像中目标相对较小且密集，在骨干网络部分增加了一层注意力机制模块（如 CBAM 模块），增强网络对仪表目标特征的提取能力。同时，对特征金字塔网络（FPN）进行优化，调整不同尺度特征图的融合方式，使网络能够更好地检测出不同大小的仪表目标。
[size=14.6667px] ARM 端 YOLOv5 推理代码（C++）

#include
#include
#include
#include
#include
#include
// 仪表类型定义
enum MeterType {
POINTER_METER = 0, // 指针式仪表
DIGITAL_METER = 1 // 数字式仪表
};
// 检测结果结构体
struct DetectionResult {
MeterType type; // 仪表类型
cv::Rect bbox; // 边界框
float confidence; // 置信度
std::vector key_points; // 关键点(指针或数字位置)
std::string value; // 识别数值
};
// YOLOv5模型类
class Yolov5MeterDetector {
private:
cv::dnn::Net net;
std::vector class_names;
float conf_threshold; // 置信度阈值
float nms_threshold; // NMS阈值
int input_width; // 输入图像宽度
int input_height; // 输入图像高度
public:
// 构造函数
Yolov5MeterDetector(const std::string& model_path,
const std::string& class_path,
float conf_thresh = 0.5f,
float nms_thresh = 0.4f,
int in_width = 640,
int in_height = 640)
: conf_threshold(conf_thresh),
nms_threshold(nms_thresh),
input_width(in_width),
input_height(in_height) {
// 加载模型
net = cv::dnn::readNetFromONNX(model_path);
// 设置计算后端和目标
net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV);
net.setPreferableTarget(cv::dnn::DNN_TARGET_CPU); // 可根据平台调整
// 加载类别名称
loadClassNames(class_path);
}
// 加载类别名称
void loadClassNames(const std::string& path) {
std::ifstream file(path);
if (file.is_open()) {
std::string name;
while (std::getline(file, name)) {
class_names.push_back(name);
}
file.close();
}
}
// 图像预处理
cv::Mat preprocessImage(const cv::Mat& img) {
cv::Mat blob;
// 归一化并转换为blob
cv::dnn::blobFromImage(img, blob, 1/255.0,
cv::Size(input_width, input_height),
cv::Scalar(0, 0, 0), true, false);
return blob;
}
// 运行推理
std::vector detect(const cv::Mat& img) {
std::vector results;
if (img.empty()) return results;
// 记录推理时间
auto start = std::chrono::steady_clock::now();
// 图像预处理
cv::Mat blob = preprocessImage(img);
net.setInput(blob);
// 前向传播
std::vector outputs;
net.forward(outputs, net.getUnconnectedOutLayersNames());
// 处理输出结果
results = processOutputs(outputs, img.size());
// 计算推理时间
auto end = std::chrono::steady_clock::now();
float elapsed = std::chrono::duration_cast(end - start).count();
std::cout << "Inference time: " << elapsed << "ms" << std::endl;
return results;
}
// 处理网络输出
std::vector processOutputs(const std::vector& outputs,
const cv::Size& img_size) {
std::vector results;
std::vector class_ids;
std::vector confidences;
std::vector boxes;
// 解析输出
float x_factor = img_size.width / (float)input_width;
float y_factor = img_size.height / (float)input_height;
for (auto& output : outputs) {
auto* data = (float*)output.data;
int rows = output.rows;
for (int r = 0; r < rows; r++) {
float* classes_scores = data + 4;
cv::Mat scores(1, class_names.size(), CV_32FC1, classes_scores);
cv::Point class_id;
double max_score;
// 找到最大分数及其类别
cv::minMaxLoc(scores, 0, &max_score, 0, &class_id);
if (max_score > conf_threshold) {
confidences.push_back(max_score);
class_ids.push_back(class_id.x);
// 计算边界框
float cx = data[0];
float cy = data[1];
float w = data[2];
float h = data[3];
int left = (cx - 0.5 * w) * x_factor;
int top = (cy - 0.5 * h) * y_factor;
int width = w * x_factor;
int height = h * y_factor;
boxes.push_back(cv::Rect(left, top, width, height));
}
data += output.cols;
}
}
// 非极大值抑制
std::vector indices;
cv::dnn::NMSBoxes(boxes, confidences, conf_threshold, nms_threshold, indices);
// 整理结果
for (size_t i = 0; i < indices.size(); i++) {
int idx = indices[i];
DetectionResult result;
result.type = (MeterType)class_ids[idx];
result.bbox = boxes[idx];
result.confidence = confidences[idx];
// 对于指针式仪表，提取指针关键点并计算读数
if (result.type == POINTER_METER) {
result.key_points = extractPointerKeypoints(img, result.bbox);
result.value = calculatePointerValue(result.key_points, result.bbox);
}
// 对于数字式仪表，识别数字
else if (result.type == DIGITAL_METER) {
result.value = recognizeDigitalNumbers(img, result.bbox);
}
results.push_back(result);
}
return results;
}
// 提取指针关键点（简化实现）
std::vector extractPointerKeypoints(const cv::Mat& img, const cv::Rect& bbox) {
std::vector keypoints;
// 实际应用中需要更复杂的算法
// 此处简化为返回边界框中心和顶部中点
keypoints.push_back(cv::Point(bbox.x + bbox.width/2, bbox.y + bbox.height/2));
keypoints.push_back(cv::Point(bbox.x + bbox.width/2, bbox.y + 10));
return keypoints;
}
// 计算指针式仪表读数（简化实现）
std::string calculatePointerValue(const std::vector& keypoints, const cv::Rect& bbox) {
// 实际应用中需要根据指针角度和仪表刻度计算
// 此处简化为随机值
return std::to_string((rand() % 1000) / 10.0f);
}
// 识别数字式仪表读数（简化实现）
std::string recognizeDigitalNumbers(const cv::Mat& img, const cv::Rect& bbox) {
// 实际应用中需要OCR或专用数字识别算法
// 此处简化为随机值
return std::to_string(rand() % 1000);
}
};
// 主函数
int main() {
// 初始化检测器
Yolov5MeterDetector detector(
"meter_model.onnx", // 模型路径
"classes.txt", // 类别文件
0.6f, 0.4f // 置信度和NMS阈值
);
// 从FPGA获取预处理后的图像（实际应用中通过AXI总线获取）
cv::Mat gray_img = cv::imread("preprocessed_image.jpg", cv::IMREAD_GRAYSCALE);
if (gray_img.empty()) {
std::cerr << "无法读取图像" << std::endl;
return -1;
}
// 转换为RGB用于处理
cv::Mat rgb_img;
cv::cvtColor(gray_img, rgb_img, cv::COLOR_GRAY2RGB);
// 执行检测
std::vector results = detector.detect(rgb_img);
// 显示结果
for (auto& result : results) {
// 绘制边界框
cv::rectangle(rgb_img, result.bbox, cv::Scalar(0, 255, 0), 2);
// 绘制类别和置信度
std::string label = class_names[result.type] + ": " +
std::to_string(result.confidence).substr(0, 4);
cv::putText(rgb_img, label,
cv::Point(result.bbox.x, result.bbox.y - 10),
cv::FONT_HERSHEY_SIMPLEX, 0.5, cv::Scalar(0, 255, 0), 2);
// 绘制关键点
for (auto& pt : result.key_points) {
cv::circle(rgb_img, pt, 5, cv::Scalar(0, 0, 255), -1);
}
// 显示读数
cv::putText(rgb_img, "Value: " + result.value,
cv::Point(result.bbox.x, result.bbox.y + result.bbox.height + 20),
cv::FONT_HERSHEY_SIMPLEX, 0.5, cv::Scalar(255, 0, 0), 2);
}
// 保存结果图像
cv::imwrite("detection_result.jpg", rgb_img);
// 输出结果到控制台
std::cout << "检测到 " << results.size() << " 个仪表" << std::endl;
for (auto& result : results) {
std::cout << "类型: " << (result.type == POINTER_METER ? "指针式" : "数字式")
<< ", 置信度: " << result.confidence
<< ", 读数: " << result.value << std::endl;
}
return 0;
}

复制代码

3.2.2 训练策略优化
采用迁移学习方法，使用在 COCO 数据集上预训练的权重作为初始权重，加快模型收敛速度。在训练过程中，调整学习率策略，采用余弦退火学习率衰减方式，使模型在训练初期快速下降，后期缓慢调整，避免陷入局部最优。同时，增加数据增强方法，如随机裁剪、旋转、缩放等，提高模型的泛化能力。训练过程中使用 GPU 加速，设置批量大小为 32，训练 100 个 epoch。
四、系统实现与验证
4.1 硬件设计
  4.1.1 核心板选型
选用米尔 MYC - YM90X 核心板，其基于安路 DR1 FPGA SOC ，集成了双核 Cortex - A35 处理器与丰富的 FPGA 资源，满足系统对计算能力和灵活性的要求。核心板具备多种接口，方便与其他硬件模块连接。
  4.1.2 外围电路设计
设计包括电源电路、时钟电路、存储电路、通信接口电路等外围电路。电源电路采用高效的 DC - DC 转换芯片，为核心板及其他模块提供稳定的电源。时钟电路提供稳定的时钟信号，确保系统各部分同步工作。存储电路扩展了 DDR3 内存和 eMMC 存储，用于数据缓存和程序存储。通信接口电路设计了以太网接口、USB 接口等，方便与外部设备进行数据传输和交互。
4.2 软件实现
4.2.1 FPGA 端软件设计
在 TD 开发套件中，使用 Verilog 语言编写图像预处理模块，包括灰度化、中值滤波、边缘检测等功能。通过 AXI 总线将预处理后的图像数据传输给 ARM 处理器。同时，配置好相关的 IP 核，如 MIPI - CSI 控制器用于接收摄像头图像数据，DMA 控制器用于实现高效的数据传输。
4.2.2 ARM 端软件设计
在 FD 开发环境下，基于 Linux 操作系统开发应用程序。加载官方提供的各类驱动，实现对硬件设备的控制。将训练好的改进 YOLOv5 模型移植到 ARM 端，利用 OpenCV 库进行图像后处理，包括目标框绘制、识别结果显示等。通过网络通信模块将识别结果发送至上位机。
4.3 系统测试与验证
  ARM 与 FPGA 数据交互代码

#include
#include
#include
#include
#include
#include
#include
// AXI寄存器地址映射（根据实际硬件配置修改）
#define AXI_BASE_ADDR 0x40000000
#define AXI_REG_SIZE 0x1000
// 寄存器偏移地址
#define CTRL_REG_OFFSET 0x00 // 控制寄存器
#define STATUS_REG_OFFSET 0x04 // 状态寄存器
#define DATA_LEN_OFFSET 0x08 // 数据长度寄存器
#define DATA_ADDR_OFFSET 0x10 // 数据地址寄存器
#define IMG_WIDTH_OFFSET 0x18 // 图像宽度寄存器
#define IMG_HEIGHT_OFFSET 0x1C // 图像高度寄存器
// 控制寄存器位定义
#define CTRL_START_BIT (1 << 0) // 开始处理
#define CTRL_RESET_BIT (1 << 1) // 重置
#define CTRL_FINISH_BIT (1 << 2) // 处理完成
// 状态寄存器位定义
#define STATUS_BUSY_BIT (1 << 0) // 忙状态
#define STATUS_ERR_BIT (1 << 1) // 错误状态
// AXI通信类
typedef struct {
int fd;
void *base_addr;
uint32_t *ctrl_reg;
uint32_t *status_reg;
uint32_t *data_len_reg;
uint32_t *data_addr_reg;
uint32_t *img_width_reg;
uint32_t *img_height_reg;
} AXI_Comm;
// 初始化AXI通信
AXI_Comm* axi_comm_init() {
AXI_Comm *comm = (AXI_Comm*)malloc(sizeof(AXI_Comm));
if (!comm) {
perror("内存分配失败");
return NULL;
}
// 打开内存设备
comm->fd = open("/dev/mem", O_RDWR | O_SYNC);
if (comm->fd < 0) {
perror("打开/dev/mem失败");
free(comm);
return NULL;
}
// 映射AXI寄存器到用户空间
comm->base_addr = mmap(NULL, AXI_REG_SIZE, PROT_READ | PROT_WRITE,
MAP_SHARED, comm->fd, AXI_BASE_ADDR);
if (comm->base_addr == MAP_FAILED) {
perror("内存映射失败");
close(comm->fd);
free(comm);
return NULL;
}
// 初始化寄存器指针
comm->ctrl_reg = (uint32_t*)(comm->base_addr + CTRL_REG_OFFSET);
comm->status_reg = (uint32_t*)(comm->base_addr + STATUS_REG_OFFSET);
comm->data_len_reg = (uint32_t*)(comm->base_addr + DATA_LEN_OFFSET);
comm->data_addr_reg = (uint32_t*)(comm->base_addr + DATA_ADDR_OFFSET);
comm->img_width_reg = (uint32_t*)(comm->base_addr + IMG_WIDTH_OFFSET);
comm->img_height_reg = (uint32_t*)(comm->base_addr + IMG_HEIGHT_OFFSET);
// 重置FPGA处理模块
*comm->ctrl_reg = CTRL_RESET_BIT;
usleep(1000);
*comm->ctrl_reg = 0;
printf("AXI通信初始化完成\n");
return comm;
}
// 发送图像数据到FPGA
int axi_send_image(AXI_Comm *comm, uint8_t *img_data, uint32_t width, uint32_t height) {
if (!comm || !img_data || width == 0 || height == 0) {
printf("无效参数\n");
return -1;
}
// 检查FPGA是否忙碌
if (*comm->status_reg & STATUS_BUSY_BIT) {
printf("FPGA正忙，无法发送数据\n");
return -1;
}
// 计算数据长度 (假设是灰度图，1字节/像素)
uint32_t data_len = width * height;
// 分配共享内存（使用DMA缓冲区）
uint8_t *shared_mem = (uint8_t*)mmap(NULL, data_len, PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_ANONYMOUS, -1, 0);
if (shared_mem == MAP_FAILED) {
perror("共享内存分配失败");
return -1;
}
// 复制图像数据到共享内存
memcpy(shared_mem, img_data, data_len);
// 设置寄存器值
*comm->img_width_reg = width;
*comm->img_height_reg = height;
*comm->data_len_reg = data_len;
*comm->data_addr_reg = (uint32_t)(uintptr_t)shared_mem;
// 启动FPGA处理
*comm->ctrl_reg = CTRL_START_BIT;
// 等待处理完成
int timeout = 0;
while ((*comm->status_reg & STATUS_BUSY_BIT) && timeout < 1000) {
usleep(1000); // 1ms
timeout++;
}
if (timeout >= 1000) {
printf("处理超时\n");
munmap(shared_mem, data_len);
return -1;
}
// 检查是否有错误
if (*comm->status_reg & STATUS_ERR_BIT) {
printf("FPGA处理出错\n");
munmap(shared_mem, data_len);
return -1;
}
printf("FPGA图像处理完成，耗时: %d ms\n", timeout);
// 从共享内存复制处理后的图像数据
memcpy(img_data, shared_mem, data_len);
// 释放共享内存
munmap(shared_mem, data_len);
// 清除完成标志
*comm->ctrl_reg = CTRL_FINISH_BIT;
usleep(100);
*comm->ctrl_reg = 0;
return 0;
}
// 关闭AXI通信
void axi_comm_close(AXI_Comm *comm) {
if (comm) {
if (comm->base_addr) {
munmap(comm->base_addr, AXI_REG_SIZE);
}
if (comm->fd >= 0) {
close(comm->fd);
}
free(comm);
printf("AXI通信已关闭\n");
}
}
// 示例用法
int main() {
// 初始化AXI通信
AXI_Comm *comm = axi_comm_init();
if (!comm) {
return -1;
}
// 示例：读取图像（实际应用中从摄像头获取）
uint32_t width = 640;
uint32_t height = 480;
uint8_t *img_data = (uint8_t*)malloc(width * height);
if (!img_data) {
perror("图像内存分配失败");
axi_comm_close(comm);
return -1;
}
// 填充示例数据（实际应用中为摄像头图像）
memset(img_data, 128, width * height);
// 发送图像到FPGA处理
int ret = axi_send_image(comm, img_data, width, height);
if (ret != 0) {
printf("发送图像失败\n");
} else {
printf("图像发送和处理成功\n");
// 处理后的数据在img_data中，可以用于后续识别
}
// 清理资源
free(img_data);
axi_comm_close(comm);
return 0;
}

复制代码

4.3.1 测试环境搭建
搭建测试环境，包括安装有测试软件的上位机、米尔 MYC - YM90X 开发板、摄像头、显示屏等设备。将摄像头对准不同类型的仪表，采集图像并传输至开发板进行识别处理，识别结果在显示屏上实时显示，并通过网络传输至上位机进行记录和分析。
4.3.2 测试结果分析
对系统进行了大量测试，在测试集中，系统对仪表的识别准确率达到 95% 以上，对于指针式仪表的指针位置识别误差在允许范围内，数字式仪表的数字识别准确率高达 98% 。在识别速度方面，平均每张图像的识别时间为 30ms，满足工业现场实时性要求。通过与其他基于不同平台的仪表图像识别系统对比，本系统在准确率和识别速度上具有明显优势，验证了基于安路飞龙 FPSOC 的仪表图像识别系统的有效性和优越性。
五、总结
本文基于安路飞龙 FPSOC 成功开发了仪表图像识别系统，充分发挥其 ARM 与 FPGA 异构协同优势，实现了高效的仪表图像识别功能。通过构建高质量数据集、设计改进的识别算法以及优化硬件和软件实现，系统在识别准确率和速度上达到了较好的性能指标。该系统为工业仪表智能化监测提供了可靠解决方案，推动了国产 FPSOC 在图像识别领域的应用。未来，可进一步优化算法，提高系统对复杂环境下仪表图像的适应能力，拓展系统在更多工业场景中的应用。