yuxingheng/009_DI-Elec
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: yuxingheng:1efa2ff9fdefcaa2d1112fbec11025910b61532b
Branches Tags
yuxingheng:main
yuxingheng:自动分配信号
...
compare: yuxingheng:0748365cdbc67a64f2375e035a115063bbb6e624
Branches Tags
yuxingheng:main
yuxingheng:自动分配信号

3 Commits
1efa2ff9fd ... 0748365cdb

Author SHA1 Message Date
xingheng
0748365cdb Merge branch 'main' of http://27.154.35.18:7053/yuxingheng/009_DI-Elec 2025-10-01 23:36:08 +08:00
xingheng
af328bdb8f 增加了homerun的分配逻辑（不需要考虑预留空白） 2025-10-01 23:35:57 +08:00
xingheng
b8b6fde9b0 重写自动分配的逻辑 2025-10-01 00:18:02 +08:00
4 changed files with 596 additions and 280 deletions
Show Stats Expand all files Collapse all files

843
Learun.Application.Web/AppApi/IOModuleApiController.cs
View File

@ -1,4 +1,5 @@
using DocumentFormat.OpenXml.Drawing.Spreadsheet; using DocumentFormat.OpenXml.Drawing.Spreadsheet;
using DocumentFormat.OpenXml.Math;
using DocumentFormat.OpenXml.Spreadsheet; using DocumentFormat.OpenXml.Spreadsheet;
using Learun.Application.Organization; using Learun.Application.Organization;
using Learun.Application.TwoDevelopment.ZZDT_EC; using Learun.Application.TwoDevelopment.ZZDT_EC;
@ -11,6 +12,10 @@ using Learun.Util.SqlSugar;
using log4net.Config; using log4net.Config;
using Microsoft.Practices.ObjectBuilder2; using Microsoft.Practices.ObjectBuilder2;
using Newtonsoft.Json; using Newtonsoft.Json;
using NPOI.POIFS.Crypt;
using NPOI.SS.Formula.Functions;
using OfficeOpenXml;
using OfficeOpenXml.Style;
using Org.BouncyCastle.Bcpg.OpenPgp; using Org.BouncyCastle.Bcpg.OpenPgp;
using Pipelines.Sockets.Unofficial.Arenas; using Pipelines.Sockets.Unofficial.Arenas;
using SqlSugar; using SqlSugar;
@ -18,9 +23,13 @@ using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Data.Entity.Infrastructure; using System.Data.Entity.Infrastructure;
using System.Diagnostics; using System.Diagnostics;
using System.IO;
using System.Linq; using System.Linq;
using System.Web.Http; using System.Web.Http;
using System.Windows;
using System.Windows.Input;
using static Learun.Application.TwoDevelopment.ZZDT_EC.IO_WorkFlowService; using static Learun.Application.TwoDevelopment.ZZDT_EC.IO_WorkFlowService;
using static Learun.Application.Web.Areas.ZZDT_EC.Controllers.ec_objecttypeController;
namespace Learun.Application.Web.AppApi namespace Learun.Application.Web.AppApi
{ {
@ -49,14 +58,56 @@ namespace Learun.Application.Web.AppApi
/// 根据模板自动创建端子排 /// 根据模板自动创建端子排
/// </summary> /// </summary>
/// <param name="projId"></param> /// <param name="projId"></param>
/// <param name="panelId"></param> /// <param name="panelObj"></param>
/// <param name="seq"></param>
/// <param name="TSname"></param>
/// <param name="iOType"></param> /// <param name="iOType"></param>
private ec_PanelStripEntity CreatePanelStripByProfile2(string projId, string TSname, string panelId, GlobalEnum.IOType iOType) private ec_PanelStripEntity CreatePanelStripByProfile2(string projId, ec_PanelEntity panelObj, int seq, GlobalEnum.IOType iOType)
{ {
var setTb = ProjectSugar.TableName<ec_projectSettingsEntity>(projId); var setTb = ProjectSugar.TableName<ec_projectSettingsEntity>(projId);
var allSettings = SqlSugarHelper.Db.Queryable<ec_projectSettingsEntity>().AS(setTb).ToList(); var allSettings = SqlSugarHelper.Db.Queryable<ec_projectSettingsEntity>().AS(setTb).ToList();
allSettings = allSettings.FindAll(x => x.SettingName.StartsWith(GlobalObject.projSetting_IOCardProfile + iOType.ToString()));
//IO_CardProfile //IO_CardProfile
return new ec_PanelStripEntity(); //IO_CardProfile_DO_TermNoPerCh
//IO_CardProfile_DO_CHNoPerStrip
//IO_CardProfile_DO_ChNamePrefix
//IO_CardProfile_DO_ChNameStartIndex
var sName = GlobalObject.projSetting_IOCardProfile + iOType.ToString() + "_TermNoPerCh";
var TermNoPerCh = allSettings.FirstOrDefault(x => x.SettingName == sName)?.SettingValue;
sName = GlobalObject.projSetting_IOCardProfile + iOType.ToString() + "_CHNoPerStrip";
var CHNoPerStrip = allSettings.FirstOrDefault(x => x.SettingName == sName)?.SettingValue;
sName = GlobalObject.projSetting_IOCardProfile + iOType.ToString() + "_ChNamePrefix";
var ChNamePrefix = allSettings.FirstOrDefault(x => x.SettingName == sName)?.SettingValue;
if (int.TryParse(TermNoPerCh, out int iTermNoPerCh))
{
//err
}
if (int.TryParse(CHNoPerStrip, out int iCHNoPerStrip))
{
//err
}
var newTs = new ec_PanelStripEntity()
{
IO_TYPE = iOType.ToString(),
PanelID = panelObj.PanelID,
Panel_Strip_Seq = seq,
StripName = "TS_" + iOType.ToString() + "_" + seq,
TagNumber = "CreatePanelStripByProfile2"
};
newTs.Create();
for (int i = 0; i < iCHNoPerStrip; i++)
{
var newCh = new ec_PanelChannelEntity()
{
ChannelName = ChNamePrefix + (i + 1).ToString(),
Channel_Seq = i + 1,
StripID = newTs.StripID,
};
newCh.Create();
newTs.Channels.Add(newCh);
}
return newTs;
} }
/// <summary> /// <summary>
/// 找到某一个预分配箱子 附近的某一个箱子。且io类型能匹配上 /// 找到某一个预分配箱子 附近的某一个箱子。且io类型能匹配上
@ -394,6 +445,36 @@ namespace Learun.Application.Web.AppApi
} }
ICache redisObj = CacheFactory.CaChe(); ICache redisObj = CacheFactory.CaChe();
/// <summary>
/// 导出分配结果
/// </summary>
/// <param name="projectId"></param>
/// <param name="flg">是否为真实结果。step2时为false，step3后为true</param>
[HttpGet]
public void AutoAssignCable2Channel_ResExport(string projectId, bool flg)
{
var BLL = new ec_Wire_GroupBLL();
var bytes = new byte[] { };
try
{
ExcelPackage.LicenseContext = LicenseContext.NonCommercial;
using (var package = new ExcelPackage())//新建
{
var sheet = package.Workbook.Worksheets.Add("test");
sheet.Cells[1, 1].Value = "test";
bytes = package.GetAsByteArray();
}
}
catch (Exception ex)
{
log4net.LogManager.GetLogger("ERROR").Error("ec_PanelChannelBLL，IOModuleExportExcel 监控系统表导出" + ex.Message + ex.StackTrace);
bytes = System.Text.Encoding.UTF8.GetBytes(ex.Message + ex.StackTrace);
}
var stream = new MemoryStream(bytes);
FileDownHelper.DownLoad(stream, $"自动分配结果{DateTime.Now.ToString("yyyyMMddHHmmss")}.xlsx");//自动化平台导出excel
}
/// <summary> /// <summary>
/// 自动分配通道(点表信号自动分配)。 /// 自动分配通道(点表信号自动分配)。
/// ///
@ -522,9 +603,7 @@ namespace Learun.Application.Web.AppApi
ICache redisObj = CacheFactory.CaChe(); ICache redisObj = CacheFactory.CaChe();
var cablesNeedAssigned = redisObj.Read<List<ec_CableEntity>>("IOModule_AutoAssign2Ch_" + projId, CacheId.IOModule_AutoAssign2Ch); var cablesNeedAssigned = redisObj.Read<List<ec_CableEntity>>("IOModule_AutoAssign2Ch_" + projId, CacheId.IOModule_AutoAssign2Ch);
var setTb = ProjectSugar.TableName<ec_projectSettingsEntity>(projId);
var allSettings = SqlSugarHelper.Db.Queryable<ec_projectSettingsEntity>().AS(setTb).ToList();
//IO_CardProfile
var signalTb = ProjectSugar.TableName<ec_Wire_GroupEntity>(projId); var signalTb = ProjectSugar.TableName<ec_Wire_GroupEntity>(projId);
var allSignals = SqlSugarHelper.Db.Queryable<ec_Wire_GroupEntity>().AS(signalTb).ToList(); var allSignals = SqlSugarHelper.Db.Queryable<ec_Wire_GroupEntity>().AS(signalTb).ToList();
@ -535,9 +614,9 @@ namespace Learun.Application.Web.AppApi
.InnerJoin<ec_PanelStripTermEntity>((a, b) => a.TermID == b.TermID).AS<ec_PanelStripTermEntity>(termTb) .InnerJoin<ec_PanelStripTermEntity>((a, b) => a.TermID == b.TermID).AS<ec_PanelStripTermEntity>(termTb)
.Select((a, b) => b.ChannelID).Distinct().ToList(); .Select((a, b) => b.ChannelID).Distinct().ToList();
//包括2部分，1是已经被信号占用的通道，2是已经被接线端子占用的通道
var allUsedCH = allSignals.Where(x => !string.IsNullOrEmpty(x.ChannelID)).Select(x => x.ChannelID).Distinct().ToList(); var allUsedCHBySignalOrSet = allSignals.Where(x => !string.IsNullOrEmpty(x.ChannelID)).Select(x => x.ChannelID).Distinct().ToList();
allUsedCH.AddRange(allConnedTerms); allUsedCHBySignalOrSet.AddRange(allConnedTerms);
//??这里有问题。通道是否被占用，需要看signal和set双重（在io分配界面） //??这里有问题。通道是否被占用，需要看signal和set双重（在io分配界面）
//1. 信号有， 电缆set有，占了 //1. 信号有， 电缆set有，占了
//2.信号no，电缆set有，占了 //2.信号no，电缆set有，占了
@ -545,29 +624,35 @@ namespace Learun.Application.Web.AppApi
//4.信号no，电缆setno，没占 //4.信号no，电缆setno，没占
//1.2 流程图 分组原则为同一信号类型、同一系统的为一组 //1.2 流程图 分组原则为同一信号类型、同一系统的为一组
var cablesGrouped = cablesNeedAssigned.OrderBy(x => x.PanelID).ThenBy(x => x.PreAssignIOType).ThenBy(x => x.System).ToList(); var cablesGrouped = cablesNeedAssigned.OrderBy(x => x.AssignedPanel?.PanelID).ThenBy(x => x.PreAssignIOType).ThenBy(x => x.System).ToList();
cablesGrouped = cablesGrouped.Where(x => x.Sets != null && x.Sets.Count() > 0 && x.AssignedPanel != null).ToList();//过滤掉没有set的，或者没有找到箱子的 var cNotPanel = cablesGrouped.FindAll(x => x.AssignedPanel == null);
cablesGrouped = cablesGrouped.Where(x => x.Sets.Where(xx => !string.IsNullOrEmpty(xx.PreAssignGroup_Desc)).Count() > 0).ToList();//过滤掉set没有分配信号的 cablesGrouped = cablesNeedAssigned.FindAll(x => x.AssignedPanel != null);
//cablesGrouped = cablesGrouped.Where(x => x.Sets != null && x.Sets.Count() > 0 && x.AssignedPanel != null).ToList();//过滤掉没有set的，或者没有找到箱子的
//cablesGrouped = cablesGrouped.Where(x => x.Sets.Where(xx => !string.IsNullOrEmpty(xx.PreAssignGroup_Desc)).Count() > 0).ToList();//过滤掉set没有分配信号的
var allPanelIds = cablesGrouped.Select(x => x.PanelID).Distinct(); var allPanelIds = cablesGrouped.Select(x => x.AssignedPanel).Select(x => x.PanelID).Distinct().ToList();
var stripBll = new ec_PanelStripBLL(); var stripBll = new ec_PanelStripBLL();
var allStrips = stripBll.GetList("{ProjectId:\"" + projId + "\"}", OnlySelf: false) var allStrips = stripBll.GetList("{ProjectId:\"" + projId + "\"}", OnlySelf: false)
.Where(x => allPanelIds.Contains(x.PanelID)) .Where(x => allPanelIds.Contains(x.PanelID))
.GroupBy(x => x.PanelID) .GroupBy(x => x.PanelID)
.ToDictionary(x => x.Key, x => x.ToList()); .ToDictionary(x => x.Key, x => x.ToList());//带出strip下的channel
//感觉逻辑上用panel来循环会更合理
foreach (var c in cNotPanel)
{
foreach (var set in c.Sets)
{
set.ConnectionInfo = "err：没有找到合适的采集箱";
}
}
foreach (var curPanelId in allPanelIds) foreach (var curPanelId in allPanelIds)
{ {
int newTSSeq = 10001; int newTSSeq = 10001;
var curStrips = allStrips[curPanelId]; var existedStrips = allStrips[curPanelId];//已经存在的所有模块
var cablesOnThisPanel = cablesGrouped.Where(x => x.PanelID == curPanelId).ToList(); var cablesOnThisPanel = cablesGrouped.Where(x => x.AssignedPanel.PanelID == curPanelId).ToList();
if (cablesOnThisPanel == null || cablesOnThisPanel.Count == 0) if (cablesOnThisPanel == null || cablesOnThisPanel.Count == 0) continue;//next panel
{
continue;//next panel
}
//var lastCableSystemAndIOType = cablesOnThisPanel.First().System + cablesOnThisPanel.First().PreAssignIOType;//用于判断是否是同一个组
var lastUsedStrip = (ec_PanelStripEntity)null; var lastUsedStrip = (ec_PanelStripEntity)null;
foreach (var cable in cablesOnThisPanel) foreach (var cable in cablesOnThisPanel)
{ {
@ -592,165 +677,52 @@ namespace Learun.Application.Web.AppApi
if (setsIn.Count > 0 && setsOut.Count > 0) if (setsIn.Count > 0 && setsOut.Count > 0)
{ {
//from cjj 25 09 23 wechat:一根电缆可能会出现既有输入也有输出，如果碰到就放到两个端子排里面，公共端不会出现一个输出，一个输入的 foreach (var set in setsIn)
{
set.ConnectionInfo = "err：digital类型的电缆，无法同时配置输入和输出。";
}
foreach (var set in setsOut)
{
set.ConnectionInfo = "err：digital类型的电缆，无法同时配置输入和输出。";
}
continue; continue;
//from cjj 25 09 23 wechat:一根电缆可能会出现既有输入也有输出，如果碰到就放到两个端子排里面，公共端不会出现一个输出，一个输入的
} }
//todo
} }
#endregion #endregion
#region inputNew #region inputNew
if (setsIn.Count > 0) if (setsIn.Count > 0)
{ {
var resIn = AutoAssignCore(GlobalEnum.inOrOut.输入, setsIn, setsSpared); var resIn = AutoAssignCore(GlobalEnum.inOrOut.输入, setsIn);
} }
#endregion
#region input
//ec_PanelStripEntity curStrip = null;
//var matchedStrips = curStrips.Where(x => x.IO_TYPE == ioTypeOnCable.ToString()).ToList();
//if (matchedStrips != null && lastUsedStrip != null && lastUsedStrip.IO_TYPE == ioTypeOnCable.ToString())
//{
// //1.2.2 优先使用上一个模块，直到模块满了再用下一个模块。
// matchedStrips.Insert(0, lastUsedStrip);
//}
//if (setsIn.Count == 0 )
//{
// //相当于没有
//}
//else if (setsIn.Count + setsSpared.Count() > 10)
//{
// //另外如果电缆对数大于10对，即像12*2*0.75这种，无论它预分配了多少根电缆对，永远预留4个以下的空白通道。
// //意思就是一个模块里面够4个或4个以上空白通道就留4个空白通道，
// //如果不够4个就留4个以下即可。
//}
//else
//{
// string PanelName = cable.AssignedPanel.TagNumber;//当前电缆预分配的箱子名称
// switch (cable.PreAssignIOType.ToLower())
// {
// case "digital":
// //数字量
// ioTypeOnCable = GlobalEnum.IOType.DI;
// break;
// case "4~20ma":
// //模拟量4-20mA
// ioTypeOnCable = GlobalEnum.IOType.AI;
// break;
// case "10v":
// ioTypeOnCable = GlobalEnum.IOType.TenVolt;
// break;
// case "pt100":
// ioTypeOnCable = GlobalEnum.IOType.PT100;
// break;
// case "pulse":
// ioTypeOnCable = GlobalEnum.IOType.PULSE;
// break;
// default:
// //通讯类 485 422啥的
// continue;
// break;
// }
// //1.2 流程图 箱子里是否已经存在端子排（io匹配）
// bool alreadyInsertNewTs = false;
// if (matchedStrips == null || matchedStrips.Count == 0)
// {
// //没有端子排
// //1.2 流程图 根据信号数里自动新建端子排，端子排通道数里根据箱子模板中的默认值获得
// var newTS = CreatePanelStripByProfile2(projId, "TS_" + ioTypeOnCable.ToString() + "_" + newTSSeq++, curPanelId, ioTypeOnCable);
// alreadyInsertNewTs = true;
// matchedStrips.Add(newTS);
// }
// #region 1.2 流程图 空的通道数够不够
// if (cable.CableClass == SWS.Share.Enum.cableClass.homerun.ToString())
// {
// //1.2.3（2）如果模块是通讯信号（像RS485这种就是通讯信号），则不用管预留空白通道这个事情，看到有空的通道就放。
// //当前这个端子排就是可用的
// curStrip = matchedStrips.First();
// }
// else
// {
// //1.2.3 (1) 非通讯，如果空的通道大于整个模块的5%，则可以利用，利用到小于5%了则停止利用，如果本身空通道数占的比例就小于5%，则不利用。
// curStrip = FindNextAvailableTS(matchedStrips, allUsedCH);
// if (curStrip == null)
// {
// var newTS = CreatePanelStripByProfile2(projId, "TS_" + ioTypeOnCable.ToString() + "_" + newTSSeq++, curPanelId, ioTypeOnCable);
// alreadyInsertNewTs = true;
// matchedStrips.Add(newTS);
// curStrip = newTS;
// }
// }
// var usedChs = curStrip.Channels.Where(x => allUsedCH.Contains(x.ChannelID)).Select(x => x.ChannelID).ToList();
// var notUsedChs = curStrip.Channels.Where(x => !usedChs.Contains(x.ChannelID)).ToList();
// #endregion
// #region 1.2 流程图 按规则先放几个信号进去
// if (notUsedChs.Count < setsIn.Count + setsSpared.Count())
// {
// //不够放，又要新建?
// if (alreadyInsertNewTs)
// {
// //压根就有问题，说明电缆的set太多了，就算是新建的模块，一个channel都没有使用的情况下，都塞不下。
// continue;
// }
// else
// {
// //相当于前面5%的判断过了，但是呢放不下所有需要的set
// var newTS = CreatePanelStripByProfile2(projId, "TS_" + ioTypeOnCable.ToString() + "_" + newTSSeq++, curPanelId, ioTypeOnCable);
// alreadyInsertNewTs = true;
// matchedStrips.Add(newTS);
// curStrip = newTS;
// usedChs = curStrip.Channels.Where(x => allUsedCH.Contains(x.ChannelID)).Select(x => x.ChannelID).ToList();
// notUsedChs = curStrip.Channels.Where(x => !usedChs.Contains(x.ChannelID)).ToList();
// if (notUsedChs.Count < setsIn.Count + setsSpared.Count())
// {
// //压根就有问题，说明电缆的set太多了，就算是新建的模块，一个channel都没有使用的情况下，都塞不下。
// continue;
// }
// }
// }
// lastUsedStrip = curStrip;
// //能放下
// for (int i = 0; i < setsIn.Count; i++)
// {
// var set = setsIn[i];
// var ch = notUsedChs[i];
// set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：{curStrip.StripName}/通道：{ch.ChannelName}";
// //更新全局已使用通道
// allUsedCH.Add(ch.ChannelID);
// }
// var chOffIdx = setsIn.Count;
// for (int i = 0; i < setsSpared.Count(); i++)
// {
// var set = setsSpared[i];
// var ch = notUsedChs[chOffIdx + i];
// set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：{curStrip.StripName}/通道：{ch.ChannelName}/冗余";
// //更新全局已使用通道
// allUsedCH.Add(ch.ChannelID);
// }
// #endregion
//}
#endregion #endregion
#region output #region output
if (setsOut.Count > 0) else if (setsOut.Count > 0)
{ {
var resOut = AutoAssignCore(GlobalEnum.inOrOut.输出, setsOut, setsSpared); var resOut = AutoAssignCore(GlobalEnum.inOrOut.输出, setsOut);
} }
else
{
//all zero
foreach (var set in cable.Sets.Where(x => !setsSpared.Select(c => c.CableSetID).Contains(x.CableSetID)))
{
set.ConnectionInfo = "err：信号描述为空";
}
foreach (var set in setsSpared)
{
set.ConnectionInfo = "err：电缆无任一set被分配";
}
}
#endregion #endregion
//in 和 out都会执行这个 //in 和 out都会执行这个
bool AutoAssignCore(GlobalEnum.inOrOut inOrOut, List<ec_CableSetEntity> sets, List<ec_CableSetEntity> sets_Spared) bool AutoAssignCore(GlobalEnum.inOrOut inOrOut, List<ec_CableSetEntity> sets)
{ {
GlobalEnum.IOType ioTypeOnC = default; GlobalEnum.IOType ioTypeOnC = default;
switch (cable.PreAssignIOType.ToLower()) switch (cable.PreAssignIOType.ToLower())
@ -792,111 +764,466 @@ namespace Learun.Application.Web.AppApi
return false; return false;
} }
ec_PanelStripEntity curStrip = null;
var matchedStrips = curStrips.Where(x => x.IO_TYPE == ioTypeOnC.ToString()).ToList(); var matchedStrips = existedStrips.Where(x => x.IO_TYPE == ioTypeOnC.ToString()).ToList();//这个电缆下符合的模块
if (matchedStrips != null && lastUsedStrip != null && lastUsedStrip.IO_TYPE == ioTypeOnC.ToString()) if (matchedStrips != null && lastUsedStrip != null && lastUsedStrip.IO_TYPE == ioTypeOnC.ToString())
{ {
//1.2.2 优先使用上一个模块，直到模块满了再用下一个模块。 //1.2.2 优先使用上一个模块，直到模块满了再用下一个模块。
matchedStrips.Insert(0, lastUsedStrip); matchedStrips.Remove(lastUsedStrip);
matchedStrips.Insert(0, lastUsedStrip);//？？？？？？？
} }
if (matchedStrips == null || matchedStrips.Count == 0)
{
#region NewTS
//1.2 流程图 根据信号数里自动新建端子排，端子排通道数里根据箱子模板中的默认值获得
var newTS = CreatePanelStripByProfile2(projId, cable.AssignedPanel, newTSSeq++, ioTypeOnC);
matchedStrips.Add(newTS);
#endregion
}
string PanelName = cable.AssignedPanel.TagNumber;//当前电缆预分配的箱子名称 string PanelName = cable.AssignedPanel.TagNumber;//当前电缆预分配的箱子名称
if (sets.Count == 0) if (sets.Count == 0) return false;
{
//相当于没有
}
else
{
var totalSets = sets.Count + setsSpared.Count();
//1.2 流程图 箱子里是否已经存在端子排（io匹配）
bool alreadyInsertNewTs = false;
if (matchedStrips == null || matchedStrips.Count == 0) //1.2 流程图 箱子里是否已经存在端子排（io匹配）
List<ec_PanelChannelEntity> usedChs = new List<ec_PanelChannelEntity>();
List<ec_PanelChannelEntity> notUsedChs = new List<ec_PanelChannelEntity>();
#region 1.2 流程图 按规则先放几个信号进去（放不下就延到下一个模块）
//if (cable.Sets.Count > 10)
//{
// //另外如果电缆对数大于10对，即像12 * 2 * 0.75这种，无论它预分配了多少根电缆对，永远预留4个以下的空白通道。意思就是一个模块里面够4个或4个以上空白通道就留4个空白通道，如果不够4个就留4个以下即可。
// #region FindNextAvailableTS（可能多个）
// //还分2种情况判断模块是否符合：
// //case1，. 占满可用通道后，还剩至少一个预分配的set和spared的set。 //这种时候要spared不用考虑
// //case2，. 占满可用通道后（或者没占满通道，预分配set已经没了），只剩下spared的set。 //这种时候要确保spared也能放下
// bool NeedNextTS = false;
// do
// {
// #region FindNextAvailableTS
// var availableTS = new List<ec_PanelStripEntity>();
// foreach (var TS in matchedStrips)
// {
// var allCh = TS.Channels;
// //被占用的(wt里有或者信号里或有），或者被锁定的，都算占用
// usedChs = allCh.Where(x => allUsedCHBySignalOrSet.Contains(x.ChannelID) || x.lock_flg == 1).ToList();
// notUsedChs = allCh.Where(x => !usedChs.Select(c => c.ChannelID).Contains(x.ChannelID)).ToList();
// if (notUsedChs.Count < sets.Count)
// {
// //case1，能顺利接完，set还有多
// //这种时候不需要考虑spared
// }
// else
// {
// //case2,占满可用通道后（或者没占满通道，预分配set已经没了），只剩下spared的set
// //想办法留出4个
// //这种时候要确保spared也能放下
// if (notUsedChs.Count < sets.Count + setsSpared.Count)
// {
// //放不下，换下一个模块
// continue;
// }
// var sparedSetFor10 = notUsedChs.Count - sets.Count - setsSpared.Count;//16-9-5=2
// if (sparedSetFor10 > 4)
// {
// //固定流出后面4个，相当于不要了
// var last4 = allCh.Skip(allCh.Count - 4).ToList();
// usedChs = allCh.Take(allCh.Count - 4).Where(x => allUsedCHBySignalOrSet.Contains(x.ChannelID) || x.lock_flg == 1).ToList();
// usedChs.AddRange(last4);
// notUsedChs = allCh.Take(allCh.Count - 4).Where(x => !usedChs.Select(c => c.ChannelID).Contains(x.ChannelID)).ToList();
// }
// else
// {
// //不够4个，就留多少是多少
// var lastN = allCh.Skip(allCh.Count - sparedSetFor10).ToList();
// usedChs = allCh.Take(allCh.Count - sparedSetFor10).Where(x => allUsedCHBySignalOrSet.Contains(x.ChannelID) || x.lock_flg == 1).ToList();
// usedChs.AddRange(lastN);
// notUsedChs = allCh.Take(allCh.Count - sparedSetFor10).Where(x => !usedChs.Select(c => c.ChannelID).Contains(x.ChannelID)).ToList();
// }
// }
// //1.2 流程图 空的通道数够不够
// double sparedRate = notUsedChs.Count * 1.0 / allCh.Count * 1.0;
// if (sparedRate < 0.05)
// {
// //没有空闲通道 next
// //或者空闲通道不够放下这个电缆的所有set
// }
// else
// {
// TS.Channels = allCh.OrderBy(X => X.Channel_Seq).ToList();//不能像之前一样过滤掉，否则下一个电缆进来时，总数就不对了。
// TS.ChannelsSpared = notUsedChs.Count;
// TS.ChannelsUsed = usedChs.Count;
// availableTS.Add(TS);//所有5%以上空闲通道的模块
// break;
// }
// }
// #endregion
// #region NewTS
// if (availableTS.Count() == 0)
// {
// //1.2 流程图 根据信号数里自动新建端子排，端子排通道数里根据箱子模板中的默认值获得
// var newTS = CreatePanelStripByProfile2(projId, cable.AssignedPanel, newTSSeq++, ioTypeOnC);
// //matchedStrips.Add(newTS);
// var allCh = newTS.Channels;
// notUsedChs = newTS.Channels.ToList();
// newTS.ChannelsSpared = notUsedChs.Count;
// newTS.ChannelsUsed = 0;
// usedChs = new List<ec_PanelChannelEntity>();//新建的没有被占用的
// availableTS.Add(newTS);
// if (notUsedChs.Count < sets.Count)
// {
// //case1，能顺利接完，set还有多
// //这种时候不需要考虑spared
// }
// else
// {
// //case2,占满可用通道后（或者没占满通道，预分配set已经没了），只剩下spared的set
// //想办法留出4个
// //这种时候要确保spared也能放下
// if (notUsedChs.Count < sets.Count + setsSpared.Count)
// {
// //放不下，换下一个模块
// continue;
// }
// var sparedSetFor10 = notUsedChs.Count - sets.Count - setsSpared.Count;//16-9-5=2
// if (sparedSetFor10 > 4)
// {
// //固定流出后面4个，相当于不要了
// var last4 = allCh.Skip(allCh.Count - 4).ToList();
// usedChs = allCh.Take(allCh.Count - 4).Where(x => allUsedCHBySignalOrSet.Contains(x.ChannelID) || x.lock_flg == 1).ToList();
// usedChs.AddRange(last4);
// notUsedChs = allCh.Take(allCh.Count - 4).Where(x => !usedChs.Select(c => c.ChannelID).Contains(x.ChannelID)).ToList();
// }
// else
// {
// //不够4个，就留多少是多少
// var lastN = allCh.Skip(allCh.Count - sparedSetFor10).ToList();
// usedChs = allCh.Take(allCh.Count - sparedSetFor10).Where(x => allUsedCHBySignalOrSet.Contains(x.ChannelID) || x.lock_flg == 1).ToList();
// usedChs.AddRange(lastN);
// notUsedChs = allCh.Take(allCh.Count - sparedSetFor10).Where(x => !usedChs.Select(c => c.ChannelID).Contains(x.ChannelID)).ToList();
// }
// }
// }
// #endregion
// lastUsedStrip = availableTS.Last();
// if (notUsedChs.Count < sets.Count)
// {
// //case1，分配完后，还有多的set和可能的spared
// //先这部分填完
// //到5%为止的数量
// var countOnThisTS = Math.Round(0.5 + notUsedChs.Count * 0.95);
// for (int i = 0; i < countOnThisTS; i++)
// {
// var set = sets[i];
// var ch = notUsedChs[i];
// if (lastUsedStrip.TagNumber == "CreatePanelStripByProfile2")
// {
// set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：(自动创建){lastUsedStrip.StripName}/通道：{ch.ChannelName}";
// }
// else
// {
// set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：(原本存在){lastUsedStrip.StripName}/通道：{ch.ChannelName}";
// }
// ch.FakeGroupDesc = set.PreAssignGroup_Desc;
// ch.FakeSignalType = set.IOType.ToString();
// ch.lock_flg = 1;
// set.IsConned = true;
// //更新全局已使用通道
// allUsedCHBySignalOrSet.Add(ch.ChannelID);
// }
// //set会剩
// NeedNextTS = true;
// }
// else
// {
// //case2，分配完后，没有多的set了，可能还有spared
// //上面已经判断过了，确保spared也是够的
// var countMin = Math.Min(sets.Count, notUsedChs.Count);
// for (int i = 0; i < countMin; i++)
// {
// var set = sets[i];
// var ch = notUsedChs[i];
// if (lastUsedStrip.TagNumber == "CreatePanelStripByProfile2")
// {
// set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：(自动创建){lastUsedStrip.StripName}/通道：{ch.ChannelName}";
// }
// else
// {
// set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：(原本存在){lastUsedStrip.StripName}/通道：{ch.ChannelName}";
// }
// ch.FakeGroupDesc = set.PreAssignGroup_Desc;
// ch.FakeSignalType = set.IOType.ToString();
// ch.lock_flg = 1;
// set.IsConned = true;
// //更新全局已使用通道
// allUsedCHBySignalOrSet.Add(ch.ChannelID);
// }
// #region spared
// for (int i = 0; i < setsSpared.Count(); i++)
// {
// var set = setsSpared[i];
// var ch = notUsedChs[countMin + i];
// if (lastUsedStrip.TagNumber == "CreatePanelStripByProfile2")
// {
// set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：(自动创建){lastUsedStrip.StripName}/通道：{ch.ChannelName}/冗余";
// }
// else
// {
// set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：(原本存在){lastUsedStrip.StripName}/通道：{ch.ChannelName}/冗余";
// }
// ch.FakeGroupDesc = "预留";
// ch.lock_flg = 1;
// //更新全局已使用通道
// allUsedCHBySignalOrSet.Add(ch.ChannelID);
// }
// NeedNextTS = false;
// #endregion
// }
// sets = sets.Where(x => !x.IsConned).ToList();//移除已经分配过的set
// } while (NeedNextTS);
// #endregion
//}
//else
//{
//5%的空白通道
#region FindNextAvailableTS（可能多个）
//还分2种情况判断模块是否符合：
//case1，. 占满可用通道后，还剩至少一个预分配的set和spared的set。 //这种时候要spared不用考虑
//case2，. 占满可用通道后（或者没占满通道，预分配set已经没了），只剩下spared的set。 //这种时候要确保spared也能放下
//case3, 刚好，只有spared可能多
bool NeedNextTS = false;
#region FindNextAvailableTS
int idx = 0;
while (idx < matchedStrips.Count)
{
NeedNextTS = false;
var TS = matchedStrips[idx];
var allCh = TS.Channels;
var allChCount = allCh.Count;
if (allChCount == 0)
{ {
//没有端子排 NeedNextTS = true;
//1.2 流程图 根据信号数里自动新建端子排，端子排通道数里根据箱子模板中的默认值获得 //同时又是最后一个了
var newTS = CreatePanelStripByProfile2(projId, "TS_" + ioTypeOnC.ToString() + "_" + newTSSeq++, curPanelId, ioTypeOnC); if (idx == matchedStrips.Count - 1)
alreadyInsertNewTs = true; {
matchedStrips.Add(newTS); var newTS = CreatePanelStripByProfile2(projId, cable.AssignedPanel, newTSSeq++, ioTypeOnC);
if (newTS.Channels.Count() < setsSpared.Count + 1)//1代表至少要放一个set
{
//有问题了 panel的io模板，估计会导致无限循环了
break;
}
matchedStrips.Add(newTS);
}
idx++; continue;//本模块没有一个ch
} }
//被占用的(wt里有或者信号里或有），或者被锁定的，都算占用
usedChs = allCh.Where(x => allUsedCHBySignalOrSet.Contains(x.ChannelID) || x.lock_flg == 1).ToList();
notUsedChs = allCh.Where(x => !usedChs.Select(c => c.ChannelID).Contains(x.ChannelID)).ToList();
#region 1.2 流程图 空的通道数够不够 var ChNeedConn = 0;
if (cable.CableClass == SWS.Share.Enum.cableClass.homerun.ToString()) var SparedNeedConn = 0;
if (cable.CableClass.ToLower() == SWS.Share.Enum.cableClass.homerun.ToString())
{ {
//1.2.3（2）如果模块是通讯信号（像RS485这种就是通讯信号），则不用管预留空白通道这个事情，看到有空的通道就放。 //1.2.3（2）如果模块是通讯信号（像RS485这种就是通讯信号），则不用管预留空白通道这个事情，看到有空的通道就放。
//当前这个端子排就是可用的
curStrip = matchedStrips.First(); if (allChCount < sets.Count)
}
else
{
//1.2.3 (1) 非通讯，如果空的通道大于整个模块的5%，则可以利用，利用到小于5%了则停止利用，如果本身空通道数占的比例就小于5%，则不利用。
curStrip = FindNextAvailableTS(cable.Sets.Count,totalSets, matchedStrips, allUsedCH);
if (curStrip == null)
{ {
var newTS = CreatePanelStripByProfile2(projId, "TS_" + ioTypeOnC.ToString() + "_" + newTSSeq++, curPanelId, ioTypeOnC); //case1，能顺利接完，set还有多,还要再do循环一次,多余的set和spared都要放到下一个模块
alreadyInsertNewTs = true; NeedNextTS = true;
matchedStrips.Add(newTS); ChNeedConn = allChCount; SparedNeedConn = 0;
curStrip = newTS;
} }
} else if (allChCount == sets.Count)
var usedChs = curStrip.Channels.Where(x => allUsedCH.Contains(x.ChannelID)).Select(x => x.ChannelID).ToList();
var notUsedChs = curStrip.Channels.Where(x => !usedChs.Contains(x.ChannelID)).ToList();
#endregion
#region 1.2 流程图 按规则先放几个信号进去
if (notUsedChs.Count < totalSets)
{
//不够放，又要新建?
if (alreadyInsertNewTs)
{ {
//压根就有问题，说明电缆的set太多了，就算是新建的模块，一个channel都没有使用的情况下，都塞不下。 //case3,刚好，只有spared可能多
return false; ChNeedConn = allChCount;
SparedNeedConn = 0; //homerun不用考虑预留一个set去配合后续的spared
} }
else else
{ {
//相当于前面5%的判断过了，但是呢放不下所有需要的set ChNeedConn = sets.Count;
var newTS = CreatePanelStripByProfile2(projId, "TS_" + ioTypeOnC.ToString() + "_" + newTSSeq++, curPanelId, ioTypeOnC); SparedNeedConn = 0;
alreadyInsertNewTs = true; }
matchedStrips.Add(newTS); }
curStrip = newTS; else
usedChs = curStrip.Channels.Where(x => allUsedCH.Contains(x.ChannelID)).Select(x => x.ChannelID).ToList(); {
notUsedChs = curStrip.Channels.Where(x => !usedChs.Contains(x.ChannelID)).ToList(); //1.2 流程图 空的通道数够不够
if (notUsedChs.Count < sets.Count + setsSpared.Count()) double sparedRate = notUsedChs.Count * 1.0 / allChCount * 1.0;
if (sparedRate < 0.05)
{
NeedNextTS = true;
//同时又是最后一个了
if (idx == matchedStrips.Count - 1)
{ {
//压根就有问题，说明电缆的set太多了，就算是新建的模块，一个channel都没有使用的情况下，都塞不下。 var newTS = CreatePanelStripByProfile2(projId, cable.AssignedPanel, newTSSeq++, ioTypeOnC);
return false; if (newTS.Channels.Count() < setsSpared.Count + 1)//1代表至少要放一个set
{
//有问题了 panel的io模板，估计会导致无限循环了
break;
}
matchedStrips.Add(newTS);
}
idx++; continue;//本模块可用的模块小于5%
}
//没有空闲通道 next
//或者空闲通道不够放下这个电缆的所有set
//算一下5%是多少个通道
var trueAvailableChs = notUsedChs.Count - (allChCount - FindMaxNumberChannel(allChCount));//真正能用的（没接过的，然后去掉5%）
if (trueAvailableChs < sets.Count)
{
//case1，能顺利接完，set还有多,还要再do循环一次,多余的set和spared都要放到下一个模块
NeedNextTS = true;
ChNeedConn = trueAvailableChs; SparedNeedConn = 0;
}
else if (trueAvailableChs == sets.Count)
{
//case3,刚好，只有spared可能多
if (setsSpared.Count > 0)
{
//自己的感觉（非客户word需求里的原话）：spared不能自己单独占用一个模块
NeedNextTS = true;
ChNeedConn = trueAvailableChs - 1;//留一个给spared
SparedNeedConn = 0;
}
else
{
ChNeedConn = trueAvailableChs; SparedNeedConn = 0;
}
}
else
{
//maxCh > sets.Count
//case2,占满可用通道后（或者没占满通道，预分配set已经没了），只剩下spared的set
if (setsSpared.Count == 0)
{
//ok
ChNeedConn = sets.Count; SparedNeedConn = 0;
}
//这种时候要确保spared也能放下
else if (trueAvailableChs < sets.Count + setsSpared.Count)
{
//自己的感觉（非客户word需求里的原话）：spared不能自己单独占用一个模块
ChNeedConn = sets.Count - 1;//留一个给spared
NeedNextTS = true;
SparedNeedConn = 0;
}
else
{
//ok,set和spared都能放下
ChNeedConn = sets.Count;
SparedNeedConn = setsSpared.Count;
} }
} }
} }
lastUsedStrip = curStrip;
for (int i = 0; i < sets.Count; i++)
//到这里，说明本模块至少都是可用的
TS.Channels = allCh.OrderBy(X => X.Channel_Seq).ToList();//不能像之前一样过滤掉，否则下一个电缆进来时，总数就不对了。
lastUsedStrip = TS;
#region conn
for (int i = 0; i < ChNeedConn; i++)
{ {
var set = sets[i]; var set = sets[i];
var ch = notUsedChs[i]; var ch = notUsedChs[i];
set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：{curStrip.StripName}/通道：{ch.ChannelName}"; if (lastUsedStrip.TagNumber == "CreatePanelStripByProfile2")
{
set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：(自动创建){lastUsedStrip.StripName}/通道：{ch.ChannelName}";
}
else
{
set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：(原本存在){lastUsedStrip.StripName}/通道：{ch.ChannelName}";
}
ch.FakeGroupDesc = set.PreAssignGroup_Desc;
ch.FakeSignalType = set.IOType.ToString();
ch.lock_flg = 1;
set.IsConned = true;
//更新全局已使用通道 //更新全局已使用通道
allUsedCH.Add(ch.ChannelID); allUsedCHBySignalOrSet.Add(ch.ChannelID);
} }
var chOffIdx = sets.Count; #endregion
for (int i = 0; i < setsSpared.Count(); i++) #region spared
for (int i = 0; i < SparedNeedConn; i++)
{ {
var set = setsSpared[i]; var set = setsSpared[i];
var ch = notUsedChs[chOffIdx + i]; var ch = notUsedChs[ChNeedConn + i];
set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：{curStrip.StripName}/通道：{ch.ChannelName}/冗余"; if (lastUsedStrip.TagNumber == "CreatePanelStripByProfile2")
{
set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：(自动创建){lastUsedStrip.StripName}/通道：{ch.ChannelName}/冗余";
}
else
{
set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：(原本存在){lastUsedStrip.StripName}/通道：{ch.ChannelName}/冗余";
}
ch.lock_flg = 1;
//更新全局已使用通道 //更新全局已使用通道
allUsedCH.Add(ch.ChannelID); allUsedCHBySignalOrSet.Add(ch.ChannelID);
} }
#endregion #endregion
//shi否要继续
TS.ChannelsSpared = notUsedChs.Where(x => x.lock_flg != 1).Count();
TS.ChannelsUsed = allChCount - TS.ChannelsSpared;// usedChs.Count + (notUsedChs.Where(x => x.lock_flg == 1).Count());
if (NeedNextTS)
{
sets = sets.Where(x => !x.IsConned ?? false).ToList();//移除已经分配过的set
//同时又是最后一个了
if (idx == matchedStrips.Count - 1)
{
var newTS = CreatePanelStripByProfile2(projId, cable.AssignedPanel, newTSSeq++, ioTypeOnC);
if (newTS.Channels.Count() < setsSpared.Count + 1)//1代表至少要放一个set
{
//有问题了 panel的io模板，估计会导致无限循环了
break;
}
matchedStrips.Add(newTS);
}
idx++; continue;// 需要下一个模块接着放本电缆
// 手动递增索引，避免无限循环
}
else
{
break;
}
} }
#endregion
#endregion
//}
#endregion
return true; return true;
} }
@ -909,50 +1236,32 @@ namespace Learun.Application.Web.AppApi
} }
/// <summary> /// <summary>
/// 找到下一个可用的端子排 /// 找到满足5%空闲通道的最大数
/// </summary> /// </summary>
/// <param name="setCount">电缆总set</param> /// <param name="ChCount">模块的所有通道数</param>
/// <param name="TSs">所有的端子排</param>
/// <param name="allUsedCH">使用过的channelId</param>
/// <returns></returns> /// <returns></returns>
private ec_PanelStripEntity FindNextAvailableTS(int setCount,int setPreAssigned, List<ec_PanelStripEntity> TSs, List<string> allUsedCH) /// <exception cref="ArgumentException"></exception>
/// <exception cref="InvalidOperationException"></exception>
static int FindMaxNumberChannel(int ChCount)
{ {
foreach (var TS in TSs) if (ChCount < 1)
{ {
var validChs = TS.Channels.Where(x => x.lock_flg == 0).ToList();//过滤掉锁定的通道 throw new ArgumentException("模块数量必须大于等于1", nameof(ChCount));
var usedChs = validChs.Where(x => allUsedCH.Contains(x.ChannelID)).Select(x => x.ChannelID).ToList();
var notUsedChs = validChs.Where(x => !usedChs.Contains(x.ChannelID)).ToList();
double sparedRate = notUsedChs.Count * 1.0 / validChs.Count * 1.0;
if (sparedRate < 0.05 || notUsedChs.Count < setPreAssigned)
{
//没有空闲通道 next
//或者空闲通道不够放下这个电缆的所有set
}
else
{
TS.Channels = validChs.OrderBy(X => X.Channel_Seq).ToList();
var seq = TSs.IndexOf(TS);
if (setCount > 10)
{
//另外如果电缆对数大于10对，即像12 * 2 * 0.75这种，无论它预分配了多少根电缆对，永远预留4个以下的空白通道。意思就是一个模块里面够4个或4个以上空白通道就留4个空白通道，如果不够4个就留4个以下即可。
if (notUsedChs.Count < 4)
{
//没有足够的空闲通道 next
continue;
}
}
return TS;//找到了
}
} }
// 从A-1开始向下寻找
for (int i = 0; i < ChCount; i++)
{
// 检查是否大于5%
if ((double)i / ChCount < 0.05 && (double)(i + 1) / ChCount > 0.05)
{
return ChCount - i;
}
}
return null;//都没有 return ChCount;
} }
/// <summary> /// <summary>
/// 根据step2的预分配结果，进行实际的分配，修改数据库。 /// 根据step2的预分配结果，进行实际的分配，修改数据库。
/// </summary> /// </summary>

