void IGXDLMSBase.Load(GXXmlReader reader)
{
Scripts.Clear();
if (reader.IsStartElement("Scripts", true))
{
while (reader.IsStartElement("Script", true))
{
GXDLMSScript it = new GXDLMSScript();
Scripts.Add(it);
it.Id = reader.ReadElementContentAsInt("ID");
if (reader.IsStartElement("Actions", true))
{
while (reader.IsStartElement("Action", true))
{
GXDLMSScriptAction a = new Objects.GXDLMSScriptAction();
a.Type = (ScriptActionType)reader.ReadElementContentAsInt("Type");
ObjectType ot = (ObjectType)reader.ReadElementContentAsInt("ObjectType");
string ln = reader.ReadElementContentAsString("LN");
a.Index = reader.ReadElementContentAsInt("Index");
a.Target = reader.Objects.FindByLN(ot, ln);
if (a.Target == null)
{
a.Target = GXDLMSClient.CreateObject(ot);
a.Target.LogicalName = ln;
}
a.ParameterDataType = (DataType)reader.ReadElementContentAsInt("ParameterDataType");
a.Parameter = reader.ReadElementContentAsObject("Parameter", null);
}
reader.ReadEndElement("Actions");
}
}
reader.ReadEndElement("Scripts");
}
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
Buffer = GXCommon.HexToBytes(reader.ReadElementContentAsString("Buffer"));
CaptureObjects.Clear();
if (reader.IsStartElement("CaptureObjects", true))
{
while (reader.IsStartElement("Item", true))
{
ObjectType ot = (ObjectType)reader.ReadElementContentAsInt("ObjectType");
string ln = reader.ReadElementContentAsString("LN");
int ai = reader.ReadElementContentAsInt("Attribute");
int di = reader.ReadElementContentAsInt("Data");
GXDLMSCaptureObject co = new GXDLMSCaptureObject(ai, di);
GXDLMSObject obj = reader.Objects.FindByLN(ot, ln);
if (obj == null)
{
obj = GXDLMSClient.CreateObject(ot);
obj.LogicalName = ln;
}
CaptureObjects.Add(new GXKeyValuePair <GXDLMSObject, GXDLMSCaptureObject>(obj, co));
}
reader.ReadEndElement("CaptureObjects");
}
TemplateId = (byte)reader.ReadElementContentAsInt("TemplateId");
TemplateDescription = GXCommon.HexToBytes(reader.ReadElementContentAsString("TemplateDescription"));
CaptureMethod = (CaptureMethod)reader.ReadElementContentAsInt("CaptureMethod");
}
private static GXKeyValuePair <GXDLMSObject, GXDLMSCaptureObject> CreateColumn(GXDLMSObjectCollection objects, GXObisCodeCollection obisCodes, ObjectType ot, string ln, int index, DataType dt)
{
GXDLMSObject obj = objects.FindByLN(ot, ln);
if (obj == null)
{
GXObisCode code = obisCodes.FindByLN(ot, ln, null);
obj = GXDLMSClient.CreateObject(ot);
obj.LogicalName = ln;
if (code != null)
{
GXDLMSAttributeSettings s = code.Attributes.Find(index);
if (s != null)
{
obj.SetDataType(index, s.Type);
obj.SetUIDataType(index, s.UIType);
obj.SetValues(index, s.Values);
}
}
else
{
obj.SetUIDataType(index, dt);
}
}
return(new GXKeyValuePair <GXDLMSObject, GXDLMSCaptureObject>(obj, new GXDLMSCaptureObject(index, 0)));
}
/// <summary>
/// Load COSEM objects from the file.
/// </summary>
/// <param name="stream">Stream.</param>
/// <returns>Collection of serialized COSEM objects.</returns>
public static GXDLMSObjectCollection Load(Stream stream)
{
GXDLMSObject obj = null;
String target;
ObjectType type;
using (GXXmlReader reader = new GXXmlReader(stream))
{
while (!reader.EOF)
{
if (reader.IsStartElement())
{
target = reader.Name;
if (string.Compare("Objects", target, true) == 0)
{
//Skip.
reader.Read();
}
else if (string.Compare("Object", target, true) == 0)
{
int r = 0;
string str = reader.GetAttribute(0);
if (int.TryParse(str, out r))
{
type = (ObjectType)r;
}
else
{
type = (ObjectType)Enum.Parse(typeof(ObjectType), str);
}
reader.Read();
obj = GXDLMSClient.CreateObject(type);
reader.Objects.Add(obj);
}
else if (string.Compare("SN", target, true) == 0)
{
obj.ShortName = (UInt16)reader.ReadElementContentAsInt("SN");
}
else if (string.Compare("LN", target, true) == 0)
{
obj.LogicalName = reader.ReadElementContentAsString("LN");
}
else if (string.Compare("Description", target, true) == 0)
{
obj.Description = reader.ReadElementContentAsString("Description");
}
else
{
(obj as IGXDLMSBase).Load(reader);
obj = null;
}
}
else
{
reader.Read();
}
}
return(reader.Objects);
}
}
private void OkBtn_Click(object sender, EventArgs e)
{
try
{
string str = converter.GetDescription(LogicalNameTb.Text, (ObjectType)ObjectTypeCb.SelectedItem)[0];
if (!ShortNameTb.ReadOnly && str.CompareTo("Invalid") == 0)
{
throw new Exception(Properties.Resources.InvalidObisCode);
}
if (ObjectTypeCb.SelectedItem == null)
{
throw new Exception(Properties.Resources.InvalidTarget);
}
if (string.IsNullOrEmpty(LogicalNameTb.Text))
{
throw new Exception(Properties.Resources.InvalidObisCode);
}
if (Target == null || Target.ObjectType != (ObjectType)ObjectTypeCb.SelectedItem)
{
Target = GXDLMSClient.CreateObject((ObjectType)ObjectTypeCb.SelectedItem);
}
Target.Version = (int)VersionCb.SelectedItem;
Target.LogicalName = LogicalNameTb.Text;
if (ShortNameTb.Visible)
{
Target.ShortName = UInt16.Parse(ShortNameTb.Text);
}
//Update access rights.
}
catch (Exception ex)
{
DialogResult = DialogResult.None;
MessageBox.Show(this, ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void UpdateMonitoredValueTargets()
{
GXDLMSRegisterMonitor target = Target as GXDLMSRegisterMonitor;
this.MonitoredValueCb.SelectedIndexChanged -= new System.EventHandler(this.MonitoredValueCb_SelectedIndexChanged);
try
{
MonitoredValueCb.Items.Clear();
if (target.Parent != null)
{
if (ShowAllTargetsCb.Checked)
{
foreach (GXDLMSObject it in target.Parent)
{
MonitoredValueCb.Items.Add(it);
}
}
else
{
foreach (GXDLMSObject it in target.Parent.GetObjects(
new ObjectType[] { ObjectType.Data, ObjectType.Register, ObjectType.ExtendedRegister, ObjectType.DemandRegister }))
{
MonitoredValueCb.Items.Add(it);
}
}
}
else if (target.MonitoredValue != null && target.MonitoredValue.ObjectType != ObjectType.None)
{
GXDLMSObject obj = GXDLMSClient.CreateObject(target.MonitoredValue.ObjectType);
obj.LogicalName = target.MonitoredValue.LogicalName;
MonitoredValueCb.Items.Add(obj);
}
if (target.MonitoredValue != null && target.MonitoredValue.ObjectType != ObjectType.None)
{
if (target.Parent != null)
{
MonitoredValueCb.SelectedItem = target.Parent.FindByLN(target.MonitoredValue.ObjectType, target.MonitoredValue.LogicalName);
}
else
{
GXDLMSObject it = GXDLMSClient.CreateObject(target.MonitoredValue.ObjectType);
it.LogicalName = target.MonitoredValue.LogicalName;
MonitoredValueCb.SelectedItem = it;
}
AttributeIndexTB.Text = target.MonitoredValue.AttributeIndex.ToString();
}
else
{
MonitoredValueCb.SelectedItem = null;
AttributeIndexTB.Text = "";
}
}
finally
{
this.MonitoredValueCb.SelectedIndexChanged += new System.EventHandler(this.MonitoredValueCb_SelectedIndexChanged);
}
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
if (reader.IsStartElement("MonitoredValue", true))
{
ObjectType ot = (ObjectType)reader.ReadElementContentAsInt("ObjectType");
string ln = reader.ReadElementContentAsString("LN");
if (ot != ObjectType.None && ln != null)
{
MonitoredValue = reader.Objects.FindByLN(ot, ln);
//If item is not serialized yet.
if (MonitoredValue == null)
{
MonitoredValue = GXDLMSClient.CreateObject(ot);
MonitoredValue.LogicalName = ln;
}
}
reader.ReadEndElement("MonitoredValue");
}
ThresholdActive = reader.ReadElementContentAsObject("ThresholdActive", null);
ThresholdNormal = reader.ReadElementContentAsObject("ThresholdNormal", null);
ThresholdEmergency = reader.ReadElementContentAsObject("ThresholdEmergency", null);
MinOverThresholdDuration = (UInt16)reader.ReadElementContentAsInt("MinOverThresholdDuration");
MinUnderThresholdDuration = (UInt16)reader.ReadElementContentAsInt("MinUnderThresholdDuration");
if (reader.IsStartElement("EmergencyProfile", true))
{
EmergencyProfile.ID = (UInt16)reader.ReadElementContentAsInt("ID");
EmergencyProfile.ActivationTime = (GXDateTime)reader.ReadElementContentAsObject("Time", new GXDateTime());
EmergencyProfile.Duration = (UInt16)reader.ReadElementContentAsInt("Duration");
reader.ReadEndElement("EmergencyProfile");
}
List <UInt16> list = new List <ushort>();
if (reader.IsStartElement("EmergencyProfileGroupIDs", true))
{
while (reader.IsStartElement("Value", false))
{
list.Add((UInt16)reader.ReadElementContentAsInt("Value"));
}
reader.ReadEndElement("EmergencyProfileGroupIDs");
}
EmergencyProfileGroupIDs = list.ToArray();
EmergencyProfileActive = reader.ReadElementContentAsInt("Active") != 0;
if (reader.IsStartElement("ActionOverThreshold", true))
{
ActionOverThreshold.LogicalName = reader.ReadElementContentAsString("LN");
ActionOverThreshold.ScriptSelector = (UInt16)reader.ReadElementContentAsInt("ScriptSelector");
reader.ReadEndElement("ActionOverThreshold");
}
if (reader.IsStartElement("ActionUnderThreshold", true))
{
ActionUnderThreshold.LogicalName = reader.ReadElementContentAsString("LN");
ActionUnderThreshold.ScriptSelector = (UInt16)reader.ReadElementContentAsInt("ScriptSelector");
reader.ReadEndElement("ActionUnderThreshold");
}
}
byte[] IGXDLMSBase.Invoke(GXDLMSSettings settings, ValueEventArgs e)
{
if (e.Index != 1 && e.Index != 2)
{
e.Error = ErrorCode.ReadWriteDenied;
}
else
{
if (e.Index == 1)
{
List <object> tmp = (List <object>)e.Parameters;
ObjectType type = (ObjectType)Convert.ToUInt16(tmp[0]);
string ln = GXCommon.ToLogicalName((byte[])tmp[1]);
byte index = Convert.ToByte(tmp[2]);
foreach (GXDLMSTarget item in Parameters)
{
if (item.Target.ObjectType == type && item.Target.LogicalName == ln && item.AttributeIndex == index)
{
Parameters.Remove(item);
break;
}
}
GXDLMSTarget it = new GXDLMSTarget();
it.Target = settings.Objects.FindByLN(type, (byte[])tmp[1]);
if (it.Target == null)
{
it.Target = GXDLMSClient.CreateObject(type);
it.Target.LogicalName = ln;
}
it.AttributeIndex = index;
Parameters.Add(it);
}
else if (e.Index == 2)
{
List <object> tmp = (List <object>)e.Parameters;
ObjectType ot = (ObjectType)Convert.ToUInt16(tmp[0]);
string ln = GXCommon.ToLogicalName((byte[])tmp[1]);
byte index = Convert.ToByte(tmp[2]);
foreach (GXDLMSTarget item in Parameters)
{
if (item.Target.ObjectType == ot && item.Target.LogicalName == ln && item.AttributeIndex == index)
{
Parameters.Remove(item);
break;
}
}
}
}
return(null);
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
Buffer.Clear();
if (reader.IsStartElement("Buffer", true))
{
while (reader.IsStartElement("Row", true))
{
List <object> row = new List <object>();
while (reader.IsStartElement("Cell", false))
{
row.Add(reader.ReadElementContentAsObject("Cell", null));
}
Buffer.Add(row.ToArray());
}
reader.ReadEndElement("Buffer");
}
CaptureObjects.Clear();
if (reader.IsStartElement("CaptureObjects", true))
{
while (reader.IsStartElement("Item", true))
{
ObjectType ot = (ObjectType)reader.ReadElementContentAsInt("ObjectType");
string ln = reader.ReadElementContentAsString("LN");
int ai = reader.ReadElementContentAsInt("Attribute");
int di = reader.ReadElementContentAsInt("Data");
GXDLMSCaptureObject co = new GXDLMSCaptureObject(ai, di);
GXDLMSObject obj = reader.Objects.FindByLN(ot, ln);
if (obj == null)
{
obj = GXDLMSClient.CreateObject(ot);
obj.LogicalName = ln;
}
CaptureObjects.Add(new GXKeyValuePair <GXDLMSObject, GXDLMSCaptureObject>(obj, co));
}
reader.ReadEndElement("CaptureObjects");
}
CapturePeriod = reader.ReadElementContentAsInt("CapturePeriod");
SortMethod = (SortMethod)reader.ReadElementContentAsInt("SortMethod");
if (reader.IsStartElement("SortObject", true))
{
CapturePeriod = reader.ReadElementContentAsInt("CapturePeriod");
ObjectType ot = (ObjectType)reader.ReadElementContentAsInt("ObjectType");
string ln = reader.ReadElementContentAsString("LN");
SortObject = reader.Objects.FindByLN(ot, ln);
reader.ReadEndElement("SortObject");
}
EntriesInUse = reader.ReadElementContentAsInt("EntriesInUse");
ProfileEntries = reader.ReadElementContentAsInt("ProfileEntries");
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
ChangedParameter = new GXDLMSTarget();
if (reader.IsStartElement("ChangedParameter", true))
{
ObjectType ot = (ObjectType)reader.ReadElementContentAsInt("Type");
string ln = reader.ReadElementContentAsString("LN");
ChangedParameter.Target = reader.Objects.FindByLN(ot, ln);
if (ChangedParameter.Target == null)
{
ChangedParameter.Target = GXDLMSClient.CreateObject(ot);
ChangedParameter.Target.LogicalName = ln;
}
ChangedParameter.AttributeIndex = (byte)reader.ReadElementContentAsInt("Index");
ChangedParameter.Value = reader.ReadElementContentAsObject("Value", null);
reader.ReadEndElement("ChangedParameter");
}
if (string.Compare("Time", reader.Name, true) == 0)
{
CaptureTime = new GXDateTime(reader.ReadElementContentAsString("Time"), CultureInfo.InvariantCulture);
}
else
{
CaptureTime = DateTime.MinValue;
}
Parameters.Clear();
if (reader.IsStartElement("Parameters", true))
{
while (reader.IsStartElement("Item", true))
{
GXDLMSTarget obj = new GXDLMSTarget();
ObjectType ot = (ObjectType)reader.ReadElementContentAsInt("Type");
string ln = reader.ReadElementContentAsString("LN");
obj.Target = reader.Objects.FindByLN(ot, ln);
if (obj.Target == null)
{
obj.Target = GXDLMSClient.CreateObject(ot);
obj.Target.LogicalName = ln;
}
obj.AttributeIndex = (byte)reader.ReadElementContentAsInt("Index");
Parameters.Add(obj);
}
reader.ReadEndElement("Parameters");
}
}
private void TemplatesView_SelectedIndexChanged(object sender, EventArgs e)
{
try
{
if (TemplatesView.SelectedItems.Count == 1)
{
PropertiesView.Items.Clear();
GXDeviceTemplate meter = (GXDeviceTemplate)TemplatesView.SelectedItems[0].Tag;
if (meter.Objects != null)
{
foreach (GXObjectTemplate it in meter.Objects)
{
GXDLMSObject obj = GXDLMSClient.CreateObject((ObjectType)it.ObjectType);
foreach (GXAttributeTemplate a in it.Attributes)
{
ListViewItem li = PropertiesView.Items.Add(it.Name);
li.SubItems.Add(it.LogicalName);
li.SubItems.Add(((ObjectType)it.ObjectType).ToString());
if (string.IsNullOrEmpty(a.Name))
{
a.Name = ((IGXDLMSBase)obj).GetNames()[a.Index - 1];
}
li.SubItems.Add(a.Index.ToString() + ": " + a.Name);
li.SubItems.Add(a.DataType == 0 ? "" : ((DataType)a.DataType).ToString());
li.SubItems.Add(a.UIDataType == 0 ? "" : ((DataType)a.UIDataType).ToString());
if (a.ExpirationTime == 0xFFFFFFFF)
{
li.SubItems.Add("Static");
}
else
{
li.SubItems.Add(a.ExpirationTime == 0 ? "" : TimeSpan.FromSeconds(a.ExpirationTime).ToString());
}
li.Tag = a;
}
}
}
}
}
catch (Exception Ex)
{
MessageBox.Show(panel1.Parent, Ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
PushObjectList.Clear();
if (reader.IsStartElement("ObjectList", true))
{
while (reader.IsStartElement("Item", true))
{
ObjectType ot = (ObjectType)reader.ReadElementContentAsInt("ObjectType");
string ln = reader.ReadElementContentAsString("LN");
int ai = reader.ReadElementContentAsInt("AI");
int di = reader.ReadElementContentAsInt("DI");
reader.ReadEndElement("Item");
GXDLMSCaptureObject co = new GXDLMSCaptureObject(ai, di);
GXDLMSObject obj = reader.Objects.FindByLN(ot, ln);
if (obj == null)
{
obj = GXDLMSClient.CreateObject(ot);
obj.LogicalName = ln;
}
PushObjectList.Add(new KeyValuePair <Objects.GXDLMSObject, Objects.GXDLMSCaptureObject>(obj, co));
}
reader.ReadEndElement("ObjectList");
}
Service = (ServiceType)reader.ReadElementContentAsInt("Service");
Destination = reader.ReadElementContentAsString("Destination");
Message = (MessageType)reader.ReadElementContentAsInt("Message");
CommunicationWindow.Clear();
if (reader.IsStartElement("CommunicationWindow", true))
{
while (reader.IsStartElement("Item", true))
{
GXDateTime start = new GXDateTime(reader.ReadElementContentAsString("Start"), CultureInfo.InvariantCulture);
GXDateTime end = new GXDateTime(reader.ReadElementContentAsString("End"), CultureInfo.InvariantCulture);
CommunicationWindow.Add(new KeyValuePair <DLMS.GXDateTime, DLMS.GXDateTime>(start, end));
}
reader.ReadEndElement("CommunicationWindow");
}
RandomisationStartInterval = (ushort)reader.ReadElementContentAsInt("RandomisationStartInterval");
NumberOfRetries = (byte)reader.ReadElementContentAsInt("NumberOfRetries");
RepetitionDelay = (ushort)reader.ReadElementContentAsInt("RepetitionDelay");
}
/// <summary>
/// Object type has changed.
/// </summary>
private void ObjectTypeCb_SelectedIndexChanged(object sender, EventArgs e)
{
LogicalNameTb.Items.Clear();
bool first = true;
foreach (KeyValuePair <string, string> it in converter.GetObisCodesByType((ObjectType)ObjectTypeCb.SelectedItem))
{
LogicalNameTb.Items.Add(it.Key);
if (first)
{
LogicalNameTb.Text = it.Key;
DescriptionTb.Text = it.Value;
first = false;
}
}
//Restore default columns if old target is association LN.
if (Target is GXDLMSAssociationLogicalName)
{
VersionCb.Enabled = true;
CreateAccessrightsColumns(version);
}
if (Target == null || Target.ObjectType != (ObjectType)ObjectTypeCb.SelectedItem)
{
Target = GXDLMSClient.CreateObject((ObjectType)ObjectTypeCb.SelectedItem);
}
UpdateAttributes();
//Update max version number.
VersionCb.Items.Clear();
for (int pos = 0; pos != 1 + (Target as IGXDLMSBase).GetMaxSupportedVersion(); ++pos)
{
VersionCb.Items.Insert(0, pos);
}
if (Target is GXDLMSAssociationLogicalName)
{
VersionCb.SelectedItem = version;
VersionCb.Enabled = false;
}
else
{
VersionCb.SelectedIndex = 0;
}
}
void UpdateTarget()
{
//If logical name is not given set default value.
if (string.IsNullOrEmpty(Target.LogicalName))
{
//Get default logical name.
GXDLMSObject obj = GXDLMSClient.CreateObject(Target.ObjectType);
Target.LogicalName = obj.LogicalName;
}
Target.Attributes.Clear();
GXObisCode code = ObisCodeCollection.FindByLN(Target.ObjectType, Target.LogicalName, null);
if (code != null && code.Attributes != null)
{
Target.Attributes.AddRange(code.Attributes);
Target.Description = code.Description;
}
else
{
Target.Description = converter.GetDescription(Target.LogicalName, Target.ObjectType)[0];
}
ObisPropertyGrid.SelectedObject = Target;
InterfaceCB.SelectedItem = Target;
}
/// <summary>
/// Show action data.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ActionsList_SelectedIndexChanged(object sender, EventArgs e)
{
if (MacrosView.SelectedIndices.Count == 1)
{
GXMacro macro = GetMacros()[MacrosView.SelectedIndices[0]];
if (macro.Type == UserActionType.Get || macro.Type == UserActionType.Set)
{
if (!tabControl1.TabPages.Contains(VisualizedTab))
{
tabControl1.TabPages.Insert(0, VisualizedTab);
}
}
else
{
if (tabControl1.TabPages.Contains(VisualizedTab))
{
tabControl1.TabPages.Remove(VisualizedTab);
}
}
string actual, expected;
if (Properties.Settings.Default.MacroRaw)
{
expected = macro.Data;
}
else
{
expected = macro.Value;
}
OriginalDataTb.Text = expected;
if (Results.ContainsKey(macro))
{
if (Properties.Settings.Default.MacroRaw)
{
actual = Results[macro].Data;
expected = macro.Data;
}
else
{
actual = Results[macro].Value;
expected = macro.Value;
}
if (actual != expected)
{
ReplyDataTb.Text = actual;
ActualPanel.Visible = true;
}
else
{
ActualPanel.Visible = false;
}
}
else
{
ActualPanel.Visible = false;
ReplyDataTb.Text = null;
}
try
{
if (macro.Type == UserActionType.Get || macro.Type == UserActionType.Set)
{
if (macro.ObjectType != 0)
{
GXDLMSObject obj = GXDLMSClient.CreateObject((ObjectType)macro.ObjectType);
if (obj != null)
{
obj.LogicalName = macro.LogicalName;
for (int pos = 1; pos != (obj as IGXDLMSBase).GetAttributeCount() + 1; ++pos)
{
obj.SetAccess(pos, AccessMode.NoAccess);
}
obj.SetAccess(macro.Index, AccessMode.ReadWrite);
obj.SetDataType(macro.Index, (DataType)macro.DataType);
obj.SetUIDataType(macro.Index, (DataType)macro.UIDataType);
if (!string.IsNullOrEmpty(macro.Data) && Target != null)
{
object value = GXDLMSTranslator.XmlToValue(macro.Data);
if (value is byte[] && macro.UIDataType != 0)
{
value = Target.Comm.client.ChangeType(new GXByteBuffer((byte[])value), (DataType)macro.UIDataType);
}
else if (value is byte[] &&
macro.DataType != (int)DataType.None &&
macro.DataType != (int)DataType.OctetString)
{
if (macro.DataType == (int)DataType.Array ||
macro.DataType == (int)DataType.Structure)
{
GXByteBuffer bb = new GXByteBuffer((byte[])value);
//Skip data type.
bb.Position = 1;
value = Target.Comm.client.ChangeType(bb, (DataType)macro.DataType);
}
else
{
GXByteBuffer bb = new GXByteBuffer((byte[])value);
value = Target.Comm.client.ChangeType(bb, (DataType)macro.DataType);
}
}
if (macro.ObjectType == (int)ObjectType.ProfileGeneric && macro.Index == 2 && !string.IsNullOrEmpty(macro.External))
{
Target.Comm.client.UpdateValue(obj, 3, GXDLMSTranslator.XmlToValue(macro.External));
}
Target.Comm.client.UpdateValue(obj, macro.Index, value);
}
if (SelectedView == null || SelectedView.Target.ObjectType != obj.ObjectType)
{
//SelectedView must remove from the controls.
ObjectPanelFrame.Controls.Clear();
if (Target == null)
{
SelectedView = GXDlmsUi.GetView(Views, obj, Standard.DLMS);
}
else
{
SelectedView = GXDlmsUi.GetView(Views, obj, Target.Comm.client.Standard);
}
SelectedView.Target = obj;
GXDlmsUi.ObjectChanged(SelectedView, obj, false);
SelectedView.OnDirtyChange(macro.Index, true);
ObjectPanelFrame.Controls.Add(((Form)SelectedView));
((Form)SelectedView).Show();
}
else
{
SelectedView.Target = obj;
GXDlmsUi.ObjectChanged(SelectedView, obj, false);
SelectedView.OnDirtyChange(macro.Index, true);
}
}
}
}
}
catch (Exception Ex)
{
GXDLMS.Common.Error.ShowError(this, Ex);
}
}
else
{
OriginalDataTb.Text = "";
if (GetMacros().Count == 0 && tabControl1.TabPages.Contains(VisualizedTab))
{
tabControl1.TabPages.Remove(VisualizedTab);
}
}
}
void UpdateData(DataTable dt)
{
Standard standard = Standard.DLMS;
if (target.Parent != null && target.Parent.Parent is GXDLMSClient)
{
standard = ((GXDLMSClient)target.Parent.Parent).Standard;
}
List <object> rows = GXDLMSCompactData.GetData(target.TemplateDescription, target.Buffer, standard == Standard.Italy);
if (structures)
{
List <object[]> data = new List <object[]>();
foreach (List <object> r in rows)
{
List <object> row = new List <object>();
int index = 0;
foreach (var it in target.CaptureObjects)
{
//If COSEM object is selected.
//Only few meters are supporting this.
if (it.Value.AttributeIndex == 0 && r[index] is List <object> )
{
//Values must be update to the list because there might be Register Scaler
//and it expects that scaler is read before value is updated.
GXDLMSObject obj = GXDLMSClient.CreateObject(it.Key.ObjectType);
byte i2 = 1;
Dictionary <byte, object> list = new Dictionary <byte, object>();
foreach (object v in (r[index] as object[]))
{
list.Add(i2, v);
++i2;
}
//Update values first.
for (byte i = 0; i != (obj as IGXDLMSBase).GetAttributeCount(); ++i)
{
ValueEventArgs ve = new ValueEventArgs(obj, i, 0, null);
ve.Value = list[i];
(obj as IGXDLMSBase).SetValue(null, ve);
}
//Show values.
for (byte i = 0; i != (obj as IGXDLMSBase).GetAttributeCount(); ++i)
{
row.Add(GetValue(obj.GetValues()[i]));
}
}
else
{
row.Add(GetValue(r[index]));
}
++index;
}
data.Add(row.ToArray());
}
for (int pos = dt.Rows.Count; pos < data.Count; ++pos)
{
object[] row = data[pos];
dt.LoadDataRow(row, true);
}
}
else
{
for (int pos = dt.Rows.Count; pos < rows.Count; ++pos)
{
List <object> row = (List <object>)rows[pos];
if (row != null)
{
for (int col = 0; col != row.Count; ++col)
{
if (row[col] is byte[])
{
if (pos < target.CaptureObjects.Count && target.CaptureObjects[col].Key.GetUIDataType(target.CaptureObjects[col].Value.AttributeIndex) == DataType.DateTime)
{
row[col] = GXDLMSClient.ChangeType(row[col] as byte[], DataType.DateTime);
}
else
{
row[col] = GXDLMSTranslator.ToHex((byte[])row[col], true);
}
}
else if (row[col] is Object[])
{
row[col] = GXDLMSTranslator.ValueToXml(row[col]);
}
else if (row[col] is List <Object> )
{
row[col] = GXDLMSTranslator.ValueToXml(row[col]);
}
else if (col < target.CaptureObjects.Count)
{
GXDLMSAttributeSettings att = target.CaptureObjects[col].Key.Attributes.Find(target.CaptureObjects[col].Value.AttributeIndex);
if (att != null && att.Values != null)
{
if (att.Type == DataType.BitString && row[col] is string)
{
string str = (string)row[col];
if (str.Length != 0 && (str[0] == '0' || str[0] == '1'))
{
StringBuilder sb = new StringBuilder();
int pos2 = 0;
foreach (char it in str)
{
if (it == '1')
{
if (sb.Length != 0)
{
sb.Append(',');
}
sb.Append(att.Values[pos2].UIValue);
}
++pos2;
if (pos2 == att.Values.Count)
{
break;
}
}
row[col] = sb.ToString();
}
}
else
{
foreach (GXObisValueItem it in att.Values)
{
if (IsNumber(row[col]) && it.Value == Convert.ToInt32(row[col]))
{
row[col] = it.UIValue;
break;
}
}
}
}
}
}
if (dt.Columns.Count != 0)
{
try
{
dt.LoadDataRow(row.ToArray(), true);
}
catch (Exception)
{
//It's OK if this fails.
}
}
}
}
}
}
/// <summary>
/// Read data from the meter.
/// </summary>
private static void ReadMeter(object parameter)
{
GXDLMSReader reader = null;
System.Net.Http.HttpClient httpClient = Helpers.client;
using (GXNet media = (GXNet)parameter)
{
try
{
var config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true)
.Build();
ListenerOptions listener = config.GetSection("Listener").Get <ListenerOptions>();
GXDLMSObjectCollection objects = new GXDLMSObjectCollection();
GXDLMSSecureClient client = new GXDLMSSecureClient(listener.UseLogicalNameReferencing, listener.ClientAddress, listener.ServerAddress, (Authentication)listener.Authentication, listener.Password, (InterfaceType)listener.Interface);
reader = new GXDLMSReader(client, media, _logger);
GXDLMSData ldn = new GXDLMSData("0.0.42.0.0.255");
ldn.SetUIDataType(2, DataType.String);
reader.InitializeConnection();
reader.Read(ldn, 2);
Console.WriteLine("Meter connected: " + ldn.Value);
//Find device.
GXDevice dev = null;
ListDevicesResponse devs = null;
{
using (System.Net.Http.HttpResponseMessage response = httpClient.PostAsJsonAsync(Startup.ServerAddress + "/api/device/ListDevices", new ListDevices()
{
Name = (string)ldn.Value
}).Result)
{
Helpers.CheckStatus(response);
devs = response.Content.ReadAsAsync <ListDevicesResponse>().Result;
}
//If device is unknown.
if (devs.Devices.Length == 0)
{
if (listener.DefaultDeviceTemplate == 0)
{
string str = "Unknown Meter try to connect to the Gurux.DLMS.AMI server: " + ldn.Value;
Console.WriteLine(str);
AddSystemError info = new AddSystemError();
info.Error = new GXSystemError()
{
Error = str
};
using (System.Net.Http.HttpResponseMessage response = httpClient.PostAsJsonAsync(Startup.ServerAddress + "/api/SystemError/AddSystemError", info).Result)
{
Helpers.CheckStatus(response);
}
return;
}
ListDeviceTemplates lt = new ListDeviceTemplates()
{
Ids = new UInt64[] { listener.DefaultDeviceTemplate }
};
using (System.Net.Http.HttpResponseMessage response = httpClient.PostAsJsonAsync(Startup.ServerAddress + "/api/template/ListDeviceTemplates", lt).Result)
{
Helpers.CheckStatus(response);
ListDeviceTemplatesResponse ret = response.Content.ReadAsAsync <ListDeviceTemplatesResponse>().Result;
if (ret.Devices.Length != 1)
{
throw new Exception("DefaultDeviceTemplate value is invalid: " + listener.DefaultDeviceTemplate);
}
dev = new GXDevice();
GXDevice.Copy(dev, ret.Devices[0]);
dev.Name = Convert.ToString(ldn.Value);
dev.TemplateId = listener.DefaultDeviceTemplate;
dev.Manufacturer = ret.Devices[0].Name;
}
dev.Dynamic = true;
UpdateDevice update = new UpdateDevice();
update.Device = dev;
using (System.Net.Http.HttpResponseMessage response = httpClient.PostAsJsonAsync(Startup.ServerAddress + "/api/device/UpdateDevice", update).Result)
{
Helpers.CheckStatus(response);
UpdateDeviceResponse r = response.Content.ReadAsAsync <UpdateDeviceResponse>().Result;
dev.Id = r.DeviceId;
}
using (System.Net.Http.HttpResponseMessage response = httpClient.PostAsJsonAsync(Startup.ServerAddress + "/api/device/ListDevices", new ListDevices()
{
Ids = new UInt64[] { dev.Id }
}).Result)
{
Helpers.CheckStatus(response);
devs = response.Content.ReadAsAsync <ListDevicesResponse>().Result;
}
}
else if (devs.Devices.Length != 1)
{
throw new Exception("There are multiple devices with same name: " + ldn.Value);
}
else
{
dev = devs.Devices[0];
if (dev.Security != Security.None)
{
Console.WriteLine("Reading frame counter.");
GXDLMSData fc = new GXDLMSData(listener.InvocationCounter);
reader.Read(fc, 2);
dev.InvocationCounter = 1 + Convert.ToUInt32(fc.Value);
Console.WriteLine("Device ID: " + dev.Id + " LDN: " + (string)ldn.Value);
Console.WriteLine("Frame counter: " + dev.FrameCounter);
}
GetNextTaskResponse ret;
using (System.Net.Http.HttpResponseMessage response = httpClient.PostAsJsonAsync(Startup.ServerAddress + "/api/task/GetNextTask", new GetNextTask()
{
Listener = true, DeviceId = dev.Id
}).Result)
{
Helpers.CheckStatus(response);
ret = response.Content.ReadAsAsync <GetNextTaskResponse>().Result;
}
if (ret.Tasks == null || ret.Tasks.Length == 0)
{
Console.WriteLine("No tasks to execute");
}
else
{
Console.WriteLine("Task count: " + ret.Tasks.Length);
if (client.ClientAddress != dev.ClientAddress || dev.Security != Security.None)
{
reader.Release();
reader.Disconnect();
client = new GXDLMSSecureClient(dev.UseLogicalNameReferencing, dev.ClientAddress, dev.PhysicalAddress, (Authentication)dev.Authentication, dev.Password, dev.InterfaceType);
client.UtcTimeZone = dev.UtcTimeZone;
client.Standard = (Standard)dev.Standard;
if (dev.Conformance != 0)
{
client.ProposedConformance = (Conformance)dev.Conformance;
}
client.Priority = dev.Priority;
client.ServiceClass = dev.ServiceClass;
client.Ciphering.SystemTitle = GXCommon.HexToBytes(dev.ClientSystemTitle);
client.Ciphering.BlockCipherKey = GXCommon.HexToBytes(dev.BlockCipherKey);
client.Ciphering.AuthenticationKey = GXCommon.HexToBytes(dev.AuthenticationKey);
client.ServerSystemTitle = GXCommon.HexToBytes(dev.DeviceSystemTitle);
client.Ciphering.InvocationCounter = dev.InvocationCounter;
client.Ciphering.Security = (Security)dev.Security;
reader = new GXDLMSReader(client, media, _logger);
reader.InitializeConnection();
}
List <GXValue> values = new List <GXValue>();
foreach (GXTask task in ret.Tasks)
{
GXDLMSObject obj = GXDLMSClient.CreateObject((ObjectType)task.Object.ObjectType);
obj.LogicalName = task.Object.LogicalName;
try
{
if (task.TaskType == TaskType.Write)
{
if (obj.LogicalName == "0.0.1.1.0.255" && task.Index == 2)
{
client.UpdateValue(obj, task.Index, GXDateTime.ToUnixTime(DateTime.UtcNow));
}
else
{
client.UpdateValue(obj, task.Index, GXDLMSTranslator.XmlToValue(task.Data));
}
reader.Write(obj, task.Index);
}
else if (task.TaskType == TaskType.Action)
{
reader.Method(obj, task.Index, GXDLMSTranslator.XmlToValue(task.Data), DataType.None);
}
else if (task.TaskType == TaskType.Read)
{
Reader.Reader.Read(null, httpClient, reader, task, media, obj);
}
}
catch (Exception ex)
{
task.Result = ex.Message;
AddError error = new AddError();
error.Error = new GXError()
{
DeviceId = dev.Id,
Error = "Failed to " + task.TaskType + " " + task.Object.LogicalName + ":" + task.Index + ". " + ex.Message
};
using (System.Net.Http.HttpResponseMessage response = httpClient.PostAsJsonAsync(Startup.ServerAddress + "/api/error/AddError", error).Result)
{
Helpers.CheckStatus(response);
response.Content.ReadAsAsync <AddErrorResponse>();
}
}
using (System.Net.Http.HttpResponseMessage response = httpClient.PostAsJsonAsync(Startup.ServerAddress + "/api/task/TaskReady", new TaskReady()
{
Tasks = new GXTask[] { task }
}).Result)
{
Helpers.CheckStatus(response);
}
}
}
}
}
}
catch (Exception ex)
{
try
{
AddSystemError info = new AddSystemError();
info.Error = new GXSystemError()
{
Error = ex.Message
};
using (System.Net.Http.HttpResponseMessage response = httpClient.PostAsJsonAsync(Startup.ServerAddress + "/api/SystemError/AddSystemError", info).Result)
{
Helpers.CheckStatus(response);
}
}
catch (Exception ex2)
{
}
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
}
void IGXDLMSBase.SetValue(GXDLMSSettings settings, ValueEventArgs e)
{
if (e.Index == 1)
{
LogicalName = GXCommon.ToLogicalName(e.Value);
}
else if (e.Index == 2)
{
Scripts.Clear();
//Fix Xemex bug here.
//Xemex meters do not return array as they shoul be according standard.
if (e.Value is IEnumerable <object> )
{
List <object> arr, arr1;
if (e.Value is List <object> )
{
arr1 = (List <object>)e.Value;
}
else
{
arr1 = new List <object>((object[])e.Value);
}
if (arr1.Count != 0 && arr1[0] is IEnumerable <object> )
{
foreach (object tmp in (IEnumerable <object>)e.Value)
{
List <object> item;
if (tmp is List <object> )
{
item = (List <object>)tmp;
}
else
{
item = new List <object>((object[])tmp);
}
GXDLMSScript script = new GXDLMSScript();
script.Id = Convert.ToInt32(item[0]);
Scripts.Add(script);
foreach (object tmp2 in (IEnumerable <object>)item[1])
{
if (tmp2 is List <object> )
{
arr = (List <object>)tmp2;
}
else
{
arr = new List <object>((object[])tmp2);
}
GXDLMSScriptAction it = new GXDLMSScriptAction();
it.Type = (ScriptActionType)Convert.ToInt32(arr[0]);
ObjectType ot = (ObjectType)Convert.ToInt32(arr[1]);
String ln = GXCommon.ToLogicalName(arr[2]);
it.Target = settings.Objects.FindByLN(ot, ln);
if (it.Target == null)
{
it.Target = GXDLMSClient.CreateObject(ot);
it.Target.LogicalName = ln;
}
it.Index = Convert.ToInt32(arr[3]);
it.Parameter = arr[4];
if (it.Parameter != null)
{
it.ParameterDataType = GXDLMSConverter.GetDLMSDataType(it.Parameter);
}
script.Actions.Add(it);
}
}
}
else //Read Xemex meter here.
{
GXDLMSScript script = new GXDLMSScript();
if (e.Value is List <object> )
{
arr1 = (List <object>)e.Value;
}
else
{
arr1 = new List <object>((object[])e.Value);
}
script.Id = Convert.ToInt32(arr1[0]);
Scripts.Add(script);
if (arr1[1] is List <object> )
{
arr = (List <object>)arr1[1];
}
else
{
arr = new List <object>((object[])arr1[1]);
}
GXDLMSScriptAction it = new GXDLMSScriptAction();
it.Type = (ScriptActionType)Convert.ToInt32(arr[0]);
ObjectType ot = (ObjectType)Convert.ToInt32(arr[1]);
String ln = GXCommon.ToLogicalName(arr[2]);
it.Target = settings.Objects.FindByLN(ot, ln);
if (it.Target == null)
{
#pragma warning disable CS0618
it.ObjectType = ot;
it.LogicalName = ln;
#pragma warning restore CS0618
}
it.Index = Convert.ToInt32(arr[3]);
it.Parameter = arr[4];
script.Actions.Add(it);
}
}
}
else
{
e.Error = ErrorCode.ReadWriteDenied;
}
}
void IGXDLMSBase.SetValue(GXDLMSSettings settings, ValueEventArgs e)
{
if (e.Index == 1)
{
LogicalName = GXCommon.ToLogicalName(e.Value);
}
else if (e.Index == 2)
{
SetBuffer(settings, e);
}
else if (e.Index == 3)
{
Reset();
//Clear file
if (e.Server != null)
{
ValueEventArgs[] list = new ValueEventArgs[] { new ValueEventArgs(this, 1, 0, null) };
e.Server.NotifyAction(list);
e.Server.NotifyPostAction(list);
}
CaptureObjects.Clear();
if (e.Value != null)
{
GetCaptureObjects(settings, CaptureObjects, e.Value as object[]);
}
}
else if (e.Index == 4)
{
//Any write access to one of the attributes will automatically call a reset
//and this call will propagate to all other profiles capturing this profile.
if (settings.IsServer)
{
Reset();
}
CapturePeriod = Convert.ToInt32(e.Value);
}
else if (e.Index == 5)
{
//Any write access to one of the attributes will automatically call a reset
//and this call will propagate to all other profiles capturing this profile.
if (settings.IsServer)
{
Reset();
}
SortMethod = (SortMethod)Convert.ToInt32(e.Value);
}
else if (e.Index == 6)
{
//Any write access to one of the attributes will automatically call a reset
//and this call will propagate to all other profiles capturing this profile.
if (settings.IsServer)
{
Reset();
}
if (e.Value is object[])
{
object[] tmp = e.Value as object[];
if (tmp.Length != 4)
{
throw new GXDLMSException("Invalid structure format.");
}
ObjectType type = (ObjectType)Convert.ToInt16(tmp[0]);
string ln = GXCommon.ToLogicalName((byte[])tmp[1]);
SortAttributeIndex = Convert.ToInt16(tmp[2]);
SortDataIndex = Convert.ToInt16(tmp[3]);
SortObject = null;
foreach (var it in CaptureObjects)
{
if (it.Key.ObjectType == type && it.Key.LogicalName == ln)
{
SortObject = it.Key;
break;
}
}
if (SortObject == null)
{
SortObject = GXDLMSClient.CreateObject(type);
SortObject.LogicalName = ln;
}
}
else
{
SortObject = null;
}
}
else if (e.Index == 7)
{
EntriesInUse = Convert.ToInt32(e.Value);
}
else if (e.Index == 8)
{
//Any write access to one of the attributes will automatically call a reset
//and this call will propagate to all other profiles capturing this profile.
if (settings.IsServer)
{
Reset();
}
ProfileEntries = Convert.ToInt32(e.Value);
}
else
{
e.Error = ErrorCode.ReadWriteDenied;
}
}
void IGXDLMSBase.SetValue(GXDLMSSettings settings, ValueEventArgs e)
{
if (e.Index == 1)
{
LogicalName = GXCommon.ToLogicalName(e.Value);
}
else if (e.Index == 2)
{
PushObjectList.Clear();
List <object> it;
if (e.Value != null)
{
foreach (object t in (IEnumerable <object>)e.Value)
{
if (t is List <object> )
{
it = (List <object>)t;
}
else
{
it = new List <object>((object[])t);
}
ObjectType type = (ObjectType)Convert.ToUInt16(it[0]);
String ln = GXCommon.ToLogicalName(it[1]);
GXDLMSObject obj = settings.Objects.FindByLN(type, ln);
if (obj == null)
{
obj = GXDLMSClient.CreateObject(type);
obj.LogicalName = ln;
}
GXDLMSCaptureObject co = new GXDLMSCaptureObject(Convert.ToInt32(it[2]), Convert.ToInt32(it[3]));
PushObjectList.Add(new KeyValuePair <GXDLMSObject, GXDLMSCaptureObject>(obj, co));
}
}
}
else if (e.Index == 3)
{
List <object> tmp = null;
if (e.Value is List <object> )
{
tmp = (List <object>)e.Value;
}
else
{
tmp = new List <object>((object[])e.Value);
}
if (tmp != null)
{
Service = (ServiceType)Convert.ToInt32(tmp[0]);
//LN can be used with HDLC
if (Service == ServiceType.Hdlc && ((byte[])tmp[1]).Length == 6 && ((byte[])tmp[1])[5] == 0xFF)
{
Destination = GXCommon.ToLogicalName((byte[])tmp[1]);
}
else
{
object str = GXDLMSClient.ChangeType((byte[])tmp[1], DataType.String, settings.UseUtc2NormalTime);
if (str is string)
{
Destination = (string)str;
}
else
{
Destination = GXCommon.ToHex((byte[])tmp[1], true);
}
}
Message = (MessageType)Convert.ToInt32(tmp[2]);
}
}
else if (e.Index == 4)
{
CommunicationWindow.Clear();
if (e.Value is List <object> )
{
foreach (List <object> it in e.Value as List <object> )
{
GXDateTime start = GXDLMSClient.ChangeType((byte[])it[0], DataType.DateTime, settings.UseUtc2NormalTime) as GXDateTime;
GXDateTime end = GXDLMSClient.ChangeType((byte[])it[1], DataType.DateTime, settings.UseUtc2NormalTime) as GXDateTime;
CommunicationWindow.Add(new KeyValuePair <GXDateTime, GXDateTime>(start, end));
}
}
}
else if (e.Index == 5)
{
RandomisationStartInterval = (UInt16)e.Value;
}
else if (e.Index == 6)
{
NumberOfRetries = (byte)e.Value;
}
else if (e.Index == 7)
{
RepetitionDelay = (UInt16)e.Value;
}
else
{
e.Error = ErrorCode.ReadWriteDenied;
}
}
private async void DoWork(object ínfo)
{
//Give some time DB server to start up.
Thread.Sleep(1000);
GetNextTaskResponse ret = null;
System.Net.Http.HttpResponseMessage response;
//Don't wait reply. It might that DB server is not up yet.
if (ínfo != null)
{
using (response = await client.PostAsJsonAsync(Startup.ServerAddress + "/api/reader/AddReader", new AddReader()
{
Reader = ínfo as GXReaderInfo
}))
{
Helpers.CheckStatus(response);
}
}
_logger.LogInformation("Reader Service is started.");
while (!_cancellationToken.IsCancellationRequested)
{
try
{
using (response = await client.PostAsJsonAsync(Startup.ServerAddress + "/api/task/GetNextTask", new GetNextTask()))
{
Helpers.CheckStatus(response);
ret = await response.Content.ReadAsAsync <GetNextTaskResponse>();
}
if (ret.Tasks != null)
{
int pos = 0;
GXDevice dev;
GXDLMSSecureClient cl;
using (response = await client.PostAsJsonAsync(Startup.ServerAddress + "/api/device/ListDevices", new ListDevices()
{
Ids = new[] { ret.Tasks[0].Object.DeviceId }
}))
{
Helpers.CheckStatus(response);
ListDevicesResponse r = await response.Content.ReadAsAsync <ListDevicesResponse>();
if (r.Devices == null || r.Devices.Length == 0)
{
continue;
}
dev = r.Devices[0];
}
IGXMedia media;
if (string.Compare(dev.MediaType, typeof(GXNet).FullName, true) == 0)
{
media = new GXNet();
}
else if (string.Compare(dev.MediaType, typeof(GXSerial).FullName, true) == 0)
{
media = new GXSerial();
}
else if (string.Compare(dev.MediaType, typeof(GXTerminal).FullName, true) == 0)
{
media = new GXTerminal();
}
else
{
Type type = Type.GetType(dev.MediaType);
if (type == null)
{
string ns = "";
pos = dev.MediaType.LastIndexOf('.');
if (pos != -1)
{
ns = dev.MediaType.Substring(0, pos);
}
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
{
if (assembly.GetName().Name == ns)
{
if (assembly.GetType(dev.MediaType, false, true) != null)
{
type = assembly.GetType(dev.MediaType);
}
}
}
}
if (type == null)
{
throw new Exception("Invalid media type: " + dev.MediaType);
}
media = (IGXMedia)Activator.CreateInstance(type);
}
if (media == null)
{
throw new Exception("Unknown media type '" + dev.MediaType + "'.");
}
media.Settings = dev.MediaSettings;
GXDLMSReader reader;
//Read frame counter from the meter.
if (dev.Security != 0)
{
cl = new GXDLMSSecureClient(dev.UseLogicalNameReferencing, 16, dev.PhysicalAddress,
Authentication.None, null, (InterfaceType)dev.InterfaceType);
reader = new GXDLMSReader(cl, media, _logger);
media.Open();
reader.InitializeConnection();
//Read Innovation counter.
GXDLMSData d = new GXDLMSData(dev.FrameCounter);
reader.Read(d, 2);
dev.InvocationCounter = 1 + Convert.ToUInt32(d.Value);
reader.Disconnect();
media.Close();
}
cl = new GXDLMSSecureClient(dev.UseLogicalNameReferencing, dev.ClientAddress, dev.PhysicalAddress,
(Authentication)dev.Authentication, dev.Password, (InterfaceType)dev.InterfaceType);
if (dev.HexPassword != null && dev.HexPassword.Length != 0)
{
cl.Password = dev.HexPassword;
}
cl.UseUtc2NormalTime = dev.UtcTimeZone;
cl.Standard = dev.Standard;
cl.Ciphering.SystemTitle = GXCommon.HexToBytes(dev.ClientSystemTitle);
if (cl.Ciphering.SystemTitle != null && cl.Ciphering.SystemTitle.Length == 0)
{
cl.Ciphering.SystemTitle = null;
}
cl.Ciphering.BlockCipherKey = GXCommon.HexToBytes(dev.BlockCipherKey);
if (cl.Ciphering.BlockCipherKey != null && cl.Ciphering.BlockCipherKey.Length == 0)
{
cl.Ciphering.BlockCipherKey = null;
}
cl.Ciphering.AuthenticationKey = GXCommon.HexToBytes(dev.AuthenticationKey);
if (cl.Ciphering.AuthenticationKey != null && cl.Ciphering.AuthenticationKey.Length == 0)
{
cl.Ciphering.AuthenticationKey = null;
}
cl.ServerSystemTitle = GXCommon.HexToBytes(dev.DeviceSystemTitle);
if (cl.ServerSystemTitle != null && cl.ServerSystemTitle.Length == 0)
{
cl.ServerSystemTitle = null;
}
cl.Ciphering.InvocationCounter = dev.InvocationCounter;
cl.Ciphering.Security = (Security)dev.Security;
reader = new GXDLMSReader(cl, media, _logger);
media.Open();
reader.InitializeConnection();
pos = 0;
int count = ret.Tasks.Length;
foreach (GXTask task in ret.Tasks)
{
++pos;
try
{
GXDLMSObject obj = GXDLMSClient.CreateObject((ObjectType)task.Object.ObjectType);
obj.LogicalName = task.Object.LogicalName;
obj.ShortName = task.Object.ShortName;
if (task.TaskType == TaskType.Write)
{
if (obj.LogicalName == "0.0.1.1.0.255" && task.Index == 2)
{
cl.UpdateValue(obj, task.Index, GXDateTime.ToUnixTime(DateTime.UtcNow));
}
else
{
cl.UpdateValue(obj, task.Index, GXDLMSTranslator.XmlToValue(task.Data));
}
reader.Write(obj, task.Index);
}
else if (task.TaskType == TaskType.Action)
{
reader.Method(obj, task.Index, GXDLMSTranslator.XmlToValue(task.Data), DataType.None);
}
else if (task.TaskType == TaskType.Read)
{
//Reading the meter.
if (task.Object.Attributes[0].DataType != 0)
{
obj.SetDataType(task.Index, (DataType)task.Object.Attributes[0].DataType);
}
if (task.Object.Attributes[0].UIDataType != 0)
{
obj.SetUIDataType(task.Index, (DataType)task.Object.Attributes[0].UIDataType);
}
Reader.Read(_logger, client, reader, task, media, obj);
if (task.Object.Attributes[0].DataType == 0)
{
task.Object.Attributes[0].DataType = (int)obj.GetDataType(task.Index);
if (task.Object.Attributes[0].UIDataType == 0)
{
task.Object.Attributes[0].UIDataType = (int)obj.GetUIDataType(task.Index);
}
UpdateDatatype u = new UpdateDatatype()
{
Items = new GXAttribute[] { task.Object.Attributes[0] }
};
response = client.PostAsJsonAsync(Startup.ServerAddress + "/api/Object/UpdateDatatype", u).Result;
Helpers.CheckStatus(response);
}
}
}
catch (Exception ex)
{
task.Result = ex.Message;
AddError error = new AddError();
error.Error = new GXError()
{
DeviceId = dev.Id,
Error = "Failed to " + task.TaskType + " " + task.Object.LogicalName + ":" + task.Index + ". " + ex.Message
};
_logger.LogError(error.Error.Error);
using (response = await client.PostAsJsonAsync(Startup.ServerAddress + "/api/error/AddError", error))
{
Helpers.CheckStatus(response);
await response.Content.ReadAsAsync <AddErrorResponse>();
}
}
task.End = DateTime.Now;
//Close connection after last task is executed.
//This must done because there might be new task to execute.
if (count == pos)
{
try
{
reader.Close();
}
catch (Exception ex)
{
task.Result = ex.Message;
AddError error = new AddError();
error.Error = new GXError()
{
DeviceId = dev.Id,
Error = "Failed to close the connection. " + ex.Message
};
_logger.LogError(error.Error.Error);
using (response = await client.PostAsJsonAsync(Startup.ServerAddress + "/api/error/AddError", error))
{
Helpers.CheckStatus(response);
await response.Content.ReadAsAsync <AddErrorResponse>();
}
}
}
//Update execution time.
response = client.PostAsJsonAsync(Startup.ServerAddress + "/api/task/TaskReady", new TaskReady()
{
Tasks = new GXTask[] { task }
}).Result;
Helpers.CheckStatus(response);
}
}
else
{
try
{
using (response = await client.PostAsJsonAsync(Startup.ServerAddress + "/api/task/WaitChange", new WaitChange()
{
Change = TargetType.Tasks, Time = lastUpdated, WaitTime = _waitTime
}))
{
Helpers.CheckStatus(response);
{
WaitChangeResponse r = await response.Content.ReadAsAsync <WaitChangeResponse>();
if (r.Time > lastUpdated)
{
lastUpdated = r.Time;
}
}
}
}
catch (Exception ex)
{
if (!_cancellationToken.IsCancellationRequested)
{
break;
}
_cancellationToken.WaitHandle.WaitOne(TimeSpan.FromSeconds(10));
}
}
}
catch (Exception ex)
{
//If app is closing.
if (_cancellationToken.IsCancellationRequested)
{
break;
}
if (ret == null)
{
_logger.LogError("Failed to connect to the DB server.");
}
else
{
AddError error = new AddError();
error.Error = new GXError()
{
DeviceId = ret.Tasks[0].Object.DeviceId,
Error = "Failed to " + ret.Tasks[0].TaskType + " " + ret.Tasks[0].Object.LogicalName + ":" + ret.Tasks[0].Index + ". " + ex.Message
};
using (response = await client.PostAsJsonAsync(Startup.ServerAddress + "/api/error/AddError", error))
{
if (ret.Tasks != null)
{
DateTime now = DateTime.Now;
foreach (GXTask it in ret.Tasks)
{
it.Result = ex.Message;
it.End = now;
}
response = await client.PostAsJsonAsync(Startup.ServerAddress + "/api/task/TaskReady", new TaskReady()
{
Tasks = ret.Tasks
});
}
}
}
_logger.LogError(ex.Message);
}
}
}
void UpdateData(DataTable dt)
{
if (target.CaptureObjects.Count == 0)
{
return;
}
if (structures)
{
List <object[]> data = new List <object[]>();
foreach (object[] r in target.Buffer)
{
List <object> row = new List <object>();
int index = 0;
foreach (var it in target.CaptureObjects)
{
//If COSEM object is selected.
//Only few meters are supporting this.
if (it.Value.AttributeIndex == 0 && r[index] is List <object> )
{
//Values must be update to the list because there might be Register Scaler
//and it expects that scaler is read before value is updated.
GXDLMSObject obj = GXDLMSClient.CreateObject(it.Key.ObjectType);
byte i2 = 1;
Dictionary <byte, object> list = new Dictionary <byte, object>();
foreach (object v in (r[index] as List <object>))
{
list.Add(i2, v);
++i2;
}
//Update values first.
foreach (byte i in (obj as IGXDLMSBase).GetAttributeIndexToRead(true))
{
ValueEventArgs ve = new ValueEventArgs(obj, i, 0, null);
ve.Value = list[i];
(obj as IGXDLMSBase).SetValue(null, ve);
}
//Show values.
for (byte i = 0; i != (obj as IGXDLMSBase).GetAttributeCount(); ++i)
{
row.Add(GetValue(obj.GetValues()[i]));
}
}
else
{
row.Add(GetValue(r[index]));
}
++index;
}
data.Add(row.ToArray());
}
for (int pos = dt.Rows.Count; pos < data.Count; ++pos)
{
object[] row = data[pos];
dt.LoadDataRow(row, true);
}
}
else
{
for (int pos = dt.Rows.Count; pos < target.Buffer.Count; ++pos)
{
object[] row = target.Buffer[pos];
if (row != null)
{
for (int col = 0; col != row.Length; ++col)
{
if (row[col] is GXDateTime)
{
if (GXDlmsUi.UseMeterTimeZone)
{
row[col] = (row[col] as GXDateTime).ToFormatMeterString();
}
else
{
row[col] = (row[col] as GXDateTime).ToFormatString();
}
}
else if (row[col] is byte[])
{
row[col] = GXDLMSTranslator.ToHex((byte[])row[col], true);
}
else if (row[col] is Object[])
{
row[col] = GXDLMSTranslator.ValueToXml(row[col]);
}
else if (row[col] is GXStructure || row[col] is GXArray)
{
if (target.CaptureObjects[col].Key is GXDLMSRegister && target.CaptureObjects[col].Value.AttributeIndex == 2)
{
GXDLMSRegister obj = new GXDLMSRegister();
ValueEventArgs ve = new ValueEventArgs(obj, target.CaptureObjects[col].Value.AttributeIndex, 0, null);
ve.Value = row[col];
(obj as IGXDLMSBase).SetValue(null, ve);
row[col] = "{" + obj.Scaler + ", " + obj.Unit + "}";
}
else
{
StringBuilder sb = new StringBuilder();
GetArrayAsString(sb, row[col]);
row[col] = sb.ToString();
}
}
else
{
GXDLMSAttributeSettings att = target.CaptureObjects[col].Key.Attributes.Find(target.CaptureObjects[col].Value.AttributeIndex);
if (att != null && att.Values != null)
{
if (att.Type == DataType.BitString && row[col] is string)
{
string str = (string)row[col];
if (str.Length != 0 && (str[0] == '0' || str[0] == '1'))
{
StringBuilder sb = new StringBuilder();
int pos2 = 0;
foreach (char it in str)
{
if (it == '1')
{
if (sb.Length != 0)
{
sb.Append(',');
}
sb.Append(att.Values[pos2].UIValue);
}
++pos2;
if (pos2 == att.Values.Count)
{
break;
}
}
row[col] = sb.ToString();
}
}
else
{
foreach (GXObisValueItem it in att.Values)
{
if (IsNumber(row[col]) && it.Value == Convert.ToInt32(row[col]))
{
row[col] = it.UIValue;
break;
}
}
}
}
}
}
dt.LoadDataRow(row, true);
}
}
}
}
void IGXDLMSBase.SetValue(GXDLMSSettings settings, ValueEventArgs e)
{
switch (e.Index)
{
case 1:
LogicalName = GXCommon.ToLogicalName(e.Value);
break;
case 2:
{
ChangedParameter = new GXDLMSTarget();
if (e.Value is List <object> )
{
List <object> tmp = (List <object>)e.Value;
if (tmp.Count != 4)
{
throw new GXDLMSException("Invalid structure format.");
}
ObjectType type = (ObjectType)Convert.ToInt16(tmp[0]);
ChangedParameter.Target = settings.Objects.FindByLN(type, (byte[])tmp[1]);
if (ChangedParameter.Target == null)
{
ChangedParameter.Target = GXDLMSClient.CreateObject(type);
ChangedParameter.Target.LogicalName = GXCommon.ToLogicalName((byte[])tmp[1]);
}
ChangedParameter.AttributeIndex = Convert.ToByte(tmp[2]);
ChangedParameter.Value = tmp[3];
}
break;
}
case 3:
{
if (e.Value == null)
{
CaptureTime = new GXDateTime(DateTime.MinValue);
}
else
{
if (e.Value is byte[])
{
e.Value = GXDLMSClient.ChangeType((byte[])e.Value, DataType.DateTime, settings.UseUtc2NormalTime);
}
else if (e.Value is string)
{
e.Value = new GXDateTime((string)e.Value);
}
if (e.Value is GXDateTime)
{
CaptureTime = (GXDateTime)e.Value;
}
else if (e.Value is String)
{
DateTime tm;
if (!DateTime.TryParse((String)e.Value, out tm))
{
CaptureTime = DateTime.ParseExact((String)e.Value, CultureInfo.CurrentCulture.DateTimeFormat.ShortDatePattern + " " + CultureInfo.CurrentCulture.DateTimeFormat.LongTimePattern, CultureInfo.CurrentUICulture);
}
else
{
CaptureTime = tm;
}
}
else
{
CaptureTime = Convert.ToDateTime(e.Value);
}
}
break;
}
case 4:
{
Parameters.Clear();
if (e.Value != null)
{
foreach (List <object> tmp in (e.Value as List <object>))
{
if (tmp.Count != 3)
{
throw new GXDLMSException("Invalid structure format.");
}
GXDLMSTarget obj = new GXDLMSTarget();
ObjectType type = (ObjectType)Convert.ToInt16(tmp[0]);
obj.Target = settings.Objects.FindByLN(type, (byte[])tmp[1]);
if (obj.Target == null)
{
obj.Target = GXDLMSClient.CreateObject(type);
obj.Target.LogicalName = GXCommon.ToLogicalName((byte[])tmp[1]);
}
obj.AttributeIndex = Convert.ToByte(tmp[2]);
Parameters.Add(obj);
}
}
break;
}
default:
e.Error = ErrorCode.ReadWriteDenied;
break;
}
}
void IGXDLMSBase.SetValue(GXDLMSSettings settings, ValueEventArgs e)
{
if (e.Index == 1)
{
if (e.Value is string)
{
LogicalName = e.Value.ToString();
}
else
{
LogicalName = GXDLMSClient.ChangeType((byte[])e.Value, DataType.OctetString, settings.UseUtc2NormalTime).ToString();
}
}
else if (e.Index == 2)
{
SetBuffer(settings, e);
}
else if (e.Index == 3)
{
Reset();
CaptureObjects.Clear();
GXDLMSObjectCollection objects = new GXDLMSObjectCollection();
if (e.Value != null)
{
foreach (object it in e.Value as object[])
{
object[] tmp = it as object[];
if (tmp.Length != 4)
{
throw new GXDLMSException("Invalid structure format.");
}
ObjectType type = (ObjectType)Convert.ToInt16(tmp[0]);
string ln = GXDLMSObject.ToLogicalName((byte[])tmp[1]);
int attributeIndex = Convert.ToInt16(tmp[2]);
int dataIndex = Convert.ToInt16(tmp[3]);
GXDLMSObject obj = null;
if (settings != null && settings.Objects != null)
{
obj = settings.Objects.FindByLN(type, ln);
}
if (obj == null)
{
obj = GXDLMSClient.CreateDLMSObject((int)type, null, 0, ln, 0);
}
CaptureObjects.Add(new GXKeyValuePair <GXDLMSObject, GXDLMSCaptureObject>(obj, new GXDLMSCaptureObject(attributeIndex, dataIndex)));
objects.Add(obj);
}
}
}
else if (e.Index == 4)
{
//Any write access to one of the attributes will automatically call a reset
//and this call will propagate to all other profiles capturing this profile.
if (settings.IsServer)
{
Reset();
}
CapturePeriod = Convert.ToInt32(e.Value);
}
else if (e.Index == 5)
{
//Any write access to one of the attributes will automatically call a reset
//and this call will propagate to all other profiles capturing this profile.
if (settings.IsServer)
{
Reset();
}
SortMethod = (SortMethod)Convert.ToInt32(e.Value);
}
else if (e.Index == 6)
{
//Any write access to one of the attributes will automatically call a reset
//and this call will propagate to all other profiles capturing this profile.
if (settings.IsServer)
{
Reset();
}
if (e.Value != null)
{
object[] tmp = e.Value as object[];
if (tmp.Length != 4)
{
throw new GXDLMSException("Invalid structure format.");
}
ObjectType type = (ObjectType)Convert.ToInt16(tmp[0]);
string ln = GXDLMSObject.ToLogicalName((byte[])tmp[1]);
SortAttributeIndex = Convert.ToInt16(tmp[2]);
SortDataIndex = Convert.ToInt16(tmp[3]);
SortObject = null;
foreach (var it in CaptureObjects)
{
if (it.Key.ObjectType == type && it.Key.LogicalName == ln)
{
SortObject = it.Key;
break;
}
}
if (SortObject == null)
{
SortObject = GXDLMSClient.CreateObject(type);
SortObject.LogicalName = ln;
}
}
else
{
SortObject = null;
}
}
else if (e.Index == 7)
{
EntriesInUse = Convert.ToInt32(e.Value);
}
else if (e.Index == 8)
{
//Any write access to one of the attributes will automatically call a reset
//and this call will propagate to all other profiles capturing this profile.
if (settings.IsServer)
{
Reset();
}
ProfileEntries = Convert.ToInt32(e.Value);
}
else
{
e.Error = ErrorCode.ReadWriteDenied;
}
}
private void SetUnitCharge(GXUnitCharge charge, object value)
{
if (value != null)
{
List <object> tmp, tmp2, it;
if (value is List <object> )
{
tmp = (List <object>)value;
}
else
{
tmp = new List <object>((object[])value);
}
if (tmp[0] is List <object> )
{
tmp2 = (List <object>)tmp[0];
}
else
{
tmp2 = new List <object>((object[])tmp[0]);
}
charge.ChargePerUnitScaling.CommodityScale = (sbyte)tmp2[0];
charge.ChargePerUnitScaling.PriceScale = (sbyte)tmp2[1];
if (tmp[1] is List <object> )
{
tmp2 = (List <object>)tmp[1];
}
else
{
tmp2 = new List <object>((object[])tmp[1]);
}
ObjectType ot = (ObjectType)Convert.ToInt32(tmp2[0]);
string ln = GXCommon.ToLogicalName(tmp2[1]);
if (ot != ObjectType.None)
{
if (Parent != null)
{
charge.Commodity.Target = Parent.FindByLN(ot, ln);
}
else
{
charge.Commodity.Target = GXDLMSClient.CreateObject(ot);
charge.Commodity.Target.LogicalName = ln;
}
}
else
{
charge.Commodity.Target = null;
}
charge.Commodity.Index = (sbyte)tmp2[2];
List <GXChargeTable> list = new List <GXChargeTable>();
foreach (object tmp3 in (IEnumerable <object>)tmp[2])
{
if (tmp3 is List <object> )
{
it = (List <object>)tmp3;
}
else
{
it = new List <object>((object[])tmp3);
}
GXChargeTable item = new GXChargeTable();
item.Index = ASCIIEncoding.ASCII.GetString((byte[])it[0]);
item.ChargePerUnit = (Int16)it[1];
list.Add(item);
}
charge.ChargeTables = list.ToArray();
}
else
{
charge.ChargePerUnitScaling.CommodityScale = 0;
charge.ChargePerUnitScaling.PriceScale = 0;
charge.Commodity.Target = null;
charge.Commodity.Index = 0;
charge.ChargeTables = new GXChargeTable[0];
}
}
void IGXDLMSBase.SetValue(GXDLMSSettings settings, ValueEventArgs e)
{
if (e.Index == 1)
{
if (e.Value is string)
{
LogicalName = e.Value.ToString();
}
else
{
LogicalName = GXDLMSClient.ChangeType((byte[])e.Value, DataType.OctetString, settings.UseUtc2NormalTime).ToString();
}
}
else if (e.Index == 2)
{
PushObjectList.Clear();
if (e.Value is Object[])
{
foreach (object it in e.Value as Object[])
{
Object[] tmp = it as Object[];
ObjectType type = (ObjectType)Convert.ToUInt16(tmp[0]);
String ln = GXDLMSClient.ChangeType((byte[])tmp[1], DataType.OctetString, settings.UseUtc2NormalTime).ToString();
GXDLMSObject obj = settings.Objects.FindByLN(type, ln);
if (obj == null)
{
obj = GXDLMSClient.CreateObject(type);
obj.LogicalName = ln;
}
GXDLMSCaptureObject co = new GXDLMSCaptureObject(Convert.ToInt32(tmp[2]), Convert.ToInt32(tmp[3]));
PushObjectList.Add(new KeyValuePair <GXDLMSObject, GXDLMSCaptureObject>(obj, co));
}
}
}
else if (e.Index == 3)
{
object[] tmp = e.Value as object[];
if (tmp != null)
{
Service = (ServiceType)Convert.ToInt32(tmp[0]);
Destination = (string)GXDLMSClient.ChangeType((byte[])tmp[1], DataType.String, settings.UseUtc2NormalTime);
Message = (MessageType)Convert.ToInt32(tmp[2]);
}
}
else if (e.Index == 4)
{
CommunicationWindow.Clear();
if (e.Value is Object[])
{
foreach (object it in e.Value as Object[])
{
Object[] tmp = it as Object[];
GXDateTime start = GXDLMSClient.ChangeType((byte[])tmp[0], DataType.DateTime, settings.UseUtc2NormalTime) as GXDateTime;
GXDateTime end = GXDLMSClient.ChangeType((byte[])tmp[1], DataType.DateTime, settings.UseUtc2NormalTime) as GXDateTime;
CommunicationWindow.Add(new KeyValuePair <GXDateTime, GXDateTime>(start, end));
}
}
}
else if (e.Index == 5)
{
RandomisationStartInterval = (UInt16)e.Value;
}
else if (e.Index == 6)
{
NumberOfRetries = (byte)e.Value;
}
else if (e.Index == 7)
{
RepetitionDelay = (UInt16)e.Value;
}
else
{
e.Error = ErrorCode.ReadWriteDenied;
}
}
public void OnValueChanged(int index, object value, bool user, bool connected)
{
GXDLMSRegisterMonitor target = Target as GXDLMSRegisterMonitor;
if (index == 2)
{
}
else if (index == 3)
{
this.MonitoredValueCb.SelectedIndexChanged -= new System.EventHandler(this.MonitoredValueCb_SelectedIndexChanged);
try
{
MonitoredValueCb.Items.Clear();
if (target.Parent != null)
{
foreach (GXDLMSObject it in target.Parent.GetObjects(
new ObjectType[] { ObjectType.Data, ObjectType.Register, ObjectType.ExtendedRegister, ObjectType.DemandRegister }))
{
MonitoredValueCb.Items.Add(it);
}
}
else if (target.MonitoredValue != null && target.MonitoredValue.ObjectType != ObjectType.None)
{
GXDLMSRegister it = new GXDLMSRegister(target.MonitoredValue.LogicalName);
MonitoredValueCb.Items.Add(it);
}
if (target.MonitoredValue != null && target.MonitoredValue.ObjectType != ObjectType.None)
{
if (target.Parent != null)
{
MonitoredValueCb.SelectedItem = target.Parent.FindByLN(target.MonitoredValue.ObjectType, target.MonitoredValue.LogicalName);
}
else
{
GXDLMSObject it = GXDLMSClient.CreateObject(target.MonitoredValue.ObjectType);
it.LogicalName = target.MonitoredValue.LogicalName;
MonitoredValueCb.SelectedItem = it;
}
AttributeIndexTB.Text = target.MonitoredValue.AttributeIndex.ToString();
}
else
{
MonitoredValueCb.SelectedItem = null;
AttributeIndexTB.Text = "";
}
}
finally
{
this.MonitoredValueCb.SelectedIndexChanged += new System.EventHandler(this.MonitoredValueCb_SelectedIndexChanged);
}
}
else if (index == 4)
{
ActionsLV.Items.Clear();
if (target.Actions != null)
{
int pos = 0;
foreach (GXDLMSActionSet it in target.Actions)
{
string threshold = "";
if (target.Thresholds != null && target.Thresholds.Length > pos)
{
threshold = Convert.ToString(target.Thresholds[pos]);
}
++pos;
ListViewItem li = ActionsLV.Items.Add(threshold);
li.SubItems.AddRange(new string[] { it.ActionUp.LogicalName, it.ActionUp.ScriptSelector.ToString(),
it.ActionDown.LogicalName, it.ActionDown.ScriptSelector.ToString() });
}
//Add extra Thresholds.
if (target.Thresholds != null && pos < target.Thresholds.Length)
{
for (; pos != target.Thresholds.Length; ++pos)
{
string threshold = Convert.ToString(target.Thresholds[pos]);
ListViewItem li = ActionsLV.Items.Add(threshold);
li.SubItems.AddRange(new string[] { "", "",
"", "" });
}
}
}
}
}
/// <summary>
/// Load COSEM objects from the file.
/// </summary>
/// <param name="stream">Stream.</param>
/// <param name="objects">Collection of COSEM objects.</param>
public static void Load(Stream stream, GXDLMSObjectCollection objects)
{
GXDLMSObject obj = null;
String target;
ObjectType type;
using (GXXmlReader reader = new GXXmlReader(stream))
{
reader.Objects = objects;
while (!reader.EOF)
{
if (reader.IsStartElement())
{
target = reader.Name;
if (string.Compare("Objects", target, true) == 0)
{
//Skip.
reader.Read();
}
else if (target.StartsWith("GXDLMS"))
{
string str = target.Substring(6);
reader.Read();
type = (ObjectType)Enum.Parse(typeof(ObjectType), str);
obj = GXDLMSClient.CreateObject(type);
obj.Version = 0;
}
else if (string.Compare("Object", target, true) == 0)
{
int r = 0;
string str = reader.GetAttribute(0);
if (int.TryParse(str, out r))
{
type = (ObjectType)r;
}
else
{
type = (ObjectType)Enum.Parse(typeof(ObjectType), str);
}
reader.Read();
obj = GXDLMSClient.CreateObject(type);
obj.Version = 0;
reader.Objects.Add(obj);
}
else if (string.Compare("SN", target, true) == 0)
{
obj.ShortName = (UInt16)reader.ReadElementContentAsInt("SN");
}
else if (string.Compare("LN", target, true) == 0)
{
obj.LogicalName = reader.ReadElementContentAsString("LN");
GXDLMSObject tmp = reader.Objects.FindByLN(obj.ObjectType, obj.LogicalName);
if (tmp == null)
{
reader.Objects.Add(obj);
}
else
{
obj = tmp;
}
}
else if (string.Compare("Description", target, true) == 0)
{
obj.Description = reader.ReadElementContentAsString("Description");
}
else if (string.Compare("Version", target, true) == 0)
{
obj.Version = (UInt16)reader.ReadElementContentAsInt("Version");
}
else if (string.Compare("Access", target, true) == 0)
{
int pos = 0;
foreach (byte it in reader.ReadElementContentAsString("Access"))
{
++pos;
obj.SetAccess(pos, (AccessMode)(it - 0x30));
}
}
else if (string.Compare("MethodAccess", target, true) == 0)
{
int pos = 0;
foreach (byte it in reader.ReadElementContentAsString("MethodAccess"))
{
++pos;
obj.SetMethodAccess(pos, (MethodAccessMode)(it - 0x30));
}
}
else
{
(obj as IGXDLMSBase).Load(reader);
obj = null;
}
}
else
{
reader.Read();
}
}
foreach (GXDLMSObject it in reader.Objects)
{
(it as IGXDLMSBase).PostLoad(reader);
}
}
}