一、行业痛点与项目背景

在食品饮料行业，生产日期喷码是产品合规上市的必备条件，直接关系到消费者权益和企业品牌信誉。我最近在一个大型食品厂的生产线改造项目中，深刻体会到了传统喷码检测方式的局限性。

该工厂有12条高速包装生产线，每条线每分钟生产600瓶饮料，原来采用人工抽检的方式，每小时抽查一次，每次抽查50瓶。这种方式存在几个致命问题：

1. 漏检率极高：人工只能抽检不到0.1%的产品，大量漏喷、错喷的产品流入市场
2. 人工成本高：每条线需要配备2名质检人员，三班倒，人力成本巨大
3. 劳动强度大：质检人员长时间盯着高速移动的产品，容易视觉疲劳
4. 无法追溯：没有检测记录，出现质量问题时无法定位具体批次和时间

我们也曾尝试过使用传统OCR技术进行自动检测，但效果非常不理想。现场环境复杂，喷码经常出现模糊、倾斜、反光、断墨等情况，传统OCR的识别率只有80%左右，误检和漏检频发，根本无法投入实际使用。

经过多方调研和技术验证，我们最终选择了C# + YOLO26的技术方案。C#在工业上位机开发中具有不可替代的优势，与PLC、工业相机等设备的兼容性极好，开发效率高；而YOLO26作为最新一代轻量级目标检测模型，在速度和精度上达到了完美平衡，非常适合边缘部署。

二、系统整体架构设计

我们设计的系统采用分层架构，各模块职责清晰，便于维护和扩展。

2.1 整体架构图

2.2 核心模块职责

1. 图像采集层：使用海康威视工业相机，通过硬件触发方式采集产品喷码区域的图像，确保每张产品都能被准确捕捉
2. 预处理层：对采集到的图像进行ROI提取、灰度化、对比度增强等处理，减少后续推理的计算量
3. YOLO推理层：加载训练好的YOLO26 ONNX模型，使用GPU加速进行目标检测，识别出喷码中的每个字符
4. 结果解析层：将检测到的字符按照顺序拼接成完整的生产日期，校验格式和日期合法性，判断是否存在漏喷、错喷
5. 逻辑控制层：通过Modbus TCP协议与PLC通信，对不合格产品发送剔除信号，控制生产线运行
6. 数据存储层：将所有检测记录保存到SQL Server数据库，包括产品图片、生产日期、检测结果、时间戳等，便于后续追溯

2.3 检测工作流程

┌─────────────┐
│产品经过光电传感器│
└──────┬──────┘
       ▼
┌─────────────┐
│ 触发相机拍照 │
└──────┬──────┘
       ▼
┌─────────────┐
│提取喷码ROI区域│
└──────┬──────┘
       ▼
┌─────────────┐
│YOLO26字符检测│
└──────┬──────┘
       ▼
┌─────────────┐
│拼接并校验喷码│
└──────┬──────┘
       ▼
┌─────────────┐    ┌─────────────┐
│ 检测合格？   │───►│ 正常放行    │
└──────┬──────┘    └─────────────┘
       │ 否
       ▼
┌─────────────┐
│ 计算剔除延迟 │
└──────┬──────┘
       ▼
┌─────────────┐
│ 发送剔除信号 │
└──────┬──────┘
       ▼
┌─────────────┐
│ 记录检测数据 │
└─────────────┘

三、关键技术实现

3.1 YOLO26模型训练与导出

YOLO26是美团开源的最新一代轻量级目标检测模型，相比YOLOv8，它在保持相同精度的情况下，推理速度提升了30%，非常适合工业边缘部署。

数据集制作

这是整个项目中最耗时也最关键的一步。我们在现场采集了5000多张不同光照、不同角度、不同喷码质量的图片，使用LabelImg工具进行标注，标注类别为数字0-9。为了提升模型的泛化能力，我们还进行了数据增强：

• 随机旋转±15度
• 随机亮度调整±20%
• 随机对比度调整±20%
• 随机添加高斯噪声

模型训练

我们使用YOLO26-nano版本进行训练，训练参数如下：

