public GXPlcDiscover(MainForm parent)
{
InitializeComponent();
MetersView_SelectedIndexChanged(null, null);
_parent = parent;
try
{
if (Settings.Default.PlcInterface == (int)InterfaceType.PlcHdlc)
{
SFskMnu.Checked = true;
}
else
{
LlcMnu.Checked = true;
}
if (Settings.Default.PlcMedia == "GXSerial" && GXSerial.GetPortNames().Length != 0)
{
OnMediaTypeChanged(SerialMnu, null);
}
else
{
OnMediaTypeChanged(NetworkMnu, null);
}
}
catch (Exception ex)
{
MessageBox.Show(this, ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
Close();
}
}
public GXSerialMonitor()
{
InitializeComponent();
try
{
serial = new GXSerial();
serial.Settings = Properties.Settings.Default.SerialMonitorSettings;
serial.OnMediaStateChange += Serial_OnMediaStateChange;
serial.OnReceived += Serial_OnReceived;
foreach (string it in GXSerial.GetPortNames())
{
PortCb.Items.Add(it);
}
if (!string.IsNullOrEmpty(serial.PortName))
{
PortCb.SelectedItem = serial.PortName;
}
if (PortCb.Items.Count == 0)
{
SettingsBtn.Enabled = OpenBtn.Enabled = false;
}
}
catch (Exception ex)
{
MessageBox.Show(this, ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
Close();
}
}
public GXHdlcAddressResolver()
{
InitializeComponent();
try
{
GXSerial s = new GXSerial();
List <ToolStripItem> rates = new List <ToolStripItem>();
List <string> list = new List <string>(Settings.Default.HdlcAddressBaudRates.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries));
bool addAll = list.Count == 0;
foreach (int rate in s.GetAvailableBaudRates(null))
{
if (rate != 0)
{
ToolStripMenuItem it = new ToolStripMenuItem();
it.Checked = list.Count == 0 || list.Contains(rate.ToString());
it.CheckOnClick = true;
it.CheckedChanged += It_CheckedChanged;
it.Text = it.Name = rate.ToString();
rates.Add(it);
if (addAll)
{
Settings.Default.HdlcAddressBaudRates += ";" + rate.ToString();
}
}
}
ScanBaudRateMnu.DropDownItems.AddRange(rates.ToArray());
if (Settings.Default.HdlcAddressMedia == "GXSerial" && GXSerial.GetPortNames().Length != 0)
{
OnMediaTypeChanged(SerialMnu, null);
}
else
{
OnMediaTypeChanged(NetworkMnu, null);
}
if (Settings.Default.HdlcAddressUseOpticalProbe && media is GXSerial)
{
UseOpticalProbeMnu_Click(null, null);
}
if (Settings.Default.HdlcAddressScanBaudRates)
{
ScanBaudRateMnu_Click(null, null);
}
Manufacturers = new GXManufacturerCollection();
GXManufacturerCollection.ReadManufacturerSettings(Manufacturers);
}
catch (Exception ex)
{
MessageBox.Show(this, ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
Close();
}
}
/// <summary>
/// Media type is changed.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnMediaTypeChanged(object sender, EventArgs e)
{
try
{
if (media != null)
{
media.OnMediaStateChange -= OnMediaStateChange;
media.OnReceived -= OnReceived;
media.OnTrace -= MediaOnTrace;
}
bool isSerial = sender == SerialMnu || sender == SerialBtn;
if (isSerial)
{
media = new GXSerial();
media.Settings = Settings.Default.HdlcAddressSerialSettings;
media.OnMediaStateChange += OnMediaStateChange;
media.OnReceived += OnReceived;
media.OnTrace += MediaOnTrace;
media.Trace = TraceLevel.Verbose;
if (GXSerial.GetPortNames().Length == 0)
{
MediaSettingsMnu.Enabled = MediaSettingsMnu.Enabled = false;
}
Settings.Default.HdlcAddressMedia = "GXSerial";
}
else
{
media = new GXNet();
(media as GXNet).ConfigurableSettings = Gurux.Net.AvailableMediaSettings.All & ~Gurux.Net.AvailableMediaSettings.Server;
media.Settings = Settings.Default.HdlcAddressNetworkSettings;
media.OnMediaStateChange += OnMediaStateChange;
media.OnReceived += OnReceived;
media.OnTrace += MediaOnTrace;
media.Trace = TraceLevel.Verbose;
MediaSettingsMnu.Enabled = MediaSettingsMnu.Enabled = true;
Settings.Default.HdlcAddressMedia = "GXNet";
}
UpdateStatus("Ready.");
SerialBtn.Checked = UseOpticalProbeMnu.Enabled = SerialMnu.Checked = isSerial;
NetworkBtn.Checked = NetworkMnu.Checked = !isSerial;
ScanBaudRatesBtn.Enabled = ScanBaudRateMnu.Enabled = OpticalProbeBtn.Enabled = UseOpticalProbeMnu.Enabled = isSerial;
}
catch (Exception ex)
{
MessageBox.Show(this, ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
void IGXPropertyPage.Initialize()
{
//Update texts.
this.Text = Resources.SettingsTxt;
this.PortNameLbl.Text = Resources.PortNameTxt;
this.BaudRateLbl.Text = Resources.BaudRateTxt;
this.DataBitsLbl.Text = Resources.DataBitsTxt;
this.ParityLbl.Text = Resources.ParityTxt;
this.StopBitsLbl.Text = Resources.StopBitsTxt;
//Hide controls which user do not want to show.
PortNamePanel.Enabled = (target.ConfigurableSettings & AvailableMediaSettings.PortName) != 0;
if (PortNamePanel.Enabled)
{
if (target.AvailablePorts != null)
{
PortNameCB.Items.AddRange(target.AvailablePorts);
}
else
{
PortNameCB.Items.AddRange(GXSerial.GetPortNames());
}
if (this.PortNameCB.Items.Contains(target.PortName))
{
this.PortNameCB.SelectedItem = target.PortName;
}
else
{
if (PortNameCB.Items.Count != 0)
{
this.PortNameCB.SelectedIndex = 0;
}
else
{
StopBitsPanel.Enabled = ParityPanel.Enabled = DataBitsPanel.Enabled = BaudRatePanel.Enabled = this.PortNameCB.Enabled = false;
return;
}
}
}
BaudRatePanel.Enabled = (target.ConfigurableSettings & AvailableMediaSettings.BaudRate) != 0;
if (BaudRatePanel.Enabled)
{
PortNameCB_SelectedIndexChanged(null, null);
this.BaudRateCB.SelectedItem = target.BaudRate;
}
DataBitsPanel.Enabled = (target.ConfigurableSettings & AvailableMediaSettings.DataBits) != 0;
if (DataBitsPanel.Enabled)
{
this.DataBitsCB.Items.Add(7);
this.DataBitsCB.Items.Add(8);
this.DataBitsCB.SelectedItem = target.DataBits;
}
ParityPanel.Enabled = (target.ConfigurableSettings & AvailableMediaSettings.Parity) != 0;
if (ParityPanel.Enabled)
{
this.ParityCB.Items.Add(System.IO.Ports.Parity.None);
this.ParityCB.Items.Add(System.IO.Ports.Parity.Odd);
this.ParityCB.Items.Add(System.IO.Ports.Parity.Even);
this.ParityCB.Items.Add(System.IO.Ports.Parity.Mark);
this.ParityCB.Items.Add(System.IO.Ports.Parity.Space);
this.ParityCB.SelectedItem = target.Parity;
}
StopBitsPanel.Enabled = (target.ConfigurableSettings & AvailableMediaSettings.StopBits) != 0;
if (StopBitsPanel.Enabled)
{
this.StopBitsCB.Items.Add(System.IO.Ports.StopBits.None);
this.StopBitsCB.Items.Add(System.IO.Ports.StopBits.One);
this.StopBitsCB.Items.Add(System.IO.Ports.StopBits.OnePointFive);
this.StopBitsCB.Items.Add(System.IO.Ports.StopBits.Two);
this.StopBitsCB.SelectedItem = target.StopBits;
}
Dirty = false;
}
public DevicePropertiesForm(GXManufacturerCollection manufacturers, GXDLMSDevice dev)
{
try
{
InitializeComponent();
SecurityCB.Items.AddRange(new object[] { Security.None, Security.Authentication,
Security.Encryption, Security.AuthenticationEncryption });
NetProtocolCB.Items.AddRange(new object[] { NetworkType.Tcp, NetworkType.Udp });
this.ServerAddressTypeCB.SelectedIndexChanged += new System.EventHandler(this.ServerAddressTypeCB_SelectedIndexChanged);
NetworkSettingsGB.Width = this.Width - NetworkSettingsGB.Left;
SerialSettingsGB.Bounds = TerminalSettingsGB.Bounds = NetworkSettingsGB.Bounds;
ServerAddressTypeCB.DrawMode = AuthenticationCB.DrawMode = DrawMode.OwnerDrawFixed;
Manufacturers = manufacturers;
//OK button is not enabled if there are no manufacturers.
if (Manufacturers.Count == 0)
{
OKBtn.Enabled = false;
}
//Show supported services tab only when they are read.
if (dev == null || dev.Comm.client.SNSettings == null && dev.Comm.client.LNSettings == null)
{
DeviceTab.TabPages.Remove(SupportedServicesTab);
}
else
{
object settings = null;
if (dev.Comm.client.UseLogicalNameReferencing)
{
settings = dev.Comm.client.LNSettings;
}
else
{
settings = dev.Comm.client.SNSettings;
}
if (settings != null)
{
SupportedServicesGrid.SelectedObject = settings;
foreach (PropertyDescriptor it in TypeDescriptor.GetProperties(settings))
{
ReadOnlyAttribute att = (ReadOnlyAttribute)it.Attributes[typeof(ReadOnlyAttribute)];
if (att != null)
{
FieldInfo[] f = att.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Instance);
f[0].SetValue(att, true);
}
}
}
}
Device = dev;
StartProtocolCB.Items.Add(StartProtocolType.IEC);
StartProtocolCB.Items.Add(StartProtocolType.DLMS);
int pos = 0;
foreach (GXManufacturer it in Manufacturers)
{
int index = this.ManufacturerCB.Items.Add(it);
if (it.Name == GXDLMSDirector.Properties.Settings.Default.SelectedManufacturer)
{
pos = index;
}
}
if (Device == null)
{
Device = new GXDLMSDevice(null);
//Select first manufacturer.
if (Manufacturers.Count != 0)
{
ManufacturerCB.SelectedIndex = pos;
}
}
else
{
foreach (GXManufacturer it in this.ManufacturerCB.Items)
{
if (string.Compare(it.Identification, Device.Manufacturer, true) == 0)
{
this.ManufacturerCB.SelectedItem = it;
break;
}
}
this.VerboseModeCB.Checked = dev.Verbose;
this.NameTB.Text = dev.Name;
SelectedMedia = dev.Media;
UseRemoteSerialCB.Checked = Device.UseRemoteSerial;
StartProtocolCB.SelectedItem = Device.StartProtocol;
PhysicalServerAddressTB.Value = Convert.ToDecimal(Device.PhysicalAddress);
LogicalServerAddressTB.Value = Convert.ToDecimal(Device.LogicalAddress);
this.ClientAddTB.Value = Convert.ToDecimal(Convert.ToUInt32(Device.ClientAddress));
WaitTimeTB.Value = Device.WaitTime;
SecurityCB.SelectedItem = dev.Security;
SystemTitleTB.Text = dev.SystemTitle;
BlockCipherKeyTB.Text = dev.BlockCipherKey;
AuthenticationKeyTB.Text = dev.AuthenticationKey;
UseUtcTimeZone.Checked = Device.UtcTimeZone;
}
ManufacturerCB.DrawMode = MediasCB.DrawMode = DrawMode.OwnerDrawFixed;
Gurux.Net.GXNet net = new Gurux.Net.GXNet();
//Initialize network settings.
if (SelectedMedia is GXNet)
{
this.MediasCB.Items.Add(SelectedMedia);
net.Protocol = Gurux.Net.NetworkType.Tcp;
this.HostNameTB.Text = ((GXNet)SelectedMedia).HostName;
this.PortTB.Text = ((GXNet)SelectedMedia).Port.ToString();
NetProtocolCB.SelectedItem = ((GXNet)SelectedMedia).Protocol;
}
else
{
NetProtocolCB.SelectedItem = net.Protocol = Gurux.Net.NetworkType.Tcp;
this.MediasCB.Items.Add(net);
}
//Set maximum baud rate.
GXSerial serial = new GXSerial();
foreach (int it in serial.GetAvailableBaudRates(""))
{
if (it != 0)
{
MaximumBaudRateCB.Items.Add(it);
}
}
if (Device.MaximumBaudRate == 0)
{
UseMaximumBaudRateCB.Checked = false;
UseMaximumBaudRateCB_CheckedChanged(null, null);
}
else
{
UseMaximumBaudRateCB.Checked = true;
this.MaximumBaudRateCB.SelectedItem = Device.MaximumBaudRate;
}
if (SelectedMedia is GXSerial)
{
this.MediasCB.Items.Add(SelectedMedia);
string[] ports = GXSerial.GetPortNames();
this.SerialPortCB.Items.AddRange(ports);
if (ports.Length != 0)
{
this.SerialPortCB.SelectedItem = ((GXSerial)SelectedMedia).PortName;
}
}
else
{
//Initialize serial settings.
string[] ports = GXSerial.GetPortNames();
this.SerialPortCB.Items.AddRange(ports);
if (ports.Length != 0)
{
serial.PortName = ports[0];
}
if (((GXManufacturer)ManufacturerCB.SelectedItem).StartProtocol == StartProtocolType.DLMS)
{
serial.BaudRate = 9600;
serial.DataBits = 8;
serial.Parity = Parity.None;
serial.StopBits = StopBits.One;
}
else
{
serial.BaudRate = 300;
serial.DataBits = 7;
serial.Parity = Parity.Even;
serial.StopBits = StopBits.One;
}
this.MediasCB.Items.Add(serial);
}
if (SelectedMedia is Gurux.Terminal.GXTerminal)
{
this.MediasCB.Items.Add(SelectedMedia);
string[] ports = GXTerminal.GetPortNames();
this.TerminalPortCB.Items.AddRange(ports);
if (ports.Length != 0)
{
this.TerminalPortCB.SelectedItem = ((Gurux.Terminal.GXTerminal)SelectedMedia).PortName;
}
this.TerminalPhoneNumberTB.Text = ((Gurux.Terminal.GXTerminal)SelectedMedia).PhoneNumber;
}
else
{
//Initialize terminal settings.
Gurux.Terminal.GXTerminal termial = new Gurux.Terminal.GXTerminal();
string[] ports = GXTerminal.GetPortNames();
this.TerminalPortCB.Items.AddRange(ports);
if (ports.Length != 0)
{
termial.PortName = ports[0];
}
termial.BaudRate = 9600;
termial.DataBits = 8;
termial.Parity = Parity.None;
termial.StopBits = StopBits.One;
this.TerminalPhoneNumberTB.Text = termial.PhoneNumber;
//termial.InitializeCommands = "AT+CBST=71,0,1\r\n";
this.MediasCB.Items.Add(termial);
}
//Select first media if medis is not selected.
if (SelectedMedia == null)
{
SelectedMedia = (Gurux.Common.IGXMedia) this.MediasCB.Items[0];
}
this.MediasCB.SelectedItem = SelectedMedia;
if (!string.IsNullOrEmpty(Device.Password))
{
this.PasswordTB.Text = ASCIIEncoding.ASCII.GetString(CryptHelper.Decrypt(Device.Password, Password.Key));
}
if (dev != null)
{
this.UseLNCB.Checked = dev.UseLogicalNameReferencing;
}
this.AuthenticationCB.SelectedIndexChanged += new System.EventHandler(this.AuthenticationCB_SelectedIndexChanged);
bool bConnected = Device.Media != null && Device.Media.IsOpen;
SerialPortCB.Enabled = AdvancedBtn.Enabled = ManufacturerCB.Enabled = MediasCB.Enabled =
AuthenticationCB.Enabled = UseRemoteSerialCB.Enabled = OKBtn.Enabled = !bConnected;
HostNameTB.ReadOnly = PortTB.ReadOnly = PasswordTB.ReadOnly = WaitTimeTB.ReadOnly = PhysicalServerAddressTB.ReadOnly = NameTB.ReadOnly = bConnected;
}
catch (Exception Ex)
{
GXDLMS.Common.Error.ShowError(this, Ex);
}
}
static int Main(string[] args)
{
Settings settings = new Settings();
Reader.GXDLMSReader reader = null;
try
{
////////////////////////////////////////
//Handle command line parameters.
int ret = Settings.GetParameters(args, settings);
if (ret != 0)
{
return(ret);
}
////////////////////////////////////////
//Initialize connection settings.
if (settings.media is GXSerial)
{
}
else if (settings.media is GXNet)
{
}
else
{
throw new Exception("Unknown media type.");
}
////////////////////////////////////////
reader = new Reader.GXDLMSReader(settings.client, settings.media, settings.trace, settings.invocationCounter);
try
{
settings.media.Open();
}
catch (System.IO.IOException ex)
{
Console.WriteLine("----------------------------------------------------------");
Console.WriteLine(ex.Message);
Console.WriteLine("Available ports:");
Console.WriteLine(string.Join(" ", GXSerial.GetPortNames()));
return(1);
}
//Some meters need a break here.
Thread.Sleep(1000);
if (settings.readObjects.Count != 0)
{
bool read = false;
if (settings.outputFile != null)
{
try
{
settings.client.Objects.Clear();
settings.client.Objects.AddRange(GXDLMSObjectCollection.Load(settings.outputFile));
read = true;
}
catch (Exception)
{
//It's OK if this fails.
}
}
reader.InitializeConnection();
if (!read)
{
reader.GetAssociationView(settings.outputFile);
}
foreach (KeyValuePair <string, int> it in settings.readObjects)
{
object val = reader.Read(settings.client.Objects.FindByLN(ObjectType.None, it.Key), it.Value);
reader.ShowValue(val, it.Value);
}
if (settings.outputFile != null)
{
try
{
settings.client.Objects.Save(settings.outputFile, new GXXmlWriterSettings()
{
UseMeterTime = true, IgnoreDefaultValues = false
});
}
catch (Exception)
{
//It's OK if this fails.
}
}
}
else
{
reader.ReadAll(settings.outputFile);
}
}
catch (GXDLMSException ex)
{
Console.WriteLine(ex.Message);
if (System.Diagnostics.Debugger.IsAttached)
{
Console.ReadKey();
}
return(1);
}
catch (GXDLMSExceptionResponse ex)
{
Console.WriteLine(ex.Message);
if (System.Diagnostics.Debugger.IsAttached)
{
Console.ReadKey();
}
return(1);
}
catch (GXDLMSConfirmedServiceError ex)
{
Console.WriteLine(ex.Message);
if (System.Diagnostics.Debugger.IsAttached)
{
Console.ReadKey();
}
return(1);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.ToString());
if (System.Diagnostics.Debugger.IsAttached)
{
Console.ReadKey();
}
return(1);
}
finally
{
if (reader != null)
{
reader.Close();
}
if (System.Diagnostics.Debugger.IsAttached)
{
Console.WriteLine("Ended. Press any key to continue.");
Console.ReadKey();
}
}
return(0);
}
static void Main(string[] args)
{
IGXMedia media = null;
GXCommunicatation comm = null;
try
{
////////////////////////////////////////
//Handle command line parameters.
String id = "", host = "", port = "", pw = "";
bool trace = false, iec = true, isSerial = false;
Authentication auth = Authentication.High;
foreach (string it in args)
{
String item = it.Trim().ToLower();
if (string.Compare(item, "/u", true) == 0)//Update
{
//Get latest manufacturer settings from Gurux web server.
GXManufacturerCollection.UpdateManufactureSettings();
}
else if (item.StartsWith("/m="))//Manufacturer
{
id = item.Replace("/m=", "");
}
else if (item.StartsWith("/h=")) //Host
{
host = item.Replace("/h=", "");
}
else if (item.StartsWith("/p="))// TCP/IP Port
{
media = new Gurux.Net.GXNet();
port = item.Replace("/p=", "");
}
else if (item.StartsWith("/sp="))//Serial Port
{
port = item.Replace("/sp=", "");
isSerial = true;
media = new GXSerial();
}
else if (item.StartsWith("/t"))//Are messages traced.
{
trace = true;
}
else if (item.StartsWith("/s="))//Start
{
String tmp = item.Replace("/s=", "");
iec = string.Compare(tmp, "dlms", true) != 0;
}
else if (item.StartsWith("/a="))//Authentication
{
auth = (Authentication)Enum.Parse(typeof(Authentication), it.Trim().Replace("/a=", ""));
}
else if (item.StartsWith("/pw="))//Password
{
pw = it.Trim().Replace("/pw=", "");
}
else
{
ShowHelp();
return;
}
}
//if (string.IsNullOrEmpty(id) || string.IsNullOrEmpty(port) || (!isSerial && string.IsNullOrEmpty(host)))
//{
// ShowHelp();
// return;
//}
////////////////////////////////////////
//Initialize connection settings.
if (isSerial)
{
GXSerial serial = media as GXSerial;
string[] t = GXSerial.GetPortNames();
serial.PortName = port;
if (iec)
{
serial.BaudRate = 300;
serial.DataBits = 7;
serial.Parity = System.IO.Ports.Parity.Even;
serial.StopBits = System.IO.Ports.StopBits.One;
}
else
{
serial.BaudRate = 9600;
serial.DataBits = 8;
serial.Parity = System.IO.Ports.Parity.None;
serial.StopBits = System.IO.Ports.StopBits.One;
}
}
else
{
Gurux.Net.GXNet net = media as Gurux.Net.GXNet;
net.Port = Convert.ToInt32(port);
net.HostName = host;
net.Protocol = Gurux.Net.NetworkType.Tcp;
}
////////////////////////////////////////
//Update manufacturer debended settings.
GXManufacturerCollection Manufacturers = new GXManufacturerCollection();
GXManufacturerCollection.ReadManufacturerSettings(Manufacturers);
GXManufacturer man = Manufacturers.FindByIdentification(id);
if (man == null)
{
throw new Exception("Unknown manufacturer: " + id);
}
Gurux.DLMS.GXDLMS dlms = new Gurux.DLMS.GXDLMS();
//Update Obis code list so we can get right descriptions to the objects.
dlms.ObisCodes = man.ObisCodes;
comm = new GXCommunicatation(dlms, media, iec, auth, pw);
comm.Trace = trace;
comm.InitializeConnection(man);
//Save Association view to the cache so it is not needed to retreave every time.
string path = man.Identification + ".xml";
Gurux.DLMS.GXDLMSObjectCollection objects = null;
Type[] extraTypes = new Type[] { typeof(GXManufacturerCollection), typeof(GXManufacturer), typeof(GXObisCodeCollection), typeof(GXObisCode), typeof(GXObisValueItem), typeof(GXObisValueItemCollection), typeof(GXDLMSProfileGenericObject) };
XmlSerializer x = new XmlSerializer(typeof(GXDLMSObjectCollection), extraTypes);
if (File.Exists(path))
{
try
{
using (Stream stream = File.Open(path, FileMode.Open))
{
Console.WriteLine("Get available objects from the cache.");
objects = x.Deserialize(stream) as Gurux.DLMS.GXDLMSObjectCollection;
stream.Close();
}
}
catch (Exception ex)
{
if (File.Exists(path))
{
File.Delete(path);
}
throw ex;
}
}
else
{
Console.WriteLine("Get available objects from the device.");
objects = comm.GetAssociationView();
try
{
using (Stream stream = File.Open(path, FileMode.Create))
{
TextWriter writer = new StreamWriter(stream);
x.Serialize(writer, objects);
writer.Close();
stream.Close();
}
}
catch (Exception ex)
{
if (File.Exists(path))
{
File.Delete(path);
}
throw ex;
}
Console.WriteLine("--- Available objects ---");
foreach (Gurux.DLMS.GXDLMSObject it in objects)
{
Console.WriteLine(it.Name + " " + it.Description);
}
}
//Read available clock and data objects.
foreach (Gurux.DLMS.GXDLMSObject it in objects.GetObjects(new ObjectType[] { ObjectType.Clock, ObjectType.Data }))
{
object value = comm.Read(it, 2);
Console.WriteLine(it.Name + " " + it.Description + " " + value);
}
//Read Profile Generic columns.
GXDLMSObjectCollection cols = null;
foreach (Gurux.DLMS.GXDLMSObject it in objects.GetObjects(ObjectType.ProfileGeneric))
{
Console.WriteLine("Profile Generic " + it.Name + " Columns:");
cols = comm.GetColumns(it);
foreach (GXDLMSObject col in cols)
{
Console.Write(col.Name + " | ");
}
Console.WriteLine("");
//Read first row from Profile Generic.
Console.WriteLine("Profile Generic " + it.Name + " Columns:");
object[] rows = comm.ReadRowsByEntry(it, 0, 1, cols);
foreach (object[] row in rows)
{
foreach (object cell in row)
{
Console.Write(cell + " | ");
}
Console.WriteLine("");
}
//Read last dayfrom Profile Generic.
Console.WriteLine("Profile Generic " + it.Name + " Columns:");
rows = comm.ReadRowsByRange(it, DateTime.Now.Date, DateTime.MaxValue, cols);
foreach (object[] row in rows)
{
foreach (object cell in row)
{
Console.Write(cell + " | ");
}
Console.WriteLine("");
}
}
}
catch (Exception ex)
{
if (comm != null)
{
comm.Close();
}
Console.WriteLine(ex.Message);
if (!System.Diagnostics.Debugger.IsAttached)
{
Console.ReadKey();
}
}
finally
{
comm.Close();
if (System.Diagnostics.Debugger.IsAttached)
{
Console.ReadKey();
}
}
}
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);
}
