|
|
using System;
|
|
|
using System.Collections.Generic;
|
|
|
using System.Linq;
|
|
|
using System.Text;
|
|
|
using System.IO;
|
|
|
using System.Reflection;
|
|
|
using Mesnac.Equips.BaseInfo;
|
|
|
using System.Xml;
|
|
|
|
|
|
namespace Mesnac.Equips.SetConfig
|
|
|
{
|
|
|
/// <summary>
|
|
|
/// 设备配置类，在平台设计环境中保存设备配置
|
|
|
/// </summary>
|
|
|
public class ConfigEquip : BaseEquip
|
|
|
{
|
|
|
#region 扩展字段
|
|
|
|
|
|
private bool _isEnableGroup = false;
|
|
|
private string _groupRange = String.Empty;
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region 扩展属性
|
|
|
|
|
|
/// <summary>
|
|
|
/// 是否启用设备群组
|
|
|
/// </summary>
|
|
|
public bool IsEnableGroup
|
|
|
{
|
|
|
get { return _isEnableGroup; }
|
|
|
set { _isEnableGroup = value; }
|
|
|
}
|
|
|
/// <summary>
|
|
|
/// 设备群组范围
|
|
|
/// </summary>
|
|
|
public string GroupRange
|
|
|
{
|
|
|
get { return _groupRange; }
|
|
|
set { _groupRange = value; }
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region 方法重载
|
|
|
public override bool Open()
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
public override bool Read(string block, int start, int len, out object[] buff)
|
|
|
{
|
|
|
buff = null;
|
|
|
return false;
|
|
|
}
|
|
|
public override bool Write(int block, int start, object[] buff)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
public override void Close()
|
|
|
{
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
}
|
|
|
|
|
|
public class ConfigEquipFactory
|
|
|
{
|
|
|
private string _configFile = string.Empty;
|
|
|
private string _projectWizardName = string.Empty;
|
|
|
public ConfigEquipFactory(string _configFile, string _projectWizardName)
|
|
|
{
|
|
|
this._configFile = _configFile;
|
|
|
this._projectWizardName = _projectWizardName;
|
|
|
this.AllEquips = new Dictionary<string, ConfigEquip>();
|
|
|
this.AllEquips.Clear();
|
|
|
}
|
|
|
public string ProjectWizardName { get { return _projectWizardName; } }
|
|
|
public Dictionary<string, ConfigEquip> AllEquips { get; set; }
|
|
|
|
|
|
public event EventHandler OnCurrentEquipChange;
|
|
|
public event EventHandler OnCurrentGroupChange;
|
|
|
public event EventHandler OnCurrentDataChange;
|
|
|
private ConfigEquip _currentEquip = null;
|
|
|
public ConfigEquip CurrentEquip
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return _currentEquip;
|
|
|
}
|
|
|
set
|
|
|
{
|
|
|
if (_currentEquip != value)
|
|
|
{
|
|
|
_currentEquip = value;
|
|
|
this.CurrentGroup = null;
|
|
|
this.CurrentData = null;
|
|
|
if (OnCurrentEquipChange != null)
|
|
|
{
|
|
|
OnCurrentEquipChange(value, EventArgs.Empty);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
private Mesnac.Equips.BaseInfo.Group _currentGroup = null;
|
|
|
public Mesnac.Equips.BaseInfo.Group CurrentGroup
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return _currentGroup;
|
|
|
}
|
|
|
set
|
|
|
{
|
|
|
if (_currentGroup != value)
|
|
|
{
|
|
|
_currentGroup = value;
|
|
|
this.CurrentData = null;
|
|
|
if (OnCurrentGroupChange != null)
|
|
|
{
|
|
|
OnCurrentEquipChange(value, EventArgs.Empty);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
private Mesnac.Equips.BaseInfo.Data _currentData = null;
|
|
|
public Mesnac.Equips.BaseInfo.Data CurrentData
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return _currentData;
|
|
|
}
|
|
|
set
|
|
|
{
|
|
|
if (_currentData != value)
|
|
|
{
|
|
|
_currentData = value;
|
|
|
}
|
|
|
if (OnCurrentDataChange != null)
|
|
|
{
|
|
|
OnCurrentDataChange(value, EventArgs.Empty);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public void SaveConfig()
|
|
|
{
|
|
|
if (string.IsNullOrWhiteSpace(_configFile))
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
if (!Directory.Exists(Path.GetDirectoryName(_configFile)))
|
|
|
{
|
|
|
Directory.CreateDirectory(Path.GetDirectoryName(_configFile));
|
|
|
}
|
|
|
XmlDocument xmlDocument = new XmlDocument();
|
|
|
XmlTextWriter xtw = new XmlTextWriter(_configFile, Encoding.UTF8);
|
|
|
xtw.WriteStartDocument();
|
|
|
xtw.WriteStartElement("EquipFactory");
|
|
|
xtw.WriteEndElement();
|
|
|
xtw.WriteEndDocument();
|
|
|
xtw.Close();
|
|
|
xmlDocument.Load(_configFile);
|
|
|
XmlNode xn = xmlDocument.DocumentElement;
|
|
|
foreach (ConfigEquip equip in this.AllEquips.Values)
|
|
|
{
|
|
|
XmlElement xe_equip = xmlDocument.CreateElement("Equip");
|
|
|
xe_equip.SetAttribute("name", equip.Name.Trim());
|
|
|
if (equip.Project == null)
|
|
|
{
|
|
|
xe_equip.SetAttribute("project", string.Empty);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
xe_equip.SetAttribute("project", equip.Project.Trim());
|
|
|
}
|
|
|
|
|
|
#region 郑立兵于2015-01-19增加，用于保存群组设备的配置至配置文件中
|
|
|
if (equip.IsEnableGroup)
|
|
|
{
|
|
|
xe_equip.SetAttribute("isEnableGroup", "True");
|
|
|
if (String.IsNullOrEmpty(equip.GroupRange))
|
|
|
{
|
|
|
xe_equip.SetAttribute("groupRange", "1");
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
xe_equip.SetAttribute("groupRange", equip.GroupRange.Trim());
|
|
|
}
|
|
|
}
|
|
|
#endregion
|
|
|
|
|
|
xn.AppendChild(xe_equip);
|
|
|
#region Main
|
|
|
XmlElement xe_main = xmlDocument.CreateElement("Main");
|
|
|
xe_equip.AppendChild(xe_main);
|
|
|
XmlElement xe_main_child = xmlDocument.CreateElement("Brand");
|
|
|
xe_main_child.SetAttribute("value", equip.Main.Brand);
|
|
|
xe_main.AppendChild(xe_main_child);
|
|
|
xe_main_child = xmlDocument.CreateElement("Model");
|
|
|
xe_main_child.SetAttribute("value", equip.Main.Model);
|
|
|
xe_main.AppendChild(xe_main_child);
|
|
|
xe_main_child = xmlDocument.CreateElement("ReadHz");
|
|
|
xe_main_child.SetAttribute("value", equip.Main.ReadHz.ToString());
|
|
|
xe_main.AppendChild(xe_main_child);
|
|
|
xe_main_child = xmlDocument.CreateElement("UnitLen");
|
|
|
xe_main_child.SetAttribute("value", equip.Main.UnitLen.ToString());
|
|
|
xe_main.AppendChild(xe_main_child);
|
|
|
xe_main_child = xmlDocument.CreateElement("Connection");
|
|
|
xe_main_child.SetAttribute("mode", equip.Main.ConnType.Name.ToString());
|
|
|
xe_main.AppendChild(xe_main_child);
|
|
|
#region 连接属性
|
|
|
PropertyInfo[] piList = (equip.Main.ConnType.GetType()).GetProperties();
|
|
|
foreach (PropertyInfo pi in piList)
|
|
|
{
|
|
|
if (pi.Name.Equals("Name", StringComparison.CurrentCultureIgnoreCase))
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
if (pi.Name.Equals("Connection", StringComparison.CurrentCultureIgnoreCase))
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
XmlElement xe_info = xmlDocument.CreateElement(pi.Name);
|
|
|
string ssValue = string.Empty;
|
|
|
if (pi.GetValue(equip.Main.ConnType, null) != null)
|
|
|
{
|
|
|
ssValue = pi.GetValue(equip.Main.ConnType, null).ToString();
|
|
|
}
|
|
|
xe_info.SetAttribute("value", ssValue.Trim());
|
|
|
xe_main_child.AppendChild(xe_info);
|
|
|
}
|
|
|
#endregion
|
|
|
#endregion
|
|
|
#region Group
|
|
|
XmlElement xe_groups = xmlDocument.CreateElement("Group");
|
|
|
xe_equip.AppendChild(xe_groups);
|
|
|
foreach (Group group in equip.Group.Values)
|
|
|
{
|
|
|
XmlElement xe_group = xmlDocument.CreateElement("Group");
|
|
|
xe_groups.AppendChild(xe_group);
|
|
|
PropertyInfo[] group_pilst = (group.GetType()).GetProperties();
|
|
|
foreach (PropertyInfo pi in group_pilst)
|
|
|
{
|
|
|
if (pi.Name.Equals("value", StringComparison.CurrentCultureIgnoreCase))
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
if (pi.Name.Equals("Data", StringComparison.CurrentCultureIgnoreCase))
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
if (pi.Name.Equals("equip", StringComparison.CurrentCultureIgnoreCase))
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
xe_group.SetAttribute(pi.Name.ToLower(), pi.GetValue(group, null).ToString().Trim());
|
|
|
}
|
|
|
XmlElement xe_datas = xmlDocument.CreateElement("Data");
|
|
|
xe_group.AppendChild(xe_datas);
|
|
|
foreach (Data data in group.Data.Values)
|
|
|
{
|
|
|
XmlElement xe_data = xmlDocument.CreateElement("Data");
|
|
|
xe_datas.AppendChild(xe_data);
|
|
|
PropertyInfo[] data_pilst = (data.GetType()).GetProperties();
|
|
|
foreach (PropertyInfo pi in data_pilst)
|
|
|
{
|
|
|
if (pi.Name.Equals("value", StringComparison.CurrentCultureIgnoreCase))
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
if (pi.Name.Equals("group", StringComparison.CurrentCultureIgnoreCase))
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
if (pi.Name.Equals("ReadTime", StringComparison.CurrentCultureIgnoreCase))
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
if (pi.Name.Equals("LastBeforeMathValue", StringComparison.CurrentCultureIgnoreCase))
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
if (pi.Name.Equals("keyname", StringComparison.CurrentCultureIgnoreCase))
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
string ssValue = string.Empty;
|
|
|
if (pi.GetValue(data, null) != null)
|
|
|
{
|
|
|
ssValue = pi.GetValue(data, null).ToString();
|
|
|
}
|
|
|
xe_data.SetAttribute(pi.Name.ToLower(), ssValue.Trim());
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
#endregion
|
|
|
}
|
|
|
xmlDocument.Save(_configFile);
|
|
|
}
|
|
|
|
|
|
|
|
|
private bool GetNodeAttributeValue(XmlNode node, string attribute, bool throwException, out string value)
|
|
|
{
|
|
|
value = string.Empty;
|
|
|
try
|
|
|
{
|
|
|
XmlAttribute a = node.Attributes[attribute.ToLower()];
|
|
|
if (a != null && a.Value != null)
|
|
|
{
|
|
|
value = a.Value.ToString().Trim();
|
|
|
}
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
if (throwException)
|
|
|
{
|
|
|
throw (ex);
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
private bool GetFirstNodeValue(XmlNode node, string path, string attribute, bool throwException, out string value)
|
|
|
{
|
|
|
value = string.Empty;
|
|
|
try
|
|
|
{
|
|
|
XmlNode a = node.SelectSingleNode(path);
|
|
|
if (a != null)
|
|
|
{
|
|
|
GetNodeAttributeValue(a, attribute, throwException, out value);
|
|
|
}
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
if (throwException)
|
|
|
{
|
|
|
throw (ex);
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
private readonly string _deviceBasePath = "\\Data\\DeviceConfig"; //设备接口基本目录
|
|
|
private BaseEquip ToEquip(BaseEquip baseEquip)
|
|
|
{
|
|
|
string thisPath = this.GetType().Assembly.Location;
|
|
|
string assPath = (new FileInfo(thisPath)).Directory + this._deviceBasePath + "\\Mesnac.Equips\\";
|
|
|
string dllName = "Mesnac.Equip." + baseEquip.Main.Brand.Trim();
|
|
|
string path = assPath + dllName + "\\" + dllName + ".dll";
|
|
|
string className = "Mesnac.Equip." + baseEquip.Main.Brand.Trim() + "."
|
|
|
+ baseEquip.Main.Model.Trim() + "."
|
|
|
+ baseEquip.Main.ConnType.Name.Trim() + ".Equip";
|
|
|
if (!File.Exists(path))
|
|
|
{
|
|
|
return baseEquip;
|
|
|
}
|
|
|
Assembly ass = Assembly.LoadFile(path);
|
|
|
if (ass == null)
|
|
|
{
|
|
|
return baseEquip;
|
|
|
}
|
|
|
Type type = ass.GetType(className);
|
|
|
if (type == null)
|
|
|
{
|
|
|
return baseEquip;
|
|
|
}
|
|
|
|
|
|
var obj = ass.CreateInstance(className, true);
|
|
|
BaseEquip to = (BaseEquip)Activator.CreateInstance(type);
|
|
|
if (to == null)
|
|
|
{
|
|
|
return baseEquip;
|
|
|
}
|
|
|
to.Name = baseEquip.Name;
|
|
|
to.Project = baseEquip.Project;
|
|
|
to.Main = baseEquip.Main;
|
|
|
to.Group = baseEquip.Group;
|
|
|
foreach (Group group in to.Group.Values)
|
|
|
{
|
|
|
group.Equip = to;
|
|
|
}
|
|
|
return to;
|
|
|
}
|
|
|
/// <summary>
|
|
|
///
|
|
|
/// </summary>
|
|
|
/// <param name="isConfigEquip"></param>
|
|
|
/// <returns></returns>
|
|
|
private Dictionary<string, BaseEquip> ReadBaseEquip(bool isConfigEquip)
|
|
|
{
|
|
|
Dictionary<string, BaseEquip> Result = new Dictionary<string, BaseEquip>();
|
|
|
if (!File.Exists(this._configFile))
|
|
|
{
|
|
|
return Result;
|
|
|
}
|
|
|
XmlDocument xmlDocument = new XmlDocument();
|
|
|
xmlDocument.Load(this._configFile);
|
|
|
foreach (XmlNode factoryNode in xmlDocument)
|
|
|
{
|
|
|
if (factoryNode.Name == "EquipFactory")
|
|
|
{
|
|
|
foreach (XmlNode EquipNode in factoryNode.ChildNodes)
|
|
|
{
|
|
|
string equipNameStr = EquipNode.Attributes["name"].Value.ToString();
|
|
|
ParseEquip(equipNameStr, isConfigEquip, Result, EquipNode);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return Result;
|
|
|
}
|
|
|
/// <summary>
|
|
|
/// 从Xml配置文件中解析设备
|
|
|
/// </summary>
|
|
|
/// <param name="equipName"></param>
|
|
|
/// <param name="isConfigEquip"></param>
|
|
|
/// <param name="Result"></param>
|
|
|
/// <param name="EquipNode"></param>
|
|
|
private void ParseEquip(string equipName, bool isConfigEquip, Dictionary<string, BaseEquip> Result, XmlNode EquipNode)
|
|
|
{
|
|
|
ConfigEquip equip = new ConfigEquip();
|
|
|
equip.Name = equipName;
|
|
|
equip.Project = EquipNode.Attributes["project"].Value.ToString();
|
|
|
|
|
|
#region 郑立兵于2014-01-19扩展，用于解析设备的群组配置
|
|
|
|
|
|
if (null == EquipNode.Attributes["isEnableGroup"] || String.IsNullOrEmpty(EquipNode.Attributes["isEnableGroup"].Value))
|
|
|
{
|
|
|
equip.IsEnableGroup = false;
|
|
|
equip.GroupRange = String.Empty;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
string strIsEnableGroup = EquipNode.Attributes["isEnableGroup"].Value.Trim();
|
|
|
bool isEnableGroup = false;
|
|
|
bool.TryParse(strIsEnableGroup, out isEnableGroup);
|
|
|
equip.IsEnableGroup = isEnableGroup;
|
|
|
if (null == EquipNode.Attributes["groupRange"])
|
|
|
{
|
|
|
equip.GroupRange = String.Empty;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
string strGroupRange = EquipNode.Attributes["groupRange"].Value.Trim();
|
|
|
if (!String.IsNullOrEmpty(strGroupRange))
|
|
|
{
|
|
|
equip.GroupRange = strGroupRange;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Main
|
|
|
string ss = string.Empty;
|
|
|
equip.Main.Equip = equip;
|
|
|
GetFirstNodeValue(EquipNode, ".//Main//Brand[@value]", "value", true, out ss);
|
|
|
equip.Main.Brand = ss;
|
|
|
GetFirstNodeValue(EquipNode, ".//Main//Model[@value]", "value", true, out ss);
|
|
|
equip.Main.Model = ss;
|
|
|
GetFirstNodeValue(EquipNode, ".//Main//ReadHz[@value]", "value", true, out ss);
|
|
|
int strToInt = 0;
|
|
|
if (int.TryParse(ss, out strToInt))
|
|
|
{
|
|
|
equip.Main.ReadHz = strToInt;
|
|
|
}
|
|
|
GetFirstNodeValue(EquipNode, ".//Main//UnitLen[@value]", "value", true, out ss);
|
|
|
strToInt = 0;
|
|
|
if (int.TryParse(ss, out strToInt))
|
|
|
{
|
|
|
equip.Main.UnitLen = strToInt;
|
|
|
}
|
|
|
GetFirstNodeValue(EquipNode, ".//Main//Connection[@mode]", "mode", true, out ss);
|
|
|
equip.Main.ConnType = Mesnac.Equips.Connection.Factory.Instance.GetConfig(EquipNode.SelectNodes(".//Main//Connection[@mode]")[0]);
|
|
|
|
|
|
//add by yinzf 2017-07-03 如果是default格式，填写ip地址信息
|
|
|
//var Conntype=equip.Main.ConnType as Mesnac.Equips.Connection.Default.ConnType;
|
|
|
//if(Conntype!=null)
|
|
|
//{
|
|
|
// GetFirstNodeValue(EquipNode, ".//Main//Connection//IP[@value]", "value", true, out ss);
|
|
|
// Conntype.IP=ss;
|
|
|
// equip.Main.ConnType=Conntype;
|
|
|
//}
|
|
|
//end add
|
|
|
#endregion
|
|
|
#region Group
|
|
|
XmlNodeList groupNodes = EquipNode.SelectNodes(".//Group")[0].ChildNodes;
|
|
|
foreach (XmlNode groupNode in groupNodes)
|
|
|
{
|
|
|
Group group = new Group();
|
|
|
group.Equip = equip;
|
|
|
GetNodeAttributeValue(groupNode, "name", true, out ss);
|
|
|
group.Name = ss;
|
|
|
GetNodeAttributeValue(groupNode, "remark", false, out ss);
|
|
|
group.Remark = ss;
|
|
|
GetNodeAttributeValue(groupNode, "start", true, out ss);
|
|
|
group.Start = Convert.ToInt32(ss);
|
|
|
GetNodeAttributeValue(groupNode, "block", true, out ss);
|
|
|
group.Block = ss;
|
|
|
GetNodeAttributeValue(groupNode, "len", true, out ss);
|
|
|
group.Len = Convert.ToInt32(ss);
|
|
|
GetNodeAttributeValue(groupNode, "isautoread", false, out ss);
|
|
|
group.IsAutoRead = true;
|
|
|
if (ss.ToLower() == "false" ||
|
|
|
ss == "0")
|
|
|
{
|
|
|
group.IsAutoRead = false;
|
|
|
}
|
|
|
GetNodeAttributeValue(groupNode, "access", false, out ss);
|
|
|
group.Access = System.IO.FileAccess.ReadWrite;
|
|
|
if (string.IsNullOrEmpty(ss))
|
|
|
{
|
|
|
ss = "ReadWrite";
|
|
|
}
|
|
|
if (ss.Equals("Read", StringComparison.CurrentCultureIgnoreCase))
|
|
|
{
|
|
|
group.Access = System.IO.FileAccess.Read;
|
|
|
}
|
|
|
if (ss.Equals("Write", StringComparison.CurrentCultureIgnoreCase))
|
|
|
{
|
|
|
group.Access = System.IO.FileAccess.Write;
|
|
|
}
|
|
|
equip.Group.Add(group.Name, group);
|
|
|
|
|
|
#region Data
|
|
|
XmlNodeList dataNodes = groupNode.SelectNodes(".//Data")[0].ChildNodes;
|
|
|
foreach (XmlNode node in dataNodes)
|
|
|
{
|
|
|
Data data = new Data();
|
|
|
data.Group = group;
|
|
|
GetNodeAttributeValue(node, "name", true, out ss);
|
|
|
data.Name = ss;
|
|
|
data.KeyName = equip.Name + "." + group.Name + "." + data.Name;
|
|
|
GetNodeAttributeValue(node, "remark", false, out ss);
|
|
|
data.Remark = ss;
|
|
|
GetNodeAttributeValue(node, "runname", false, out ss);
|
|
|
data.RunName = ss;
|
|
|
if (GetNodeAttributeValue(node, "max", false, out ss))
|
|
|
{
|
|
|
double d = 0;
|
|
|
if (double.TryParse(ss, out d))
|
|
|
{
|
|
|
data.Max = d.ToString();
|
|
|
}
|
|
|
}
|
|
|
if (GetNodeAttributeValue(node, "subtractor", false, out ss))
|
|
|
{
|
|
|
double d = 0;
|
|
|
if (double.TryParse(ss, out d))
|
|
|
{
|
|
|
data.Subtractor = d.ToString();
|
|
|
}
|
|
|
}
|
|
|
GetNodeAttributeValue(node, "start", true, out ss);
|
|
|
data.Start = Convert.ToInt32(ss);
|
|
|
GetNodeAttributeValue(node, "len", true, out ss);
|
|
|
data.Len = Convert.ToInt32(ss);
|
|
|
GetNodeAttributeValue(node, "method", false, out ss);
|
|
|
data.Method = ss;
|
|
|
GetNodeAttributeValue(node, "issave", false, out ss);
|
|
|
if (!string.IsNullOrWhiteSpace(ss))
|
|
|
{
|
|
|
data.IsSave = ss.ToLower().Trim() == "true";
|
|
|
}
|
|
|
group.Data.Add(data.Name, data);
|
|
|
}
|
|
|
#endregion
|
|
|
}
|
|
|
#endregion
|
|
|
|
|
|
#region 郑立兵于2014-01-19修改，用于解析设备群组，通过一个设备组配置，生成多个设备
|
|
|
|
|
|
if (!isConfigEquip)
|
|
|
{
|
|
|
BaseEquip baseEquip = ToEquip(equip as BaseEquip);
|
|
|
|
|
|
if (equip.IsEnableGroup)
|
|
|
{
|
|
|
string[] nameIndexes = EquipTools.GetNameIndexFromRange(equip.GroupRange);
|
|
|
if (nameIndexes != null && nameIndexes.Length > 0)
|
|
|
{
|
|
|
foreach (string nameIndex in nameIndexes)
|
|
|
{
|
|
|
string keyName = equip.Name + nameIndex;
|
|
|
BaseEquip newEquip = new ConfigEquip();
|
|
|
newEquip.Name = keyName;
|
|
|
newEquip.Project = equip.Project;
|
|
|
newEquip.Main.Brand = equip.Main.Brand;
|
|
|
newEquip.Main.ConnType = equip.Main.ConnType;
|
|
|
newEquip.Main.Model = equip.Main.Model;
|
|
|
newEquip.Main.ReadHz = equip.Main.ReadHz;
|
|
|
newEquip.Main.UnitLen = equip.Main.UnitLen;
|
|
|
newEquip.Main.Equip = newEquip;
|
|
|
|
|
|
newEquip = ToEquip(newEquip);
|
|
|
|
|
|
foreach (string groupkey in equip.Group.Keys)
|
|
|
{
|
|
|
Group g = new Group();
|
|
|
g.Access = equip.Group[groupkey].Access;
|
|
|
g.Block = equip.Group[groupkey].Block;
|
|
|
g.Equip = newEquip;
|
|
|
g.IsAutoRead = equip.Group[groupkey].IsAutoRead;
|
|
|
g.Len = equip.Group[groupkey].Len;
|
|
|
g.Name = equip.Group[groupkey].Name;
|
|
|
g.Remark = equip.Group[groupkey].Remark;
|
|
|
g.Start = equip.Group[groupkey].Start;
|
|
|
//g.Value = equip.Group[groupkey].Value;
|
|
|
|
|
|
foreach (string datakey in equip.Group[groupkey].Data.Keys)
|
|
|
{
|
|
|
Data d = new Data();
|
|
|
d.Group = g;
|
|
|
d.IsSave = equip.Group[groupkey].Data[datakey].IsSave;
|
|
|
d.KeyName = newEquip.Name + equip.Group[groupkey].Data[datakey].KeyName.Substring(equip.Group[groupkey].Data[datakey].KeyName.IndexOf("."));
|
|
|
d.LastBeforeMathValue = equip.Group[groupkey].Data[datakey].LastBeforeMathValue;
|
|
|
d.Len = equip.Group[groupkey].Data[datakey].Len;
|
|
|
d.Max = equip.Group[groupkey].Data[datakey].Max;
|
|
|
d.Method = equip.Group[groupkey].Data[datakey].Method;
|
|
|
d.Name = equip.Group[groupkey].Data[datakey].Name;
|
|
|
d.ReadTime = equip.Group[groupkey].Data[datakey].ReadTime;
|
|
|
d.Remark = equip.Group[groupkey].Data[datakey].Remark;
|
|
|
d.RunName = equip.Group[groupkey].Data[datakey].RunName;
|
|
|
d.Start = equip.Group[groupkey].Data[datakey].Start;
|
|
|
d.Subtractor = equip.Group[groupkey].Data[datakey].Subtractor;
|
|
|
//d.Value = equip.Group[groupkey].Data[datakey].Value;
|
|
|
g.Data.Add(datakey, d);
|
|
|
}
|
|
|
|
|
|
newEquip.Group.Add(groupkey, g);
|
|
|
}
|
|
|
|
|
|
|
|
|
Result.Add(keyName, newEquip);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
Result.Add(equip.Name, equip);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
Result.Add(baseEquip.Name, baseEquip);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
Result.Add(equip.Name, equip);
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
}
|
|
|
|
|
|
public void ReadConfig()
|
|
|
{
|
|
|
if (!File.Exists(_configFile))
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
this.AllEquips.Clear();
|
|
|
this.CurrentEquip = null;
|
|
|
this.CurrentGroup = null;
|
|
|
this.CurrentData = null;
|
|
|
Dictionary<string, BaseEquip> Result = new Dictionary<string, BaseEquip>();
|
|
|
Result = ReadBaseEquip(true);
|
|
|
foreach (BaseEquip baseEquip in Result.Values)
|
|
|
{
|
|
|
this.AllEquips.Add(baseEquip.Name, (ConfigEquip)baseEquip);
|
|
|
}
|
|
|
}
|
|
|
public Dictionary<string, BaseEquip> GetBaseEquip()
|
|
|
{
|
|
|
Dictionary<string, BaseEquip> Result = new Dictionary<string, BaseEquip>();
|
|
|
if (!File.Exists(_configFile))
|
|
|
{
|
|
|
return Result;
|
|
|
}
|
|
|
Result = ReadBaseEquip(false);
|
|
|
return Result;
|
|
|
}
|
|
|
|
|
|
public Dictionary<string, ConfigEquip> GetAllConfigEquip()
|
|
|
{
|
|
|
if (File.Exists(_configFile))
|
|
|
{
|
|
|
this.AllEquips.Clear();
|
|
|
this.CurrentEquip = null;
|
|
|
this.CurrentGroup = null;
|
|
|
this.CurrentData = null;
|
|
|
Dictionary<string, BaseEquip> Result = new Dictionary<string, BaseEquip>();
|
|
|
Result = ReadBaseEquip(true);
|
|
|
foreach (BaseEquip baseEquip in Result.Values)
|
|
|
{
|
|
|
this.AllEquips.Add(baseEquip.Name, (ConfigEquip)baseEquip);
|
|
|
}
|
|
|
}
|
|
|
return this.AllEquips;
|
|
|
}
|
|
|
}
|
|
|
}
|