• 输入尺寸：640x640
• 批次大小：16
• 训练轮数：100
• 初始学习率：0.01
• 优化器：SGD

训练完成后，将模型导出为ONNX格式，方便C#调用：

python export.py --weights yolov26-n.pt --include onnx --imgsz 640 --simplify

3.2 C#调用ONNX Runtime推理

我们使用Microsoft.ML.OnnxRuntime库来加载和运行ONNX模型，实现了工业级的推理服务，包含完整的异常处理和资源释放机制。

using Microsoft.ML.OnnxRuntime;
using Microsoft.ML.OnnxRuntime.Tensors;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;

public class Yolo26Detector : IDisposable
{
    private readonly OrtEnvironment _env;
    private readonly OrtSession _session;
    private readonly string[] _inputNames;
    private readonly string[] _outputNames;
    private readonly int _inputSize = 640;
    private readonly float _confidenceThreshold = 0.6f;
    private readonly float _iouThreshold = 0.4f;
    private bool _disposed = false;

    public Yolo26Detector(string modelPath, bool useGpu = true)
    {
        _env = OrtEnvironment.GetEnvironment();
        var sessionOptions = new SessionOptions();
        
        // 优先使用GPU加速
        if (useGpu)
        {
            try
            {
                sessionOptions.AppendExecutionProvider_CUDA(0);
                Console.WriteLine("GPU加速已启用");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"GPU加速不可用，切换到CPU模式：{ex.Message}");
            }
        }
        
        // 优化推理性能
        sessionOptions.GraphOptimizationLevel = GraphOptimizationLevel.ORT_ENABLE_ALL;
        sessionOptions.InterOpNumThreads = 4;
        sessionOptions.IntraOpNumThreads = 4;
        sessionOptions.EnableMemoryPattern = true;
        
