LIN 调度表功能同步 25002

CapMachine.Wpf/ViewModels/DialogLINSchConfigViewModel.cs

@@ -0,0 +1,581 @@
+using AutoMapper;
+using CapMachine.Core;
+using CapMachine.Model.CANLIN;
+using CapMachine.Wpf.Dtos;
+using CapMachine.Wpf.Services;
+using Prism.Commands;
+using Prism.Services.Dialogs;
+using System.Collections.ObjectModel;
+using System.Windows;
+using System.Linq;
+using System.ComponentModel;
+using System;
+
+namespace CapMachine.Wpf.ViewModels
+{
+    public class DialogLINSchConfigViewModel : DialogViewModel
+    {
+        public DialogLINSchConfigViewModel(IFreeSql freeSql, IMapper mapper, LinDriveService linDriveService)
+        {
+            Title = "调度表 LIN 配置";
+            FreeSql = freeSql;
+            Mapper = mapper;
+            LinDriveService = linDriveService;
+
+            //默认只能用1号调度器
+            SchTabIndexCbxItems = new ObservableCollection<CbxItems>()
+            {
+                new CbxItems(){
+                    Key="0",
+                    Text="0",
+                },
+                //new CbxItems(){
+                //    Key="1",
+                //    Text="1",
+                //},
+                //new CbxItems(){
+                //    Key="2",
+                //    Text="2",
+                //},
+                //new CbxItems(){
+                //    Key="3",
+                //    Text="3",
+                //},
+                //new CbxItems(){
+                //    Key="4",
+                //    Text="4",
+                //},
+            };
+
+            // 初始化树结构集合
+            SchTabTree = new ObservableCollection<LinSchTabNode>();
+
+        }
+
+        public IFreeSql FreeSql { get; }
+        public IMapper Mapper { get; }
+        public LinDriveService LinDriveService { get; }
+
+        private string name;
+        /// <summary>
+        /// 名称
+        /// </summary>
+        public string Name
+        {
+            get { return name; }
+            set { name = value; RaisePropertyChanged(); }
+        }
+
+        private ObservableCollection<LINScheduleConfigDto> _ListLINScheduleConfigDto = new ObservableCollection<LINScheduleConfigDto>();
+        /// <summary>
+        /// LIN 调度表数据集合
+        /// </summary>
+        public ObservableCollection<LINScheduleConfigDto> ListLINScheduleConfigDto
+        {
+            get { return _ListLINScheduleConfigDto; }
+            set { _ListLINScheduleConfigDto = value; RaisePropertyChanged(); }
+        }
+
+        /// <summary>
+        /// 消息/帧报文信息集合
+        /// </summary>
+        public List<string> ListMsg { get; set; }
+
+        private ObservableCollection<CbxItems> _MsgCbxItems;
+        /// <summary>
+        /// 消息名称 集合信息
+        /// </summary>
+        public ObservableCollection<CbxItems> MsgCbxItems
+        {
+            get { return _MsgCbxItems; }
+            set { _MsgCbxItems = value; RaisePropertyChanged(); }
+        }
+
+        /// <summary>
+        /// 选中的程序的Id
+        /// </summary>
+        public long SelectCanLinConfigProId { get; set; }
+
+
+        private ObservableCollection<CbxItems> _SchTabIndexCbxItems;
+        /// <summary>
+        /// 调度器序号 集合信息
+        /// </summary>
+        public ObservableCollection<CbxItems> SchTabIndexCbxItems
+        {
+            get { return _SchTabIndexCbxItems; }
+            set { _SchTabIndexCbxItems = value; RaisePropertyChanged(); }
+        }
+
+        private LINScheduleConfigDto _CurSelectedItem;
+        /// <summary>
+        /// 选中的数据
+        /// </summary>
+        public LINScheduleConfigDto CurSelectedItem
+        {
+            get { return _CurSelectedItem; }
+            set { _CurSelectedItem = value; RaisePropertyChanged(); }
+        }
+
+        //================ TreeView 数据源与选择逻辑 ================
+        // 说明：
+        //  1) SchTabTree 为 XAML 中 TreeView 的 ItemsSource，父节点为调度表 LinSchTabNode，子节点为 LinMsgNode。
+        //  2) 仅允许“单选”一个调度表（父节点）。父节点上的 CheckBox 为 TwoWay 绑定 ViewModel 模型的 IsSelected 属性。
+        //  3) 我们在 BuildTree() 完成后，通过 AttachNodeHandlers() 给父节点订阅 PropertyChanged，
+        //     当 IsSelected 变化时，统一走 OnSelectSchTab() 做单选互斥与子节点联动，避免在 XAML 上用行为触发器造成递归。
+        private ObservableCollection<LinSchTabNode> _SchTabTree;
+        /// <summary>
+        /// 调度表-消息 树结构数据源（父：SchTabName，子：消息/帧）
+        /// </summary>
+        public ObservableCollection<LinSchTabNode> SchTabTree
+        {
+            get { return _SchTabTree; }
+            set { _SchTabTree = value; RaisePropertyChanged(); }
+        }
+
+        // 防止选择联动时的递归重入。
+        // 在 OnSelectSchTab() 中统一设置 _isUpdatingSelection = true，
+        // 以避免模型属性变化再次触发 Node_PropertyChanged() / OnSelectSchTab() 形成递归导致 StackOverflow。
+        private bool _isUpdatingSelection = false;
+
+        private DelegateCommand<LinSchTabNode> _SelectSchTabCmd;
+        /// <summary>
+        /// 选择/激活 调度表命令（单选），联动选中其下所有消息
+        /// </summary>
+        public DelegateCommand<LinSchTabNode> SelectSchTabCmd
+        {
+            get
+            {
+                if (_SelectSchTabCmd == null)
+                {
+                    _SelectSchTabCmd = new DelegateCommand<LinSchTabNode>(OnSelectSchTab);
+                }
+                return _SelectSchTabCmd;
+            }
+            set { _SelectSchTabCmd = value; }
+        }
+
+        /// <summary>
+        /// 激活选中的调度表（父节点单选），并联动：
+        /// 1) 取消其它调度表的选中；
+        /// 2) 仅控制子节点可编辑状态（不强制选中/取消），子节点勾选独立由用户控制；
+        /// 3) 同步底层 ListLINScheduleConfigDto 的 IsActive（只允许一个调度表 Active）。
+        /// 通过 _isUpdatingSelection 防重入，避免模型 -> 视图 -> 模型 的递归通知。
+        /// </summary>
+        /// <param name="node"></param>
+        private void OnSelectSchTab(LinSchTabNode node)
+        {
+            if (node == null) return;
+            if (_isUpdatingSelection) return;
+            try
+            {
+                _isUpdatingSelection = true;
+
+                // 单选：当前节点选中时，取消其它调度表选中
+                if (node.IsSelected)
+                {
+                    foreach (var n in SchTabTree)
+                    {
+                        bool isTarget = ReferenceEquals(n, node);
+                        n.IsSelected = isTarget;
+                        // 仅控制可编辑性
+                        foreach (var c in n.Children) c.CanEdit = isTarget;
+                    }
+                }
+                else
+                {
+                    // 取消选中：仅禁止子节点编辑，保留勾选状态
+                    foreach (var c in node.Children) c.CanEdit = false;
+                }
+
+                // 同步 DTO 激活状态：按当前树中第一个被选中的调度表名写回
+                var active = SchTabTree?.FirstOrDefault(n => n.IsSelected);
+                foreach (var dto in ListLINScheduleConfigDto)
+                {
+                    dto.IsActive = active != null && string.Equals(dto.SchTabName, active.SchTabName, StringComparison.Ordinal);
+                }
+            }
+            finally
+            {
+                _isUpdatingSelection = false;
+            }
+        }
+
+        /// <summary>
+        /// 基于当前 ListLINScheduleConfigDto 构建树结构。
+        /// - 将 DTO 以 SchTabName 分组，生成父节点；
+        /// - 子节点为每条消息/帧（MsgName, MsgNameIndex），IsSelected 与 DTO.IsActive 同步；
+        /// - 若出现多个分组均被标记 IsActive，则仅保留第一个为选中，其它重置为未选中（保证单选约束）；
+        /// - 构建完成后调用 AttachNodeHandlers() 订阅父节点的 PropertyChanged，实现勾选即联动。
+        /// </summary>
+        private void BuildTree()
+        {
+            var newTree = new ObservableCollection<LinSchTabNode>();
+            if (ListLINScheduleConfigDto != null && ListLINScheduleConfigDto.Any())
+            {
+                var groups = ListLINScheduleConfigDto
+                    .GroupBy(x => x.SchTabName ?? string.Empty)
+                    .OrderBy(g => g.Key);
+
+                foreach (var g in groups)
+                {
+                    var node = new LinSchTabNode
+                    {
+                        SchTabName = g.Key,
+                        IsSelected = g.Any(x => x.IsActive),
+                        Children = new ObservableCollection<LinMsgNode>(
+                            g.Select(x => new LinMsgNode
+                            {
+                                SchTabName = g.Key,
+                                MsgName = x.MsgName ?? string.Empty,
+                                MsgNameIndex = x.MsgNameIndex,
+                                IsSelected = x.IsMsgActived,
+                                CanEdit = g.Any(t => t.IsActive) // 仅激活的调度表可编辑
+                            }))
+                    };
+                    newTree.Add(node);
+                }
+
+                // 如果没有任何 IsActive，确保默认不选；若存在多个组被标记，保持第一个，其他置为 false
+                var activeOnes = newTree.Where(n => n.IsSelected).ToList();
+                if (activeOnes.Count > 1)
+                {
+                    var keep = activeOnes.First();
+                    foreach (var n in activeOnes.Skip(1)) n.IsSelected = false;
+                    foreach (var dto in ListLINScheduleConfigDto)
+                    {
+                        dto.IsActive = string.Equals(dto.SchTabName, keep.SchTabName, StringComparison.Ordinal);
+                    }
+                }
+            }
+            SchTabTree = newTree;
+
+            // 绑定节点属性变化事件：
+            //  - 父节点 IsSelected 变化 -> Node_PropertyChanged() -> OnSelectSchTab()
+            //  - 子节点 IsSelected 变化 -> Child_PropertyChanged() -> 回写 DTO.IsMsgActived
+            // 这样可以不依赖 XAML EventTrigger，减少 UI 侧的递归触发风险。
+            AttachNodeHandlers(SchTabTree);
+        }
+
+        /// <summary>
+        /// 订阅父节点集合的 PropertyChanged。
+        /// 注意：子节点当前仅用于显示，不处理其 PropertyChanged。
+        /// </summary>
+        private void AttachNodeHandlers(IEnumerable<LinSchTabNode> nodes)
+        {
+            if (nodes == null) return;
+            foreach (var n in nodes)
+            {
+                n.PropertyChanged -= Node_PropertyChanged;
+                n.PropertyChanged += Node_PropertyChanged;
+                if (n.Children != null && n.Children.Any())
+                {
+                    foreach (var c in n.Children)
+                    {
+                        c.PropertyChanged -= Child_PropertyChanged;
+                        c.PropertyChanged += Child_PropertyChanged;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// 父节点属性变更回调：当 IsSelected 变化时，统一交由 OnSelectSchTab() 处理单选与联动。
+        /// </summary>
+        private void Node_PropertyChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
+        {
+            if (e.PropertyName == nameof(LinSchTabNode.IsSelected))
+            {
+                OnSelectSchTab(sender as LinSchTabNode);
+            }
+        }
+
+        /// <summary>
+        /// 子节点属性变更：当 IsSelected 变化时，回写对应 DTO.IsMsgActived。
+        /// 仅当其父节点为选中状态时允许写回（CanEdit=true）。
+        /// </summary>
+        private void Child_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+        {
+            if (e.PropertyName != nameof(LinMsgNode.IsSelected)) return;
+            if (_isUpdatingSelection) return;
+
+            try
+            {
+                _isUpdatingSelection = true;
+
+                var child = sender as LinMsgNode;
+                if (child == null) return;
+
+                // 查找父节点
+                var parent = SchTabTree?.FirstOrDefault(n => n.Children.Contains(child));
+                if (parent == null) return;
+
+                // 仅在父节点选中（可编辑）时回写 DTO
+                if (!parent.IsSelected || !child.CanEdit) return;
+
+                var dto = ListLINScheduleConfigDto?.FirstOrDefault(d =>
+                    string.Equals(d.SchTabName ?? string.Empty, parent.SchTabName ?? string.Empty, StringComparison.Ordinal)
+                    && string.Equals(d.MsgName ?? string.Empty, child.MsgName ?? string.Empty, StringComparison.Ordinal)
+                    && d.MsgNameIndex == child.MsgNameIndex);
+                if (dto != null)
+                {
+                    dto.IsMsgActived = child.IsSelected;
+                }
+            }
+            finally
+            {
+                _isUpdatingSelection = false;
+            }
+        }
+
+
+        private DelegateCommand<object> _GridSelectionChangedCmd;
+        /// <summary>
+        /// 选中行数据命令
+        /// </summary>
+        public DelegateCommand<object> GridSelectionChangedCmd
+        {
+            set
+            {
+                _GridSelectionChangedCmd = value;
+            }
+            get
+            {
+                if (_GridSelectionChangedCmd == null)
+                {
+                    _GridSelectionChangedCmd = new DelegateCommand<object>((par) => GridSelectionChangedCmdMethod(par));
+                }
+                return _GridSelectionChangedCmd;
+            }
+        }
+        private void GridSelectionChangedCmdMethod(object par)
+        {
+            //先判断是否是正确的集合数据，防止DataGrid的数据源刷新导致的触发事件
+            var Selecteddata = par as LINScheduleConfigDto;
+
+            if (Selecteddata != null)
+            {
+                CurSelectedItem = Selecteddata;
+            }
+        }
+
+        //OpCmd
+        private DelegateCommand<string> _OpCmd;
+        /// <summary>
+        /// 增加方法命令
+        /// </summary>
+        public DelegateCommand<string> OpCmd
+        {
+            set
+            {
+                _OpCmd = value;
+            }
+            get
+            {
+                if (_OpCmd == null)
+                {
+                    _OpCmd = new DelegateCommand<string>((Par) => OpCmdCall(Par));
+                }
+                return _OpCmd;
+            }
+        }
+
+        private void OpCmdCall(string Par)
+        {
+            switch (Par)
+            {
+                // 禁止新增/删除：来自 LDF 的数据不允许变更
+                case "LoadSch":
+
+                    //通过CAN驱动加载调度表
+                    if (ListLINScheduleConfigDto != null && ListLINScheduleConfigDto.Count > 0)
+                    {
+                        var messageBoxResult = MessageBox.Show("检测到当前存在数据，下载后将要覆盖当前数据，请你确认？", "提示", MessageBoxButton.OKCancel, MessageBoxImage.Hand);
+                        if (messageBoxResult == MessageBoxResult.OK)
+                        {
+                            LoadSch();
+                        }
+                        else
+                        {
+                            //不动作
+                        }
+                    }
+                    else
+                    {
+                        LoadSch();
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// 加载调度表
+        /// </summary>
+        private void LoadSch()
+        {
+            var ListLINScheduleConfig = LinDriveService.ToomossLinDrive.GetLINScheduleConfigs();
+            ListLINScheduleConfigDto.Clear();
+            //先清空
+            FreeSql.Delete<LINScheduleConfig>()
+                .Where(a => a.CanLinConfigProId == SelectCanLinConfigProId)
+                .ExecuteAffrows();
+
+            foreach (var item in ListLINScheduleConfig)
+            {
+                ListLINScheduleConfigDto.Add(Mapper.Map<LINScheduleConfigDto>(item));
+            }
+            // 重新构建树
+            BuildTree();
+        }
+
+
+        private DelegateCommand saveCmd;
+        /// <summary>
+        /// 保存命令
+        /// </summary>
+        public DelegateCommand SaveCmd
+        {
+            set
+            {
+                saveCmd = value;
+            }
+            get
+            {
+                if (saveCmd == null)
+                {
+                    saveCmd = new DelegateCommand(() => SaveCmdMethod());
+                }
+                return saveCmd;
+            }
+        }
+
+        /// <summary>
+        /// 保存命令方法
+        /// </summary>
+        /// <exception cref="NotImplementedException"></exception>
+        private void SaveCmdMethod()
+        {
+            //检查空的数据
+            foreach (var item in ListLINScheduleConfigDto)
+            {
+
+                if (string.IsNullOrEmpty(item.MsgName))
+                {
+                    MessageBox.Show("请确认消息名称是否正确", "提示", MessageBoxButton.OK, MessageBoxImage.Hand);
+                    return;
+                }
+                //if (item.Cycle == 0)
+                //{
+                //    MessageBox.Show("请确认周期是否正确", "提示", MessageBoxButton.OK, MessageBoxImage.Hand);
+                //    return;
+                //}
+            }
+
+            // 保存前：根据树中选中的调度表更新 DTO 的 IsActive，确保只保留一个激活调度表
+            var activeNode = SchTabTree?.FirstOrDefault(n => n.IsSelected);
+            foreach (var dto in ListLINScheduleConfigDto)
+            {
+                dto.IsActive = activeNode != null && string.Equals(dto.SchTabName, activeNode.SchTabName, StringComparison.Ordinal);
+            }
+
+            // 保存前：将子节点的勾选状态写回 DTO.IsMsgActived
+            foreach (var parent in SchTabTree)
+            {
+                foreach (var child in parent.Children)
+                {
+                    var dto = ListLINScheduleConfigDto.FirstOrDefault(d =>
+                        string.Equals(d.SchTabName ?? string.Empty, parent.SchTabName ?? string.Empty, StringComparison.Ordinal)
+                        && string.Equals(d.MsgName ?? string.Empty, child.MsgName ?? string.Empty, StringComparison.Ordinal)
+                        && d.MsgNameIndex == child.MsgNameIndex);
+                    if (dto != null)
+                    {
+                        dto.IsMsgActived = child.IsSelected;
+                    }
+                }
+            }
+
+            //检查数据是否正常并持久化（结构来自 LDF，不允许新增/删除，仅更新激活状态与周期等）
+            foreach (var item in ListLINScheduleConfigDto)
+            {
+                item.CanLinConfigProId = SelectCanLinConfigProId;
+
+                FreeSql.InsertOrUpdate<LINScheduleConfig>()
+                    .SetSource(Mapper.Map<LINScheduleConfig>(item))
+                    .ExecuteAffrows();
+            }
+
+            ListLINScheduleConfigDto = new ObservableCollection<LINScheduleConfigDto>(
+                Mapper.Map<List<LINScheduleConfigDto>>(FreeSql.Select<LINScheduleConfig>().Where(a => a.CanLinConfigProId == SelectCanLinConfigProId).ToList()));
+            // 重新构建树，反映保存结果
+            BuildTree();
+
+            DialogParameters pars = new DialogParameters
+             {
+                 { "ReturnValue", ListLINScheduleConfigDto }
+             };
+
+            RaiseRequestClose(new DialogResult(ButtonResult.OK, pars));
+        }
+
+        private DelegateCommand cancelCmd;
+        /// <summary>
+        /// 保存命令
+        /// </summary>
+        public DelegateCommand CancelCmd
+        {
+            set
+            {
+                cancelCmd = value;
+            }
+            get
+            {
+                if (cancelCmd == null)
+                {
+                    cancelCmd = new DelegateCommand(() => CancelCmdMethod());
+                }
+                return cancelCmd;
+            }
+        }
+
+
+        /// <summary>
+        /// 取消命令方法
+        /// </summary>
+        /// <exception cref="NotImplementedException"></exception>
+        private void CancelCmdMethod()
+        {
+            RaiseRequestClose(new DialogResult(ButtonResult.Cancel));
+        }
+
+        /// <summary>
+        /// 窗口打开时的传递的参数
+        /// </summary>
+        /// <param name="parameters"></param>
+        public override void OnDialogOpened(IDialogParameters parameters)
+        {
+            ListMsg = parameters.GetValue<List<string>>("ListMsg");
+            // 转换为CbxItems集合，都是文本内容
+            MsgCbxItems = new ObservableCollection<CbxItems>(
+            ListMsg.Select(value => new CbxItems
+            {
+                Key = value,
+                Text = value
+            }));
+
+            ListLINScheduleConfigDto = parameters.GetValue<ObservableCollection<LINScheduleConfigDto>>("ListLINScheduleConfigDto");
+            //防止返回的数据为空，就无法增加了
+            if (ListLINScheduleConfigDto == null) ListLINScheduleConfigDto = new ObservableCollection<LINScheduleConfigDto>();
+            //Name = parameters.GetValue<string>("Name");
+
+            SelectCanLinConfigProId = parameters.GetValue<long>("SelectCanLinConfigProId");
+
+            // 初次打开时构建树，并根据已有 IsActive 状态渲染
+            BuildTree();
+        }
+
+
+    }
+}
+

CapMachine.Wpf/ViewModels/LinConfigViewModel.cs

@@ -38,7 +38,7 @@ namespace CapMachine.Wpf.ViewModels
         /// <param name="machineRtDataService"></param>
         public LinConfigViewModel(IDialogService dialogService, IFreeSql freeSql,
            IEventAggregator eventAggregator, IRegionManager regionManager, SysRunService sysRunService,
-           ConfigService configService, LinDriveService linDriveService, ComActionService comActionService,
+           ConfigService configService, LinDriveService linDriveService, ComActionService comActionService, LogicRuleService logicRuleService,
            IMapper mapper, MachineRtDataService machineRtDataService)
         {
             //LogService = logService;
@@ -49,12 +49,24 @@ namespace CapMachine.Wpf.ViewModels
             ConfigService = configService;
             LinDriveService = linDriveService;
             ComActionService = comActionService;
+            LogicRuleService = logicRuleService;
             Mapper = mapper;
             this.MachineRtDataService = machineRtDataService;
 
             //MachineDataService = machineDataService;
             DialogService = dialogService;
 
+            //数据波特率
+            DataBaudRateCbxItems = new ObservableCollection<CbxItems>()
+            {
+                new CbxItems(){ Key="38400",Text="38400"},
+                new CbxItems(){ Key="19200",Text="19200"},
+                new CbxItems(){ Key="14400",Text="14400"},
+                new CbxItems(){ Key="9600",Text="9600"},
+                new CbxItems(){ Key="4800",Text="4800"},
+                new CbxItems(){ Key="2400",Text="2400"},
+            };
+
             WriteNameCbxItems = new ObservableCollection<CbxItems>()
             {
                 new CbxItems(){ Key="转速",Text="转速"},
@@ -84,7 +96,8 @@ namespace CapMachine.Wpf.ViewModels
                 new CbxItems(){ Key="通讯PTC模块温度",Text="通讯PTC模块温度"},
             };
             InitLoadLinConfigPro();
-
+            //初始化写规则下拉框
+            InitWriteRuleCbx();
         }
 
 
@@ -98,6 +111,7 @@ namespace CapMachine.Wpf.ViewModels
         public ConfigService ConfigService { get; }
         public LinDriveService LinDriveService { get; }
         public ComActionService ComActionService { get; }
+        public LogicRuleService LogicRuleService { get; }
         public IMapper Mapper { get; }
         private MachineRtDataService MachineRtDataService { get; }
 
@@ -106,6 +120,49 @@ namespace CapMachine.Wpf.ViewModels
         /// </summary>
         public IDialogService DialogService { get; }
 
+        private ObservableCollection<CbxItems> _WriteRuleCbxItems;
+        /// <summary>
+        /// 写入的规格集合
+        /// </summary>
+        public ObservableCollection<CbxItems> WriteRuleCbxItems
+        {
+            get { return _WriteRuleCbxItems; }
+            set { _WriteRuleCbxItems = value; RaisePropertyChanged(); }
+        }
+
+
+        #region 规则
+
+
+        /// <summary>
+        /// 逻辑更改事件
+        /// </summary>
+        /// <param name="msg"></param>
+        /// <exception cref="NotImplementedException"></exception>
+        private void LogicRuleChangeEventCall(string msg)
+        {
+            //InitWriteRuleCbx();
+        }
+
+        /// <summary>
+        /// 初始化写规则下拉框
+        /// </summary>
+        private void InitWriteRuleCbx()
+        {
+            WriteRuleCbxItems = new ObservableCollection<CbxItems>();
+            //选择的读写规则
+            foreach (var itemRule in LogicRuleService.LogicRuleDtos)
+            {
+                WriteRuleCbxItems.Add(new CbxItems()
+                {
+                    Key = itemRule.Id.ToString(),
+                    Text = itemRule.Name
+                });
+            }
+        }
+
+
+        #endregion
 
 
         #region LinConfigPro
@@ -118,7 +175,8 @@ namespace CapMachine.Wpf.ViewModels
             //LIN配置集合数据
             canLinConfigPros = FreeSql.Select<CanLinConfigPro>().Where(a => a.CANLINInfo == CANLIN.LIN)
                 .Include(a => a.LINConfigExd)
-                .IncludeMany(a => a.CanLinConfigContents)
+                .IncludeMany(a => a.CanLinConfigContents, then => then.Include(b => b.LogicRule))
+                .IncludeMany(a => a.LinScheduleConfigs)
                 .ToList();
 
             ListCanLinConfigPro = new ObservableCollection<CanLinConfigPro>(canLinConfigPros);
@@ -145,6 +203,7 @@ namespace CapMachine.Wpf.ViewModels
                             MsgName = item.MsgFrameName,
                             SignalName = item.SignalName,
                             SignalCmdValue = double.TryParse(item.DefautValue, out double result) == true ? result : 0,
+                            LogicRuleDto = Mapper.Map<LogicRuleDto>(item.LogicRule),
                         });
                         //LinDriveService.CmdData.Add(new LinCmdData()
                         //{
@@ -156,11 +215,30 @@ namespace CapMachine.Wpf.ViewModels
                     }
 
                 }
+                else
+                {
+                    ListWriteCanLinRWConfigDto = new ObservableCollection<CanLinRWConfigDto>();
+                }
+
                 var ReadData = SelectCanLinConfigPro.CanLinConfigContents!.Where(a => a.RWInfo == RW.Read).ToList();
                 if (ReadData != null && ReadData.Count > 0)
                 {
                     ListReadCanLinRWConfigDto = new ObservableCollection<CanLinRWConfigDto>(Mapper.Map<List<CanLinRWConfigDto>>(ReadData));
                 }
+                else
+                {
+                    ListReadCanLinRWConfigDto = new ObservableCollection<CanLinRWConfigDto>();
+                }
+
+                //调度表配置信息
+                if (SelectCanLinConfigPro.LinScheduleConfigs != null && SelectCanLinConfigPro.LinScheduleConfigs.Count() > 0)
+                {
+                    ListLINScheduleConfigDto = new ObservableCollection<LINScheduleConfigDto>(Mapper.Map<List<LINScheduleConfigDto>>(SelectCanLinConfigPro.LinScheduleConfigs));
+                }
+                else
+                {
+                    ListLINScheduleConfigDto = new ObservableCollection<LINScheduleConfigDto>();
+                }
 
                 //匹配选中的SelectCanLinConfigPro.CanLinConfigContents和ListLinLdfModel
                 MatchSeletedAndLinLdfModel();
@@ -408,6 +486,8 @@ namespace CapMachine.Wpf.ViewModels
                             LinDriveService.InitLinConfig(SelectCanLinConfigPro);
 
                             InitLoadLinConfigPro();
+                            // 订阅 CmdData 的数据变化事件，用于基于数据变化刷新调度表
+                            LinDriveService.ToomossLinDrive.LoadCmdDataToDrive(LinDriveService.CmdData);
                         }
                         else
                         {
@@ -496,6 +576,7 @@ namespace CapMachine.Wpf.ViewModels
                             MsgName = item.MsgFrameName,
                             SignalName = item.SignalName,
                             SignalCmdValue = double.TryParse(item.DefautValue, out double result) == true ? result : 0,
+                            LogicRuleDto = Mapper.Map<LogicRuleDto>(item.LogicRule),
                         });
 
                         //LinDriveService.CmdData.Add(new LinCmdData()
@@ -508,13 +589,33 @@ namespace CapMachine.Wpf.ViewModels
                     }
 
                 }