3
Learun.Framework.Module/Learun.Application.Module/Learun.Application.TwoDevelopment/ZZDT_EC/ec_cable/ec_CableSetEntity.cs
View File

@ -148,7 +148,7 @@ namespace Learun.Application.TwoDevelopment.ZZDT_EC
/// 是否被连接 /// 是否被连接
/// </summary> /// </summary>
[SugarColumn(IsIgnore = true)] [SugarColumn(IsIgnore = true)]
public bool? IsConned { set; get; } public bool? IsConned { set; get; } = false;
/// <summary> /// <summary>
/// 当前这个set的连接情况 /// 当前这个set的连接情况
@ -169,7 +169,6 @@ namespace Learun.Application.TwoDevelopment.ZZDT_EC
public ec_CableSetEntity() public ec_CableSetEntity()
{ {
IsConned = null;
} }
} }
} }

2
Learun.Framework.Module/Learun.Application.Module/Learun.Application.TwoDevelopment/ZZDT_EC/ec_panel_channel/ec_PanelChannelEntity.cs
View File

@ -117,7 +117,7 @@ namespace Learun.Application.TwoDevelopment.ZZDT_EC
this.ChannelID = Guid.NewGuid().ToString(); this.ChannelID = Guid.NewGuid().ToString();
this.CreateTime = Time.MySqlTime; this.CreateTime = Time.MySqlTime;
UserInfo userInfo = LoginUserInfo.Get(); UserInfo userInfo = LoginUserInfo.Get();
this.CreateUserID = userInfo.userId; this.CreateUserID = userInfo?.userId;
} }

