public GXNotifyService(ILogger <GXNotifyService> logger, IOptions <NotifyOptions> optionsAccessor)
{
_useLogicalNameReferencing = optionsAccessor.Value.UseLogicalNameReferencing;
_systemTitle = optionsAccessor.Value.SystemTitle;
_blockCipherKey = optionsAccessor.Value.BlockCipherKey;
_interfaceType = optionsAccessor.Value.Interface;
_logger = logger;
notify = new GXNet((NetworkType)optionsAccessor.Value.NetworkType, optionsAccessor.Value.Port);
ExpirationTime = optionsAccessor.Value.ExpirationTime;
notify.OnReceived += OnNotifyReceived;
_logger.LogInformation("Listening notifications in port: " + notify.Port);
notify.Open();
/*
* if (!string.IsNullOrEmpty(n.Parser))
* {
* string[] tmp = n.Parser.Split(";");
* //GXNotifyListener.Parser = new Gurux.DLMS.AMI.NotifyParser.GXNotifyParser();
* string path = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), tmp[0]);
* Assembly asm = Assembly.LoadFile(path);
* foreach (Type type in asm.GetTypes())
* {
* //if (!type.IsAbstract && type.IsClass && typeof(IGXNotifyParser).IsAssignableFrom(type))
* {
* GXNotifyListener.Parser = Activator.CreateInstance(type) as IGXNotifyParser;
* break;
* }
* }
* //GXNotifyListener.Parser = asm.CreateInstance(tmp[1]) as IGXNotifyParser;
* }
*/
}
void SendPush(GXDLMSPushSetup target)
{
int pos = target.Destination.IndexOf(':');
if (pos == -1)
{
throw new ArgumentException("Invalid destination.");
}
GXDLMSNotify notify = new GXDLMSNotify(true, 1, 1, InterfaceType.WRAPPER);
byte[][] data = notify.GeneratePushSetupMessages(DateTime.MinValue, target);
string host = target.Destination.Substring(0, pos);
int port = int.Parse(target.Destination.Substring(pos + 1));
GXNet net = new GXNet(NetworkType.Tcp, host, port);
try
{
net.Open();
foreach (byte[] it in data)
{
net.Send(it, null);
}
}
finally
{
net.Close();
}
}
/// <summary>
/// Set initial settings.
/// </summary>
/// <param name="eventSender"></param>
/// <param name="eventArgs"></param>
private void Form1_Load(System.Object eventSender, System.EventArgs eventArgs)
{
try
{
Net1 = new GXNet();
Net1.Settings = Gurux.NetSample.Properties.Settings.Default.MediaSetting;
Net1.Trace = TraceLevel.Verbose;
Net1.OnTrace += new TraceEventHandler(Net1_OnTrace);
Net1.OnError += new Gurux.Common.ErrorEventHandler(Net1_OnError);
Net1.OnReceived += new ReceivedEventHandler(Net1_OnReceived);
Net1.OnMediaStateChange += new MediaStateChangeEventHandler(Net1_OnMediaStateChange);
Net1.OnClientConnected += new ClientConnectedEventHandler(Net1_OnClientConnected);
Net1.OnClientDisconnected += new ClientDisconnectedEventHandler(Net1_OnClientDisconnected);
if (Net1.IsOpen)
{
Net1_OnMediaStateChange(Net1, new MediaStateEventArgs(MediaState.Open));
}
else
{
Net1_OnMediaStateChange(Net1, new MediaStateEventArgs(MediaState.Closed));
}
}
catch (Exception Ex)
{
MessageBox.Show(Ex.Message);
}
}
/// <summary>
/// Set initial settings.
/// </summary>
/// <param name="eventSender"></param>
/// <param name="eventArgs"></param>
private void Form1_Load(System.Object eventSender, System.EventArgs eventArgs)
{
try
{
Net1 = new GXNet();
Net1.Settings = Gurux.NetSample.Properties.Settings.Default.MediaSetting;
Net1.Trace = TraceLevel.Verbose;
Net1.OnTrace += new TraceEventHandler(Net1_OnTrace);
Net1.OnError += new Gurux.Common.ErrorEventHandler(Net1_OnError);
Net1.OnReceived += new ReceivedEventHandler(Net1_OnReceived);
Net1.OnMediaStateChange += new MediaStateChangeEventHandler(Net1_OnMediaStateChange);
Net1.OnClientConnected += new ClientConnectedEventHandler(Net1_OnClientConnected);
Net1.OnClientDisconnected += new ClientDisconnectedEventHandler(Net1_OnClientDisconnected);
if (Net1.IsOpen)
{
Net1_OnMediaStateChange(Net1, new MediaStateEventArgs(MediaState.Open));
}
else
{
Net1_OnMediaStateChange(Net1, new MediaStateEventArgs(MediaState.Closed));
}
}
catch (Exception Ex)
{
MessageBox.Show(Ex.Message);
}
}
public void InitializeMedia(object sender, Gurux.Common.IGXMedia media)
{
if (media is GXNet)
{
GXNet net = media as GXNet;
net.ConfigurableSettings = Gurux.Net.AvailableMediaSettings.Port | Gurux.Net.AvailableMediaSettings.Host;
}
}
public void Dispose()
{
if (listener != null)
{
listener.Dispose();
listener = null;
}
}
public void Dispose()
{
if (notify != null)
{
notify.Dispose();
notify = null;
}
}
/// <summary>
/// Read data from the meter.
/// </summary>
private static void ReadMeter(GXNet media)
{
GXDLMSReader reader = new Net.GXDLMSReader(media);
reader.ReadAll();
//Create own thread for each meter if you are handling multiple meters simultaneously.
//new Thread(new ThreadStart(reader.ReadAll));
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="port">Port to listen.</param>
public GXDLMSPushListener(int port)
{
// TODO: Must set communication specific settings.
media = new GXNet(NetworkType.Tcp, port);
media.Trace = TraceLevel.Verbose;
media.OnReceived += new Gurux.Common.ReceivedEventHandler(OnReceived);
media.OnClientConnected += new Gurux.Common.ClientConnectedEventHandler(OnClientConnected);
media.OnClientDisconnected += new Gurux.Common.ClientDisconnectedEventHandler(OnClientDisconnected);
media.OnError += new Gurux.Common.ErrorEventHandler(OnError);
media.Open();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="port">Port to listen.</param>
public GXDLMSPushListener(int port)
: base(true, 1, 1, InterfaceType.WRAPPER)
{
// TODO: Must set communication specific settings.
media = new GXNet(NetworkType.Tcp, port);
media.Trace = TraceLevel.Verbose;
media.OnReceived += new Gurux.Common.ReceivedEventHandler(OnReceived);
media.OnClientConnected += new Gurux.Common.ClientConnectedEventHandler(OnClientConnected);
media.OnClientDisconnected += new Gurux.Common.ClientDisconnectedEventHandler(OnClientDisconnected);
media.OnError += new Gurux.Common.ErrorEventHandler(OnError);
media.Open();
}
public Startup(IConfiguration configuration)
{
int port = configuration.GetSection("Listener").Get <ListenerOptions>().Port;
if (port != 0)
{
listener = new GXNet(NetworkType.Tcp, port);
listener.OnClientConnected += OnClientConnected;
Console.WriteLine("Listening port:" + listener.Port);
listener.Open();
}
Configuration = configuration;
ServerAddress = configuration.GetSection("Client").Get <ClientOptions>().Address;
Console.WriteLine("RestAddress: " + ServerAddress);
}
private static void OnClientConnected(object sender, Gurux.Common.ConnectionEventArgs e)
{
Console.WriteLine("Client {0} is connected.", e.Info);
GXNet server = (GXNet)sender;
try
{
GXNet media = server.Attach(e.Info);
Thread thread = new Thread(new ParameterizedThreadStart(ReadMeter));
thread.Start(media);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
internal static void OnOnReceived(object sender, Common.ReceiveEventArgs e)
{
Console.WriteLine("Client {0} is connected.", e.SenderInfo);
GXNet server = (GXNet)sender;
try
{
GXNet media = server.Attach(e);
Thread thread = new Thread(new ParameterizedThreadStart(ReadMeter));
thread.Start(media);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// New client is connected.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private static void OnClientConnected(object sender, Common.ConnectionEventArgs e)
{
Console.WriteLine("Client {0} is connected.", e.Info);
GXNet server = (GXNet)sender;
try
{
using (GXNet cl = server.Attach(e.Info))
{
ReadMeter(cl);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="media"></param>
public GXSettingsDlg(GXNet media)
{
InitializeComponent();
try
{
//Show notification settings.
Form notifications = media.PropertiesForm;
(notifications as IGXPropertyPage).Initialize();
Move2(notifications.Controls, NotificationsTab.Controls, !media.IsOpen);
//Show custom settings.
MediaPropertiesForm = new List <IGXSettingsPage>();
foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies())
{
try
{
foreach (Type type in a.GetTypes())
{
if (!type.IsAbstract && type.IsClass && typeof(IGXSettingsPage).IsAssignableFrom(type))
{
MediaPropertiesForm.Add(Activator.CreateInstance(type) as IGXSettingsPage);
}
}
}
catch (Exception)
{
//It's OK if this fails.
}
}
foreach (Form it in MediaPropertiesForm)
{
TabPage page = new TabPage((it as IGXSettingsPage).Caption);
Tabs.TabPages.Add(page);
(it as IGXSettingsPage).Initialize();
Move2(it.Controls, page.Controls, true);
}
//Show external medias.
foreach (string it in Properties.Settings.Default.ExternalMedias.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
{
AddMedia(it);
}
}
catch (Exception Ex)
{
GXDLMS.Common.Error.ShowError(this, Ex);
}
}
/// <summary>
/// Close connection to the meter.
/// </summary>
public void Close()
{
if (Media != null && Client != null)
{
try
{
Console.WriteLine("Disconnecting from the meter.");
GXReplyData reply = new GXReplyData();
ReadDLMSPacket(Client.DisconnectRequest(), reply);
Media.Close();
}
catch
{
}
Media = null;
Client = null;
}
}
public GXListenerService(ILogger <GXListenerService> logger, IOptions <ListenerOptions> optionsAccessor)
{
_logger = logger;
int port = optionsAccessor.Value.Port;
GXListener._logger = logger;
listener = new GXNet((NetworkType)optionsAccessor.Value.NetworkType, port);
if (listener.Protocol == NetworkType.Tcp)
{
listener.OnClientConnected += GXListener.OnClientConnected;
}
else
{
listener.OnReceived += GXListener.OnOnReceived;
}
_logger.LogInformation("Listening incoming connections in port:" + listener.Port);
listener.Open();
}
/// <summary>
/// Read data from the meter.
/// </summary>
private static void ReadMeter(GXNet media)
{
GXDLMSClient client = new GXDLMSClient(true, 0x10, 1, Enums.Authentication.None, null, Enums.InterfaceType.HDLC);
GXDLMSReader reader = null;
try
{
reader = new GXDLMSReader(client, media, TraceLevel.Verbose);
reader.ReadAll(false);
//Create own thread for each meter if you are handling multiple meters simultaneously.
//new Thread(new ThreadStart(reader.ReadAll));
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
static void Main(string[] args)
{
try
{
int port = 4059;
GXNet media = new GXNet(NetworkType.Tcp, "localhost", port);
GXDLMSSecureNotify notify = new GXDLMSSecureNotify(true, 16, 1, InterfaceType.WRAPPER);
// Un-comment this if you want to send encrypted push messages.
// notify.Ciphering.Security = Security.AuthenticationEncryption;
GXDLMSPushSetup p = new GXDLMSPushSetup();
GXDLMSClock clock = new GXDLMSClock();
p.PushObjectList.Add(new KeyValuePair <GXDLMSObject, GXDLMSCaptureObject>(p, new GXDLMSCaptureObject(2, 0)));
p.PushObjectList.Add(new KeyValuePair <GXDLMSObject, GXDLMSCaptureObject>(clock, new GXDLMSCaptureObject(2, 0)));
///////////////////////////////////////////////////////////////////////
//Create Gurux DLMS server component for Short Name and start listen events.
GXDLMSPushListener pushListener = new GXDLMSPushListener(port);
Console.WriteLine("Listening DLMS Push IEC 62056-47 messages on port " + port + ".");
Console.WriteLine("Press X to close and Enter to send a Push message.");
ConsoleKey key;
while ((key = Console.ReadKey().Key) != ConsoleKey.X)
{
if (key == ConsoleKey.Enter)
{
Console.WriteLine("Sending Push message.");
media.Open();
clock.Time = DateTime.Now;
foreach (byte[] it in notify.GeneratePushSetupMessages(DateTime.MinValue, p))
{
media.Send(it, null);
}
Thread.Sleep(100);
media.Close();
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
static void Main(string[] args)
{
try
{
GXNet server = new GXNet(NetworkType.Tcp, 7777);
server.Open();
server.OnClientConnected += OnClientConnected;
server.OnClientDisconnected += OnClientDisconnected;
server.OnReceived += OnReceived;
Console.WriteLine("This server is listening port {0} and waiting incoming connections from the meters.", server.Port);
Console.WriteLine("This server can be used with DLMS meters that are using dynamic IP addresses.");
while (Console.ReadKey().Key != ConsoleKey.Enter)
{
;
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
static void Main(string[] args)
{
try
{
int port = 4059;
GXNet media = new GXNet(NetworkType.Tcp, "localhost", port);
GXDLMSNotify cl = new GXDLMSNotify(true, 1, 1, InterfaceType.WRAPPER);
GXDLMSPushSetup p = new GXDLMSPushSetup();
GXDLMSClock clock = new GXDLMSClock();
p.PushObjectList.Add(new KeyValuePair<GXDLMSObject, GXDLMSCaptureObject>(p, new GXDLMSCaptureObject(2, 0)));
p.PushObjectList.Add(new KeyValuePair<GXDLMSObject, GXDLMSCaptureObject>(clock, new GXDLMSCaptureObject(2, 0)));
///////////////////////////////////////////////////////////////////////
//Create Gurux DLMS server component for Short Name and start listen events.
GXDLMSPushListener pushListener = new GXDLMSPushListener(port);
Console.WriteLine("Listening DLMS Push IEC 62056-47 messages on port " + port + ".");
Console.WriteLine("Press X to close and Enter to send a Push message.");
ConsoleKey key;
while ((key = Console.ReadKey().Key) != ConsoleKey.X)
{
if (key == ConsoleKey.Enter)
{
Console.WriteLine("Sending Push message.");
media.Open();
clock.Time = DateTime.Now;
foreach (byte[] it in cl.GeneratePushSetupMessages(DateTime.MinValue, p))
{
media.Send(it, null);
}
Thread.Sleep(100);
media.Close();
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public ReceiveThread(GXNet parent, Socket socket)
{
Closing = new ManualResetEvent(false);
m_Parent = parent;
m_Socket = socket;
}
/// <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();
}
}
}
}
public Settings(GXNet target)
{
this.target = target;
InitializeComponent();
}
static int GetParameters(string[] args, Settings settings)
{
List <GXCmdParameter> parameters = GXCommon.GetParameters(args, "h:p:c:s:r:it:a:p:wP:g:");
GXNet net = null;
foreach (GXCmdParameter it in parameters)
{
switch (it.Tag)
{
case 'w':
settings.client.InterfaceType = InterfaceType.WRAPPER;
break;
case 'r':
if (string.Compare(it.Value, "sn", true) == 0)
{
settings.client.UseLogicalNameReferencing = false;
}
else if (string.Compare(it.Value, "ln", true) == 0)
{
settings.client.UseLogicalNameReferencing = true;
}
else
{
throw new ArgumentException("Invalid reference option.");
}
break;
case 'h':
//Host address.
if (settings.media == null)
{
settings.media = new GXNet();
}
net = settings.media as GXNet;
net.HostName = it.Value;
break;
case 't':
//Trace.
try
{
settings.trace = (TraceLevel)Enum.Parse(typeof(TraceLevel), it.Value);
}
catch (Exception)
{
throw new ArgumentException("Invalid Authentication option. (Error, Warning, Info, Verbose, Off)");
}
break;
case 'p':
//Port.
if (settings.media == null)
{
settings.media = new GXNet();
}
net = settings.media as GXNet;
net.Port = int.Parse(it.Value);
break;
case 'P': //Password
settings.client.Password = ASCIIEncoding.ASCII.GetBytes(it.Value);
break;
case 'i':
//IEC.
settings.iec = true;
break;
case 'g':
//Get (read) selected objects.
foreach (string o in it.Value.Split(new char[] { ';', ',' }))
{
string[] tmp = o.Split(new char[] { ':' });
if (tmp.Length != 2)
{
throw new ArgumentOutOfRangeException("Invalid Logical name or attribute index.");
}
settings.readObjects.Add(new KeyValuePair <string, int>(tmp[0].Trim(), int.Parse(tmp[1].Trim())));
}
break;
case 'S': //Serial Port
settings.media = new GXSerial();
GXSerial serial = settings.media as GXSerial;
serial.PortName = it.Value;
break;
case 'a':
try
{
if (string.Compare("None", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.None;
}
else if (string.Compare("Low", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.Low;
}
else if (string.Compare("High", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.High;
}
else if (string.Compare("HighMd5", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.HighMD5;
}
else if (string.Compare("HighSha1", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.HighSHA1;
}
else if (string.Compare("HighSha256", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.HighSHA256;
}
else if (string.Compare("HighGMac", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.HighGMAC;
}
else
{
throw new ArgumentException("Invalid Authentication option: '" + it.Value + "'. (None, Low, High, HighMd5, HighSha1, HighGMac, HighSha256)");
}
}
catch (Exception)
{
throw new ArgumentException("Invalid Authentication option: '" + it.Value + "'. (None, Low, High, HighMd5, HighSha1, HighGMac, HighSha256)");
}
break;
case 'o':
break;
case 'c':
settings.client.ClientAddress = int.Parse(it.Value);
break;
case 's':
settings.client.ServerAddress = int.Parse(it.Value);
break;
case '?':
switch (it.Tag)
{
case 'c':
throw new ArgumentException("Missing mandatory client option.");
case 's':
throw new ArgumentException("Missing mandatory server option.");
case 'h':
throw new ArgumentException("Missing mandatory host name option.");
case 'p':
throw new ArgumentException("Missing mandatory port option.");
case 'r':
throw new ArgumentException("Missing mandatory reference option.");
case 'a':
throw new ArgumentException("Missing mandatory authentication option.");
case 'S':
throw new ArgumentException("Missing mandatory Serial port option.");
case 't':
throw new ArgumentException("Missing mandatory trace option.");
case 'g':
throw new ArgumentException("Missing mandatory OBIS code option.");
default:
ShowHelp();
return(1);
}
default:
ShowHelp();
return(1);
}
}
if (settings.media == null)
{
ShowHelp();
return(1);
}
return(0);
}
void SendPush(GXDLMSPushSetup target)
{
int pos = target.Destination.IndexOf(':');
if (pos == -1)
{
throw new ArgumentException("Invalid destination.");
}
GXDLMSNotify notify = new GXDLMSNotify(true, 1, 1, InterfaceType.WRAPPER);
byte[][] data = notify.GeneratePushSetupMessages(DateTime.MinValue, target);
string host = target.Destination.Substring(0, pos);
int port = int.Parse(target.Destination.Substring(pos + 1));
GXNet net = new GXNet(NetworkType.Tcp, host, port);
try
{
net.Open();
foreach (byte[] it in data)
{
net.Send(it, null);
}
}
finally
{
net.Close();
}
}
public static int GetParameters(string[] args, Settings settings)
{
string[] tmp;
List <GXCmdParameter> parameters = GXCommon.GetParameters(args, "h:p:c:s:r:iIt:a:wP:g:S:C:n:v:o:T:A:B:D:d:l:F:");
GXNet net = null;
foreach (GXCmdParameter it in parameters)
{
switch (it.Tag)
{
case 'w':
settings.client.InterfaceType = InterfaceType.WRAPPER;
break;
case 'r':
if (string.Compare(it.Value, "sn", true) == 0)
{
settings.client.UseLogicalNameReferencing = false;
}
else if (string.Compare(it.Value, "ln", true) == 0)
{
settings.client.UseLogicalNameReferencing = true;
}
else
{
throw new ArgumentException("Invalid reference option.");
}
break;
case 'h':
//Host address.
if (settings.media == null)
{
settings.media = new GXNet();
}
net = settings.media as GXNet;
net.HostName = it.Value;
break;
case 't':
//Trace.
try
{
settings.trace = (TraceLevel)Enum.Parse(typeof(TraceLevel), it.Value);
}
catch (Exception)
{
throw new ArgumentException("Invalid trace level option. (Error, Warning, Info, Verbose, Off)");
}
break;
case 'p':
//Port.
if (settings.media == null)
{
settings.media = new GXNet();
}
net = settings.media as GXNet;
net.Port = int.Parse(it.Value);
break;
case 'P': //Password
settings.client.Password = ASCIIEncoding.ASCII.GetBytes(it.Value);
break;
case 'i':
//IEC.
settings.iec = true;
break;
case 'I':
//AutoIncreaseInvokeID.
settings.client.AutoIncreaseInvokeID = true;
break;
case 'v':
settings.invocationCounter = it.Value.Trim();
Objects.GXDLMSObject.ValidateLogicalName(settings.invocationCounter);
break;
case 'g':
//Get (read) selected objects.
foreach (string o in it.Value.Split(new char[] { ';', ',' }))
{
tmp = o.Split(new char[] { ':' });
if (tmp.Length != 2)
{
throw new ArgumentOutOfRangeException("Invalid Logical name or attribute index.");
}
settings.readObjects.Add(new KeyValuePair <string, int>(tmp[0].Trim(), int.Parse(tmp[1].Trim())));
}
break;
case 'S': //Serial Port
settings.media = new GXSerial();
GXSerial serial = settings.media as GXSerial;
tmp = it.Value.Split(':');
serial.PortName = tmp[0];
if (tmp.Length > 1)
{
serial.BaudRate = int.Parse(tmp[1]);
serial.DataBits = int.Parse(tmp[2].Substring(0, 1));
serial.Parity = (Parity)Enum.Parse(typeof(Parity), tmp[2].Substring(1, tmp[2].Length - 2));
serial.StopBits = (StopBits)int.Parse(tmp[2].Substring(tmp[2].Length - 1, 1));
}
else
{
serial.BaudRate = 9600;
serial.DataBits = 8;
serial.Parity = Parity.None;
serial.StopBits = StopBits.One;
}
break;
case 'a':
try
{
if (string.Compare("None", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.None;
}
else if (string.Compare("Low", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.Low;
}
else if (string.Compare("High", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.High;
}
else if (string.Compare("HighMd5", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.HighMD5;
}
else if (string.Compare("HighSha1", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.HighSHA1;
}
else if (string.Compare("HighSha256", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.HighSHA256;
}
else if (string.Compare("HighGMac", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.HighGMAC;
}
else
{
throw new ArgumentException("Invalid Authentication option: '" + it.Value + "'. (None, Low, High, HighMd5, HighSha1, HighGMac, HighSha256)");
}
}
catch (Exception)
{
throw new ArgumentException("Invalid Authentication option: '" + it.Value + "'. (None, Low, High, HighMd5, HighSha1, HighGMac, HighSha256)");
}
break;
case 'C':
try
{
settings.client.Ciphering.Security = Convert.ToByte(Enum.Parse(typeof(Security), it.Value));
}
catch (Exception)
{
throw new ArgumentException("Invalid Ciphering option '" + it.Value + "'. (None, Authentication, Encryption, AuthenticationEncryption)");
}
break;
case 'T':
settings.client.Ciphering.SystemTitle = GXCommon.HexToBytes(it.Value);
break;
case 'A':
settings.client.Ciphering.AuthenticationKey = GXCommon.HexToBytes(it.Value);
break;
case 'B':
settings.client.Ciphering.BlockCipherKey = GXCommon.HexToBytes(it.Value);
break;
case 'D':
settings.client.Ciphering.DedicatedKey = GXCommon.HexToBytes(it.Value);
break;
case 'F':
settings.client.Ciphering.InvocationCounter = UInt32.Parse(it.Value.Trim());
break;
case 'o':
settings.outputFile = it.Value;
break;
case 'd':
try
{
settings.client.Standard = (Standard)Enum.Parse(typeof(Standard), it.Value);
if (settings.client.Standard == Standard.Italy || settings.client.Standard == Standard.India || settings.client.Standard == Standard.SaudiArabia)
{
settings.client.UseUtc2NormalTime = true;
}
}
catch (Exception)
{
throw new ArgumentException("Invalid DLMS standard option '" + it.Value + "'. (DLMS, India, Italy, SaudiArabia, IDIS)");
}
break;
case 'c':
settings.client.ClientAddress = int.Parse(it.Value);
break;
case 's':
if (settings.client.ServerAddress != 1)
{
settings.client.ServerAddress = GXDLMSClient.GetServerAddress(settings.client.ServerAddress, int.Parse(it.Value));
}
else
{
settings.client.ServerAddress = int.Parse(it.Value);
}
break;
case 'l':
settings.client.ServerAddress = GXDLMSClient.GetServerAddress(int.Parse(it.Value), settings.client.ServerAddress);
break;
case 'n':
settings.client.ServerAddress = GXDLMSClient.GetServerAddress(int.Parse(it.Value));
break;
case '?':
switch (it.Tag)
{
case 'c':
throw new ArgumentException("Missing mandatory client option.");
case 's':
throw new ArgumentException("Missing mandatory server option.");
case 'h':
throw new ArgumentException("Missing mandatory host name option.");
case 'p':
throw new ArgumentException("Missing mandatory port option.");
case 'r':
throw new ArgumentException("Missing mandatory reference option.");
case 'a':
throw new ArgumentException("Missing mandatory authentication option.");
case 'S':
throw new ArgumentException("Missing mandatory Serial port option.");
case 't':
throw new ArgumentException("Missing mandatory trace option.");
case 'g':
throw new ArgumentException("Missing mandatory OBIS code option.");
case 'C':
throw new ArgumentException("Missing mandatory Ciphering option.");
case 'v':
throw new ArgumentException("Missing mandatory invocation counter logical name option.");
case 'T':
throw new ArgumentException("Missing mandatory system title option.");
case 'A':
throw new ArgumentException("Missing mandatory authentication key option.");
case 'B':
throw new ArgumentException("Missing mandatory block cipher key option.");
case 'D':
throw new ArgumentException("Missing mandatory dedicated key option.");
case 'F':
throw new ArgumentException("Missing mandatory frame counter option.");
case 'd':
throw new ArgumentException("Missing mandatory DLMS standard option.");
default:
ShowHelp();
return(1);
}
default:
ShowHelp();
return(1);
}
}
if (settings.media == null)
{
ShowHelp();
return(1);
}
return(0);
}
/// <summary>
/// Start simulator.
/// </summary>
static void StartSimulator(Settings settings)
{
if (settings.media is GXSerial)
{
GXDLMSMeter server = new GXDLMSMeter(settings.useLogicalNameReferencing, Enums.InterfaceType.HDLC);
if (settings.useLogicalNameReferencing)
{
Console.WriteLine("Logical Name DLMS Server in serial port {0}.", settings.media);
}
else
{
Console.WriteLine("Short Name DLMS Server in serial port {0}.", settings.media);
}
server.Initialize(settings.media, settings.trace, settings.inputFile, 1);
Console.WriteLine("----------------------------------------------------------");
ConsoleKey k;
while ((k = Console.ReadKey().Key) != ConsoleKey.Escape)
{
if (k == ConsoleKey.Delete)
{
Console.Clear();
}
Console.WriteLine("Press Esc to close application or delete clear the console.");
}
//Close servers.
server.Close();
}
else
{
//Create Network media component and start listen events.
//4059 is Official DLMS port.
///////////////////////////////////////////////////////////////////////
//Create Gurux DLMS server component for Short Name and start listen events.
List <GXDLMSMeter> servers = new List <GXDLMSMeter>();
string str;
if (settings.interfaceType == Enums.InterfaceType.HDLC)
{
str = "DLMS HDLC";
}
else
{
str = "DLMS WRAPPER";
}
if (settings.useLogicalNameReferencing)
{
str += " Logical Name ";
}
else
{
str += " Short Name ";
}
GXNet net = (GXNet)settings.media;
net.Server = true;
if (settings.exclusive)
{
Console.WriteLine(str + "simulator start in port {0} implementing {1} meters.", net.Port, settings.serverCount);
}
else
{
Console.WriteLine(str + "simulator start in ports {0}-{1}.", net.Port, net.Port + settings.serverCount - 1);
}
for (int pos = 0; pos != settings.serverCount; ++pos)
{
GXDLMSMeter server = new GXDLMSMeter(settings.useLogicalNameReferencing, settings.interfaceType);
server.Conformance = Conformance.None;
server.MaxReceivePDUSize = 0;
servers.Add(server);
if (settings.exclusive)
{
server.Initialize(net, settings.trace, settings.inputFile, (UInt32)pos + 1);
}
else
{
server.Initialize(new GXNet(net.Protocol, net.Port + pos), settings.trace, settings.inputFile, (UInt32)pos + 1);
}
if (pos == 0 && settings.useLogicalNameReferencing)
{
Console.WriteLine("Associations:");
foreach (GXDLMSAssociationLogicalName it in server.Items.GetObjects(ObjectType.AssociationLogicalName))
{
if (it.AuthenticationMechanismName.MechanismId == Authentication.None)
{
Console.WriteLine("Without authentication.");
}
else
{
Console.WriteLine("{0} authentication, password {1}",
it.AuthenticationMechanismName.MechanismId,
ASCIIEncoding.ASCII.GetString(it.Secret));
}
}
}
}
ConsoleKey k;
while ((k = Console.ReadKey().Key) != ConsoleKey.Escape)
{
if (k == ConsoleKey.Delete)
{
Console.Clear();
}
Console.WriteLine("Press Esc to close application or delete clear the console.");
}
Console.WriteLine("Closing servers.");
//Close servers.
foreach (GXDLMSMeter server in servers)
{
server.Close();
}
Console.WriteLine("Servers closed.");
}
}
/// <summary>
/// Start simulator.
/// </summary>
static void StartSimulator(Settings settings)
{
if (settings.media is GXSerial)
{
GXDLMSMeter server = new GXDLMSMeter(settings.client.UseLogicalNameReferencing, Enums.InterfaceType.HDLC);
if (settings.client.UseLogicalNameReferencing)
{
Console.WriteLine("Logical Name DLMS Server in serial port {0}.", settings.media);
}
else
{
Console.WriteLine("Short Name DLMS Server in serial port {0}.", settings.media);
}
server.Initialize(settings.media, settings.trace, settings.inputFile, 1, false);
Console.WriteLine("----------------------------------------------------------");
ConsoleKey k;
while ((k = Console.ReadKey().Key) != ConsoleKey.Escape)
{
if (k == ConsoleKey.Delete)
{
Console.Clear();
}
Console.WriteLine("Press Esc to close application or delete clear the console.");
}
//Close servers.
server.Close();
}
else
{
//Create Network media component and start listen events.
//4059 is Official DLMS port.
///////////////////////////////////////////////////////////////////////
//Create Gurux DLMS server component for Short Name and start listen events.
List <GXDLMSMeter> servers = new List <GXDLMSMeter>();
string str;
if (settings.client.InterfaceType == Enums.InterfaceType.HDLC)
{
str = "DLMS HDLC";
}
else
{
str = "DLMS WRAPPER";
}
if (settings.gatewaySettings != null)
{
str += " Gateway for " + settings.gatewaySettings + " meters.";
}
if (settings.client.UseLogicalNameReferencing)
{
str += " Logical Name ";
}
else
{
str += " Short Name ";
}
GXNet net = (GXNet)settings.media;
net.Server = true;
if (settings.exclusive)
{
Console.WriteLine(str + "simulator start in port {0} implementing {1} meters.", net.Port, settings.serverCount);
if (settings.gatewaySettings != null)
{
net.OnReceived += new Gurux.Common.ReceivedEventHandler(GXDLMSMeter.OnGatewayReceived);
GXDLMSMeter.GatewayServer = new GXDLMSMeter(settings.client.UseLogicalNameReferencing, settings.client.InterfaceType);
GXDLMSMeter.GatewayServer.Initialize();
settings.client.InterfaceType = (InterfaceType)settings.gatewaySettings;
}
else
{
net.OnReceived += new Gurux.Common.ReceivedEventHandler(GXDLMSMeter.OnExclusiveReceived);
}
net.OnClientConnected += new Gurux.Common.ClientConnectedEventHandler(GXDLMSMeter.OnClientConnected);
net.OnClientDisconnected += new Gurux.Common.ClientDisconnectedEventHandler(GXDLMSMeter.OnClientDisconnected);
net.OnError += new Gurux.Common.ErrorEventHandler(GXDLMSMeter.OnError);
}
else
{
Console.WriteLine(str + "simulator start in ports {0}-{1}.", net.Port, net.Port + settings.serverCount - 1);
}
for (int pos = 0; pos != settings.serverCount; ++pos)
{
GXDLMSMeter server = new GXDLMSMeter(settings.client.UseLogicalNameReferencing, settings.client.InterfaceType);
servers.Add(server);
if (settings.exclusive)
{
server.Initialize(net, settings.trace, settings.inputFile, (UInt32)pos + 1, settings.exclusive);
GXDLMSMeter.meters.Add(pos + 1, server);
}
else
{
try
{
server.Initialize(new GXNet(net.Protocol, net.Port + pos), settings.trace, settings.inputFile, (UInt32)pos + 1, settings.exclusive);
}
catch (System.Net.Sockets.SocketException ex)
{
Console.WriteLine(string.Format("Port {0} already in use.", net.Port + pos));
}
}
if (pos == 0 && settings.client.UseLogicalNameReferencing)
{
str = "Client address: " + settings.client.ClientAddress.ToString();
str += ", Server address: " + settings.client.ServerAddress.ToString();
Console.WriteLine(str);
Console.WriteLine("Associations:");
foreach (GXDLMSAssociationLogicalName it in server.Items.GetObjects(ObjectType.AssociationLogicalName))
{
//Overwrite the password.
if (settings.client.Password != null && settings.client.Password.Length != 0)
{
it.Secret = settings.client.Password;
}
if (it.AuthenticationMechanismName.MechanismId == Authentication.None)
{
Console.WriteLine("Without authentication.");
}
else
{
Console.WriteLine("{0} authentication, password {1}",
it.AuthenticationMechanismName.MechanismId,
ASCIIEncoding.ASCII.GetString(it.Secret));
}
}
}
}
ConsoleKey k;
while ((k = Console.ReadKey().Key) != ConsoleKey.Escape)
{
if (k == ConsoleKey.Delete)
{
Console.Clear();
}
Console.WriteLine("Press Esc to close application or delete clear the console.");
}
Console.WriteLine("Closing servers.");
//Close servers.
foreach (GXDLMSMeter server in servers)
{
server.Close();
}
Console.WriteLine("Servers closed.");
}
}
/// <summary>
/// Generic initialize for all servers.
/// </summary>
/// <param name="server"></param>
public void Initialize(int port)
{
Media = new GXNet(NetworkType.Tcp, port);
Media.OnReceived += new Gurux.Common.ReceivedEventHandler(OnReceived);
Media.OnClientConnected += new Gurux.Common.ClientConnectedEventHandler(OnClientConnected);
Media.OnClientDisconnected += new Gurux.Common.ClientDisconnectedEventHandler(OnClientDisconnected);
Media.OnError += new Gurux.Common.ErrorEventHandler(OnError);
Media.Open();
///////////////////////////////////////////////////////////////////////
//Add Logical Device Name. 123456 is meter serial number.
GXDLMSData d = new GXDLMSData("0.0.42.0.0.255");
d.Value = "Gurux123456";
//Set access right. Client can't change Device name.
d.SetAccess(2, AccessMode.Read);
//Value is get as Octet String.
d.SetDataType(2, DataType.OctetString);
Items.Add(d);
//Add Last avarage.
GXDLMSRegister r = new GXDLMSRegister("1.1.21.25.0.255");
//Set access right. Client can't change average value.
r.SetAccess(2, AccessMode.Read);
Items.Add(r);
//Add default clock. Clock's Logical Name is 0.0.1.0.0.255.
GXDLMSClock clock = new GXDLMSClock();
clock.Begin = new GXDateTime(-1, 9, 1, -1, -1, -1, -1);
clock.End = new GXDateTime(-1, 3, 1, -1, -1, -1, -1);
clock.Deviation = 0;
Items.Add(clock);
//Add Tcp Udp setup. Default Logical Name is 0.0.25.0.0.255.
GXDLMSTcpUdpSetup tcp = new GXDLMSTcpUdpSetup();
Items.Add(tcp);
///////////////////////////////////////////////////////////////////////
//Add Load profile.
GXDLMSProfileGeneric pg = new GXDLMSProfileGeneric("1.0.99.1.0.255");
//Set capture period to 60 second.
pg.CapturePeriod = 60;
//Maximum row count.
pg.ProfileEntries = 100;
pg.SortMethod = SortMethod.FiFo;
pg.SortObject = clock;
//Add colums.
//Set saved attribute index.
clock.SelectedAttributeIndex = 2;
pg.CaptureObjects.Add(clock);
//Set saved attribute index.
r.SelectedAttributeIndex = 2;
pg.CaptureObjects.Add(r);
Items.Add(pg);
//Add initial rows.
pg.Buffer.Add(new object[] { DateTime.Now, (int)10 });
///////////////////////////////////////////////////////////////////////
//Add Auto connect object.
GXDLMSAutoConnect ac = new GXDLMSAutoConnect();
ac.Mode = AutoConnectMode.AutoDiallingAllowedAnytime;
ac.Repetitions = 10;
ac.RepetitionDelay = 60;
//Calling is allowed between 1am to 6am.
ac.CallingWindow.Add(new KeyValuePair<GXDateTime, GXDateTime>(new GXDateTime(-1, -1, -1, 1, 0, 0, -1), new GXDateTime(-1, -1, -1, 6, 0, 0, -1)));
ac.Destinations = new string[] { "www.gurux.org"};
Items.Add(ac);
///////////////////////////////////////////////////////////////////////
//Add Activity Calendar object.
GXDLMSActivityCalendar activity = new GXDLMSActivityCalendar();
activity.CalendarNameActive = "Active";
activity.SeasonProfileActive = new GXDLMSSeasonProfile[] { new GXDLMSSeasonProfile("Summer time", new GXDateTime(-1, 3, 31, -1, -1, -1, -1), "")};
activity.WeekProfileTableActive = new GXDLMSWeekProfile[]{new GXDLMSWeekProfile("Monday", 1, 1, 1, 1, 1, 1, 1)};
activity.DayProfileTableActive = new GXDLMSDayProfile[]{new GXDLMSDayProfile(1, new GXDLMSDayProfileAction[]{new GXDLMSDayProfileAction(new GXDateTime(DateTime.Now), "test", 1)})};
activity.CalendarNamePassive = "Passive";
activity.SeasonProfilePassive = new GXDLMSSeasonProfile[] { new GXDLMSSeasonProfile("Winter time", new GXDateTime(-1, 10, 30, -1, -1, -1, -1), "")};
activity.WeekProfileTablePassive = new GXDLMSWeekProfile[]{new GXDLMSWeekProfile("Tuesday", 1, 1, 1, 1, 1, 1, 1)};
activity.DayProfileTablePassive = new GXDLMSDayProfile[] { new GXDLMSDayProfile(1, new GXDLMSDayProfileAction[] { new GXDLMSDayProfileAction(new GXDateTime(DateTime.Now), "0.0.1.0.0.255", 1) }) };
activity.Time = new GXDateTime(DateTime.Now);
Items.Add(activity);
///////////////////////////////////////////////////////////////////////
//Add Optical Port Setup object.
GXDLMSIECOpticalPortSetup optical = new GXDLMSIECOpticalPortSetup();
optical.DefaultMode = OpticalProtocolMode.Default;
optical.ProposedBaudrate = BaudRate.Baudrate9600;
optical.DefaultBaudrate = BaudRate.Baudrate300;
optical.ResponseTime = LocalPortResponseTime.ms200;
optical.DeviceAddress = "Gurux";
optical.Password1 = "Gurux1";
optical.Password2 = "Gurux2";
optical.Password5 = "Gurux5";
Items.Add(optical);
///////////////////////////////////////////////////////////////////////
//Add Demand Register object.
GXDLMSDemandRegister dr = new GXDLMSDemandRegister();
dr.LogicalName = "0.0.1.0.0.255";
dr.CurrentAvarageValue = (uint) 10;
dr.LastAvarageValue = (uint) 20;
dr.Status = (byte)1;
dr.StartTimeCurrent = dr.CaptureTime = new GXDateTime(DateTime.Now);
dr.Period = 10;
dr.NumberOfPeriods = 1;
Items.Add(dr);
///////////////////////////////////////////////////////////////////////
//Add Register Monitor object.
GXDLMSRegisterMonitor rm = new GXDLMSRegisterMonitor();
rm.LogicalName = "0.0.1.0.0.255";
rm.Thresholds = new object[] { (int)0x1234, (int)0x5678 };
GXDLMSActionSet set = new GXDLMSActionSet();
set.ActionDown.LogicalName = rm.LogicalName;
set.ActionDown.ScriptSelector = 1;
set.ActionUp.LogicalName = rm.LogicalName;
set.ActionUp.ScriptSelector = 2;
rm.Actions = new GXDLMSActionSet[] {set };
rm.MonitoredValue.Update(r, 2);
Items.Add(rm);
///////////////////////////////////////////////////////////////////////
//Add action schedule object.
GXDLMSActionSchedule actionS = new GXDLMSActionSchedule();
actionS.LogicalName = "0.0.1.0.0.255";
actionS.ExecutedScriptLogicalName = "1.2.3.4.5.6";
actionS.ExecutedScriptSelector = 1;
actionS.Type = SingleActionScheduleType.SingleActionScheduleType1;
actionS.ExecutionTime = new GXDateTime[] {new GXDateTime(DateTime.Now) };
Items.Add(actionS);
///////////////////////////////////////////////////////////////////////
//Add SAP Assignment object.
GXDLMSSapAssignment sap = new GXDLMSSapAssignment();
sap.SapAssignmentList.Add(new KeyValuePair<UInt16, string>(1, "Gurux"));
sap.SapAssignmentList.Add(new KeyValuePair<UInt16, string>(16, "Gurux-2"));
Items.Add(sap);
///////////////////////////////////////////////////////////////////////
//Add Auto Answer object.
GXDLMSAutoAnswer aa = new GXDLMSAutoAnswer();
aa.Mode = AutoConnectMode.EmailSending;
aa.ListeningWindow.Add(new KeyValuePair<GXDateTime, GXDateTime>(new GXDateTime(-1, -1, -1, 6, -1, -1, -1), new GXDateTime(-1, -1, -1, 8, -1, -1, -1)));
aa.Status = AutoAnswerStatus.Inactive;
aa.NumberOfCalls = 0;
aa.NumberOfRingsInListeningWindow = 1;
aa.NumberOfRingsOutListeningWindow = 2;
Items.Add(aa);
///////////////////////////////////////////////////////////////////////
//Add Modem Configuration object.
GXDLMSModemConfiguration mc = new GXDLMSModemConfiguration();
mc.CommunicationSpeed = BaudRate.Baudrate57600;
GXDLMSModemInitialisation init = new GXDLMSModemInitialisation();
init.Request = "AT";
init.Response = "OK";
init.Delay = 0;
mc.InitialisationStrings = new GXDLMSModemInitialisation[] { init };
Items.Add(mc);
///////////////////////////////////////////////////////////////////////
//Add Mac Address Setup object.
GXDLMSMacAddressSetup mac = new GXDLMSMacAddressSetup();
mac.MacAddress = "00:11:22:33:44:55:66";
Items.Add(mac);
///////////////////////////////////////////////////////////////////////
//Server must initialize after all objects are added.
Initialize();
}
public int GetParameters(Settings settings)
{
string[] tmp;
List <GxCommand> parameters = new List <GxCommand>();//List<GXCmdParameter> parameters = GXCommon.GetParameters(args, "h:p:c:s:r:it:a:wP:g:S:C:");
parameters.Add(new GxCommand()
{
Tag = 'c', Value = configuration.ClientAdd
}); //"32"
parameters.Add(new GxCommand()
{
Tag = 'r', Value = configuration.Name
}); //"ln"
parameters.Add(new GxCommand()
{
Tag = 'h', Value = configuration.IpAddress
}); //"192.168.5.104"
parameters.Add(new GxCommand()
{
Tag = 'p', Value = Convert.ToString(configuration.Port)
}); //"502"
parameters.Add(new GxCommand()
{
Tag = 'a', Value = configuration.Authentication
}); //"Low"
parameters.Add(new GxCommand()
{
Tag = 'P', Value = configuration.Password
}); //"1111111111111111"
parameters.Add(new GxCommand()
{
Tag = 'g', Value = configuration.SObisValue
}); //"1.0.1.8.0.255:2"
parameters.Add(new GxCommand()
{
Tag = 'g', Value = configuration.RObisValue
});
GXNet net = null;
foreach (GxCommand it in parameters)
{
switch (it.Tag)
{
case 'w':
settings.client.InterfaceType = InterfaceType.WRAPPER;
break;
case 'r':
if (string.Compare(it.Value, "sn", true) == 0)
{
settings.client.UseLogicalNameReferencing = false;
}
else if (string.Compare(it.Value, "ln", true) == 0)
{
settings.client.UseLogicalNameReferencing = true;
}
else
{
throw new ArgumentException("Invalid reference option.");
}
break;
case 'h':
//Host address.
if (settings.media == null)
{
settings.media = new GXNet();
}
net = settings.media as GXNet;
net.HostName = it.Value;
break;
case 't':
//Trace.
try
{
settings.trace = (TraceLevel)Enum.Parse(typeof(TraceLevel), it.Value);
}
catch (Exception)
{
throw new ArgumentException("Invalid trace level option. (Error, Warning, Info, Verbose, Off)");
}
break;
case 'p':
//Port.
if (settings.media == null)
{
settings.media = new GXNet();
}
net = settings.media as GXNet;
net.Port = int.Parse(it.Value);
break;
case 'P': //Password
settings.client.Password = ASCIIEncoding.ASCII.GetBytes(it.Value);
break;
case 'i':
//IEC.
settings.iec = true;
break;
case 'g':
//Get (read) selected objects.
foreach (string o in it.Value.Split(new char[] { ';', ',' }))
{
tmp = o.Split(new char[] { ':' });
if (tmp.Length != 2)
{
throw new ArgumentOutOfRangeException("Invalid Logical name or attribute index.");
}
settings.readObjects.Add(new KeyValuePair <string, int>(tmp[0].Trim(), int.Parse(tmp[1].Trim())));
}
break;
case 'S': //Serial Port
settings.media = new GXSerial();
GXSerial serial = settings.media as GXSerial;
tmp = it.Value.Split(':');
serial.PortName = tmp[0];
if (tmp.Length > 1)
{
serial.BaudRate = int.Parse(tmp[1]);
serial.DataBits = int.Parse(tmp[2].Substring(0, 1));
serial.Parity = (Parity)Enum.Parse(typeof(Parity), tmp[2].Substring(1, tmp[2].Length - 2));
serial.StopBits = (StopBits)int.Parse(tmp[2].Substring(tmp[2].Length - 1, 1));
}
else
{
serial.BaudRate = 9600;
serial.DataBits = 8;
serial.Parity = Parity.None;
serial.StopBits = StopBits.One;
}
break;
case 'a':
try
{
if (string.Compare("None", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.None;
}
else if (string.Compare("Low", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.Low;
}
else if (string.Compare("High", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.High;
}
else if (string.Compare("HighMd5", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.HighMD5;
}
else if (string.Compare("HighSha1", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.HighSHA1;
}
else if (string.Compare("HighSha256", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.HighSHA256;
}
else if (string.Compare("HighGMac", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.HighGMAC;
}
else
{
throw new ArgumentException("Invalid Authentication option: '" + it.Value + "'. (None, Low, High, HighMd5, HighSha1, HighGMac, HighSha256)");
}
}
catch (Exception)
{
throw new ArgumentException("Invalid Authentication option: '" + it.Value + "'. (None, Low, High, HighMd5, HighSha1, HighGMac, HighSha256)");
}
break;
case 'C':
try
{
settings.client.Ciphering.Security = (Security)Enum.Parse(typeof(Security), it.Value);
}
catch (Exception)
{
throw new ArgumentException("Invalid Ciphering option. (None, Authentication, Encrypted, AuthenticationEncryption)");
}
break;
case 'o':
break;
case 'c':
settings.client.ClientAddress = int.Parse(it.Value);
break;
case 's':
settings.client.ServerAddress = int.Parse(it.Value);
break;
case '?':
switch (it.Tag)
{
case 'c':
throw new ArgumentException("Missing mandatory client option.");
case 's':
throw new ArgumentException("Missing mandatory server option.");
case 'h':
throw new ArgumentException("Missing mandatory host name option.");
case 'p':
throw new ArgumentException("Missing mandatory port option.");
case 'r':
throw new ArgumentException("Missing mandatory reference option.");
case 'a':
throw new ArgumentException("Missing mandatory authentication option.");
case 'S':
throw new ArgumentException("Missing mandatory Serial port option.");
case 't':
throw new ArgumentException("Missing mandatory trace option.");
case 'g':
throw new ArgumentException("Missing mandatory OBIS code option.");
case 'C':
throw new ArgumentException("Missing mandatory Ciphering option.");
default:
//ShowHelp();
return(1);
}
default:
//ShowHelp();
return(1);
}
}
if (settings.media == null)
{
// ShowHelp();
return(1);
}
return(0);
}
internal static int GetParameters(string[] args, GXSettings settings)
{
List <GXCmdParameter> parameters = GXCommon.GetParameters(args, "bh:p:c:s:r:it:a:p:wP:x:S:e:C:");
GXNet net = null;
foreach (GXCmdParameter it in parameters)
{
switch (it.Tag)
{
case 'w':
settings.client.InterfaceType = InterfaceType.WRAPPER;
break;
case 'r':
if (string.Compare(it.Value, "sn", true) == 0)
{
settings.client.UseLogicalNameReferencing = false;
}
else if (string.Compare(it.Value, "ln", true) == 0)
{
settings.client.UseLogicalNameReferencing = true;
}
else
{
throw new ArgumentException("Invalid reference option.");
}
break;
case 'h':
//Host address.
if (settings.media == null)
{
settings.media = new GXNet();
}
net = settings.media as GXNet;
net.HostName = it.Value;
break;
case 't':
//Trace.
try
{
settings.trace = (TraceLevel)Enum.Parse(typeof(TraceLevel), it.Value);
}
catch (Exception)
{
throw new ArgumentException("Invalid Authentication option. (Error, Warning, Info, Verbose, Off)");
}
break;
case 'p':
//Port.
if (settings.media == null)
{
settings.media = new GXNet();
}
net = settings.media as GXNet;
net.Port = int.Parse(it.Value);
break;
case 'P': //Password
settings.client.Password = ASCIIEncoding.ASCII.GetBytes(it.Value);
break;
case 'i':
//IEC.
settings.iec = true;
break;
case 'e':
//Exclude object type.
foreach (string ot in it.Value.Split(','))
{
settings.excludedObjects.Add((ObjectType)Enum.Parse(typeof(ObjectType), ot));
}
break;
case 'S': //Serial Port
settings.media = new GXSerial();
GXSerial serial = settings.media as GXSerial;
string[] tmp = it.Value.Split(':');
serial.PortName = tmp[0];
if (tmp.Length > 1)
{
serial.BaudRate = int.Parse(tmp[1]);
serial.DataBits = int.Parse(tmp[2].Substring(0, 1));
serial.Parity = (Parity)Enum.Parse(typeof(Parity), tmp[2].Substring(1, tmp[2].Length - 2));
serial.StopBits = (StopBits)int.Parse(tmp[2].Substring(tmp[2].Length - 1, 1));
}
else
{
serial.BaudRate = 9600;
serial.DataBits = 8;
serial.Parity = Parity.None;
serial.StopBits = StopBits.One;
}
break;
case 'a':
try
{
settings.client.Authentication = (Authentication)Enum.Parse(typeof(Authentication), it.Value);
}
catch (Exception)
{
throw new ArgumentException("Invalid Authentication option. (None, Low, High, HighMd5, HighSha1, HighGmac, HighSha256)");
}
break;
case 'C':
settings.tests = 0;
foreach (string ot in it.Value.Split(','))
{
settings.tests |= (ConformanceTest)Enum.Parse(typeof(ConformanceTest), ot);
}
break;
case 'o':
break;
case 'c':
settings.client.ClientAddress = int.Parse(it.Value);
break;
case 's':
settings.client.ServerAddress = int.Parse(it.Value);
break;
case 'x':
settings.path = it.Value;
break;
case '?':
switch (it.Tag)
{
case 'c':
throw new ArgumentException("Missing mandatory client option.");
case 's':
throw new ArgumentException("Missing mandatory server option.");
case 'h':
throw new ArgumentException("Missing mandatory host name option.");
case 'p':
throw new ArgumentException("Missing mandatory port option.");
case 'r':
throw new ArgumentException("Missing mandatory reference option.");
case 'a':
throw new ArgumentException("Missing mandatory authentication option.");
case 'S':
throw new ArgumentException("Missing mandatory Serial port option.\n");
case 't':
throw new ArgumentException("Missing mandatory trace option.\n");
case 'e':
throw new ArgumentException("Missing mandatory exclude object type option.\n");
default:
ShowHelp();
return(1);
}
default:
ShowHelp();
return(1);
}
}
if (settings.media == null)
{
ShowHelp();
return(1);
}
return(0);
}
public static int GetParameters(string[] args, Settings settings)
{
string[] tmp;
List <GXCmdParameter> parameters = GXCommon.GetParameters(args, "h:p:c:s:r:i:It:a:P:g:S:C:n:v:o:T:A:B:D:d:l:F:K:k:m:");
GXNet net = null;
foreach (GXCmdParameter it in parameters)
{
switch (it.Tag)
{
case 'r':
if (string.Compare(it.Value, "sn", true) == 0)
{
settings.client.UseLogicalNameReferencing = false;
}
else if (string.Compare(it.Value, "ln", true) == 0)
{
settings.client.UseLogicalNameReferencing = true;
}
else
{
throw new ArgumentException("Invalid reference option.");
}
break;
case 'h':
//Host address.
if (settings.media == null)
{
settings.media = new GXNet();
}
net = settings.media as GXNet;
net.HostName = it.Value;
break;
case 't':
//Trace.
try
{
settings.trace = (TraceLevel)Enum.Parse(typeof(TraceLevel), it.Value);
}
catch (Exception)
{
throw new ArgumentException("Invalid trace level option. (Error, Warning, Info, Verbose, Off)");
}
break;
case 'p':
//Port.
if (settings.media == null)
{
settings.media = new GXNet();
}
net = settings.media as GXNet;
net.Port = int.Parse(it.Value);
break;
case 'P': //Password
settings.client.Password = ASCIIEncoding.ASCII.GetBytes(it.Value);
break;
case 'i':
try
{
settings.client.InterfaceType = (InterfaceType)Enum.Parse(typeof(InterfaceType), it.Value);
settings.client.Plc.Reset();
}
catch (Exception)
{
throw new ArgumentException("Invalid interface type option. (HDLC, WRAPPER, HdlcWithModeE, Plc, PlcHdlc)");
}
break;
case 'I':
//AutoIncreaseInvokeID.
settings.client.AutoIncreaseInvokeID = true;
break;
case 'v':
settings.invocationCounter = it.Value.Trim();
Objects.GXDLMSObject.ValidateLogicalName(settings.invocationCounter);
break;
case 'g':
//Get (read) selected objects.
foreach (string o in it.Value.Split(new char[] { ';', ',' }))
{
tmp = o.Split(new char[] { ':' });
if (tmp.Length != 2)
{
throw new ArgumentOutOfRangeException("Invalid Logical name or attribute index.");
}
settings.readObjects.Add(new KeyValuePair <string, int>(tmp[0].Trim(), int.Parse(tmp[1].Trim())));
}
break;
case 'S': //Serial Port
settings.media = new GXSerial();
GXSerial serial = settings.media as GXSerial;
tmp = it.Value.Split(':');
serial.PortName = tmp[0];
if (tmp.Length > 1)
{
serial.BaudRate = int.Parse(tmp[1]);
serial.DataBits = int.Parse(tmp[2].Substring(0, 1));
serial.Parity = (Parity)Enum.Parse(typeof(Parity), tmp[2].Substring(1, tmp[2].Length - 2));
serial.StopBits = (StopBits)int.Parse(tmp[2].Substring(tmp[2].Length - 1, 1));
}
else
{
if (settings.client.InterfaceType == InterfaceType.HdlcWithModeE)
{
serial.BaudRate = 300;
serial.DataBits = 7;
serial.Parity = Parity.Even;
serial.StopBits = StopBits.One;
}
else
{
serial.BaudRate = 9600;
serial.DataBits = 8;
serial.Parity = Parity.None;
serial.StopBits = StopBits.One;
}
}
break;
case 'a':
try
{
if (string.Compare("None", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.None;
}
else if (string.Compare("Low", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.Low;
}
else if (string.Compare("High", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.High;
}
else if (string.Compare("HighMd5", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.HighMD5;
}
else if (string.Compare("HighSha1", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.HighSHA1;
}
else if (string.Compare("HighSha256", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.HighSHA256;
}
else if (string.Compare("HighGMac", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.HighGMAC;
}
else if (string.Compare("HighECDSA", it.Value, true) == 0)
{
settings.client.Authentication = Authentication.HighECDSA;
}
else
{
throw new ArgumentException("Invalid Authentication option: '" + it.Value + "'. (None, Low, High, HighMd5, HighSha1, HighGMac, HighSha256)");
}
}
catch (Exception)
{
throw new ArgumentException("Invalid Authentication option: '" + it.Value + "'. (None, Low, High, HighMd5, HighSha1, HighGMac, HighSha256)");
}
break;
case 'C':
try
{
settings.client.Ciphering.Security = Convert.ToByte(Enum.Parse(typeof(Security), it.Value));
}
catch (Exception)
{
throw new ArgumentException("Invalid Ciphering option '" + it.Value + "'. (None, Authentication, Encryption, AuthenticationEncryption)");
}
break;
case 'T':
settings.client.Ciphering.SystemTitle = GXCommon.HexToBytes(it.Value);
break;
case 'A':
settings.client.Ciphering.AuthenticationKey = GXCommon.HexToBytes(it.Value);
break;
case 'B':
settings.client.Ciphering.BlockCipherKey = GXCommon.HexToBytes(it.Value);
break;
case 'D':
settings.client.Ciphering.DedicatedKey = GXCommon.HexToBytes(it.Value);
break;
case 'F':
settings.client.Ciphering.InvocationCounter = UInt32.Parse(it.Value.Trim());
break;
case 'K':
GXPkcs8 cert1 = GXPkcs8.Load(it.Value);
settings.client.Ciphering.SigningKeyPair = new KeyValuePair <GXPrivateKey, GXPublicKey>(cert1.PrivateKey, cert1.PublicKey);
Console.WriteLine("Client Private key: " + GXDLMSTranslator.ToHex(cert1.PrivateKey.RawValue));
Console.WriteLine("Client Public key: " + GXDLMSTranslator.ToHex(cert1.PublicKey.RawValue));
break;
case 'k':
GXx509Certificate cert = GXx509Certificate.Load(it.Value);
if ((cert.KeyUsage & ASN.Enums.KeyUsage.DigitalSignature) == 0)
{
throw new Exception("This certificate is not used for digital signature.");
}
settings.client.Ciphering.PublicKeys.Add(new KeyValuePair <CertificateType, GXx509Certificate>(CertificateType.DigitalSignature, cert));
string[] sn = cert.Subject.Split('=');
if (sn.Length != 2)
{
throw new ArgumentOutOfRangeException("Invalid public key subject.");
}
settings.client.Ciphering.SystemTitle = GXDLMSTranslator.HexToBytes(sn[1]);
Console.WriteLine("Server Public key: " + GXDLMSTranslator.ToHex(cert.PublicKey.RawValue));
break;
case 'o':
settings.outputFile = it.Value;
break;
case 'd':
try
{
settings.client.Standard = (Standard)Enum.Parse(typeof(Standard), it.Value);
if (settings.client.Standard == Standard.Italy || settings.client.Standard == Standard.India || settings.client.Standard == Standard.SaudiArabia)
{
settings.client.UseUtc2NormalTime = true;
}
}
catch (Exception)
{
throw new ArgumentException("Invalid DLMS standard option '" + it.Value + "'. (DLMS, India, Italy, SaudiArabia, IDIS)");
}
break;
case 'c':
settings.client.ClientAddress = int.Parse(it.Value);
break;
case 's':
if (settings.client.ServerAddress != 1)
{
settings.client.ServerAddress = GXDLMSClient.GetServerAddress(settings.client.ServerAddress, int.Parse(it.Value));
}
else
{
settings.client.ServerAddress = int.Parse(it.Value);
}
break;
case 'l':
settings.client.ServerAddress = GXDLMSClient.GetServerAddress(int.Parse(it.Value), settings.client.ServerAddress);
break;
case 'n':
settings.client.ServerAddress = GXDLMSClient.GetServerAddress(int.Parse(it.Value));
break;
case 'm':
settings.client.Plc.MacDestinationAddress = UInt16.Parse(it.Value);
break;
case '?':
switch (it.Tag)
{
case 'c':
throw new ArgumentException("Missing mandatory client option.");
case 's':
throw new ArgumentException("Missing mandatory server option.");
case 'h':
throw new ArgumentException("Missing mandatory host name option.");
case 'p':
throw new ArgumentException("Missing mandatory port option.");
case 'r':
throw new ArgumentException("Missing mandatory reference option.");
case 'a':
throw new ArgumentException("Missing mandatory authentication option.");
case 'S':
throw new ArgumentException("Missing mandatory Serial port option.");
case 't':
throw new ArgumentException("Missing mandatory trace option.");
case 'g':
throw new ArgumentException("Missing mandatory OBIS code option.");
case 'C':
throw new ArgumentException("Missing mandatory Ciphering option.");
case 'v':
throw new ArgumentException("Missing mandatory invocation counter logical name option.");
case 'T':
throw new ArgumentException("Missing mandatory system title option.");
case 'A':
throw new ArgumentException("Missing mandatory authentication key option.");
case 'B':
throw new ArgumentException("Missing mandatory block cipher key option.");
case 'D':
throw new ArgumentException("Missing mandatory dedicated key option.");
case 'F':
throw new ArgumentException("Missing mandatory frame counter option.");
case 'd':
throw new ArgumentException("Missing mandatory DLMS standard option.");
case 'K':
throw new ArgumentException("Missing mandatory private key file option.");
case 'k':
throw new ArgumentException("Missing mandatory public key file option.");
case 'l':
throw new ArgumentException("Missing mandatory logical server address option.");
case 'm':
throw new ArgumentException("Missing mandatory MAC destination address option.");
default:
ShowHelp();
return(1);
}
default:
ShowHelp();
return(1);
}
}
if (settings.media == null)
{
ShowHelp();
return(1);
}
return(0);
}
public Settings(GXNet target)
{
Target = target;
InitializeComponent();
}
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);
}
}
}
public ReceiveThread(GXNet parent, Socket socket)
{
Closing = new ManualResetEvent(false);
m_Parent = parent;
m_Socket = socket;
}
public GXProperties(GXSettings settings)
{
Target = settings;
Target.client.UseLogicalNameReferencing = false;
InitializeComponent();
LNSettings.Dock = SNSettings.Dock = DockStyle.Fill;
SecurityCB.Items.AddRange(new object[] { Security.None, Security.Authentication,
Security.Encryption, Security.AuthenticationEncryption });
NetProtocolCB.Items.AddRange(new object[] { NetworkType.Tcp, NetworkType.Udp });
ServerAddressTypeCB.SelectedIndexChanged += new System.EventHandler(this.ServerAddressTypeCB_SelectedIndexChanged);
NetworkSettingsGB.Width = this.Width - NetworkSettingsGB.Left;
CustomSettings.Bounds = SerialSettingsGB.Bounds = TerminalSettingsGB.Bounds = NetworkSettingsGB.Bounds;
ManufacturerCB.DrawMode = MediasCB.DrawMode = ServerAddressTypeCB.DrawMode = AuthenticationCB.DrawMode = DrawMode.OwnerDrawFixed;
StartProtocolCB.Items.Add(StartProtocolType.IEC);
StartProtocolCB.Items.Add(StartProtocolType.DLMS);
GXNet net = new GXNet()
{
Protocol = NetworkType.Tcp
};
GXSerial serial = new GXSerial();
MediasCB.Items.Add(net);
MediasCB.Items.Add(serial);
//Initialize serial settings.
string[] ports = GXSerial.GetPortNames();
this.SerialPortCB.Items.AddRange(ports);
GXManufacturerCollection Manufacturers = new GXManufacturerCollection();
if (GXManufacturerCollection.IsFirstRun())
{
if (MessageBox.Show(this, Properties.Resources.InstallManufacturersOnlineTxt, Properties.Resources.CTT, MessageBoxButtons.YesNoCancel) == DialogResult.Yes)
{
GXManufacturerCollection.UpdateManufactureSettings();
}
}
GXManufacturerCollection.ReadManufacturerSettings(Manufacturers);
int pos = 0;
foreach (GXManufacturer it in Manufacturers)
{
int index = this.ManufacturerCB.Items.Add(it);
if (it.Identification == Properties.Settings.Default.SelectedManufacturer)
{
pos = index;
}
}
ManufacturerCB.SelectedIndex = pos;
if (Properties.Settings.Default.WaitTime != 0)
{
WaitTimeTB.Value = Properties.Settings.Default.WaitTime;
}
if (Properties.Settings.Default.Media == "Net")
{
MediasCB.SelectedIndex = 0;
net.Settings = Properties.Settings.Default.MediaSettings;
}
else
{
MediasCB.SelectedIndex = 1;
serial.Settings = Properties.Settings.Default.MediaSettings;
}
if (SerialPortCB.Items.Count != 0)
{
SerialPortCB.SelectedItem = serial.PortName;
}
HostNameTB.Text = net.HostName;
PortTB.Text = net.Port.ToString();
NetProtocolCB.SelectedItem = net.Protocol;
ShowConformance(Target.client.ProposedConformance);
}