+                else
+                {
+                    ListWriteCanLinRWConfigDto = new ObservableCollection<CanLinRWConfigDto>();
+                }
                 var ReadData = SelectCanLinConfigPro.CanLinConfigContents!.Where(a => a.RWInfo == RW.Read).ToList();
                 if (ReadData != null && ReadData.Count > 0)
                 {
                     ListReadCanLinRWConfigDto = new ObservableCollection<CanLinRWConfigDto>(Mapper.Map<List<CanLinRWConfigDto>>(ReadData));
                 }
+                else
+                {
+                    ListReadCanLinRWConfigDto = new ObservableCollection<CanLinRWConfigDto>();
+                }
 
                 SelectCanLinConfigProConfigName = SelectCanLinConfigPro.ConfigName;
+
+                //调度表配置信息
+                if (SelectCanLinConfigPro.LinScheduleConfigs != null && SelectCanLinConfigPro.LinScheduleConfigs.Count() > 0)
+                {
+                    ListLINScheduleConfigDto = new ObservableCollection<LINScheduleConfigDto>(Mapper.Map<List<LINScheduleConfigDto>>(SelectCanLinConfigPro.LinScheduleConfigs));
+                }
+                else
+                {
+                    ListLINScheduleConfigDto = new ObservableCollection<LINScheduleConfigDto>();
+                }
+
+
                 return;
             }
             //先判断是否是正确的集合数据，防止DataGrid的数据源刷新导致的触发事件