14
Learun.Framework.Module/Learun.Application.Module/Learun.Application.TwoDevelopment/ZZDT_EC/ec_panel_strip/ec_PanelStripEntity.cs
View File

@ -73,7 +73,7 @@ namespace Learun.Application.TwoDevelopment.ZZDT_EC
this.StripID = Guid.NewGuid().ToString(); this.StripID = Guid.NewGuid().ToString();
this.CreateTime = Time.MySqlTime; this.CreateTime = Time.MySqlTime;
UserInfo userInfo = LoginUserInfo.Get(); UserInfo userInfo = LoginUserInfo.Get();
this.CreateUserID = userInfo.userId; this.CreateUserID = userInfo?.userId;
} }
@ -96,15 +96,23 @@ namespace Learun.Application.TwoDevelopment.ZZDT_EC
/// </summary> /// </summary>
[SugarColumn(IsIgnore = true)] [SugarColumn(IsIgnore = true)]
public List<ec_PanelChannelEntity> Channels { set; get; } = new List<ec_PanelChannelEntity>(); public List<ec_PanelChannelEntity> Channels { set; get; } = new List<ec_PanelChannelEntity>();
/// <summary>
/// channel在<see cref="ec_WireTerminalEntity"/>里有，同时<see cref="ec_Wire_GroupEntity.ChannelID"/>也有
/// </summary>
[SugarColumn(IsIgnore = true)] [SugarColumn(IsIgnore = true)]
public int ChannelsUsed { set; get; } = 0; public int ChannelsUsed { set; get; } = 0;
/// <summary>
/// channel在<see cref="ec_WireTerminalEntity"/>里有，但是没有信号
/// </summary>
[SugarColumn(IsIgnore = true)] [SugarColumn(IsIgnore = true)]
public int ChannelsUsedNoSignal { set; get; } = 0; public int ChannelsUsedNoSignal { set; get; } = 0;
/// <summary>
/// channel在<see cref="ec_WireTerminalEntity"/>里没有
/// </summary>
[SugarColumn(IsIgnore = true)] [SugarColumn(IsIgnore = true)]
public int ChannelsSpared { set; get; } = 0; public int ChannelsSpared { set; get; } = 0;
[SugarColumn(IsIgnore = true)] [SugarColumn(IsIgnore = true)]
public string TagNumber { set; get; } public string TagNumber { set; get; }