void InitRead(object sender, GXPacket GXPacket)
{
LastNotifiedTransactionProgress = 0;
parser = new Gurux.DLMS.GXDLMSClient();
GXDLMSDevice device = sender as GXDLMSDevice;
parser.UseLogicalNameReferencing = device.UseLogicalNameReferencing;
Gurux.Common.IGXMedia media = device.GXClient.Media as Gurux.Common.IGXMedia;
SupportNetworkSpecificSettings = device.SupportNetworkSpecificSettings && media is GXNet;
if (SupportNetworkSpecificSettings)
{
parser.InterfaceType = Gurux.DLMS.InterfaceType.Net;
}
else
{
media.Eop = (byte)0x7E;
}
if (device.Manufacturers == null)
{
device.Manufacturers = new GXManufacturerCollection();
GXManufacturerCollection.ReadManufacturerSettings(device.Manufacturers);
}
GXManufacturer man = device.Manufacturers.FindByIdentification(device.Identification);
if (man == null)
{
throw new Exception("Unknown DLMS manufacturer type: " + device.Identification);
}
if (!string.IsNullOrEmpty(man.Extension))
{
Type t = Type.GetType(man.Extension);
Extension = Activator.CreateInstance(t) as IGXManufacturerExtension;
}
if (media is GXSerial && device.StartProtocol == StartProtocolType.IEC)
{
byte Terminator = 0xA;
GXSerial serial = media as GXSerial;
serial.Eop = Terminator;
ReceiveParameters<string> p = new ReceiveParameters<string>()
{
Eop = Terminator,
WaitTime = device.WaitTime * 1000
};
lock (media.Synchronous)
{
//Init IEC connection. This must done first with serial connections.
string data = "/?!\r\n";
if (device.HDLCAddressing == HDLCAddressType.SerialNumber)
{
data = "/?" + device.SerialNumber + "!\r\n";
}
media.Send(data, null);
if (!media.Receive(p))
{
//Try to move away from mode E.
//TODO: this.ReadDLMSPacket(this.DisconnectRequest());
data = "Failed to receive reply from the device in given time.";
GXLogWriter.WriteLog(data);
throw new Exception(data);
}
//If echo is used.
if (p.Reply == data)
{
p.Reply = null;
if (!media.Receive(p))
{
//Try to move away from mode E.
//TODO: this.ReadDLMSPacket(this.DisconnectRequest());
data = "Failed to receive reply from the device in given time.";
GXLogWriter.WriteLog(data);
throw new Exception(data);
}
}
}
string manufactureID = p.Reply.Substring(1, 3);
char baudrate = p.Reply[4];
int bitrate = 0;
switch (baudrate)
{
case '0':
bitrate = 300;
break;
case '1':
bitrate = 600;
break;
case '2':
bitrate = 1200;
break;
case '3':
bitrate = 2400;
break;
case '4':
bitrate = 4800;
break;
case '5':
bitrate = 9600;
break;
case '6':
bitrate = 19200;
break;
default:
throw new Exception("Unknown baud rate.");
}
//Send ACK
//Send Protocol control character
byte controlCharacter = (byte)'2';// "2" HDLC protocol procedure (Mode E)
//Send Baudrate character
//Mode control character
byte ModeControlCharacter = (byte)'2';//"2" //(HDLC protocol procedure) (Binary mode)
//We are not receive anything.
lock (media.Synchronous)
{
media.Send(new byte[] { 0x06, controlCharacter, (byte)baudrate, ModeControlCharacter, 0x8D, 0x0A }, null);
System.Threading.Thread.Sleep(1000);
serial.BaudRate = bitrate;
ReceiveParameters<byte[]> args = new ReceiveParameters<byte[]>();
args.Eop = (byte)0x0A;
args.WaitTime = 500;
media.Receive(args);
}
serial.DataBits = 8;
serial.Parity = System.IO.Ports.Parity.None;
serial.StopBits = System.IO.Ports.StopBits.One;
serial.ResetSynchronousBuffer();
serial.Eop = (byte)0x7E;
}
}
void IGXDLMSBase.SetValue(GXDLMSSettings settings, ValueEventArgs e)
{
if (e.Index == 1)
{
LogicalName = GXCommon.ToLogicalName(e.Value);
}
else if (e.Index == 2)
{
if (Scaler != 1 && e.Value != null && !e.User)
{
SetDataType(2, GXCommon.GetDLMSDataType(e.Value.GetType()));
try
{
if (settings.IsServer)
{
Value = e.Value;
}
else
{
Value = Convert.ToDouble(e.Value) * Scaler;
}
}
catch (Exception)
{
//Sometimes scaler is set for wrong Object type.
Value = e.Value;
}
}
else
{
Value = e.Value;
}
}
else if (e.Index == 3)
{
if (e.Value == null)
{
Scaler = 1;
Unit = Unit.None;
}
else
{
object[] arr = (object[])e.Value;
if (arr.Length != 2)
{
throw new Exception("setValue failed. Invalid scaler unit value.");
}
scaler = Convert.ToInt32(arr[0]);
Unit = (Unit)Convert.ToInt32(arr[1]);
}
}
else if (e.Index == 4)
{
Status = e.Value;
}
else if (e.Index == 5)
{
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);
}
//Actaris meters might return null.
if (e.Value == null)
{
CaptureTime = new GXDateTime();
}
else
{
CaptureTime = ((GXDateTime)e.Value).Value.LocalDateTime;
}
}
else
{
e.Error = ErrorCode.ReadWriteDenied;
}
}
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).ToString();
}
}
else if (e.Index == 2)
{
SynchronizationRegister.Clear();
foreach (object it in (object[])e.Value)
{
object[] tmp = (object[])it;
SynchronizationRegister.Add(new KeyValuePair <UInt16, UInt32>((UInt16)tmp[0], (UInt32)tmp[1]));
}
}
else if (e.Index == 3)
{
object[] tmp = (object[])e.Value;
PhysicalLayerDesynchronization = (UInt32)tmp[0];
TimeOutNotAddressedDesynchronization = (UInt32)tmp[1];
TimeOutFrameNotOkDesynchronization = (UInt32)tmp[2];
WriteRequestDesynchronization = (UInt32)tmp[3];
WrongInitiatorDesynchronization = (UInt32)tmp[4];
}
else if (e.Index == 4)
{
BroadcastFramesCounter.Clear();
foreach (object it in (object[])e.Value)
{
object[] tmp = (object[])it;
BroadcastFramesCounter.Add(new KeyValuePair <UInt16, UInt32>((UInt16)tmp[0], (UInt32)tmp[1]));
}
}
else if (e.Index == 5)
{
RepetitionsCounter = (UInt32)e.Value;
}
else if (e.Index == 6)
{
TransmissionsCounter = (UInt32)e.Value;
}
else if (e.Index == 7)
{
CrcOkFramesCounter = (UInt32)e.Value;
}
else if (e.Index == 8)
{
CrcNOkFramesCounter = (UInt32)e.Value;
}
else
{
e.Error = ErrorCode.ReadWriteDenied;
}
}
/// <summary>
/// Imports an X.509 v3 certificate of a public key.
/// </summary>
/// <param name="client">DLMS client that is used to generate action.</param>
/// <param name="key">Public key.</param>
/// <returns>Generated action.</returns>
public byte[][] ImportCertificate(GXDLMSClient client, byte[] key)
{
return(client.Method(this, 6, key, DataType.OctetString));
}
/// <summary>
/// Import server settings and COSEM objects from GXDLMSDirector trace.
/// </summary>
/// <param name="server">Server where settings are updated.</param>
/// <param name="data">GXDLMSDirector trace in byte array.</param>
public static void Import(GXDLMSServer server, byte[] data, Standard standard)
{
GXDLMSTranslator translator = new GXDLMSTranslator(TranslatorOutputType.StandardXml);
translator.CompletePdu = true;
translator.PduOnly = true;
translator.OmitXmlNameSpace = translator.OmitXmlDeclaration = true;
XmlDocument doc = new XmlDocument();
List <ValueEventArgs> targets = new List <ValueEventArgs>();
GXDLMSSettings settings = new GXDLMSSettings(true);
GXByteBuffer pdu = new GXByteBuffer();
GXByteBuffer bb = new GXByteBuffer(data);
server.InterfaceType = GXDLMSTranslator.GetDlmsFraming(bb);
bool lastBlock = true;
GXByteBuffer val = new DLMS.GXByteBuffer();
GXDLMSConverter converter = new GXDLMSConverter(standard);
while (translator.FindNextFrame(bb, pdu, server.InterfaceType))
{
String xml = translator.MessageToXml(bb);
if (xml != "")
{
doc.LoadXml(xml.Replace("&", "&"));
foreach (XmlNode node in doc.ChildNodes[doc.ChildNodes.Count - 1].ChildNodes)
{
string name = doc.ChildNodes[doc.ChildNodes.Count - 1].Name;
if (name == "Ua" || name == "aarq" || name == "aare")
{
break;
}
else if (name == "get-request")
{
server.UseLogicalNameReferencing = true;
GetLN(settings.Objects, targets, node.ChildNodes);
}
else if (name == "readRequest")
{
List <short> items = GetSN(node.ChildNodes);
server.UseLogicalNameReferencing = false;
foreach (short it in items)
{
GXSNInfo i = GXDLMSSNCommandHandler.FindSNObject(settings.Objects, Convert.ToUInt16((it) & 0xFFFF));
targets.Add(new ValueEventArgs(i.Item, i.Index, 0, null));
}
}
else if (name == "readResponse" ||
name == "get-response")
{
if (targets != null)
{
List <string> items;
if (server.UseLogicalNameReferencing)
{
items = GetLNValues(doc.ChildNodes[doc.ChildNodes.Count - 1].ChildNodes);
}
else
{
items = GetSNValues(doc.ChildNodes[doc.ChildNodes.Count - 1].ChildNodes);
}
int pos = 0;
foreach (string it in items)
{
if ("other-reason".Equals(it) ||
"read-write-denied".Equals(it) ||
"scope-of-access-violated".Equals(it) ||
"object-unavailable".Equals(it) ||
"object-class-inconsistent".Equals(it))
{
ValueEventArgs ve = targets[pos];
ve.Target.SetAccess(ve.Index, AccessMode.NoAccess);
continue;
}
try
{
if (server.UseLogicalNameReferencing)
{
lastBlock = IsLastBlock(doc.ChildNodes[doc.ChildNodes.Count - 1].ChildNodes);
}
val.Set(translator.XmlToData(it));
if (lastBlock)
{
if (settings.Objects.Count == 0)
{
GXDLMSClient c = new GXDLMSClient();
c.UseLogicalNameReferencing = server.UseLogicalNameReferencing;
settings.Objects = c.ParseObjects(val, true);
//Update OBIS code description.
converter.UpdateOBISCodeInformation(settings.Objects);
}
else
{
ValueEventArgs ve = targets[pos];
GXDataInfo info = new GXDataInfo();
ve.Value = GXCommon.GetData(server.Settings, val, info);
if (ve.Value is byte[])
{
DataType tp = ve.Target.GetUIDataType(ve.Index);
if (tp != DataType.None)
{
ve.Value = GXDLMSClient.ChangeType((byte[])ve.Value, tp, false);
ve.Target.SetDataType(ve.Index, DataType.OctetString);
}
}
if (ve.Target is IGXDLMSBase)
{
((IGXDLMSBase)ve.Target).SetValue(settings, ve);
}
}
val.Clear();
}
}
catch (Exception)
{
ValueEventArgs ve = targets[pos];
ve.Target.SetAccess(ve.Index, AccessMode.NoAccess);
}
++pos;
}
if (lastBlock)
{
targets.Clear();
break;
}
}
}
}
}
}
server.Items.Clear();
server.Items.AddRange(settings.Objects);
}
/// <summary>
/// Activate image.
/// </summary>
/// <param name="client">DLMS Client.</param>
/// <returns>Bytes send to the meter.</returns>
public byte[][] ImageActivate(GXDLMSClient client)
{
return(client.Method(this, 4, 0, DataType.Int8));
}
/// <summary>
/// Ask Server sends the Certificate Signing Request (CSR) data.
/// </summary>
/// <param name="client">DLMS client that is used to generate action.</param>
/// <param name="type">identifies the key pair for which the certificate will be requested.</param>
/// <returns>Generated action.</returns>
public byte[][] GenerateCertificate(GXDLMSClient client, CertificateType type)
{
return(client.Method(this, 5, type, DataType.Enum));
}
/// <summary>
/// Executes selected script.
/// </summary>
/// <param name="client">DLMS client.</param>
/// <param name="script">Executed script.</param>
/// <returns>Action bytes.</returns>
public byte[][] Execute(GXDLMSClient client, GXDLMSScript script)
{
return(client.Method(this, 1, (UInt16)script.Id));
}
/// <summary>
/// Executes selected script by id.
/// </summary>
/// <param name="client">DLMS client.</param>
/// <param name="scriptId">Executed script id.</param>
/// <returns>Action bytes.</returns>
public byte[][] Execute(GXDLMSClient client, UInt16 scriptId)
{
return(client.Method(this, 1, scriptId));
}
/// <summary>
/// Deletes an entry in the table.
/// </summary>
/// <returns></returns>
public byte[][] Delete(GXDLMSClient client, GXDLMSSpecialDay entry)
{
return(client.Method(this, 2, (UInt16)entry.Index));
}
void IGXDLMSBase.SetValue(GXDLMSSettings settings, ValueEventArgs e)
{
if (e.Index == 1)
{
LogicalName = GXCommon.ToLogicalName(e.Value);
}
else if (e.Index == 2)
{
if (Scaler != 1 && e.Value != null && !e.User)
{
try
{
if (settings.IsServer)
{
CurrentAverageValue = e.Value;
}
else
{
CurrentAverageValue = Convert.ToDouble(e.Value) * Scaler;
}
}
catch (Exception)
{
//Sometimes scaler is set for wrong Object type.
CurrentAverageValue = e.Value;
}
}
else
{
CurrentAverageValue = e.Value;
}
}
else if (e.Index == 3)
{
if (Scaler != 1 && e.Value != null && !e.User)
{
try
{
if (settings.IsServer)
{
LastAverageValue = e.Value;
}
else
{
LastAverageValue = Convert.ToDouble(e.Value) * Scaler;
}
}
catch (Exception)
{
//Sometimes scaler is set for wrong Object type.
LastAverageValue = e.Value;
}
}
else
{
LastAverageValue = e.Value;
}
}
else if (e.Index == 4)
{
if (e.Value == null)
{
Scaler = 1;
Unit = Unit.None;
}
else
{
object[] arr = (object[])e.Value;
if (arr.Length != 2)
{
throw new Exception("setValue failed. Invalid scaler unit value.");
}
scaler = Convert.ToInt32(arr[0]);
Unit = (Unit)Convert.ToInt32(arr[1]);
}
}
else if (e.Index == 5)
{
Status = Convert.ToInt32(e.Value);
}
else if (e.Index == 6)
{
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);
}
CaptureTime = (GXDateTime)e.Value;
}
}
else if (e.Index == 7)
{
if (e.Value == null)
{
StartTimeCurrent = new GXDateTime(DateTime.MinValue);
}
else
{
if (e.Value is byte[])
{
e.Value = GXDLMSClient.ChangeType((byte[])e.Value, DataType.DateTime, settings.UseUtc2NormalTime);
}
StartTimeCurrent = (GXDateTime)e.Value;
}
}
else if (e.Index == 8)
{
Period = Convert.ToUInt32(e.Value);
}
else if (e.Index == 9)
{
NumberOfPeriods = Convert.ToUInt16(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)
{
if (e.Value is byte[])
{
CalendarNameActive = ASCIIEncoding.ASCII.GetString((byte[])e.Value);
}
else
{
CalendarNameActive = Convert.ToString(e.Value);
}
}
else if (e.Index == 3)
{
SeasonProfileActive = SetSeasonProfile(settings, e.Value);
}
else if (e.Index == 4)
{
WeekProfileTableActive = SetWeekProfileTable(settings, e.Value);
}
else if (e.Index == 5)
{
DayProfileTableActive = SetDayProfileTable(settings, e.Value);
}
else if (e.Index == 6)
{
if (e.Value is byte[])
{
CalendarNamePassive = ASCIIEncoding.ASCII.GetString((byte[])e.Value);
}
else
{
CalendarNamePassive = Convert.ToString(e.Value);
}
}
else if (e.Index == 7)
{
SeasonProfilePassive = SetSeasonProfile(settings, e.Value);
}
else if (e.Index == 8)
{
WeekProfileTablePassive = SetWeekProfileTable(settings, e.Value);
}
else if (e.Index == 9)
{
DayProfileTablePassive = SetDayProfileTable(settings, e.Value);
}
else if (e.Index == 10)
{
if (e.Value is byte[])
{
Time = (GXDateTime)GXDLMSClient.ChangeType((byte[])e.Value, DataType.DateTime, settings.UseUtc2NormalTime);
}
else
{
Time = new GXDateTime(Convert.ToDateTime(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)
{
if (e.Value is string)
{
this.DataLinkLayerReference = e.Value.ToString();
}
else
{
this.DataLinkLayerReference = GXDLMSClient.ChangeType((byte[])e.Value, DataType.OctetString, settings.UseUtc2NormalTime).ToString();
}
}
else if (e.Index == 3)
{
AddressConfigMode = (AddressConfigMode)Convert.ToInt32(e.Value);
}
else if (e.Index == 4)
{
List <IPAddress> data = new List <IPAddress>();
if (e.Value != null)
{
foreach (object it in (Object[])e.Value)
{
data.Add(new IPAddress((byte[])it));
}
}
UnicastIPAddress = data.ToArray();
}
else if (e.Index == 5)
{
List <IPAddress> data = new List <IPAddress>();
if (e.Value != null)
{
foreach (object it in (Object[])e.Value)
{
data.Add(new IPAddress((byte[])it));
}
}
MulticastIPAddress = data.ToArray();
}
else if (e.Index == 6)
{
List <IPAddress> data = new List <IPAddress>();
if (e.Value != null)
{
foreach (object it in (Object[])e.Value)
{
data.Add(new IPAddress((byte[])it));
}
}
GatewayIPAddress = data.ToArray();
}
else if (e.Index == 7)
{
if (e.Value == null || ((byte[])e.Value).Length == 0)
{
PrimaryDNSAddress = null;
}
else
{
PrimaryDNSAddress = new IPAddress((byte[])e.Value);
}
}
else if (e.Index == 8)
{
if (e.Value == null || ((byte[])e.Value).Length == 0)
{
SecondaryDNSAddress = null;
}
else
{
SecondaryDNSAddress = new IPAddress((byte[])e.Value);
}
}
else if (e.Index == 9)
{
TrafficClass = Convert.ToByte(e.Value);
}
else if (e.Index == 10)
{
List <GXNeighborDiscoverySetup> data = new List <GXNeighborDiscoverySetup>();
if (e.Value != null)
{
foreach (object it in (Object[])e.Value)
{
object[] tmp = (object[])it;
GXNeighborDiscoverySetup v = new GXNeighborDiscoverySetup();
v.MaxRetry = Convert.ToByte(tmp[0]);
v.RetryWaitTime = Convert.ToUInt16(tmp[1]);
v.SendPeriod = Convert.ToUInt32(tmp[2]);
data.Add(v);
}
}
NeighborDiscoverySetup = data.ToArray();
}
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)
{
MBusPortReference = GXCommon.ToLogicalName(e.Value);
}
else if (e.Index == 3)
{
CaptureDefinition.Clear();
if (e.Value != null)
{
foreach (object tmp in (IEnumerable <object>)e.Value)
{
List <object> it;
if (tmp is List <object> )
{
it = (List <object>)tmp;
}
else
{
it = new List <object>((object[])tmp);
}
CaptureDefinition.Add(new KeyValuePair <string, string>(GXDLMSClient.ChangeType((byte[])it[0], DataType.OctetString, settings.UseUtc2NormalTime).ToString(),
GXDLMSClient.ChangeType((byte[])it[1], DataType.OctetString, settings.UseUtc2NormalTime).ToString()));
}
}
}
else if (e.Index == 4)
{
CapturePeriod = Convert.ToUInt32(e.Value);
}
else if (e.Index == 5)
{
PrimaryAddress = Convert.ToByte(e.Value);
}
else if (e.Index == 6)
{
IdentificationNumber = Convert.ToUInt32(e.Value);
}
else if (e.Index == 7)
{
ManufacturerID = Convert.ToUInt16(e.Value);
}
else if (e.Index == 8)
{
DataHeaderVersion = Convert.ToByte(e.Value);
}
else if (e.Index == 9)
{
DeviceType = Convert.ToByte(e.Value);
}
else if (e.Index == 10)
{
AccessNumber = Convert.ToByte(e.Value);
}
else if (e.Index == 11)
{
Status = Convert.ToByte(e.Value);
}
else if (e.Index == 12)
{
Alarm = Convert.ToByte(e.Value);
}
else if (Version > 0)
{
if (e.Index == 13)
{
Configuration = Convert.ToUInt16(e.Value);
}
else if (e.Index == 14)
{
EncryptionKeyStatus = (MBusEncryptionKeyStatus)Convert.ToInt32(e.Value);
}
else
{
e.Error = ErrorCode.ReadWriteDenied;
}
}
else
{
e.Error = ErrorCode.ReadWriteDenied;
}
}
/// <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, listener.TraceLevel, 60000, 3, 0);
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,
dev.Authentication, dev.Password, dev.InterfaceType);
client.UseUtc2NormalTime = 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 = dev.Security;
UInt64 devId = 0;
if (dev.TraceLevel != TraceLevel.Off)
{
devId = dev.Id;
}
reader = new GXDLMSReader(client, media, _logger, listener.TraceLevel, dev.WaitTime, dev.ResendCount, devId);
reader.InitializeConnection();
}
List <GXValue> values = new List <GXValue>();
foreach (GXTask task in ret.Tasks)
{
GXDLMSObject obj = GXDLMSClient.CreateObject((ObjectType)task.Object.ObjectType);
obj.Version = task.Object.Version;
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)
{
//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.Reader.Read(null, httpClient, reader, task, 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] }
};
using (System.Net.Http.HttpResponseMessage response = httpClient.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
};
using (System.Net.Http.HttpResponseMessage response = httpClient.PostAsJsonAsync(Startup.ServerAddress + "/api/error/AddError", error).Result)
{
Helpers.CheckStatus(response);
}
}
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)
{
}
}
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[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;
}
}
/// <summary>
/// Verify image.
/// </summary>
/// <param name="client">DLMS Client.</param>
/// <returns>Bytes send to the meter.</returns>
public byte[][] ImageVerify(GXDLMSClient client)
{
return(client.Method(this, 3, 0, DataType.Int8));
}
/// <summary>
/// Forces the disconnect control object into the 'ready_for_reconnection'
/// state if a direct remote reconnection is disabled(control_mode = 1, 3, 5, 6).
/// Forces the disconnect control object into the 'connected' state if
/// a direct remote reconnection is enabled(control_mode = 2, 4).
/// </summary>
/// <param name="client">DLMS client.</param>
/// <returns>Action bytes.</returns>
public byte[][] RemoteReconnect(GXDLMSClient client)
{
return(client.Method(this, 2, (sbyte)0));
}
/// <summary>
/// Activates and strengthens the security policy.
/// </summary>
/// <param name="client">DLMS client that is used to generate action.</param>
/// <param name="security">New security level.</param>
/// <returns>Generated action.</returns>
public byte[][] Activate(GXDLMSClient client, Gurux.DLMS.Enums.Security security)
{
return(client.Method(this, 1, GetSecurityValue(security), DataType.Enum));
}
/// <summary>
/// Copies the values of the objects to capture into the buffer by reading each capture object.
/// </summary>
/// <param name="client">DLMS client.</param>
/// <returns>Action bytes.</returns>
public byte[][] Capture(GXDLMSClient client)
{
return(client.Method(this, 2, (sbyte)0));
}
/// <summary>
/// Imports an X.509 v3 certificate of a public key.
/// </summary>
/// <param name="client">DLMS client that is used to generate action.</param>
/// <param name="key">Public key.</param>
/// <returns>Generated action.</returns>
public byte[][] Import(GXDLMSClient client, CngKey key)
{
return(ImportCertificate(client, key.Export(CngKeyBlobFormat.EccPublicBlob)));
}
private void SetBuffer(GXDLMSSettings settings, ValueEventArgs e)
{
List <GXKeyValuePair <GXDLMSObject, GXDLMSCaptureObject> > cols = null;
if (e.Parameters is List <GXKeyValuePair <GXDLMSObject, GXDLMSCaptureObject> > )
{
cols = (List <GXKeyValuePair <GXDLMSObject, GXDLMSCaptureObject> >)e.Parameters;
}
if (cols == null)
{
cols = CaptureObjects;
}
if (e.Value != null && (e.Value as object[]).Length != 0)
{
int index2 = 0;
DateTime lastDate = DateTime.MinValue;
foreach (object[] row in (e.Value as object[]))
{
if ((row as object[]).Length != cols.Count)
{
throw new Exception("Number of columns do not match.");
}
for (int pos = 0; pos != row.Length; ++pos)
{
if (cols == null)
{
index2 = 0;
}
else
{
index2 = cols[pos].Value.AttributeIndex;
}
DataType type;
//Actaris SL 7000 and ACE 6000 returns 0.
if (index2 != 0)
{
type = cols[pos].Key.GetUIDataType(index2);
}
else
{
type = DataType.None;
}
if (row[pos] is byte[])
{
if (type != DataType.None && row[pos] is byte[])
{
row[pos] = GXDLMSClient.ChangeType(row[pos] as byte[], type, settings.UseUtc2NormalTime);
if (row[pos] is GXDateTime)
{
GXDateTime dt = (GXDateTime)row[pos];
lastDate = dt.Value.LocalDateTime;
}
}
}
else if (type == DataType.DateTime && row[pos] == null && CapturePeriod != 0)
{
if (lastDate == DateTime.MinValue && Buffer.Count != 0)
{
lastDate = ((GXDateTime)Buffer[Buffer.Count - 1].GetValue(pos)).Value.LocalDateTime;
}
if (lastDate != DateTime.MinValue)
{
lastDate = lastDate.AddSeconds(CapturePeriod);
row[pos] = new GXDateTime(lastDate);
}
}
if (cols[pos].Key is GXDLMSRegister && index2 == 2)
{
double scaler = (cols[pos].Key as GXDLMSRegister).Scaler;
if (scaler != 1)
{
try
{
row[pos] = Convert.ToDouble(row[pos]) * scaler;
}
catch
{
//Skip error
}
}
}
else if (cols[pos].Key is GXDLMSDemandRegister && (index2 == 2 || index2 == 3))
{
double scaler = (cols[pos].Key as GXDLMSDemandRegister).Scaler;
if (scaler != 1)
{
try
{
row[pos] = Convert.ToDouble(row[pos]) * scaler;
}
catch
{
//Skip error
}
}
}
else if (cols[pos].Key is GXDLMSRegister && index2 == 3)
{
try
{
GXDLMSRegister r = new GXDLMSRegister();
ValueEventArgs v = new ValueEventArgs(r, 3, 0, null);
v.Value = row[pos];
(r as IGXDLMSBase).SetValue(null, v);
row[pos] = new object[] { r.Scaler, r.Unit };
}
catch
{
//Skip error
}
}
}
Buffer.Add(row);
}
EntriesInUse = Buffer.Count;
}
}
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 Object[])
{
Object[] tmp = (Object[])e.Value;
if (tmp.Length != 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 (object[] tmp in (e.Value as object[]))
{
if (tmp.Length != 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)
{
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;
}
}
internal static void Read(ILogger _logger, HttpClient client, GXDLMSReader reader, GXTask task, IGXMedia net, GXDLMSObject obj)
{
AddValue v;
HttpResponseMessage response;
if (_logger != null)
{
_logger.LogInformation("Reading: " + obj.ToString());
}
Console.WriteLine("Reading: " + obj.ToString());
object val;
if (obj.ObjectType == ObjectType.ProfileGeneric && task.Index == 2 && task.Object.Attributes[GetBufferIndex(task.Object)].Read != DateTime.MinValue)
{
//Read profile generic using range.
DateTime now = DateTime.Now;
now = now.AddSeconds(-now.Second);
now = now.AddMinutes(-now.Minute);
now = now.AddHours(1);
val = reader.ReadRowsByRange((GXDLMSProfileGeneric)obj, task.Object.Attributes[GetBufferIndex(task.Object)].Read, now);
}
else
{
val = reader.Read(obj, task.Index);
}
if (val is Enum)
{
//Enum values are saved as interger.
val = Convert.ToString(Convert.ToInt32(val));
}
else if (val is byte[])
{
DataType dt = (DataType)task.Object.Attributes[GetBufferIndex(task.Object)].UIDataType;
if (dt == DataType.String)
{
val = ASCIIEncoding.ASCII.GetString((byte[])val);
}
else if (dt == DataType.StringUTF8)
{
val = ASCIIEncoding.UTF8.GetString((byte[])val);
}
else
{
val = GXCommon.ToHex((byte[])val);
}
}
else if (val is GXDateTime)
{
val = ((GXDateTime)val).ToFormatString();
}
if (obj.ObjectType == ObjectType.ProfileGeneric && task.Index == 2)
{
//Make own value from each row.
if (val != null)
{
UInt64 attributeId = task.Object.Attributes[GetBufferIndex(task.Object)].Id;
List <GXValue> list = new List <GXValue>();
DateTime latest = task.Object.Attributes[GetBufferIndex(task.Object)].Read;
DateTime first = latest;
Boolean read = false;
foreach (GXStructure row in (GXArray)val)
{
DateTime dt = DateTime.MinValue;
task.Data = GXDLMSTranslator.ValueToXml(row);
for (int pos = 0; pos != row.Count; ++pos)
{
if (row[pos] is byte[])
{
row[pos] = GXDLMSClient.ChangeType((byte[])row[pos], DataType.DateTime);
if (pos == 0)
{
dt = ((GXDateTime)row[pos]).Value.LocalDateTime;
//If we have already read this row.
if (dt <= first)
{
read = true;
break;
}
if (dt > latest)
{
latest = dt;
}
}
}
//Some meters are returning null as date time to save bytes...
if (pos == 0 && row[pos] == null)
{
row[pos] = latest.AddHours(1);
}
}
if (_logger != null)
{
_logger.LogInformation("Read: " + task.Data);
}
if (!read)
{
list.Add(new GXValue()
{
Read = dt,
Value = task.Data,
AttributeId = attributeId
});
}
}
if (list.Count != 0)
{
v = new AddValue()
{
Items = list.ToArray()
};
response = client.PostAsJsonAsync(Startup.ServerAddress + "/api/value/AddValue", v).Result;
Helpers.CheckStatus(response);
ListDevicesResponse r = response.Content.ReadAsAsync <ListDevicesResponse>().Result;
}
}
}
else
{
if (!(val is string))
{
val = Convert.ToString(val);
}
task.Data = (string)val;
if (_logger != null)
{
_logger.LogInformation("Read: " + (string)val);
}
int index = GetAttributeIndex(task.Object, task.Index);
if (index != -1)
{
UInt64 attributeId = task.Object.Attributes[index].Id;
v = new AddValue()
{
Items = new GXValue[] { new GXValue()
{
AttributeId = attributeId,
Read = DateTime.Now,
Value = (string)val
} }
};
response = client.PostAsJsonAsync(Startup.ServerAddress + "/api/value/AddValue", v).Result;
Helpers.CheckStatus(response);
AddValueResponse r = response.Content.ReadAsAsync <AddValueResponse>().Result;
}
else
{
if (_logger != null)
{
_logger.LogInformation("Invalid task index: " + task.Index);
}
}
}
}
static public object ConvertFromDLMS(object data, DataType from, DataType type, bool arrayAsString)
{
if (type == DataType.Array)
{
return(data);
}
if (type == DataType.None)
{
if (arrayAsString && data != null && data.GetType().IsArray)
{
data = GXHelpers.GetArrayAsString(data);
}
return(data);
}
//Show Octet string...
if (from == DataType.OctetString && type == DataType.OctetString)
{
if (data is byte[])
{
string str = "";
byte[] arr = (byte[])data;
if (arr.Length == 0)
{
data = string.Empty;
}
else
{
foreach (byte it in arr)
{
str += it.ToString() + ".";
}
data = str.Substring(0, str.Length - 1);
}
}
}
//Convert DLMS octect string to Windows string.
else if (from == DataType.OctetString && type == DataType.String)
{
if (data is string)
{
return(data);
}
else if (data is byte[])
{
byte[] arr = (byte[])data;
data = System.Text.Encoding.ASCII.GetString(arr);
}
}
//Convert DLMS date time to Windows Time.
else if (type == DataType.DateTime)
{
if (data is byte[])
{
if (((byte[])data).Length == 5)
{
return(GXDLMSClient.ChangeType((byte[])data, DataType.Date));
}
return(GXDLMSClient.ChangeType((byte[])data, DataType.DateTime));
}
return(data);
}
//Convert DLMS date time to Windows Date.
else if (type == DataType.Date)
{
if (data is DateTime)
{
return(data);
}
if (data is string)
{
return(data);
}
if (!data.GetType().IsArray || ((Array)data).Length < 5)
{
throw new Exception("DateTime conversion failed. Invalid DLMS format.");
}
return(GXDLMSClient.ChangeType((byte[])data, DataType.Date));
}
//Convert DLMS date time to Windows Time.
else if (type == DataType.Time)
{
if (data is byte[])
{
return(GXDLMSClient.ChangeType((byte[])data, type));
}
return(data);
}
else if (data is byte[])
{
if (type == DataType.String)
{
data = System.Text.Encoding.ASCII.GetString((byte[])data);
}
else
{
data = ToHexString(data);
}
}
else if (data is Array)
{
data = ArrayToString(data);
}
return(data);
}
/// <summary>
/// Reset value.
/// </summary>
/// <param name="client">DLMS client.</param>
/// <returns>Action bytes.</returns>
public byte[][] Reset(GXDLMSClient client)
{
return(client.Method(this, 1, (sbyte)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)
{
InitiatorElectricalPhase = (InitiatorElectricalPhase)Convert.ToInt32(e.Value);
}
else if (e.Index == 3)
{
DeltaElectricalPhase = (DeltaElectricalPhase)Convert.ToInt32(e.Value);
}
else if (e.Index == 4)
{
MaxReceivingGain = (byte)e.Value;
}
else if (e.Index == 5)
{
MaxTransmittingGain = (byte)e.Value;
}
else if (e.Index == 6)
{
SearchInitiatorThreshold = (byte)e.Value;
}
else if (e.Index == 7)
{
object[] tmp = (object[])e.Value;
MarkFrequency = (UInt32)tmp[0];
SpaceFrequency = (UInt32)tmp[1];
}
else if (e.Index == 8)
{
MacAddress = (UInt16)e.Value;
}
else if (e.Index == 9)
{
List <ushort> list = new List <ushort>();
if (e.Value != null)
{
foreach (object it in (object[])e.Value)
{
list.Add((ushort)it);
}
}
MacGroupAddresses = list.ToArray();
}
else if (e.Index == 10)
{
Repeater = (Repeater)Convert.ToInt32(e.Value);
}
else if (e.Index == 11)
{
RepeaterStatus = (bool)e.Value;
}
else if (e.Index == 12)
{
MinDeltaCredit = (byte)e.Value;
}
else if (e.Index == 13)
{
InitiatorMacAddress = (UInt16)e.Value;
}
else if (e.Index == 14)
{
SynchronizationLocked = (bool)e.Value;
}
else if (e.Index == 15)
{
TransmissionSpeed = (BaudRate)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)
{
if (e.Value != null)
{
String ln = GXCommon.ToLogicalName(((List <object>)e.Value)[0]);
Target = (GXDLMSScriptTable)settings.Objects.FindByLN(ObjectType.ScriptTable, ln);
if (Target == null)
{
Target = new GXDLMSScriptTable(ln);
}
ExecutedScriptSelector = Convert.ToUInt16(((List <object>)e.Value)[1]);
}
else
{
Target = null;
ExecutedScriptSelector = 0;
}
}
else if (e.Index == 3)
{
Type = (SingleActionScheduleType)Convert.ToInt32(e.Value);
}
else if (e.Index == 4)
{
ExecutionTime = null;
if (e.Value != null)
{
List <GXDateTime> items = new List <GXDateTime>();
foreach (List <object> it in (List <object>)e.Value)
{
GXDateTime time;
if (it[0] is byte[])
{
time = (GXDateTime)GXDLMSClient.ChangeType((byte[])it[0], DataType.Time, settings.UseUtc2NormalTime);
}
else if (it[0] is GXDateTime)
{
time = (GXDateTime)it[0];
}
else
{
throw new Exception("Invalid time.");
}
time.Skip &= ~(DateTimeSkips.Year | DateTimeSkips.Month | DateTimeSkips.Day | DateTimeSkips.DayOfWeek);
GXDateTime date;
if (it[1] is byte[])
{
date = (GXDateTime)GXDLMSClient.ChangeType((byte[])it[1], DataType.Date, settings.UseUtc2NormalTime);
}
else if (it[1] is GXDateTime)
{
date = (GXDateTime)it[1];
}
else
{
throw new Exception("Invalid date.");
}
date.Skip &= ~(DateTimeSkips.Hour | DateTimeSkips.Minute | DateTimeSkips.Second | DateTimeSkips.Ms);
GXDateTime tmp = new DLMS.GXDateTime(date);
tmp.Value = tmp.Value.AddHours(time.Value.Hour);
tmp.Value = tmp.Value.AddMinutes(time.Value.Minute);
tmp.Value = tmp.Value.AddSeconds(time.Value.Second);
tmp.Skip = date.Skip | time.Skip;
items.Add(tmp);
}
ExecutionTime = items.ToArray();
}
}
else
{
e.Error = ErrorCode.ReadWriteDenied;
}
}
public byte[][] ImageTransferInitiate(GXDLMSClient client, string imageIdentifier, long imageSize)
{
return(ImageTransferInitiate(client, ASCIIEncoding.ASCII.GetBytes(imageIdentifier), imageSize));
}
/// <summary>
/// Import server settings and COSEM objects from GXDLMSDirector trace.
/// </summary>
/// <param name="server">Server where settings are updated.</param>
/// <param name="data">GXDLMSDirector trace in byte array.</param>
public static void Import(GXDLMSServer server, byte[] data)
{
GXDLMSTranslator translator = new GXDLMSTranslator(TranslatorOutputType.StandardXml);
translator.CompletePdu = true;
translator.PduOnly = true;
XmlDocument doc = new XmlDocument();
List<ValueEventArgs> targets = new List<ValueEventArgs>();
GXDLMSSettings settings = new GXDLMSSettings(true);
GXByteBuffer pdu = new GXByteBuffer();
GXByteBuffer bb = new GXByteBuffer(data);
server.InterfaceType = GXDLMSTranslator.GetDlmsFraming(bb);
bool lastBlock = true;
GXByteBuffer val = new DLMS.GXByteBuffer();
while (translator.FindNextFrame(bb, pdu, server.InterfaceType))
{
String xml = translator.MessageToXml(bb);
if (xml != "")
{
doc.LoadXml(xml);
foreach (XmlNode node in doc.ChildNodes[doc.ChildNodes.Count - 1].ChildNodes)
{
if (node.Name == "x:get-request")
{
server.UseLogicalNameReferencing = true;
GetLN(settings.Objects, targets, node.ChildNodes);
}
else if (node.Name == "x:readRequest")
{
List<short> items = GetSN(node.ChildNodes);
server.UseLogicalNameReferencing = false;
foreach (short it in items)
{
GXSNInfo i = GXDLMSSNCommandHandler.FindSNObject(settings.Objects, Convert.ToUInt16((it) & 0xFFFF));
targets.Add(new ValueEventArgs(i.Item, i.Index, 0, null));
}
}
else if (node.Name == "x:readResponse" ||
node.Name == "x:get-response")
{
if (targets != null)
{
List<string> items;
if (server.UseLogicalNameReferencing)
{
items = GetLNValues(node.ChildNodes);
}
else
{
items = GetSNValues(node.ChildNodes);
}
int pos = 0;
foreach (string it in items)
{
if ("read-write-denied".Equals(it) ||
"scope-of-access-violated".Equals(it) ||
"object-unavailable".Equals(it))
{
ValueEventArgs ve = targets[pos];
ve.Target.SetAccess(ve.Index, AccessMode.NoAccess);
continue;
}
try
{
if (server.UseLogicalNameReferencing)
{
lastBlock = IsLastBlock(node.ChildNodes);
}
val.Set(translator.XmlToData(it));
if (lastBlock)
{
if (settings.Objects.Count == 0)
{
GXDLMSClient c = new GXDLMSClient();
c.UseLogicalNameReferencing = server.UseLogicalNameReferencing;
settings.Objects = c.ParseObjects(val, true);
//Update OBIS code description.
GXDLMSConverter converter = new GXDLMSConverter();
converter.UpdateOBISCodeInformation(settings.Objects);
}
else
{
ValueEventArgs ve = targets[pos];
GXDataInfo info = new GXDataInfo();
ve.Value = GXCommon.GetData(server.Settings, val, info);
if (ve.Value is byte[])
{
DataType tp = ve.Target.GetUIDataType(ve.Index);
if (tp != DataType.None)
{
ve.Value = GXDLMSClient.ChangeType((byte[])ve.Value, tp);
}
}
((IGXDLMSBase)ve.Target).SetValue(settings, ve);
}
val.Clear();
}
}
catch (Exception)
{
ValueEventArgs ve = targets[pos];
ve.Target.SetAccess(ve.Index, AccessMode.NoAccess);
}
++pos;
}
if (lastBlock)
{
targets.Clear();
}
}
}
}
}
}
server.Items.Clear();
server.Items.AddRange(settings.Objects);
}
static GXDLMSDayProfile[] SetDayProfileTable(GXDLMSSettings settings, Object value)
{
if (value != null)
{
List <object> arr, item, it2;
if (value is List <object> )
{
arr = (List <object>)value;
}
else
{
arr = new List <object>((object[])value);
}
List <GXDLMSDayProfile> items = new List <GXDLMSDayProfile>();
foreach (object tmp in arr)
{
if (tmp is List <object> )
{
item = (List <object>)tmp;
}
else
{
item = new List <object>((object[])tmp);
}
GXDLMSDayProfile it = new GXDLMSDayProfile();
it.DayId = Convert.ToInt32(item[0]);
List <GXDLMSDayProfileAction> actions = new List <GXDLMSDayProfileAction>();
if (item[1] is List <object> )
{
item = (List <object>)item[1];
}
else
{
item = new List <object>((object[])item[1]);
}
foreach (object tmp2 in item)
{
if (tmp2 is List <object> )
{
it2 = (List <object>)tmp2;
}
else
{
it2 = new List <object>((object[])tmp2);
}
GXDLMSDayProfileAction ac = new GXDLMSDayProfileAction();
if (it2[0] is GXTime)
{
ac.StartTime = (GXTime)it2[0];
}
else if (it2[0] is GXDateTime)
{
ac.StartTime = new GXTime((GXDateTime)it2[0]);
}
else
{
ac.StartTime = (GXTime)GXDLMSClient.ChangeType((byte[])it2[0], DataType.Time, settings.UseUtc2NormalTime);
}
ac.ScriptLogicalName = GXCommon.ToLogicalName(it2[1]);
ac.ScriptSelector = Convert.ToUInt16(it2[2]);
actions.Add(ac);
}
it.DaySchedules = actions.ToArray();
items.Add(it);
}
return(items.ToArray());
}
return(null);
}
