using AutoMapper;
using CapMachine.Model;
using CapMachine.Shared.Controls;
using CapMachine.Wpf.ChannelModel;
using CapMachine.Wpf.Dtos;
using CapMachine.Wpf.Models;
using CapMachine.Wpf.Models.ProModelPars;
using CapMachine.Wpf.Models.Tag;
using CapMachine.Wpf.PrismEvent;
using CapMachine.Wpf.ProPars;
using CapMachine.Wpf.Tool;
using ImTools;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Channels;
using System.Threading.Tasks;
using static CapMachine.Wpf.Models.ComEnum;
using System.Windows.Forms;
using HslCommunication.Profinet.Siemens;
using Masuit.Tools.Hardware;
using CapMachine.Model.MeterConfig;
using Masuit.Tools;
using System.Timers;
using Prism.Events;
namespace CapMachine.Wpf.Services
{
///
/// 程序运行时服务
/// 负责程序的解析、运行、调度等功能
///
public class ProRuntimeService
{
///
/// 实例化函数
///
public ProRuntimeService(IFreeSql freeSql, IMapper mapper, IEventAggregator eventAggregator,
MachineRtDataService machineRtDataService, ConfigService configService, CanDriveService canDriveService, LinDriveService linDriveService,
ILogService logService)
{
FreeSql = freeSql;
Mapper = mapper;
EventAggregator = eventAggregator;
MachineRtDataService = machineRtDataService;
ConfigService = configService;
CanDriveService = canDriveService;
LinDriveService = linDriveService;
ProRunChannel = MachineRtDataService.ProRunChannel;
LogService = logService;
//实例化函数
ListProExModel = new List();
//从变量集合中加载PLC转制的配置数据
ListPlcLoadConfigCell = new List();
foreach (var itemKeyValue in MachineRtDataService.TagManger.DicTags)
{
//是否未仪表的参数
if (itemKeyValue.Value.IsMeter)
{
ListPlcLoadConfigCell.Add(new PlcLoadConfigCell()
{
Name = itemKeyValue.Key,
SvAddress = MachineRtDataService.TagManger.TryGetSVModel(itemKeyValue.Value.Name, out MeterValueAttrCell? controlAttrCell) == true ? controlAttrCell!.Address : "",
Limit_UpAddress = MachineRtDataService.TagManger.TryGetLimitUpModel(itemKeyValue.Value.Name, out MeterExdAttrCell? controlAttrCell2) == true ? controlAttrCell2!.Address : "",
Limit_DownAddress = MachineRtDataService.TagManger.TryGetLimitDownModel(itemKeyValue.Value.Name, out MeterExdAttrCell? controlAttrCell3) == true ? controlAttrCell3!.Address : "",
Pid_PAddress = MachineRtDataService.TagManger.TryGetPidPModel(itemKeyValue.Value.Name, out MeterExdAttrCell? controlAttrCell4) == true ? controlAttrCell4!.Address : "",
Pid_IAddress = MachineRtDataService.TagManger.TryGetPidIModel(itemKeyValue.Value.Name, out MeterExdAttrCell? controlAttrCell5) == true ? controlAttrCell5!.Address : "",
Pid_DAddress = MachineRtDataService.TagManger.TryGetPidDModel(itemKeyValue.Value.Name, out MeterExdAttrCell? controlAttrCell6) == true ? controlAttrCell6!.Address : "",
Precision = itemKeyValue.Value.Precision,
});
// 给ListProExModel 增加数据
ListProExModel.Add(new ProExModel(ProRunChannel)
{
MeterName = itemKeyValue.Value.NameNoUnit,
ListProStepExe = new List(),
IsSpeed = itemKeyValue.Value.Name.Contains("转速") == true ? true : false,
});
}
}
SpeedProExModel= ListProExModel.FindFirst(a => a.MeterName.Contains("转速"));//转速执行模型
//SpeedRunEndEvent
ListProExModel.FindFirst(a => a.MeterName.Contains("转速")).SpeedRunEndEvent += ProRuntimeService_SpeedRunEndEvent;
//反写给MachineRtDataService，MachineRtDataService也要写到PLC中
MachineRtDataService.ListPlcLoadConfigCell = ListPlcLoadConfigCell;
//驱动实例
SiemensDrive = MachineRtDataService.SiemensDrive;
MachineRunState1 = new MachineRunState("M1", EventAggregator, ConfigService, canDriveService, linDriveService);
//程序运行实时管道数据监听
//Task.Run(() => ListenProRunChannelAction());
}
///
/// 选中的程序运行集合
///
public List SelectedListProSegRun { get; set; }
public IFreeSql FreeSql { get; }
public IMapper Mapper { get; }
public IEventAggregator EventAggregator { get; }
public MachineRtDataService MachineRtDataService { get; }
public ConfigService ConfigService { get; }
public CanDriveService CanDriveService { get; }
public LinDriveService LinDriveService { get; }
public ILogService LogService { get; }
///
/// 西门子连接驱动程序
///
public SiemensS7Net SiemensDrive { get; set; }
///
/// Task扫描 程序运行时间扫描任务
///
private static Task ProRunTimeScanTask { get; set; }
///
/// 程序运行集合
///
public List ListProExModel { get; set; }
///
/// 转速执行模型
/// 摘出来给界面展示用，因为速度的时间和步骤代表整个程序的时间和步骤
///
public ProExModel SpeedProExModel { get; set; }
///
/// PLC加载配置数据集合
///
public List ListPlcLoadConfigCell { get; set; }
///
/// 设备运行状态
///
public MachineRunState MachineRunState1 { get; set; }
///
/// 加载选中的程序运行集合
/// 目前步骤设置常值，是OK的，但是在斜坡多步骤里面也可以设置 50-50 10秒的常值设置，那么在打点时，上面的两个常值都能识别
///
public void LoadProSegRun(List SelectedListProSegRun)
{
if (SelectedListProSegRun == null || SelectedListProSegRun.Count() == 0)
{
return;
}
//取消之前的程序执行
EndProRun();
//先清空之前的步骤数据
foreach (var itemProExModel in ListProExModel)
{
itemProExModel.ListProStepExe.Clear();
itemProExModel.ListSlopExStep.Clear();
}
//多个选中的程序块循环
foreach (var itemProSegRun in SelectedListProSegRun)
{
//获取当前程序块
//逐个对应的程序
var CurProgramSeg = FreeSql.Select(itemProSegRun.ProgramSegId)
.IncludeMany(a => a.ProSteps,
then => then.IncludeMany(b => b.MeterSpeeds)
.IncludeMany(b => b.MeterCond1Temps)
.IncludeMany(b => b.MeterCond2Temps)
.IncludeMany(b => b.MeterCond2Presss)
.IncludeMany(b => b.MeterEVAPExpTemps)
.IncludeMany(b => b.MeterExPresss)
.IncludeMany(b => b.MeterHVVols)
.IncludeMany(b => b.MeterInhPresss)
.IncludeMany(b => b.MeterInhTemps)
.IncludeMany(b => b.MeterLubePresss)
.IncludeMany(b => b.MeterLVVols)
.IncludeMany(b => b.MeterOCRs)
.IncludeMany(b => b.MeterOS1Temps)
.IncludeMany(b => b.MeterOS2Temps)
.IncludeMany(b => b.MeterPTCEntTemps)
.IncludeMany(b => b.MeterPTCFlows)
.IncludeMany(b => b.MeterPTCPws)
.IncludeMany(b => b.MeterEnvRHs)
.IncludeMany(b => b.MeterEnvTemps)
).ToList().FirstOrDefault();
//获取当前的程序
if (CurProgramSeg != null && CurProgramSeg.ProSteps != null && CurProgramSeg.ProSteps.Any())
{
//CurProgramSeg有重复运行的次数
for (int SegIndex = 0; SegIndex < CurProgramSeg.ProRepeat; SegIndex++)
{
//解析程序的多行步骤，表格中的行步骤数据，牟定速度
foreach (var itemStep in CurProgramSeg.ProSteps.OrderBy(a => a.StepNo))
{
//单行步骤中包含多个仪表参数的配置，需要逐个仪表参数手动操作解析
//统计当前步骤itemStep的速度所有时间，供后面的其他参数使用，因为其他的参数也是牟定当前步骤速度是总时间，在这个步骤中，所有的参数的总时间是一样的
var SpeedStepTotaolTime = 0;
//********* 单个【转速】步骤信息的解析 *********
{
var CurMeterName = "转速";
if (itemStep.MeterSpeeds != null && itemStep.MeterSpeeds.Any())
{
switch (itemStep.MeterSpeeds.FirstOrDefault()!.ValueType)
{
case ConfigValueType.Constant: //常值
//常值没有斜率和多个步骤，就一个总时间
SpeedStepTotaolTime = itemStep.MeterSpeeds.FirstOrDefault()!.KeepTime;
//常值的话就一个数据，循环执行一次
foreach (var itemMeterValueCell in itemStep.MeterSpeeds)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
StartSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = false,//常值没有斜率 //开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
MeterName = CurMeterName,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ListStepExd = new List()
{
new StepExd(){ Name="输出锁定",Value=itemMeterValueCell.OutLock,ValueType=ExdValueType.Bool},
new StepExd(){ Name="吸排气阀",Value=itemMeterValueCell.InhExhValve,ValueType=ExdValueType.Bool},
new StepExd(){ Name="EV",Value=(short)itemMeterValueCell.Ev,ValueType=ExdValueType.Short},
new StepExd(){ Name="压缩机使能",Value=itemMeterValueCell.CapEnable,ValueType=ExdValueType.Bool},
},
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
});
}
break;
case ConfigValueType.Slope: //斜率
//斜率有多个步骤和循环的次数，统计一个总时间
SpeedStepTotaolTime = itemStep.SpeedCycle * itemStep.MeterSpeeds.Sum(a => a.KeepTime);
//根据循环次数确定
for (int StepIndex = 0; StepIndex < itemStep.SpeedCycle; StepIndex++)
{
//根据循环次数执行
foreach (var itemMeterValueCell in itemStep.MeterSpeeds)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
//SV = CALCHelper.GetQuickSV(itemMeterValueCell.Constant, 1),
StartSV = GetSVByProcess(itemMeterValueCell.StartValue, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.EndValue, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = itemMeterValueCell.StartValue == itemMeterValueCell.EndValue ? false : true,//开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ListStepExd = new List()
{
new StepExd(){ Name="输出锁定",Value=itemMeterValueCell.OutLock,ValueType=ExdValueType.Bool},
new StepExd(){ Name="吸排气阀",Value=itemMeterValueCell.InhExhValve,ValueType=ExdValueType.Bool},
new StepExd(){ Name="EV",Value=(short)itemMeterValueCell.Ev,ValueType=ExdValueType.Short},
new StepExd(){ Name="压缩机使能",Value=itemMeterValueCell.CapEnable,ValueType=ExdValueType.Bool},
},
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
MeterName = CurMeterName,
});
}
}
break;
default:
break;
}
}
else
{
//当前步骤转速没有配置的话，后面的也不需要执行，直接返回
continue;
}
}
//********* 单个【排气压力】步骤信息的解析 *********
{
var CurMeterName = "排气压力";
if (itemStep.MeterExPresss != null && itemStep.MeterExPresss.Any())
{
switch (itemStep.MeterExPresss.FirstOrDefault()!.ValueType)
{
case ConfigValueType.Constant: //常值
//常值的话就一个数据，循环执行一次
foreach (var itemMeterValueCell in itemStep.MeterExPresss)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
StartSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = false,//常值没有斜率 //开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
MeterName = CurMeterName,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
});
}
break;
case ConfigValueType.Slope:
//带斜率
//根据循环次数确定
var Cycle = GetCycleBySpeed(itemStep.MeterSpeeds, itemStep.SpeedCycle, itemStep.MeterExPresss.Select(p => new MeterCom { Constant = p.Constant, KeepTime = p.KeepTime, StepNo = p.StepNo, ValueType = p.ValueType }).ToList());
for (int StepCycleIndex = 1; StepCycleIndex <= Cycle; StepCycleIndex++)
{
//根据循环次数执行
foreach (var itemMeterValueCell in itemStep.MeterExPresss)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
//SV = CALCHelper.GetQuickSV(itemMeterValueCell.Constant, 1),
StartSV = GetSVByProcess(itemMeterValueCell.StartValue, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.EndValue, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = itemMeterValueCell.StartValue == itemMeterValueCell.EndValue ? false : true,//开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
MeterName = CurMeterName,
});
}
}
break;
default:
break;
}
}
else
{
//判断当前的参数是全部都没有设置还是这一步没有设置，如果这个步骤没有设置，则沿用上一个步骤数据
var CurMeterListStepExe = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe;
if (CurMeterListStepExe.Any())
{
//之前有步骤数据的话，则直接使用上一步的数据
//Copy这个步骤的数据
var LastStepData = CurMeterListStepExe.OrderByDescending(a => a.MeterStep).FirstOrDefault().DeepClone();
//处理这个步骤的数据-处理按照常值的恒定的模式运行，就是维持结束的常值数据
LastStepData!.MeterStep = LastStepData.MeterStep + 1;//步骤+1
LastStepData.KeepTime = SpeedStepTotaolTime;//时间是整个时间
LastStepData.ExistSlop = false;
LastStepData.StartSV = LastStepData.EndSV;
LastStepData.ProStepInfo = $"{itemStep.StepNo}-{1}";
//添加
CurMeterListStepExe.Add(LastStepData);
//SpeedStepTotaolTime
}
else
{
//之前步骤没有数据的话，则放弃，不做任何处理
}
LogService.Warn($"【名称】： {CurMeterName} - 未找到步骤信息。步骤为空");
}
}
//********* 单个【COND1温度/冷凝器出口水温】步骤信息的解析 *********
{
var CurMeterName = "COND1温度";
if (itemStep.MeterCond1Temps != null && itemStep.MeterCond1Temps.Any())
{
switch (itemStep.MeterCond1Temps.FirstOrDefault()!.ValueType)
{
case ConfigValueType.Constant: //常值
//常值的话就一个数据，循环执行一次
foreach (var itemMeterValueCell in itemStep.MeterCond1Temps)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
StartSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = false,//常值没有斜率 //开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
MeterName = CurMeterName,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
});
}
break;
case ConfigValueType.Slope:
//带斜率
//根据循环次数确定
var Cycle = GetCycleBySpeed(itemStep.MeterSpeeds, itemStep.SpeedCycle, itemStep.MeterCond1Temps.Select(p => new MeterCom { Constant = p.Constant, KeepTime = p.KeepTime, StepNo = p.StepNo, ValueType = p.ValueType }).ToList());
for (int StepCycleIndex = 1; StepCycleIndex <= Cycle; StepCycleIndex++)
{
//根据循环次数执行
foreach (var itemMeterValueCell in itemStep.MeterCond1Temps)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
//SV = CALCHelper.GetQuickSV(itemMeterValueCell.Constant, 1),
StartSV = GetSVByProcess(itemMeterValueCell.StartValue, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.EndValue, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = itemMeterValueCell.StartValue == itemMeterValueCell.EndValue ? false : true,//开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
MeterName = CurMeterName,
});
}
}
break;
default:
break;
}
}
else
{
//判断当前的参数是全部都没有设置还是这一步没有设置，如果这个步骤没有设置，则沿用上一个步骤数据
var CurMeterListStepExe = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe;
if (CurMeterListStepExe.Any())
{
//之前有步骤数据的话，则直接使用上一步的数据
//Copy这个步骤的数据
var LastStepData = CurMeterListStepExe.OrderByDescending(a => a.MeterStep).FirstOrDefault().DeepClone();
//处理这个步骤的数据-处理按照常值的恒定的模式运行，就是维持结束的常值数据
LastStepData!.MeterStep = LastStepData.MeterStep + 1;//步骤+1
LastStepData.KeepTime = SpeedStepTotaolTime;//时间是整个时间
LastStepData.ExistSlop = false;
LastStepData.StartSV = LastStepData.EndSV;
LastStepData.ProStepInfo = $"{itemStep.StepNo}-{1}";
//添加
CurMeterListStepExe.Add(LastStepData);
//SpeedStepTotaolTime
}
else
{
//之前步骤没有数据的话，则放弃，不做任何处理
}
LogService.Warn($"【名称】： {CurMeterName} - 未找到步骤信息。步骤为空");
}
}
//********* 单个【COND2温度】步骤信息的解析 *********
{
var CurMeterName = "COND2温度";
if (itemStep.MeterCond2Temps != null && itemStep.MeterCond2Temps.Any())
{
switch (itemStep.MeterCond2Temps.FirstOrDefault()!.ValueType)
{
case ConfigValueType.Constant: //常值
//常值的话就一个数据，循环执行一次
foreach (var itemMeterValueCell in itemStep.MeterCond2Temps)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
StartSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = false,//常值没有斜率 //开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
MeterName = CurMeterName,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
});
}
break;
case ConfigValueType.Slope:
//带斜率
//根据循环次数确定
var Cycle = GetCycleBySpeed(itemStep.MeterSpeeds, itemStep.SpeedCycle, itemStep.MeterCond2Temps.Select(p => new MeterCom { Constant = p.Constant, KeepTime = p.KeepTime, StepNo = p.StepNo, ValueType = p.ValueType }).ToList());
for (int StepCycleIndex = 1; StepCycleIndex <= Cycle; StepCycleIndex++)
{
//根据循环次数执行
foreach (var itemMeterValueCell in itemStep.MeterCond2Temps)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
//SV = CALCHelper.GetQuickSV(itemMeterValueCell.Constant, 1),
StartSV = GetSVByProcess(itemMeterValueCell.StartValue, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.EndValue, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = itemMeterValueCell.StartValue == itemMeterValueCell.EndValue ? false : true,//开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
MeterName = CurMeterName,
});
}
}
break;
default:
break;
}
}
else
{
//判断当前的参数是全部都没有设置还是这一步没有设置，如果这个步骤没有设置，则沿用上一个步骤数据
var CurMeterListStepExe = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe;
if (CurMeterListStepExe.Any())
{
//之前有步骤数据的话，则直接使用上一步的数据
//Copy这个步骤的数据
var LastStepData = CurMeterListStepExe.OrderByDescending(a => a.MeterStep).FirstOrDefault().DeepClone();
//处理这个步骤的数据-处理按照常值的恒定的模式运行，就是维持结束的常值数据
LastStepData!.MeterStep = LastStepData.MeterStep + 1;//步骤+1
LastStepData.KeepTime = SpeedStepTotaolTime;//时间是整个时间
LastStepData.ExistSlop = false;
LastStepData.StartSV = LastStepData.EndSV;
LastStepData.ProStepInfo = $"{itemStep.StepNo}-{1}";
//添加
CurMeterListStepExe.Add(LastStepData);
//SpeedStepTotaolTime
}
else
{
//之前步骤没有数据的话，则放弃，不做任何处理
}
LogService.Warn($"【名称】： {CurMeterName} - 未找到步骤信息。步骤为空");
}
}
//********* 单个【COND2压力】步骤信息的解析 *********
{
var CurMeterName = "COND2压力";
if (itemStep.MeterCond2Presss != null && itemStep.MeterCond2Presss.Any())
{
switch (itemStep.MeterCond2Presss.FirstOrDefault()!.ValueType)
{
case ConfigValueType.Constant: //常值
//常值的话就一个数据，循环执行一次
foreach (var itemMeterValueCell in itemStep.MeterCond2Presss)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
StartSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = false,//常值没有斜率 //开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
MeterName = CurMeterName,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
});
}
break;
case ConfigValueType.Slope:
//带斜率
//根据循环次数确定
var Cycle = GetCycleBySpeed(itemStep.MeterSpeeds, itemStep.SpeedCycle, itemStep.MeterCond2Presss.Select(p => new MeterCom { Constant = p.Constant, KeepTime = p.KeepTime, StepNo = p.StepNo, ValueType = p.ValueType }).ToList());
for (int StepCycleIndex = 1; StepCycleIndex <= Cycle; StepCycleIndex++)
{
//根据循环次数执行
foreach (var itemMeterValueCell in itemStep.MeterCond2Presss)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
//SV = CALCHelper.GetQuickSV(itemMeterValueCell.Constant, 1),
StartSV = GetSVByProcess(itemMeterValueCell.StartValue, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.EndValue, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = itemMeterValueCell.StartValue == itemMeterValueCell.EndValue ? false : true,//开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
MeterName = CurMeterName,
});
}
}
break;
default:
break;
}
}
else
{
//判断当前的参数是全部都没有设置还是这一步没有设置，如果这个步骤没有设置，则沿用上一个步骤数据
var CurMeterListStepExe = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe;
if (CurMeterListStepExe.Any())
{
//之前有步骤数据的话，则直接使用上一步的数据
//Copy这个步骤的数据
var LastStepData = CurMeterListStepExe.OrderByDescending(a => a.MeterStep).FirstOrDefault().DeepClone();
//处理这个步骤的数据-处理按照常值的恒定的模式运行，就是维持结束的常值数据
LastStepData!.MeterStep = LastStepData.MeterStep + 1;//步骤+1
LastStepData.KeepTime = SpeedStepTotaolTime;//时间是整个时间
LastStepData.ExistSlop = false;
LastStepData.StartSV = LastStepData.EndSV;
LastStepData.ProStepInfo = $"{itemStep.StepNo}-{1}";
//添加
CurMeterListStepExe.Add(LastStepData);
//SpeedStepTotaolTime
}
else
{
//之前步骤没有数据的话，则放弃，不做任何处理
}
LogService.Warn($"【名称】： {CurMeterName} - 未找到步骤信息。步骤为空");
}
}
//********* 单个【EVAP出口温度】步骤信息的解析 *********
{
var CurMeterName = "EVAP出口温度";
if (itemStep.MeterEVAPExpTemps != null && itemStep.MeterEVAPExpTemps.Any())
{
switch (itemStep.MeterEVAPExpTemps.FirstOrDefault()!.ValueType)
{
case ConfigValueType.Constant: //常值
//常值的话就一个数据，循环执行一次
foreach (var itemMeterValueCell in itemStep.MeterEVAPExpTemps)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
StartSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = false,//常值没有斜率 //开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
MeterName = CurMeterName,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
});
}
break;
case ConfigValueType.Slope:
//带斜率
//根据循环次数确定
var Cycle = GetCycleBySpeed(itemStep.MeterSpeeds, itemStep.SpeedCycle, itemStep.MeterEVAPExpTemps.Select(p => new MeterCom { Constant = p.Constant, KeepTime = p.KeepTime, StepNo = p.StepNo, ValueType = p.ValueType }).ToList());
for (int StepCycleIndex = 1; StepCycleIndex <= Cycle; StepCycleIndex++)
{
//根据循环次数执行
foreach (var itemMeterValueCell in itemStep.MeterEVAPExpTemps)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
//SV = CALCHelper.GetQuickSV(itemMeterValueCell.Constant, 1),
StartSV = GetSVByProcess(itemMeterValueCell.StartValue, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.EndValue, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = itemMeterValueCell.StartValue == itemMeterValueCell.EndValue ? false : true,//开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
MeterName = CurMeterName,
});
}
}
break;
default:
break;
}
}
else
{
//判断当前的参数是全部都没有设置还是这一步没有设置，如果这个步骤没有设置，则沿用上一个步骤数据
var CurMeterListStepExe = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe;
if (CurMeterListStepExe.Any())
{
//之前有步骤数据的话，则直接使用上一步的数据
//Copy这个步骤的数据
var LastStepData = CurMeterListStepExe.OrderByDescending(a => a.MeterStep).FirstOrDefault().DeepClone();
//处理这个步骤的数据-处理按照常值的恒定的模式运行，就是维持结束的常值数据
LastStepData!.MeterStep = LastStepData.MeterStep + 1;//步骤+1
LastStepData.KeepTime = SpeedStepTotaolTime;//时间是整个时间
LastStepData.ExistSlop = false;
LastStepData.StartSV = LastStepData.EndSV;
LastStepData.ProStepInfo = $"{itemStep.StepNo}-{1}";
//添加
CurMeterListStepExe.Add(LastStepData);
//SpeedStepTotaolTime
}
else
{
//之前步骤没有数据的话，则放弃，不做任何处理
}
LogService.Warn($"【名称】： {CurMeterName} - 未找到步骤信息。步骤为空");
}
}
//********* 单个【HV[V]】步骤信息的解析 *********
{
var CurMeterName = "HV[V]";
if (itemStep.MeterHVVols != null && itemStep.MeterHVVols.Any())
{
switch (itemStep.MeterHVVols.FirstOrDefault()!.ValueType)
{
case ConfigValueType.Constant: //常值
//常值的话就一个数据，循环执行一次
foreach (var itemMeterValueCell in itemStep.MeterHVVols)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
StartSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = false,//常值没有斜率 //开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
MeterName = CurMeterName,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
});
}
break;
case ConfigValueType.Slope:
//带斜率
//根据循环次数确定
var Cycle = GetCycleBySpeed(itemStep.MeterSpeeds, itemStep.SpeedCycle, itemStep.MeterHVVols.Select(p => new MeterCom { Constant = p.Constant, KeepTime = p.KeepTime, StepNo = p.StepNo, ValueType = p.ValueType }).ToList());
for (int StepCycleIndex = 1; StepCycleIndex <= Cycle; StepCycleIndex++)
{
//根据循环次数执行
foreach (var itemMeterValueCell in itemStep.MeterHVVols)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
//SV = CALCHelper.GetQuickSV(itemMeterValueCell.Constant, 1),
StartSV = GetSVByProcess(itemMeterValueCell.StartValue, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.EndValue, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = itemMeterValueCell.StartValue == itemMeterValueCell.EndValue ? false : true,//开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
MeterName = CurMeterName,
});
}
}
break;
default:
break;
}
}
else
{
//判断当前的参数是全部都没有设置还是这一步没有设置，如果这个步骤没有设置，则沿用上一个步骤数据
var CurMeterListStepExe = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe;
if (CurMeterListStepExe.Any())
{
//之前有步骤数据的话，则直接使用上一步的数据
//Copy这个步骤的数据
var LastStepData = CurMeterListStepExe.OrderByDescending(a => a.MeterStep).FirstOrDefault().DeepClone();
//处理这个步骤的数据-处理按照常值的恒定的模式运行，就是维持结束的常值数据
LastStepData!.MeterStep = LastStepData.MeterStep + 1;//步骤+1
LastStepData.KeepTime = SpeedStepTotaolTime;//时间是整个时间
LastStepData.ExistSlop = false;
LastStepData.StartSV = LastStepData.EndSV;
LastStepData.ProStepInfo = $"{itemStep.StepNo}-{1}";
//添加
CurMeterListStepExe.Add(LastStepData);
//SpeedStepTotaolTime
}
else
{
//之前步骤没有数据的话，则放弃，不做任何处理
}
LogService.Warn($"【名称】： {CurMeterName} - 未找到步骤信息。步骤为空");
}
}
//********* 单个【吸气压力】步骤信息的解析 *********
{
var CurMeterName = "吸气压力";
if (itemStep.MeterInhPresss != null && itemStep.MeterInhPresss.Any())
{
switch (itemStep.MeterInhPresss.FirstOrDefault()!.ValueType)
{
case ConfigValueType.Constant: //常值
//常值的话就一个数据，循环执行一次
foreach (var itemMeterValueCell in itemStep.MeterInhPresss)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
StartSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = false,//常值没有斜率 //开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
MeterName = CurMeterName,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
});
}
break;
case ConfigValueType.Slope:
//带斜率
//根据循环次数确定
var Cycle = GetCycleBySpeed(itemStep.MeterSpeeds, itemStep.SpeedCycle, itemStep.MeterInhPresss.Select(p => new MeterCom { Constant = p.Constant, KeepTime = p.KeepTime, StepNo = p.StepNo, ValueType = p.ValueType }).ToList());
for (int StepCycleIndex = 1; StepCycleIndex <= Cycle; StepCycleIndex++)
{
//根据循环次数执行
foreach (var itemMeterValueCell in itemStep.MeterInhPresss)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
//SV = CALCHelper.GetQuickSV(itemMeterValueCell.Constant, 1),
StartSV = GetSVByProcess(itemMeterValueCell.StartValue, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.EndValue, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = itemMeterValueCell.StartValue == itemMeterValueCell.EndValue ? false : true,//开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
MeterName = CurMeterName,
});
}
}
break;
default:
break;
}
}
else
{
//判断当前的参数是全部都没有设置还是这一步没有设置，如果这个步骤没有设置，则沿用上一个步骤数据
var CurMeterListStepExe = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe;
if (CurMeterListStepExe.Any())
{
//之前有步骤数据的话，则直接使用上一步的数据
//Copy这个步骤的数据
var LastStepData = CurMeterListStepExe.OrderByDescending(a => a.MeterStep).FirstOrDefault().DeepClone();
//处理这个步骤的数据-处理按照常值的恒定的模式运行，就是维持结束的常值数据
LastStepData!.MeterStep = LastStepData.MeterStep + 1;//步骤+1
LastStepData.KeepTime = SpeedStepTotaolTime;//时间是整个时间
LastStepData.ExistSlop = false;
LastStepData.StartSV = LastStepData.EndSV;
LastStepData.ProStepInfo = $"{itemStep.StepNo}-{1}";
//添加
CurMeterListStepExe.Add(LastStepData);
//SpeedStepTotaolTime
}
else
{
//之前步骤没有数据的话，则放弃，不做任何处理
}
LogService.Warn($"【名称】： {CurMeterName} - 未找到步骤信息。步骤为空");
}
}
//********* 单个【吸气温度】步骤信息的解析 *********
{
var CurMeterName = "吸气温度";
if (itemStep.MeterInhTemps != null && itemStep.MeterInhTemps.Any())
{
switch (itemStep.MeterInhTemps.FirstOrDefault()!.ValueType)
{
case ConfigValueType.Constant: //常值
//常值的话就一个数据，循环执行一次
foreach (var itemMeterValueCell in itemStep.MeterInhTemps)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
StartSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = false,//常值没有斜率 //开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
MeterName = CurMeterName,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
});
}
break;
case ConfigValueType.Slope:
//带斜率
//根据循环次数确定
var Cycle = GetCycleBySpeed(itemStep.MeterSpeeds, itemStep.SpeedCycle, itemStep.MeterInhTemps.Select(p => new MeterCom { Constant = p.Constant, KeepTime = p.KeepTime, StepNo = p.StepNo, ValueType = p.ValueType }).ToList());
for (int StepCycleIndex = 1; StepCycleIndex <= Cycle; StepCycleIndex++)
{
//根据循环次数执行
foreach (var itemMeterValueCell in itemStep.MeterInhTemps)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
//SV = CALCHelper.GetQuickSV(itemMeterValueCell.Constant, 1),
StartSV = GetSVByProcess(itemMeterValueCell.StartValue, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.EndValue, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = itemMeterValueCell.StartValue == itemMeterValueCell.EndValue ? false : true,//开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
MeterName = CurMeterName,
});
}
}
break;
default:
break;
}
}
else
{
//判断当前的参数是全部都没有设置还是这一步没有设置，如果这个步骤没有设置，则沿用上一个步骤数据
var CurMeterListStepExe = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe;
if (CurMeterListStepExe.Any())
{
//之前有步骤数据的话，则直接使用上一步的数据
//Copy这个步骤的数据
var LastStepData = CurMeterListStepExe.OrderByDescending(a => a.MeterStep).FirstOrDefault().DeepClone();
//处理这个步骤的数据-处理按照常值的恒定的模式运行，就是维持结束的常值数据
LastStepData!.MeterStep = LastStepData.MeterStep + 1;//步骤+1
LastStepData.KeepTime = SpeedStepTotaolTime;//时间是整个时间
LastStepData.ExistSlop = false;
LastStepData.StartSV = LastStepData.EndSV;
LastStepData.ProStepInfo = $"{itemStep.StepNo}-{1}";
//添加
CurMeterListStepExe.Add(LastStepData);
//SpeedStepTotaolTime
}
else
{
//之前步骤没有数据的话，则放弃，不做任何处理
}
LogService.Warn($"【名称】： {CurMeterName} - 未找到步骤信息。步骤为空");
}
}
//********* 单个【润滑油压力】步骤信息的解析 *********
{
var CurMeterName = "润滑油压力";
if (itemStep.MeterLubePresss != null && itemStep.MeterLubePresss.Any())
{
switch (itemStep.MeterLubePresss.FirstOrDefault()!.ValueType)
{
case ConfigValueType.Constant: //常值
//常值的话就一个数据，循环执行一次
foreach (var itemMeterValueCell in itemStep.MeterLubePresss)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
StartSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = false,//常值没有斜率 //开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
MeterName = CurMeterName,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
});
}
break;
case ConfigValueType.Slope:
//带斜率
//根据循环次数确定
var Cycle = GetCycleBySpeed(itemStep.MeterSpeeds, itemStep.SpeedCycle, itemStep.MeterLubePresss.Select(p => new MeterCom { Constant = p.Constant, KeepTime = p.KeepTime, StepNo = p.StepNo, ValueType = p.ValueType }).ToList());
for (int StepCycleIndex = 1; StepCycleIndex <= Cycle; StepCycleIndex++)
{
//根据循环次数执行
foreach (var itemMeterValueCell in itemStep.MeterLubePresss)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
//SV = CALCHelper.GetQuickSV(itemMeterValueCell.Constant, 1),
StartSV = GetSVByProcess(itemMeterValueCell.StartValue, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.EndValue, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = itemMeterValueCell.StartValue == itemMeterValueCell.EndValue ? false : true,//开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
MeterName = CurMeterName,
});
}
}
break;
default:
break;
}
}
else
{
//判断当前的参数是全部都没有设置还是这一步没有设置，如果这个步骤没有设置，则沿用上一个步骤数据
var CurMeterListStepExe = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe;
if (CurMeterListStepExe.Any())
{
//之前有步骤数据的话，则直接使用上一步的数据
//Copy这个步骤的数据
var LastStepData = CurMeterListStepExe.OrderByDescending(a => a.MeterStep).FirstOrDefault().DeepClone();
//处理这个步骤的数据-处理按照常值的恒定的模式运行，就是维持结束的常值数据
LastStepData!.MeterStep = LastStepData.MeterStep + 1;//步骤+1
LastStepData.KeepTime = SpeedStepTotaolTime;//时间是整个时间
LastStepData.ExistSlop = false;
LastStepData.StartSV = LastStepData.EndSV;
LastStepData.ProStepInfo = $"{itemStep.StepNo}-{1}";
//添加
CurMeterListStepExe.Add(LastStepData);
//SpeedStepTotaolTime
}
else
{
//之前步骤没有数据的话，则放弃，不做任何处理
}
LogService.Warn($"【名称】： {CurMeterName} - 未找到步骤信息。步骤为空");
}
}
//********* 单个【LV[V]】步骤信息的解析 *********
{
var CurMeterName = "LV[V]";
if (itemStep.MeterLVVols != null && itemStep.MeterLVVols.Any())
{
switch (itemStep.MeterLVVols.FirstOrDefault()!.ValueType)
{
case ConfigValueType.Constant: //常值
//常值的话就一个数据，循环执行一次
foreach (var itemMeterValueCell in itemStep.MeterLVVols)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
StartSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = false,//常值没有斜率 //开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
MeterName = CurMeterName,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
});
}
break;
case ConfigValueType.Slope:
//带斜率
//根据循环次数确定
var Cycle = GetCycleBySpeed(itemStep.MeterSpeeds, itemStep.SpeedCycle, itemStep.MeterLVVols.Select(p => new MeterCom { Constant = p.Constant, KeepTime = p.KeepTime, StepNo = p.StepNo, ValueType = p.ValueType }).ToList());
for (int StepCycleIndex = 1; StepCycleIndex <= Cycle; StepCycleIndex++)
{
//根据循环次数执行
foreach (var itemMeterValueCell in itemStep.MeterLVVols)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
//SV = CALCHelper.GetQuickSV(itemMeterValueCell.Constant, 1),
StartSV = GetSVByProcess(itemMeterValueCell.StartValue, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.EndValue, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = itemMeterValueCell.StartValue == itemMeterValueCell.EndValue ? false : true,//开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
MeterName = CurMeterName,
});
}
}
break;
default:
break;
}
}
else
{
//判断当前的参数是全部都没有设置还是这一步没有设置，如果这个步骤没有设置，则沿用上一个步骤数据
var CurMeterListStepExe = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe;
if (CurMeterListStepExe.Any())
{
//之前有步骤数据的话，则直接使用上一步的数据
//Copy这个步骤的数据
var LastStepData = CurMeterListStepExe.OrderByDescending(a => a.MeterStep).FirstOrDefault().DeepClone();
//处理这个步骤的数据-处理按照常值的恒定的模式运行，就是维持结束的常值数据
LastStepData!.MeterStep = LastStepData.MeterStep + 1;//步骤+1
LastStepData.KeepTime = SpeedStepTotaolTime;//时间是整个时间
LastStepData.ExistSlop = false;
LastStepData.StartSV = LastStepData.EndSV;
LastStepData.ProStepInfo = $"{itemStep.StepNo}-{1}";
//添加
CurMeterListStepExe.Add(LastStepData);
//SpeedStepTotaolTime
}
else
{
//之前步骤没有数据的话，则放弃，不做任何处理
}
LogService.Warn($"【名称】： {CurMeterName} - 未找到步骤信息。步骤为空");
}
}
//********* 单个【OCR】步骤信息的解析 *********
{
var CurMeterName = "OCR";
if (itemStep.MeterOCRs != null && itemStep.MeterOCRs.Any())
{
switch (itemStep.MeterOCRs.FirstOrDefault()!.ValueType)
{
case ConfigValueType.Constant: //常值
//常值的话就一个数据，循环执行一次
foreach (var itemMeterValueCell in itemStep.MeterOCRs)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
StartSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = false,//常值没有斜率 //开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
MeterName = CurMeterName,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
});
}
break;
case ConfigValueType.Slope:
//带斜率
//根据循环次数确定
var Cycle = GetCycleBySpeed(itemStep.MeterSpeeds, itemStep.SpeedCycle, itemStep.MeterOCRs.Select(p => new MeterCom { Constant = p.Constant, KeepTime = p.KeepTime, StepNo = p.StepNo, ValueType = p.ValueType }).ToList());
for (int StepCycleIndex = 1; StepCycleIndex <= Cycle; StepCycleIndex++)
{
//根据循环次数执行
foreach (var itemMeterValueCell in itemStep.MeterOCRs)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
//SV = CALCHelper.GetQuickSV(itemMeterValueCell.Constant, 1),
StartSV = GetSVByProcess(itemMeterValueCell.StartValue, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.EndValue, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = itemMeterValueCell.StartValue == itemMeterValueCell.EndValue ? false : true,//开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
MeterName = CurMeterName,
});
}
}
break;
default:
break;
}
}
else
{
//判断当前的参数是全部都没有设置还是这一步没有设置，如果这个步骤没有设置，则沿用上一个步骤数据
var CurMeterListStepExe = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe;
if (CurMeterListStepExe.Any())
{
//之前有步骤数据的话，则直接使用上一步的数据
//Copy这个步骤的数据
var LastStepData = CurMeterListStepExe.OrderByDescending(a => a.MeterStep).FirstOrDefault().DeepClone();
//处理这个步骤的数据-处理按照常值的恒定的模式运行，就是维持结束的常值数据
LastStepData!.MeterStep = LastStepData.MeterStep + 1;//步骤+1
LastStepData.KeepTime = SpeedStepTotaolTime;//时间是整个时间
LastStepData.ExistSlop = false;
LastStepData.StartSV = LastStepData.EndSV;
LastStepData.ProStepInfo = $"{itemStep.StepNo}-{1}";
//添加
CurMeterListStepExe.Add(LastStepData);
//SpeedStepTotaolTime
}
else
{
//之前步骤没有数据的话，则放弃，不做任何处理
}
LogService.Warn($"【名称】： {CurMeterName} - 未找到步骤信息。步骤为空");
}
}
////********* 单个【OS1温度】步骤信息的解析 *********
{
var CurMeterName = "OS1温度";
if (itemStep.MeterOS1Temps != null && itemStep.MeterOS1Temps.Any())
{
switch (itemStep.MeterOS1Temps.FirstOrDefault()!.ValueType)
{
case ConfigValueType.Constant: //常值
//常值的话就一个数据，循环执行一次
foreach (var itemMeterValueCell in itemStep.MeterOS1Temps)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
StartSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = false,//常值没有斜率 //开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
MeterName = CurMeterName,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
});
}
break;
case ConfigValueType.Slope:
//带斜率
//根据循环次数确定
var Cycle = GetCycleBySpeed(itemStep.MeterSpeeds, itemStep.SpeedCycle, itemStep.MeterOS1Temps.Select(p => new MeterCom { Constant = p.Constant, KeepTime = p.KeepTime, StepNo = p.StepNo, ValueType = p.ValueType }).ToList());
for (int StepCycleIndex = 1; StepCycleIndex <= Cycle; StepCycleIndex++)
{
//根据循环次数执行
foreach (var itemMeterValueCell in itemStep.MeterOS1Temps)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
//SV = CALCHelper.GetQuickSV(itemMeterValueCell.Constant, 1),
StartSV = GetSVByProcess(itemMeterValueCell.StartValue, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.EndValue, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = itemMeterValueCell.StartValue == itemMeterValueCell.EndValue ? false : true,//开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
MeterName = CurMeterName,
});
}
}
break;
default:
break;
}
}
else
{
//判断当前的参数是全部都没有设置还是这一步没有设置，如果这个步骤没有设置，则沿用上一个步骤数据
var CurMeterListStepExe = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe;
if (CurMeterListStepExe.Any())
{
//之前有步骤数据的话，则直接使用上一步的数据
//Copy这个步骤的数据
var LastStepData = CurMeterListStepExe.OrderByDescending(a => a.MeterStep).FirstOrDefault().DeepClone();
//处理这个步骤的数据-处理按照常值的恒定的模式运行，就是维持结束的常值数据
LastStepData!.MeterStep = LastStepData.MeterStep + 1;//步骤+1
LastStepData.KeepTime = SpeedStepTotaolTime;//时间是整个时间
LastStepData.ExistSlop = false;
LastStepData.StartSV = LastStepData.EndSV;
LastStepData.ProStepInfo = $"{itemStep.StepNo}-{1}";
//添加
CurMeterListStepExe.Add(LastStepData);
//SpeedStepTotaolTime
}
else
{
//之前步骤没有数据的话，则放弃，不做任何处理
}
LogService.Warn($"【名称】： {CurMeterName} - 未找到步骤信息。步骤为空");
}
}
//********* 单个【OS2温度/吸气混合器温度】步骤信息的解析 *********
{
var CurMeterName = "OS2温度";
if (itemStep.MeterOS2Temps != null && itemStep.MeterOS2Temps.Any())
{
switch (itemStep.MeterOS2Temps.FirstOrDefault()!.ValueType)
{
case ConfigValueType.Constant: //常值
//常值的话就一个数据，循环执行一次
foreach (var itemMeterValueCell in itemStep.MeterOS2Temps)
{
var Pid = new ConfigPID();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).Any())
{
Pid = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.PIDNo).First();
}
var Limit = new ConfigLimit();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).Any())
{
Limit = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.LimitNo).First();
}
var Alarm = new ConfigAlarm();
if (FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).Any())
{
Alarm = FreeSql.Select().Where(a => a.MeterName == CurMeterName && a.IndexNo == itemMeterValueCell.AlarmNo).First();
}
ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Add(new ProStepExe()
{
//程序块
ProSegName = CurProgramSeg.Name,
ProSegStep = SegIndex,
ProSegRepeat = CurProgramSeg.ProRepeat,
ProSegIsExeing = false,//配置阶段默认不执行 false
//程序步骤数据
StartSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
EndSV = GetSVByProcess(itemMeterValueCell.Constant, CurMeterName),
KeepTime = itemMeterValueCell.KeepTime,
MeterStepIsExeing = false,//配置阶段默认不执行 false
MeterStepIsOK = false,//配置阶段默认不完成 false
ExistSlop = false,//常值没有斜率 //开始和结束不一样则存在斜率
MeterStep = ListProExModel.FindFirst(a => a.MeterName == CurMeterName).ListProStepExe.Count + 1,
MeterName = CurMeterName,
LimitNo = itemMeterValueCell.LimitNo,
AlarmNo = itemMeterValueCell.AlarmNo,
PIDNo = itemMeterValueCell.PIDNo,
CurConfigPIDDto = Mapper.Map(Pid),
CurConfigLimitDto = Mapper.Map(Limit),
CurConfigAlarmDto = Mapper.Map(Alarm),
ProStepInfo = $"{itemStep.StepNo}-{itemMeterValueCell.StepNo}",
});
}
break;
case ConfigValueType.Slope:
//带斜率
//根据循环次数确定
var Cycle = GetCycleBySpeed(itemStep.MeterSpeeds, itemStep.SpeedCycle, itemStep.MeterOS2Temps.Select(p => new MeterCom { Constant = p.Constant, KeepTime = p.KeepTime, StepNo = p.StepNo, ValueType = p.ValueType }).ToList());
for (int StepCycleIndex = 1; StepCycleIndex <= Cycle; StepCycleIndex++)
{
//根据循环次数执行
foreach (var itemMeterValueCell in itemStep.MeterOS2Temps)
{
var Pid = new ConfigPID();
if (FreeSql.Select