@@ -792,6 +893,58 @@ namespace CapMachine.Wpf.ViewModels
             set { _SelectedLINConfigExdDto = value; RaisePropertyChanged(); }
         }
 
+        private ObservableCollection<CbxItems> _DataBaudRateCbxItems;
+        /// <summary>
+        /// CAN 数据波特率 
+        /// </summary>
+        public ObservableCollection<CbxItems> DataBaudRateCbxItems
+        {
+            get { return _DataBaudRateCbxItems; }
+            set { _DataBaudRateCbxItems = value; RaisePropertyChanged(); }
+        }
+
+
+        private DelegateCommand<object> _SchEnableCmd;
+        /// <summary>
+        /// 调度表的使能 操作的指令
+        /// </summary>
+        public DelegateCommand<object> SchEnableCmd
+        {
+            set
+            {
+                _SchEnableCmd = value;
+            }
+            get
+            {
+                if (_SchEnableCmd == null)
+                {
+                    _SchEnableCmd = new DelegateCommand<object>((Par) => SchEnableCmdCall(Par));
+                }
+                return _SchEnableCmd;
+            }
+        }
+        /// <summary>
+        /// 调度表的使能信息
+        /// </summary>
+        /// <param name="par"></param>
+        /// <exception cref="NotImplementedException"></exception>
+        private void SchEnableCmdCall(object par)
+        {
+            var dd = SelectedLINConfigExdDto.SchEnable;
+            var Result = (bool)par;
+            if (Result)
+            {
+                LinDriveService.ToomossLinDrive.SchEnable = true;
+
+            }
+            else
+            {
+                LinDriveService.ToomossLinDrive.SchEnable = false;
+
+            }
+        }
+
+
         private DelegateCommand<string> _LinOpCmd;
         /// <summary>
         /// LIN操作的指令