        _session = _env.CreateSession(modelPath, sessionOptions);
        _inputNames = _session.InputMetadata.Keys.ToArray();
        _outputNames = _session.OutputMetadata.Keys.ToArray();
    }

    public List<DetectionResult> Detect(Bitmap image)
    {
        if (_disposed)
            throw new ObjectDisposedException(nameof(Yolo26Detector));

        try
        {
            // 图像预处理：保持宽高比缩放并填充
            var (resizedImage, scale) = PreprocessImage(image);
            
            // 转换为模型输入张量
            var inputTensor = ConvertToTensor(resizedImage);
            resizedImage.Dispose();
            
            // 执行推理
            using var inputs = new List<NamedOnnxValue>
            {
                NamedOnnxValue.CreateFromTensor(_inputNames[0], inputTensor)
            };
            
            using var results = _session.Run(inputs);
            var outputTensor = results.First().AsTensor<float>();
            
            // 解析并后处理结果
            return PostProcess(outputTensor, image.Width, image.Height, scale);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"推理异常：{ex.Message}");
            return new List<DetectionResult>();
        }
    }

    private (Bitmap resizedImage, float scale) PreprocessImage(Bitmap image)
    {
        float scale = Math.Min((float)_inputSize / image.Width, (float)_inputSize / image.Height);
        int newWidth = (int)(image.Width * scale);
        int newHeight = (int)(image.Height * scale);
        
        var resizedImage = new Bitmap(_inputSize, _inputSize);
        using (var g = Graphics.FromImage(resizedImage))
        {
            g.Clear(Color.Black);
            g.DrawImage(image, 
                new Rectangle((_inputSize - newWidth) / 2, (_inputSize - newHeight) / 2, newWidth, newHeight),
                new Rectangle(0, 0, image.Width, image.Height),
                GraphicsUnit.Pixel);
        }
        
        return (resizedImage, scale);
    }

    private Tensor<float> ConvertToTensor(Bitmap image)
    {
        var tensorData = new float[1 * 3 * _inputSize * _inputSize];
        int index = 0;
        
        for (int y = 0; y < _inputSize; y++)
        {
            for (int x = 0; x < _inputSize; x++)
            {
                var pixel = image.GetPixel(x, y);
                // YOLO输入格式：RGB归一化到[0,1]
                tensorData[index++] = pixel.R / 255.0f;
                tensorData[index++] = pixel.G / 255.0f;
                tensorData[index++] = pixel.B / 255.0f;
            }
        }
        
        return new DenseTensor<float>(tensorData, new[] { 1, 3, _inputSize, _inputSize });
    }

    private List<DetectionResult> PostProcess(Tensor<float> output, int originalWidth, int originalHeight, float scale)
    {
        var results = new List<DetectionResult>();
        int numDetections = output.Dimensions[1];
        
        for (int i = 0; i < numDetections; i++)
        {
            float confidence = output[0, i, 4];
            if (confidence < _confidenceThreshold) continue;
            
            // 获取最大类别
            float maxScore = 0;
            int classId = 0;
            for (int j = 0; j < 10; j++) // 只有0-9十个数字类别
            {
                float score = output[0, i, 5 + j];
                if (score > maxScore)
                {
                    maxScore = score;
                    classId = j;
                }
            }
            
            float finalScore = confidence * maxScore;
            if (finalScore < _confidenceThreshold) continue;
            
            // 转换坐标到原始图像
            float xCenter = output[0, i, 0] / scale;
            float yCenter = output[0, i, 1] / scale;
            float width = output[0, i, 2] / scale;
            float height = output[0, i, 3] / scale;
            
            results.Add(new DetectionResult
            {
                ClassId = classId,
                Confidence = finalScore,
                X1 = Math.Max(0, xCenter - width / 2),
                Y1 = Math.Max(0, yCenter - height / 2),
                X2 = Math.Min(originalWidth, xCenter + width / 2),
                Y2 = Math.Min(originalHeight, yCenter + height / 2)
            });
        }
        
        // 非极大值抑制
        return NMS(results);
    }

    private List<DetectionResult> NMS(List<DetectionResult> results)
    {
        var sorted = results.OrderByDescending(r => r.Confidence).ToList();
        var kept = new List<DetectionResult>();
        
        while (sorted.Count > 0)
        {
            var current = sorted[0];
            kept.Add(current);
            sorted.RemoveAt(0);
            
            for (int i = sorted.Count - 1; i >= 0; i--)
            {
                if (CalculateIOU(current, sorted[i]) > _iouThreshold)
                {
                    sorted.RemoveAt(i);
                }
            }
        }
        
        return kept;
    }

    private float CalculateIOU(DetectionResult a, DetectionResult b)
    {
        float areaA = (a.X2 - a.X1) * (a.Y2 - a.Y1);
        float areaB = (b.X2 - b.X1) * (b.Y2 - b.Y1);
        
        float x1 = Math.Max(a.X1, b.X1);
        float y1 = Math.Max(a.Y1, b.Y1);
        float x2 = Math.Min(a.X2, b.X2);
        float y2 = Math.Min(a.Y2, b.Y2);
        
        float intersection = Math.Max(0, x2 - x1) * Math.Max(0, y2 - y1);
        return intersection / (areaA + areaB - intersection);
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (_disposed) return;
        
        if (disposing)
        {
            _session?.Dispose();
            _env?.Dispose();
        }
        
        _disposed = true;
    }

    ~Yolo26Detector()
    {
        Dispose(false);
    }
}

public class DetectionResult
{
    public int ClassId { get; set; }
    public float Confidence { get; set; }
    public float X1 { get; set; }
    public float Y1 { get; set; }
    public float X2 { get; set; }
    public float Y2 { get; set; }
}

3.3 喷码解析与合法性校验

YOLO26检测出每个字符后，我们需要将它们按照正确的顺序拼接成完整的生产日期，并进行格式和合法性校验。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using System.Globalization;

public class SprayCodeParser
{
    // 喷码格式：8位数字，例如20260506
    private const int ExpectedLength = 8;
    private const string DateFormat = "yyyyMMdd";

