CapMachine/CapMachine.Wpf/Services/ZlgLinDriveService.cs

using CapMachine.Model.CANLIN;
using CapMachine.Wpf.LinDrive;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;

namespace CapMachine.Wpf.Services
{
    /// <summary>
    /// ZLG LIN 驱动服务（共享设备句柄）。
    /// </summary>
    public sealed class ZlgLinDriveService : BindableBase
    {
        private readonly ILogService _log;
        private readonly ZlgCanDriveService _zlgCanDriveService;

        /// <summary>
        /// 当前选中的配置程序（沿用原有 FreeSql 模型）。
        /// </summary>
        public CanLinConfigPro? SelectedCanLinConfigPro { get; set; }

        private bool _openState;
        /// <summary>
        /// LIN 打开状态。
        /// </summary>
        public bool OpenState
        {
            get { return _openState; }
            private set { _openState = value; RaisePropertyChanged(); }
        }

        private bool _ldfParserState;
        /// <summary>
        /// LDF 解析状态（ZLG LIN 暂未接入 LDF，固定为 false）。
        /// </summary>
        public bool LdfParserState
        {
            get { return _ldfParserState; }
            private set { _ldfParserState = value; RaisePropertyChanged(); }
        }

        /// <summary>
        /// LDF 消息集合（UI 绑定），ZLG LIN 暂未接入 LDF，默认空。
        /// </summary>
        public ObservableCollection<LinLdfModel> ListLinLdfModel { get; private set; } = new ObservableCollection<LinLdfModel>();

        /// <summary>
        /// 是否启用调度发送（与 UI 的调度表使能语义对齐）。
        /// </summary>
        public bool SchEnable
        {
            get { return _zlgCanDriveService.Driver.SchEnable; }
            set { _zlgCanDriveService.Driver.SchEnable = value; RaisePropertyChanged(); }
        }

        /// <summary>
        /// 是否启用事件驱动发送。
        /// </summary>
        public bool IsCycleSend
        {
            get { return _zlgCanDriveService.Driver.IsCycleSend; }
            set { _zlgCanDriveService.Driver.IsCycleSend = value; RaisePropertyChanged(); }
        }

        /// <summary>
        /// 构造。
        /// </summary>
        /// <param name="zlgCanDriveService">共享 CAN 服务。</param>
        /// <param name="logService">日志服务。</param>
        public ZlgLinDriveService(ZlgCanDriveService zlgCanDriveService, ILogService logService)
        {
            _zlgCanDriveService = zlgCanDriveService;
            _log = logService;

            _zlgCanDriveService.Driver.LinFrameReceived += frame =>
            {
                // 未来接入 LDF 后在这里做 Sync/Decode；当前仅保留事件链路，不做假解析。
            };
        }

        /// <summary>
        /// 初始化 LIN 配置信息（目前仅缓存）。
        /// </summary>
        /// <param name="selectedLinConfigPro">选中的配置。</param>
        public void InitLinConfig(CanLinConfigPro selectedLinConfigPro)
        {
            SelectedCanLinConfigPro = selectedLinConfigPro;
        }

        /// <summary>
        /// 打开 LIN（共享设备句柄）。
        /// </summary>
        /// <param name="deviceIndex">设备索引。</param>
        /// <param name="baudRate">波特率。</param>
        /// <param name="isMaster">是否主节点。</param>
        public void StartLinDrive(uint deviceIndex, uint baudRate, bool isMaster)
        {
            if (OpenState)
            {
                return;
            }

            try
            {
                // 先确保设备打开（不影响 CAN 后续 Init）
                _zlgCanDriveService.Driver.OpenDevice(deviceIndex);

                // 初始化 LIN 通道
                _zlgCanDriveService.Driver.OpenAndInitLin(0, new CanDrive.ZlgCan.ZlgLinChannelOptions
                {
                    BaudRate = baudRate,
                    IsMaster = isMaster,
                    MaxLength = 8,
                    ChecksumMode = 3
                });

                // 统一由 CAN 服务侧启动接收线程（设备级 merge 接收可以同时收 CAN/LIN）
                if (!_zlgCanDriveService.Driver.IsReceiving)
                {
                    _zlgCanDriveService.Driver.StartReceiveLoop(mergeReceive: true, bufferFrames: 200);
                }

                OpenState = true;
                LdfParserState = false;
            }
            catch (Exception ex)
            {
                _log.Error($"ZLG LIN 打开失败：{ex.Message}");
                OpenState = false;
                throw;
            }
        }

        /// <summary>
        /// 关闭 LIN（共享设备句柄下，当前实现以 CloseDevice 为准：关闭将同时关闭 CAN/LIN）。
        /// </summary>
        public void CloseDevice()
        {
            // ZLG 的通道句柄都在 Driver 内部；当前 Close 会关闭所有通道，保持与旧系统“同一时刻只有一种驱动工作”的原则一致。
            _zlgCanDriveService.CloseDevice();
            OpenState = false;
            LdfParserState = false;
        }

        /// <summary>
        /// 加载 LDF（ZLG LIN 暂未接入 LDF 解析 DLL，因此此处明确失败，不返回模拟数据）。
        /// </summary>
        /// <param name="path">LDF 路径。</param>
        public ObservableCollection<LinLdfModel> StartLdf(string path)
        {
            _log.Warn("ZLG LIN 当前版本未接入 LDF 解析（项目内仅存在 USB2XXX.dll 的 LDFParser）。");
            throw new NotSupportedException("ZLG LIN 暂未支持 LDF 解析，请后续提供/确认 ZLG 的 LDF DLL 接口（如 zldf.dll）后再接入。");
        }
    }
}