@@ -835,7 +988,7 @@ namespace CapMachine.Wpf.ViewModels
                             //系统使用了LIN
                             ConfigService.CanLinRunStateModel.CurSysSelectedCanLin = CanLinEnum.Lin;
                         }
-                      
+
                         //LIN LDF配置 有LDF配置的话，则直接加载LDF信息
                         if (!string.IsNullOrEmpty(SelectCanLinConfigPro.LINConfigExd.LdfPath))
                         {
@@ -877,6 +1030,7 @@ namespace CapMachine.Wpf.ViewModels
                              .Set(a => a.LdfPath, SelectedLINConfigExdDto.LdfPath)
                              .Set(a => a.Cycle, SelectedLINConfigExdDto.Cycle)
                              .Set(a => a.BaudRate, SelectedLINConfigExdDto.BaudRate)
+                             .Set(a => a.SchEnable, SelectedLINConfigExdDto.SchEnable)
                              .Where(a => a.Id == SelectedLINConfigExdDto.Id)
                              .ExecuteUpdated();
                         }
@@ -938,6 +1092,12 @@ namespace CapMachine.Wpf.ViewModels
 
                     break;
                 case "CycleSend"://循环发送你
+
+                    //有可能加载完毕后不手动改变状态，导致值没有传输，所以这里赋值
+                    LinDriveService.ToomossLinDrive.SchEnable = SelectedLINConfigExdDto.SchEnable;
+                    //无论有没有调度表，都要把这个配置给LinDriveService
+                    LinDriveService.ListLINScheduleConfig = ListLINScheduleConfigDto.ToList();
+
                     //循环发送数据
                     LinDriveService.CycleSendMsg();
 