    public ParseResult Parse(List<DetectionResult> detections)
    {
        // 漏喷检测：字符数量不足
        if (detections == null || detections.Count < ExpectedLength)
        {
            return new ParseResult
            {
                IsValid = false,
                ErrorType = ErrorType.MissingCharacters,
                ErrorMessage = $"检测到{detections?.Count ?? 0}个字符，预期{ExpectedLength}个"
            };
        }

        // 按照X坐标升序排序，得到正确的字符顺序
        var sorted = detections.OrderBy(d => d.X1).ToList();

        // 拼接字符
        var codeBuilder = new System.Text.StringBuilder();
        foreach (var detection in sorted)
        {
            codeBuilder.Append(detection.ClassId);
        }

        string sprayCode = codeBuilder.ToString();

        // 格式校验：必须是8位数字
        if (!Regex.IsMatch(sprayCode, @"^\d{8}$"))
        {
            return new ParseResult
            {
                IsValid = false,
                SprayCode = sprayCode,
                ErrorType = ErrorType.InvalidFormat,
                ErrorMessage = $"喷码格式错误：{sprayCode}"
            };
        }

        // 日期合法性校验
        if (!DateTime.TryParseExact(sprayCode, DateFormat, 
            CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime date))
        {
            return new ParseResult
            {
                IsValid = false,
                SprayCode = sprayCode,
                ErrorType = ErrorType.InvalidDate,
                ErrorMessage = $"无效日期：{sprayCode}"
            };
        }

        // 日期范围校验：不能是未来日期，也不能超过保质期
        if (date > DateTime.Now.Date)
        {
            return new ParseResult
            {
                IsValid = false,
                SprayCode = sprayCode,
                ErrorType = ErrorType.FutureDate,
                ErrorMessage = $"生产日期不能是未来日期：{sprayCode}"
            };
        }

        return new ParseResult
        {
            IsValid = true,
            SprayCode = sprayCode,
            ProductionDate = date
        };
    }
}

public enum ErrorType
{
    MissingCharacters,
    InvalidFormat,
    InvalidDate,
    FutureDate
}

public class ParseResult
{
    public bool IsValid { get; set; }
    public string SprayCode { get; set; }
    public DateTime? ProductionDate { get; set; }
    public ErrorType? ErrorType { get; set; }
    public string ErrorMessage { get; set; }
}

3.4 PLC通信与剔除控制

系统通过Modbus TCP协议与西门子S7-1200 PLC通信，当检测到不合格产品时，发送信号控制剔除装置将其从生产线上剔除。

using System;
using System.Net.Sockets;
using System.Threading;
using Modbus.Device;

public class PlcController : IDisposable
{
    private TcpClient _tcpClient;
    private ModbusIpMaster _modbusMaster;
    private readonly string _plcIp;
    private readonly int _plcPort;
    private readonly int _rejectCoilAddress;
    private bool _disposed = false;

    public PlcController(string plcIp, int plcPort = 502, int rejectCoilAddress = 0)
    {
        _plcIp = plcIp;
        _plcPort = plcPort;
        _rejectCoilAddress = rejectCoilAddress;
    }

    public bool Connect()
    {
        try
        {
            _tcpClient = new TcpClient();
            _tcpClient.Connect(_plcIp, _plcPort);
            _modbusMaster = ModbusIpMaster.CreateIp(_tcpClient);
            Console.WriteLine($"PLC连接成功：{_plcIp}:{_plcPort}");
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"PLC连接失败：{ex.Message}");
            return false;
        }
    }

    public bool RejectProduct(int delayMs = 0)
    {
        if (_modbusMaster == null || !_tcpClient.Connected)
        {
            if (!Connect())
            {
                return false;
            }
        }

        try
        {
            // 根据生产线速度计算剔除延迟
            if (delayMs > 0)
            {
                Thread.Sleep(delayMs);
            }

            // 触发剔除线圈
            _modbusMaster.WriteSingleCoil((ushort)_rejectCoilAddress, true);
            Thread.Sleep(100); // 保持信号100ms
            _modbusMaster.WriteSingleCoil((ushort)_rejectCoilAddress, false);

            Console.WriteLine("剔除信号已发送");
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"发送剔除信号失败：{ex.Message}");
            _tcpClient?.Close();
            return false;
        }
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (_disposed) return;

        if (disposing)
        {
            _modbusMaster?.Dispose();
            _tcpClient?.Close();
            _tcpClient?.Dispose();
        }

        _disposed = true;
    }

    ~PlcController()
    {
        Dispose(false);
    }
}

