void IGXDLMSBase.Load(GXXmlReader reader)
{
SapAssignmentList.Clear();
if (reader.IsStartElement("SapAssignmentList", true))
{
while (reader.IsStartElement("Item", true))
{
UInt16 sap = (UInt16)reader.ReadElementContentAsInt("SAP");
string ldn = reader.ReadElementContentAsString("LDN");
SapAssignmentList.Add(new KeyValuePair <UInt16, string>(sap, ldn));
}
reader.ReadEndElement("SapAssignmentList");
}
}
private void LoadKeyTable(GXXmlReader reader)
{
KeyTable.Clear();
if (reader.IsStartElement("KeyTable", true))
{
while (reader.IsStartElement("Item", true))
{
byte k = (byte)reader.ReadElementContentAsInt("Key");
byte[] d = GXDLMSTranslator.HexToBytes(reader.ReadElementContentAsString("Data"));
KeyTable.Add(new GXKeyValuePair <byte, byte[]>(k, d));
}
reader.ReadEndElement("KeyTable");
}
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
Entries.Clear();
if (reader.IsStartElement("Entries", true))
{
while (reader.IsStartElement("Item", true))
{
GXScheduleEntry it = new GXScheduleEntry();
it.Index = (byte)reader.ReadElementContentAsInt("Index");
it.Enable = reader.ReadElementContentAsInt("Enable") != 0;
it.LogicalName = reader.ReadElementContentAsString("LogicalName");
it.ScriptSelector = (byte)reader.ReadElementContentAsInt("ScriptSelector");
it.SwitchTime = (GXDateTime)reader.ReadElementContentAsObject("SwitchTime", new GXDateTime(), null, 0);
it.ValidityWindow = (byte)reader.ReadElementContentAsInt("ValidityWindow");
it.ExecWeekdays = reader.ReadElementContentAsString("ExecWeekdays");
it.ExecSpecDays = reader.ReadElementContentAsString("ExecSpecDays");
it.BeginDate = (GXDateTime)reader.ReadElementContentAsObject("BeginDate", new GXDateTime(), null, 0);
it.EndDate = (GXDateTime)reader.ReadElementContentAsObject("EndDate", new GXDateTime(), null, 0);
Entries.Add(it);
}
reader.ReadEndElement("Entries");
}
}
private void LoadGroupTable(GXXmlReader reader)
{
List <ushort> list = new List <ushort>();
if (reader.IsStartElement("GroupTable", true))
{
while (reader.IsStartElement("Value", false))
{
list.Add((ushort)reader.ReadElementContentAsInt("Value"));
}
reader.ReadEndElement("GroupTable");
}
GroupTable = list.ToArray();
}
private Int16[] LoadSwitchTable(GXXmlReader reader)
{
List <Int16> list = new List <Int16>();
if (reader.IsStartElement("SwitchTable", true))
{
while (reader.IsStartElement("Item", false))
{
list.Add((Int16)reader.ReadElementContentAsInt("Item"));
}
reader.ReadEndElement("SwitchTable");
}
return(list.ToArray());
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
if (string.Compare("Time", reader.Name, true) == 0)
{
Time = new GXDateTime(reader.ReadElementContentAsString("Time"), CultureInfo.InvariantCulture);
}
TimeZone = reader.ReadElementContentAsInt("TimeZone");
Status = (ClockStatus)reader.ReadElementContentAsInt("Status");
string str = reader.ReadElementContentAsString("Begin");
if (str != null)
{
Begin = new GXDateTime(str, CultureInfo.InvariantCulture);
}
str = reader.ReadElementContentAsString("End");
if (str != null)
{
End = new GXDateTime(str, CultureInfo.InvariantCulture);
}
Deviation = reader.ReadElementContentAsInt("Deviation");
Enabled = reader.ReadElementContentAsInt("Enabled") != 0;
ClockBase = (ClockBase)reader.ReadElementContentAsInt("ClockBase");
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
DataLinkLayerReference = reader.ReadElementContentAsString("DataLinkLayerReference");
IPAddress = reader.ReadElementContentAsString("IPAddress");
List <UInt32> list = new List <UInt32>();
if (reader.IsStartElement("MulticastIPAddress", true))
{
while (reader.IsStartElement("Value", false))
{
list.Add((UInt32)reader.ReadElementContentAsInt("Value"));
}
reader.ReadEndElement("MulticastIPAddress");
}
MulticastIPAddress = list.ToArray();
List <GXDLMSIp4SetupIpOption> ipOptions = new List <GXDLMSIp4SetupIpOption>();
if (reader.IsStartElement("IPOptions", true))
{
while (reader.IsStartElement("IPOptions", true))
{
GXDLMSIp4SetupIpOption it = new GXDLMSIp4SetupIpOption();
it.Type = (Ip4SetupIpOptionType)reader.ReadElementContentAsInt("Type");
it.Length = (byte)reader.ReadElementContentAsInt("Length");
it.Data = GXDLMSTranslator.HexToBytes(reader.ReadElementContentAsString("Data"));
ipOptions.Add(it);
}
reader.ReadEndElement("IPOptions");
}
IPOptions = ipOptions.ToArray();
SubnetMask = reader.ReadElementContentAsULong("SubnetMask");
GatewayIPAddress = reader.ReadElementContentAsULong("GatewayIPAddress");
UseDHCP = reader.ReadElementContentAsInt("UseDHCP") != 0;
PrimaryDNSAddress = reader.ReadElementContentAsULong("PrimaryDNSAddress");
SecondaryDNSAddress = reader.ReadElementContentAsULong("SecondaryDNSAddress");
}
private static void LoadTokenGatewayConfigurations(GXXmlReader reader, List <GXTokenGatewayConfiguration> list)
{
list.Clear();
if (reader.IsStartElement("TokenGatewayConfigurations", true))
{
while (reader.IsStartElement("Item", true))
{
GXTokenGatewayConfiguration it = new GXTokenGatewayConfiguration();
it.CreditReference = reader.ReadElementContentAsString("Credit");
it.TokenProportion = (byte)reader.ReadElementContentAsInt("Token");
list.Add(it);
}
reader.ReadEndElement("TokenGatewayConfigurations");
}
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
PHYReference = reader.ReadElementContentAsString("PHYReference");
List <GXDLMSPppSetupLcpOption> options = new List <GXDLMSPppSetupLcpOption>();
if (reader.IsStartElement("LCPOptions", true))
{
while (reader.IsStartElement("Item", true))
{
GXDLMSPppSetupLcpOption it = new GXDLMSPppSetupLcpOption();
it.Type = (PppSetupLcpOptionType)reader.ReadElementContentAsInt("Type");
it.Length = (byte)reader.ReadElementContentAsInt("Length");
it.Data = reader.ReadElementContentAsObject("Data", null);
}
reader.ReadEndElement("LCPOptions");
}
LCPOptions = options.ToArray();
List <GXDLMSPppSetupIPCPOption> list = new List <GXDLMSPppSetupIPCPOption>();
if (reader.IsStartElement("IPCPOptions", true))
{
while (reader.IsStartElement("Item", true))
{
GXDLMSPppSetupIPCPOption it = new GXDLMSPppSetupIPCPOption();
it.Type = (PppSetupIPCPOptionType)reader.ReadElementContentAsInt("Type");
it.Length = (byte)reader.ReadElementContentAsInt("Length");
it.Data = reader.ReadElementContentAsObject("Data", null);
}
reader.ReadEndElement("IPCPOptions");
}
IPCPOptions = list.ToArray();
UserName = GXDLMSTranslator.HexToBytes(reader.ReadElementContentAsString("UserName"));
Password = GXDLMSTranslator.HexToBytes(reader.ReadElementContentAsString("Password"));
}
private static void LoadCreditChargeConfigurations(GXXmlReader reader, List <GXCreditChargeConfiguration> list)
{
list.Clear();
if (reader.IsStartElement("CreditChargeConfigurations", true))
{
while (reader.IsStartElement("Item", true))
{
GXCreditChargeConfiguration it = new GXCreditChargeConfiguration();
it.CreditReference = reader.ReadElementContentAsString("Credit");
it.ChargeReference = reader.ReadElementContentAsString("Charge");
it.CollectionConfiguration = (CreditCollectionConfiguration)reader.ReadElementContentAsInt("Configuration");
list.Add(it);
}
reader.ReadEndElement("CreditChargeConfigurations");
}
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
Unit = (Unit)reader.ReadElementContentAsInt("Unit", 0);
Scaler = reader.ReadElementContentAsDouble("Scaler", 1);
Value = reader.ReadElementContentAsObject("Value", null, this, 2);
Status = reader.ReadElementContentAsObject("Status", null, this, 4);
GXDateTime dt = reader.ReadElementContentAsDateTime("CaptureTime");
if (dt == null)
{
CaptureTime = DateTime.MinValue;
}
else
{
CaptureTime = dt.Value.ToLocalTime().LocalDateTime;
}
}
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");
}
private GXMacPhyCommunication[] LoadCommunications(GXXmlReader reader)
{
List <GXMacPhyCommunication> list = new List <GXMacPhyCommunication>();
if (reader.IsStartElement("Communications", true))
{
while (reader.IsStartElement("Item", true))
{
GXMacPhyCommunication it = new GXMacPhyCommunication();
list.Add(it);
it.Eui = GXCommon.HexToBytes(reader.ReadElementContentAsString("Eui"));
it.TxPower = (sbyte)reader.ReadElementContentAsInt("TxPower");
it.TxCoding = (sbyte)reader.ReadElementContentAsInt("TxCoding");
it.RxCoding = (sbyte)reader.ReadElementContentAsInt("RxCoding");
it.RxLvl = (sbyte)reader.ReadElementContentAsInt("RxLvl");
it.Snr = (sbyte)reader.ReadElementContentAsInt("Snr");
it.TxPowerModified = (sbyte)reader.ReadElementContentAsInt("TxPowerModified");
it.TxCodingModified = (sbyte)reader.ReadElementContentAsInt("TxCodingModified");
it.RxCodingModified = (sbyte)reader.ReadElementContentAsInt("RxCodingModified");
}
reader.ReadEndElement("Communications");
}
return(list.ToArray());
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
TotalAmountPaid = reader.ReadElementContentAsInt("TotalAmountPaid");
ChargeType = (ChargeType)reader.ReadElementContentAsInt("ChargeType");
Priority = (byte)reader.ReadElementContentAsInt("Priority");
LoadUnitChargeActive(reader, "UnitChargeActive", UnitChargeActive);
LoadUnitChargeActive(reader, "UnitChargePassive", UnitChargePassive);
string tmp = reader.ReadElementContentAsString("UnitChargeActivationTime");
if (tmp != null)
{
UnitChargeActivationTime = new GXDateTime(tmp, System.Globalization.CultureInfo.InvariantCulture);
}
Period = (UInt16)reader.ReadElementContentAsInt("Period");
ChargeConfiguration = (ChargeConfiguration)reader.ReadElementContentAsInt("ChargeConfiguration");
tmp = reader.ReadElementContentAsString("LastCollectionTime");
if (tmp != null)
{
LastCollectionTime = new GXDateTime(tmp, System.Globalization.CultureInfo.InvariantCulture);
}
LastCollectionAmount = reader.ReadElementContentAsInt("LastCollectionAmount");
TotalAmountRemaining = reader.ReadElementContentAsInt("TotalAmountRemaining");
Proportion = (UInt16)reader.ReadElementContentAsInt("Proportion");
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
MBusPortReference = reader.ReadElementContentAsString("MBusPortReference");
CaptureDefinition.Clear();
if (reader.IsStartElement("CaptureDefinition", true))
{
while (reader.IsStartElement("Item", true))
{
string d = reader.ReadElementContentAsString("Data");
string v = reader.ReadElementContentAsString("Value");
CaptureDefinition.Add(new KeyValuePair <string, string>(d, v));
}
reader.ReadEndElement("CaptureDefinition");
}
CapturePeriod = (UInt16)reader.ReadElementContentAsInt("CapturePeriod");
PrimaryAddress = reader.ReadElementContentAsInt("PrimaryAddress");
IdentificationNumber = (UInt16)reader.ReadElementContentAsInt("IdentificationNumber");
ManufacturerID = (UInt16)reader.ReadElementContentAsInt("ManufacturerID");
DataHeaderVersion = reader.ReadElementContentAsInt("DataHeaderVersion");
DeviceType = reader.ReadElementContentAsInt("DeviceType");
AccessNumber = reader.ReadElementContentAsInt("AccessNumber");
}
private void LoadRoutingTable(GXXmlReader reader)
{
RoutingTable.Clear();
if (reader.IsStartElement("RoutingTable", true))
{
while (reader.IsStartElement("Item", false))
{
GXDLMSRoutingTable it = new GXDLMSRoutingTable();
RoutingTable.Add(it);
it.DestinationAddress = (UInt16)reader.ReadElementContentAsInt("DestinationAddress");
it.NextHopAddress = (UInt16)reader.ReadElementContentAsInt("NextHopAddress");
it.RouteCost = (UInt16)reader.ReadElementContentAsInt("RouteCost");
it.HopCount = (byte)reader.ReadElementContentAsInt("HopCount");
it.WeakLinkCount = (byte)reader.ReadElementContentAsInt("WeakLinkCount");
it.ValidTime = (UInt16)reader.ReadElementContentAsInt("ValidTime");
}
reader.ReadEndElement("RoutingTable");
}
}
private static GXDLMSWeekProfile[] LoadWeekProfileTable(GXXmlReader reader, string name)
{
List <GXDLMSWeekProfile> list = new List <GXDLMSWeekProfile>();
if (reader.IsStartElement(name, true))
{
while (reader.IsStartElement("Item", true))
{
GXDLMSWeekProfile it = new GXDLMSWeekProfile();
it.Name = GXDLMSTranslator.HexToBytes(reader.ReadElementContentAsString("Name"));
it.Monday = reader.ReadElementContentAsInt("Monday");
it.Tuesday = reader.ReadElementContentAsInt("Tuesday");
it.Wednesday = reader.ReadElementContentAsInt("Wednesday");
it.Thursday = reader.ReadElementContentAsInt("Thursday");
it.Friday = reader.ReadElementContentAsInt("Friday");
it.Saturday = reader.ReadElementContentAsInt("Saturday");
it.Sunday = reader.ReadElementContentAsInt("Sunday");
list.Add(it);
}
reader.ReadEndElement(name);
}
return(list.ToArray());
}
private GXMacDirectTable[] LoadDirectTable(GXXmlReader reader)
{
List <GXMacDirectTable> list = new List <GXMacDirectTable>();
if (reader.IsStartElement("DirectTable", true))
{
while (reader.IsStartElement("Item", true))
{
GXMacDirectTable it = new GXMacDirectTable();
list.Add(it);
it.SourceSId = (Int16)reader.ReadElementContentAsInt("SourceSId");
it.SourceLnId = (Int16)reader.ReadElementContentAsInt("SourceLnId");
it.SourceLcId = (Int16)reader.ReadElementContentAsInt("SourceLcId");
it.DestinationSId = (Int16)reader.ReadElementContentAsInt("DestinationSId");
it.DestinationLnId = (Int16)reader.ReadElementContentAsInt("DestinationLnId");
it.DestinationLcId = (Int16)reader.ReadElementContentAsInt("DestinationLcId");
it.Did = GXCommon.HexToBytes(reader.ReadElementContentAsString("Did"));
}
reader.ReadEndElement("DirectTable");
}
return(list.ToArray());
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
SynchronizationRegister.Clear();
if (reader.IsStartElement("SynchronizationRegisters", true))
{
while (reader.IsStartElement("Item", true))
{
UInt16 k = (UInt16)reader.ReadElementContentAsInt("Key");
UInt32 v = (UInt32)reader.ReadElementContentAsInt("Value");
SynchronizationRegister.Add(new KeyValuePair <UInt16, UInt32>(k, v));
}
reader.ReadEndElement("SynchronizationRegisters");
}
PhysicalLayerDesynchronization = (UInt16)reader.ReadElementContentAsInt("PhysicalLayerDesynchronization");
TimeOutNotAddressedDesynchronization = (UInt16)reader.ReadElementContentAsInt("TimeOutNotAddressedDesynchronization");
TimeOutFrameNotOkDesynchronization = (UInt16)reader.ReadElementContentAsInt("TimeOutFrameNotOkDesynchronization");
WriteRequestDesynchronization = (UInt16)reader.ReadElementContentAsInt("WriteRequestDesynchronization");
WrongInitiatorDesynchronization = (UInt16)reader.ReadElementContentAsInt("WrongInitiatorDesynchronization");
BroadcastFramesCounter.Clear();
if (reader.IsStartElement("BroadcastFramesCounters", true))
{
while (reader.IsStartElement("Item", true))
{
UInt16 k = (UInt16)reader.ReadElementContentAsInt("Key");
UInt32 v = (UInt32)reader.ReadElementContentAsInt("Value");
BroadcastFramesCounter.Add(new KeyValuePair <UInt16, UInt32>(k, v));
}
reader.ReadEndElement("BroadcastFramesCounters");
}
RepetitionsCounter = (UInt16)reader.ReadElementContentAsInt("RepetitionsCounter");
TransmissionsCounter = (UInt16)reader.ReadElementContentAsInt("TransmissionsCounter");
CrcOkFramesCounter = (UInt16)reader.ReadElementContentAsInt("CrcOkFramesCounter");
CrcNOkFramesCounter = (UInt16)reader.ReadElementContentAsInt("CrcNOkFramesCounter");
}
private void LoadRoutingConfiguration(GXXmlReader reader)
{
RoutingConfiguration.Clear();
if (reader.IsStartElement("RoutingConfiguration", true))
{
while (reader.IsStartElement("Item", false))
{
GXDLMSRoutingConfiguration it = new GXDLMSRoutingConfiguration();
RoutingConfiguration.Add(it);
it.NetTraversalTime = (byte)reader.ReadElementContentAsInt("NetTraversalTime");
it.RoutingTableEntryTtl = (UInt16)reader.ReadElementContentAsInt("RoutingTableEntryTtl");
it.Kr = (byte)reader.ReadElementContentAsInt("Kr");
it.Km = (byte)reader.ReadElementContentAsInt("Km");
it.Kc = (byte)reader.ReadElementContentAsInt("Kc");
it.Kq = (byte)reader.ReadElementContentAsInt("Kq");
it.Kh = (byte)reader.ReadElementContentAsInt("Kh");
it.Krt = (byte)reader.ReadElementContentAsInt("Krt");
it.RreqRetries = (byte)reader.ReadElementContentAsInt("RreqRetries");
it.RreqRerrWait = (byte)reader.ReadElementContentAsInt("RreqRerrWait");
it.BlacklistTableEntryTtl = (UInt16)reader.ReadElementContentAsInt("BlacklistTableEntryTtl");
it.UnicastRreqGenEnable = reader.ReadElementContentAsInt("UnicastRreqGenEnable") != 0;
it.RlcEnabled = reader.ReadElementContentAsInt("RlcEnabled") != 0;
it.AddRevLinkCost = (byte)reader.ReadElementContentAsInt("AddRevLinkCost");
}
reader.ReadEndElement("RoutingConfiguration");
}
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
MaxHops = (byte)reader.ReadElementContentAsInt("MaxHops");
WeakLqiValue = (byte)reader.ReadElementContentAsInt("WeakLqiValue");
SecurityLevel = (byte)reader.ReadElementContentAsInt("SecurityLevel");
LoadPrefixTable(reader);
LoadRoutingConfiguration(reader);
BroadcastLogTableEntryTtl = (UInt16)reader.ReadElementContentAsInt("BroadcastLogTableEntryTtl");
LoadRoutingTable(reader);
LoadContextInformationTable(reader);
LoadBlacklistTable(reader);
LoadBroadcastLogTable(reader);
LoadGroupTable(reader);
MaxJoinWaitTime = (UInt16)reader.ReadElementContentAsInt("MaxJoinWaitTime");
PathDiscoveryTime = (byte)reader.ReadElementContentAsInt("PathDiscoveryTime");
ActiveKeyIndex = (byte)reader.ReadElementContentAsInt("ActiveKeyIndex");
MetricType = (byte)reader.ReadElementContentAsInt("MetricType");
CoordShortAddress = (UInt16)reader.ReadElementContentAsInt("CoordShortAddress");
DisableDefaultRouting = reader.ReadElementContentAsInt("DisableDefaultRouting") != 0;
DeviceType = (DeviceType)reader.ReadElementContentAsInt("DeviceType");
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
SystemTitle = GXDLMSTranslator.HexToBytes(reader.ReadElementContentAsString("SystemTitle"));
MacAddress = (UInt16)reader.ReadElementContentAsInt("MacAddress");
LSapSelector = (byte)reader.ReadElementContentAsInt("LSapSelector");
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
InitiatorElectricalPhase = (InitiatorElectricalPhase)reader.ReadElementContentAsInt("InitiatorElectricalPhase");
DeltaElectricalPhase = (DeltaElectricalPhase)reader.ReadElementContentAsInt("DeltaElectricalPhase");
MaxReceivingGain = (byte)reader.ReadElementContentAsInt("MaxReceivingGain");
MaxTransmittingGain = (byte)reader.ReadElementContentAsInt("MaxTransmittingGain");
SearchInitiatorThreshold = (byte)reader.ReadElementContentAsInt("SearchInitiatorThreshold");
MarkFrequency = (UInt32)reader.ReadElementContentAsInt("MarkFrequency");
SpaceFrequency = (UInt32)reader.ReadElementContentAsInt("SpaceFrequency");
MacAddress = (UInt16)reader.ReadElementContentAsInt("MacAddress");
List <UInt16> list = new List <ushort>();
if (reader.IsStartElement("MacGroupAddresses", true))
{
while (reader.IsStartElement("Value", false))
{
list.Add((UInt16)reader.ReadElementContentAsInt("Value"));
}
reader.ReadEndElement("MacGroupAddresses");
}
MacGroupAddresses = list.ToArray();
Repeater = (Repeater)reader.ReadElementContentAsInt("Repeater");
RepeaterStatus = reader.ReadElementContentAsInt("RepeaterStatus") != 0;
MinDeltaCredit = (byte)reader.ReadElementContentAsInt("MinDeltaCredit");
InitiatorMacAddress = (UInt16)reader.ReadElementContentAsInt("InitiatorMacAddress");
SynchronizationLocked = reader.ReadElementContentAsInt("SynchronizationLocked") != 0;
TransmissionSpeed = (BaudRate)reader.ReadElementContentAsInt("TransmissionSpeed");
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
ShortAddress = (ushort)reader.ReadElementContentAsInt("ShortAddress");
RcCoord = (ushort)reader.ReadElementContentAsInt("RcCoord");
PANId = (ushort)reader.ReadElementContentAsInt("PANId");
LoadKeyTable(reader);
FrameCounter = (ushort)reader.ReadElementContentAsInt("FrameCounter");
ToneMask = reader.ReadElementContentAsString("ToneMask");
TmrTtl = (byte)reader.ReadElementContentAsInt("TmrTtl");
MaxFrameRetries = (byte)reader.ReadElementContentAsInt("MaxFrameRetries");
NeighbourTableEntryTtl = (byte)reader.ReadElementContentAsInt("NeighbourTableEntryTtl");
LoadNeighbourTable(reader);
HighPriorityWindowSize = (byte)reader.ReadElementContentAsInt("HighPriorityWindowSize");
CscmFairnessLimit = (byte)reader.ReadElementContentAsInt("CscmFairnessLimit");
BeaconRandomizationWindowLength = (byte)reader.ReadElementContentAsInt("BeaconRandomizationWindowLength");
A = (byte)reader.ReadElementContentAsInt("A");
K = (byte)reader.ReadElementContentAsInt("K");
MinCwAttempts = (byte)reader.ReadElementContentAsInt("MinCwAttempts");
CenelecLegacyMode = (byte)reader.ReadElementContentAsInt("CenelecLegacyMode");
FccLegacyMode = (byte)reader.ReadElementContentAsInt("FccLegacyMode");
MaxBe = (byte)reader.ReadElementContentAsInt("MaxBe");
MaxCsmaBackoffs = (byte)reader.ReadElementContentAsInt("MaxCsmaBackoffs");
MinBe = (byte)reader.ReadElementContentAsInt("MinBe");
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
CommSpeed = (BaudRate)reader.ReadElementContentAsInt("CommSpeed");
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
ClientSAP = (byte)reader.ReadElementContentAsInt("ClientSAP");
ServerSAP = (byte)reader.ReadElementContentAsInt("ServerSAP");
if (reader.IsStartElement("ApplicationContextName", true))
{
ApplicationContextName.JointIsoCtt = (byte)reader.ReadElementContentAsInt("JointIsoCtt");
ApplicationContextName.Country = (byte)reader.ReadElementContentAsInt("Country");
ApplicationContextName.CountryName = (UInt16)reader.ReadElementContentAsInt("CountryName");
ApplicationContextName.IdentifiedOrganization = (byte)reader.ReadElementContentAsInt("IdentifiedOrganization");
ApplicationContextName.DlmsUA = (byte)reader.ReadElementContentAsInt("DlmsUA");
ApplicationContextName.ApplicationContext = (byte)reader.ReadElementContentAsInt("ApplicationContext");
ApplicationContextName.ContextId = (ApplicationContextName)reader.ReadElementContentAsInt("ContextId");
reader.ReadEndElement("ApplicationContextName");
}
if (reader.IsStartElement("XDLMSContextInfo", true))
{
XDLMSContextInfo.Conformance = (Conformance)reader.ReadElementContentAsInt("Conformance");
XDLMSContextInfo.MaxReceivePduSize = (UInt16)reader.ReadElementContentAsInt("MaxReceivePduSize");
XDLMSContextInfo.MaxSendPduSize = (UInt16)reader.ReadElementContentAsInt("MaxSendPduSize");
XDLMSContextInfo.DlmsVersionNumber = (byte)reader.ReadElementContentAsInt("DlmsVersionNumber");
XDLMSContextInfo.QualityOfService = (sbyte)reader.ReadElementContentAsInt("QualityOfService");
XDLMSContextInfo.CypheringInfo = GXDLMSTranslator.HexToBytes(reader.ReadElementContentAsString("CypheringInfo"));
reader.ReadEndElement("XDLMSContextInfo");
}
if (reader.IsStartElement("XDLMSContextInfo", true))
{
AuthenticationMechanismName.JointIsoCtt = (byte)reader.ReadElementContentAsInt("JointIsoCtt");
AuthenticationMechanismName.Country = (byte)reader.ReadElementContentAsInt("Country");
AuthenticationMechanismName.CountryName = (UInt16)reader.ReadElementContentAsInt("CountryName");
AuthenticationMechanismName.IdentifiedOrganization = (byte)reader.ReadElementContentAsInt("IdentifiedOrganization");
AuthenticationMechanismName.DlmsUA = (byte)reader.ReadElementContentAsInt("DlmsUA");
AuthenticationMechanismName.AuthenticationMechanismName = (byte)reader.ReadElementContentAsInt("AuthenticationMechanismName");
AuthenticationMechanismName.MechanismId = (Authentication)reader.ReadElementContentAsInt("MechanismId");
reader.ReadEndElement("XDLMSContextInfo");
}
string str = reader.ReadElementContentAsString("Secret");
if (str == null)
{
Secret = null;
}
else
{
Secret = GXDLMSTranslator.HexToBytes(str);
}
AssociationStatus = (AssociationStatus)reader.ReadElementContentAsInt("AssociationStatus");
SecuritySetupReference = reader.ReadElementContentAsString("SecuritySetupReference");
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
Unit = (Unit)reader.ReadElementContentAsInt("Unit", 0);
Scaler = reader.ReadElementContentAsDouble("Scaler", 1);
Value = reader.ReadElementContentAsObject("Value", null);
}
/// <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);
reader.Objects.Add(obj);
}
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();
}
}
}
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
APN = reader.ReadElementContentAsString("APN");
PINCode = (UInt16)reader.ReadElementContentAsInt("PINCode");
if (reader.IsStartElement("DefaultQualityOfService", true))
{
DefaultQualityOfService.Precedence = (byte)reader.ReadElementContentAsInt("Precedence");
DefaultQualityOfService.Delay = (byte)reader.ReadElementContentAsInt("Delay");
DefaultQualityOfService.Reliability = (byte)reader.ReadElementContentAsInt("Reliability");
DefaultQualityOfService.PeakThroughput = (byte)reader.ReadElementContentAsInt("PeakThroughput");
DefaultQualityOfService.MeanThroughput = (byte)reader.ReadElementContentAsInt("MeanThroughput");
reader.ReadEndElement("DefaultQualityOfService");
}
if (reader.IsStartElement("RequestedQualityOfService", true))
{
RequestedQualityOfService.Precedence = (byte)reader.ReadElementContentAsInt("Precedence");
RequestedQualityOfService.Delay = (byte)reader.ReadElementContentAsInt("Delay");
RequestedQualityOfService.Reliability = (byte)reader.ReadElementContentAsInt("Reliability");
RequestedQualityOfService.PeakThroughput = (byte)reader.ReadElementContentAsInt("PeakThroughput");
RequestedQualityOfService.MeanThroughput = (byte)reader.ReadElementContentAsInt("MeanThroughput");
reader.ReadEndElement("DefaultQualityOfService");
}
}
void IGXDLMSBase.Load(GXXmlReader reader)
{
PaymentMode = (PaymentMode)reader.ReadElementContentAsInt("PaymentMode");
AccountStatus = (AccountStatus)reader.ReadElementContentAsInt("AccountStatus");
CurrentCreditInUse = (byte)reader.ReadElementContentAsInt("CurrentCreditInUse");
CurrentCreditStatus = (AccountCreditStatus)reader.ReadElementContentAsInt("CurrentCreditStatus");
AvailableCredit = reader.ReadElementContentAsInt("AvailableCredit");
AmountToClear = reader.ReadElementContentAsInt("AmountToClear");
ClearanceThreshold = reader.ReadElementContentAsInt("ClearanceThreshold");
AggregatedDebt = reader.ReadElementContentAsInt("AggregatedDebt");
LoadReferences(reader, "CreditReferences", CreditReferences);
LoadReferences(reader, "ChargeReferences", ChargeReferences);
LoadCreditChargeConfigurations(reader, CreditChargeConfigurations);
LoadTokenGatewayConfigurations(reader, TokenGatewayConfigurations);
AccountActivationTime = reader.ReadElementContentAsDateTime("AccountActivationTime");
AccountClosureTime = reader.ReadElementContentAsDateTime("AccountClosureTime");
Currency.Name = reader.ReadElementContentAsString("CurrencyName");
Currency.Scale = (sbyte)reader.ReadElementContentAsInt("CurrencyScale");
Currency.Unit = (Currency)reader.ReadElementContentAsInt("CurrencyUnit");
LowCreditThreshold = reader.ReadElementContentAsInt("LowCreditThreshold");
NextCreditAvailableThreshold = reader.ReadElementContentAsInt("NextCreditAvailableThreshold");
MaxProvision = (UInt16)reader.ReadElementContentAsInt("MaxProvision");
MaxProvisionPeriod = reader.ReadElementContentAsInt("MaxProvisionPeriod");
}