@@ -992,6 +1152,17 @@ namespace CapMachine.Wpf.ViewModels
         }
 
 
+        private ObservableCollection<LINScheduleConfigDto> _ListLINScheduleConfigDto;
+        /// <summary>
+        ///调度表集合
+        /// </summary>
+        public ObservableCollection<LINScheduleConfigDto> ListLINScheduleConfigDto
+        {
+            get { return _ListLINScheduleConfigDto; }
+            set { _ListLINScheduleConfigDto = value; RaisePropertyChanged(); }
+        }
+
+
         //private string _SelectedWriteName;
         ///// <summary>
         ///// 选中的写入的Name
@@ -1106,6 +1277,7 @@ namespace CapMachine.Wpf.ViewModels
                             //直接修改
                             FreeSql.Update<CanLinRWConfig>(item.Id)
                                 .Set(a => a.Name, item.Name)
+                                .Set(a => a.LogicRuleId, item.LogicRuleId)
                                 .Set(a => a.DefautValue, item.DefautValue)
                                 .ExecuteAffrows();
                             //ListWriteCanLinRWConfigDto.Remove(SelectedWriteCanLinRWConfigDto);
@@ -1117,8 +1289,6 @@ namespace CapMachine.Wpf.ViewModels
                         InitLoadLinConfigPro();
                     }
 