四、性能优化与现场踩坑

4.1 核心性能优化

1. ROI提取优化
   这是最有效的优化手段。我们只提取喷码所在的300x100区域进行推理，而不是处理整张1920x1080的图片，推理时间从50ms降到了12ms以内。

2. 模型量化
   使用ONNX Runtime的量化工具将FP32模型量化为INT8模型，推理速度提升了2.5倍，精度损失不到0.5%，完全可以接受。

3. 多线程架构
   采用生产者消费者模式，将图像采集和推理分离。采集线程负责从相机获取图片并放入队列，推理线程池从队列中取图片进行处理，充分利用了CPU和GPU资源。

4. 资源复用
   避免频繁创建和销毁Bitmap对象，使用对象池复用图像资源，减少GC压力。

4.2 现场部署踩坑经验

1. 光照问题
   现场光照变化大，喷码容易出现反光和阴影。我们加装了白色环形光源，并将相机和光源安装在封闭的遮光罩内，彻底解决了光照问题。

2. 剔除延迟计算
   生产线速度为60米/分钟，产品从相机位置到剔除装置的距离是1米，计算得出剔除延迟为1000ms。我们在系统中提供了可配置的延迟参数，方便现场调试。

3. 相机触发方式
   一开始使用软件触发，经常出现漏拍。后来改为硬件触发，使用光电传感器触发相机拍照，确保每张产品都能被准确采集。

4. 异常处理
   工业现场环境复杂，经常出现网络波动、相机断开等情况。我们在代码中加入了自动重连机制和异常报警，确保系统7x24小时稳定运行。

五、系统效果与对比

我们在工厂的一条生产线上进行了为期一个月的试运行，效果非常显著。

5.1 性能指标对比

指标	人工检测	传统OCR	YOLO26方案
识别准确率	~70%	82%	99.8%
漏检率	>10%	5.2%	0.01%
误检率	~5%	3.5%	0.1%
单帧处理时间	-	35ms	18ms
支持生产线速度	60米/分钟	30米/分钟	120米/分钟
人力成本	6人/线	2人/线	0人/线

5.2 经济效益分析

• 每条线每年节省人力成本约30万元
• 减少因不合格产品流入市场导致的罚款和品牌损失
• 实现了全量检测和完整追溯，满足了监管要求
• 系统投资回收期不到3个月

六、进阶扩展与未来规划

目前系统已经稳定运行，我们计划在以下几个方面进行扩展：

1. 多品种支持：在系统中配置不同产品的ROI区域和喷码格式，实现一键切换
2. 数据自动标注：将检测到的结果自动保存，定期重新训练模型，持续提升准确率
3. 模型在线更新：实现模型的热更新，不需要重启系统就可以加载新模型
4. 异常报警：当连续出现多个不合格产品时，发出声光报警，提醒工作人员检查喷码机
5. 数据统计分析：生成日报、周报、月报，统计喷码合格率、故障次数等指标

七、总结

在这篇文章中，我们详细介绍了如何使用C# + YOLO26实现食品包装生产线的喷码识别与漏喷检测系统。这个方案解决了传统检测方式的诸多痛点，在速度、精度和稳定性上都达到了工业级要求。

整个项目的核心经验是：工业视觉项目不仅仅是算法问题，更多的是工程问题。从数据集制作、模型训练到现场部署，每一个环节都需要精心设计和调试。只有深入了解现场需求，才能打造出真正可用的工业级系统。

这个方案已经在多个食品饮料厂的生产线上成功部署，帮助企业大幅降低了人力成本，提高了产品质量。希望这篇文章能给正在做类似项目的朋友提供一些参考和帮助。

---

👉 点击我的头像进入主页，关注专栏第一时间收到更新提醒，有问题评论区交流，看到都会回。