-
-
                     break;
                 case "Delete":
                     if (SelectedWriteCanLinRWConfigDto != null)
@@ -1136,6 +1306,47 @@ namespace CapMachine.Wpf.ViewModels
                         System.Windows.MessageBox.Show("请选中后再进行【删除】操作？", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                     }
 
+                    break;
+                case "WriteSch"://调度表
+
+                    //LinDriveService.ToomossLinDrive.LinTest();
+
+                    //LinDriveService.ToomossLinDrive.StartSchedule();
+                    //break;
+                    //
+                    if (LinDriveService.ToomossLinDrive.OpenState)
+                    {
+                        //弹窗
+                        DialogService.ShowDialog("DialogLINSchConfigView", new DialogParameters() {
+                            {"ListMsg", LinDriveService.CmdData.GroupBy(a=>a.MsgName).Select(a=>a.Key).ToList() },
+                            { "ListLINScheduleConfigDto",ListLINScheduleConfigDto},
+                            { "SelectCanLinConfigProId",SelectCanLinConfigPro.Id},
+
+                         }, (par) =>
+                         {
+                             if (par.Result == ButtonResult.OK)
+                             {
+                                 ////程序名称
+                                 ListLINScheduleConfigDto = par.Parameters.GetValue<ObservableCollection<LINScheduleConfigDto>>("ReturnValue");
+                                 //把更新后的最新值给当前的主集合中
+                                 SelectCanLinConfigPro.LinScheduleConfigs = Mapper.Map<List<LINScheduleConfig>>(ListLINScheduleConfigDto.ToList());
+
+                             }
+                             else if (par.Result == ButtonResult.Cancel)
+                             {
+                                 //取消
+
+                             }
+
+                         });
+                    }
+                    else
+                    {
+                        System.Windows.MessageBox.Show("未发现写入的执行的命令数据，无法配置？", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
+                    }
+
+
+
                     break;
                 default:
                     break;

CapMachine.Wpf/ViewModels/LinSchTabNode.cs

@@ -0,0 +1,109 @@
+using Prism.Mvvm;
+using System.Collections.ObjectModel;
+
+namespace CapMachine.Wpf.ViewModels
+{
+    /// <summary>
+    /// 调度表节点（父节点）。
+    /// 与 XAML 中父级 <TreeView> 的 <HierarchicalDataTemplate> 绑定：
+    /// - 显示字段：<see cref="SchTabName"/>
+    /// - 选择字段：<see cref="IsSelected"/>（TwoWay 绑定至 CheckBox）
+    /// - 子集合：<see cref="Children"/>（用于展开显示消息/帧子节点）
+    ///
+    /// 使用 Prism 的 <see cref="BindableBase.SetProperty{T}(ref T, T, string?)"/>
+    /// 以避免值未发生变化时重复触发 PropertyChanged 引起的联动递归。
+    /// </summary>
+    public class LinSchTabNode : BindableBase
+    {
+        /// <summary>
+        /// 调度表名称（父节点标题）。
+        /// </summary>
+        private string _SchTabName;
+        public string SchTabName
+        {
+            get => _SchTabName;
+            set => SetProperty(ref _SchTabName, value);
+        }
+
+        private bool _IsSelected;
+        /// <summary>
+        /// 是否被激活/选中（父节点单选）。
+        /// 该属性与 XAML 中父节点的 CheckBox 进行 TwoWay 绑定，
+        /// 其变更由 ViewModel 监听并处理“单选联动”和“子节点跟随”。
+        /// </summary>
+        public bool IsSelected
+        {
+            get => _IsSelected;
+            set => SetProperty(ref _IsSelected, value);
+        }
+
+        /// <summary>
+        /// 子节点集合（消息/帧条目）。
+        /// </summary>
+        private ObservableCollection<LinMsgNode> _Children = new ObservableCollection<LinMsgNode>();
+        public ObservableCollection<LinMsgNode> Children
+        {
+            get => _Children;
+            set => SetProperty(ref _Children, value);
+        }
+    }
+
+    /// <summary>
+    /// 消息/帧 节点（子节点）。
+    /// 与 XAML 中父级 <HierarchicalDataTemplate.ItemTemplate> 绑定：
+    /// - 显示字段：<see cref="MsgName"/> / <see cref="MsgNameIndex"/>
+    /// - 选择字段：<see cref="IsSelected"/>（当前设计作为“显示联动”，非编辑入口）
+    /// </summary>
+    public class LinMsgNode : BindableBase
+    {
+        /// <summary>
+        /// 所属的调度表名称（便于回写 DTO 时定位）。
+        /// </summary>
+        private string _SchTabName;
+        public string SchTabName
+        {
+            get => _SchTabName;
+            set => SetProperty(ref _SchTabName, value);
+        }
+
+        /// <summary>
+        /// 消息/帧名称。
+        /// </summary>
+        private string _MsgName;
+        public string MsgName
+        {
+            get => _MsgName;
+            set => SetProperty(ref _MsgName, value);
+        }
+
+        /// <summary>
+        /// 消息/帧 Index。
+        /// </summary>
+        private int _MsgNameIndex;
+        public int MsgNameIndex
+        {
+            get => _MsgNameIndex;
+            set => SetProperty(ref _MsgNameIndex, value);
+        }
+
+        private bool _IsSelected;
+        /// <summary>
+        /// 是否被选中（随父节点联动显示）。
+        /// </summary>
+        public bool IsSelected
+        {
+            get => _IsSelected;
+            set => SetProperty(ref _IsSelected, value);
+        }
+
+        /// <summary>
+        /// 子节点勾选是否可用（仅当父调度表被选中时可编辑）。
+        /// </summary>
+        private bool _CanEdit;
+        public bool CanEdit
+        {
+            get => _CanEdit;
+            set => SetProperty(ref _CanEdit, value);
+        }
+    }
+}