/// <summary>
/// Read Profile Generic Columns by entry.
/// </summary>
public object[] ReadRowsByEntry(GXDLMSProfileGeneric it, int index, int count)
{
GXReplyData reply = new GXReplyData();
ReadDataBlock(Client.ReadRowsByEntry(it, index, count), reply);
return (object[])Client.UpdateValue(it, 2, reply.Value);
}
/// <summary>
/// Read Profile Generic Columns by range.
/// </summary>
public object[] ReadRowsByRange(GXDLMSProfileGeneric it, DateTime start, DateTime end)
{
GXReplyData reply = new GXReplyData();
ReadDataBlock(Client.ReadRowsByRange(it, start, end), reply);
return (object[])Client.UpdateValue(it, 2, reply.Value);
}
public List<GXKeyValuePair<GXDLMSObject, GXDLMSCaptureObject>> Refresh(GXDLMSProfileGeneric item, GXDLMSCommunicator comm)
{
if (item.LogicalName.CompareTo("0.0.99.1.2.255") == 0) // LoadProfile1EndOfRecordingData
{
List<GXKeyValuePair<GXDLMSObject, GXDLMSCaptureObject>> items = new List<GXKeyValuePair<GXDLMSObject, GXDLMSCaptureObject>>();
//Read profile generic columns.
object value = comm.GetProfileGenericColumns(item.Name);
byte[] data = comm.Read("0.0.99.128.1.255", ObjectType.ProfileGeneric, 2);
byte[] allData = comm.ReadDataBlock(data, "Get profile generic columns...", 1);
object[] values = (object[])comm.m_Cosem.GetValue(allData);
Array info = values[0] as Array;
GXDLMSObject obj = new GXDLMSData();
obj.Description = "DateTime";
obj.SetUIDataType(1, DataType.DateTime);
items.Add(new GXKeyValuePair<GXDLMSObject, GXDLMSCaptureObject>(obj, new GXDLMSCaptureObject(1, 0)));
obj = new GXDLMSData();
obj.Description = "Status";
items.Add(new GXKeyValuePair<GXDLMSObject, GXDLMSCaptureObject>(obj, new GXDLMSCaptureObject(2, 0)));
//Two last items contains Start and end date.
int cnt = 4;
for (int pos = 0; pos < info.Length - 2; pos += 2)
{
obj = new GXDLMSData();
obj.LogicalName = GXHelpers.ConvertFromDLMS(info.GetValue(pos), DataType.OctetString, DataType.OctetString, false).ToString();
object scalerUnit = info.GetValue(pos + 1);
obj.Description = "";
items.Add(new GXKeyValuePair<GXDLMSObject, GXDLMSCaptureObject>(obj, new GXDLMSCaptureObject(++cnt, 0)));
}
LastDateTime = ((GXDateTime) GXDLMS.Common.GXHelpers.ConvertFromDLMS(info.GetValue(info.Length - 1), DataType.OctetString, DataType.DateTime, true)).Value;
return items;
}
return null;
}
/// <summary>
/// Returns collection of manufacturer Obis codes to implement custom read.
/// </summary>
/// <param name="name">Short or Logical Name.</param>
/// <param name="type">Interface type.</param>
/// <returns>True, if data read is handled.</returns>
public bool Read(object sender, GXDLMSObject item, GXDLMSObjectCollection columns, int attribute, GXDLMSCommunicator comm)
{
MainForm = sender as System.Windows.Forms.Form;
if (!(item is GXDLMSProfileGeneric))
{
return false;
}
//Actaris do not support other than index 2.
if (attribute != 0 && attribute != 2)
{
return true;
}
if (comm.OnBeforeRead != null)
{
comm.OnBeforeRead(item, attribute);
}
CurrentProfileGeneric = item as GXDLMSProfileGeneric;
if (item is GXDLMSProfileGeneric)
{
GXDLMSProfileGeneric pg = item as GXDLMSProfileGeneric;
byte[] data;
try
{
comm.OnDataReceived += new GXDLMSCommunicator.DataReceivedEventHandler(this.OnProfileGenericDataReceived);
//Read profile generic columns.
if (pg.AccessSelector != AccessRange.Entry)
{
data = comm.m_Cosem.ReadRowsByRange(pg.Name, pg.CaptureObjects[0].Key.LogicalName,
pg.CaptureObjects[0].Key.ObjectType, pg.CaptureObjects[0].Key.Version, Convert.ToDateTime(pg.From).Date, Convert.ToDateTime(pg.To).Date);
data = comm.ReadDataBlock(data, "Reading profile generic data", 1);
}
else
{
data = comm.m_Cosem.ReadRowsByEntry(pg.Name, Convert.ToInt32(pg.From), Convert.ToInt32(pg.To));
data = comm.ReadDataBlock(data, "Reading profile generic data " + pg.Name, 1);
}
}
finally
{
CurrentProfileGeneric = null;
comm.OnDataReceived -= new GXDLMSCommunicator.DataReceivedEventHandler(this.OnProfileGenericDataReceived);
}
return true;
}
return false;
}
void GetProfileGenericData(GXDLMSProfileGeneric pg, byte[] data)
{
int selector;
object from, to;
//If all data is readed.
if (data.Length == 0)
{
SendData.AddRange(GetData(pg.Buffer));
return;
}
GetAccessSelector(data, out selector, out from, out to);
DataTable table = pg.Buffer.Clone();
if (selector == 1) //Read by range
{
DateTime start = (DateTime)from;
DateTime end = (DateTime)to;
foreach (DataRow row in pg.Buffer.Rows)
{
DateTime tm = Convert.ToDateTime(row[0]);
if (tm >= start && tm <= end)
{
table.Rows.Add(row.ItemArray);
}
}
}
else if (selector == 2)//Read by entry.
{
int start = Convert.ToInt32(from);
int count = Convert.ToInt32(to);
if (start + count < pg.Buffer.Rows.Count)
{
for (int pos = 0; pos < count; ++pos)
{
if (pos == pg.Buffer.Rows.Count)
{
break;
}
table.Rows.Add(pg.Buffer.Rows[start + pos].ItemArray);
}
}
}
SendData.AddRange(GetData(table));
}
public GXProfileGenericUpdater(GXDLMSServerBase server, GXDLMSProfileGeneric pg)
{
Server = server;
Target = pg;
}
/// <summary>
/// Read object.
/// </summary>
/// <param name="InitialValues"></param>
/// <param name="obj"></param>
/// <param name="attribute"></param>
public void Read(object sender, GXDLMSObject obj, int attribute)
{
foreach (int it in (obj as IGXDLMSBase).GetAttributeIndexToRead())
{
if (obj is GXDLMSProfileGeneric && it == 2)
{
if (OnBeforeRead != null)
{
OnBeforeRead(obj, it);
}
try
{
CurrentProfileGeneric = obj as GXDLMSProfileGeneric;
OnDataReceived += new GXDLMSCommunicator.DataReceivedEventHandler(this.OnProfileGenericDataReceived);
if (CurrentProfileGeneric.AccessSelector != AccessRange.Entry)
{
GXDLMSObject obj2 = CurrentProfileGeneric.CaptureObjects[0].Key;
byte[] tmp = m_Cosem.ReadRowsByRange(CurrentProfileGeneric.Name, obj2.LogicalName,
obj2.ObjectType, obj2.Version,
Convert.ToDateTime(CurrentProfileGeneric.From), Convert.ToDateTime(CurrentProfileGeneric.To));
ReadDataBlock(tmp, "Reading profile generic data", 1);
}
else
{
byte[] tmp = m_Cosem.ReadRowsByEntry(CurrentProfileGeneric.Name, Convert.ToInt32(CurrentProfileGeneric.From), Convert.ToInt32(CurrentProfileGeneric.To));
ReadDataBlock(tmp, "Reading profile generic data " + CurrentProfileGeneric.Name, 1);
}
}
finally
{
if (OnAfterRead != null)
{
OnAfterRead(obj, it);
}
OnDataReceived -= new GXDLMSCommunicator.DataReceivedEventHandler(OnProfileGenericDataReceived);
}
continue;
}
else
{
if (OnBeforeRead != null)
{
OnBeforeRead(obj, it);
}
byte[] data = m_Cosem.Read(obj.Name, obj.ObjectType, it)[0];
try
{
data = ReadDataBlock(data, "Read object type " + obj.ObjectType + " index: " + it);
}
catch (GXDLMSException ex)
{
if (ex.ErrorCode == 3 || //If read is denied.
ex.ErrorCode == 4 || // Undefined object.
ex.ErrorCode == 13) //Actaris returns access violation error.
{
obj.SetAccess(it, AccessMode.NoAccess);
continue;
}
else
{
throw ex;
}
}
if (obj is IGXDLMSBase)
{
object value = m_Cosem.GetValue(data);
DataType type;
if (value is byte[] && (type = obj.GetUIDataType(it)) != DataType.None)
{
value = GXDLMS.Common.GXHelpers.ConvertFromDLMS(value, obj.GetDataType(it), type, true);
}
(obj as IGXDLMSBase).SetValue(it, value);
}
if (OnAfterRead != null)
{
OnAfterRead(obj, it);
}
obj.SetLastReadTime(it, DateTime.Now);
//If only selected attribute is read.
if (attribute != 0)
{
break;
}
}
}
}
/// <summary>
/// Read object.
/// </summary>
/// <param name="InitialValues"></param>
/// <param name="obj"></param>
/// <param name="attribute"></param>
public void Read(object sender, GXDLMSObject obj, int attribute)
{
GXReplyData reply = new GXReplyData();
foreach (int it in (obj as IGXDLMSBase).GetAttributeIndexToRead())
{
reply.Clear();
if (obj is GXDLMSProfileGeneric && it == 2)
{
if (OnBeforeRead != null)
{
OnBeforeRead(obj, it);
}
try
{
CurrentProfileGeneric = obj as GXDLMSProfileGeneric;
OnDataReceived += new GXDLMSCommunicator.DataReceivedEventHandler(this.OnProfileGenericDataReceived);
if (CurrentProfileGeneric.AccessSelector == AccessRange.Range ||
CurrentProfileGeneric.AccessSelector == AccessRange.Last)
{
byte[][] tmp = client.ReadRowsByRange(CurrentProfileGeneric, Convert.ToDateTime(CurrentProfileGeneric.From), Convert.ToDateTime(CurrentProfileGeneric.To));
ReadDataBlock(tmp[0], "Reading profile generic data", 1, reply);
}
else if (CurrentProfileGeneric.AccessSelector == AccessRange.Entry)
{
byte[][] tmp = client.ReadRowsByEntry(CurrentProfileGeneric, Convert.ToInt32(CurrentProfileGeneric.From), Convert.ToInt32(CurrentProfileGeneric.To));
ReadDataBlock(tmp[0], "Reading profile generic data " + CurrentProfileGeneric.Name, 1, reply);
}
else //Read all.
{
byte[] tmp = client.Read(CurrentProfileGeneric, 2)[0];
ReadDataBlock(tmp, "Reading profile generic data " + CurrentProfileGeneric.Name, 1, reply);
}
}
finally
{
if (OnAfterRead != null)
{
OnAfterRead(obj, it);
}
OnDataReceived -= new GXDLMSCommunicator.DataReceivedEventHandler(OnProfileGenericDataReceived);
}
continue;
}
else
{
if (OnBeforeRead != null)
{
OnBeforeRead(obj, it);
}
byte[] data = client.Read(obj.Name, obj.ObjectType, it)[0];
try
{
ReadDataBlock(data, "Read object type " + obj.ObjectType + " index: " + it, reply);
}
catch (GXDLMSException ex)
{
if (ex.ErrorCode == 3 || //If read is denied.
ex.ErrorCode == 4 || // Undefined object.
ex.ErrorCode == 13) //Actaris returns access violation error.
{
obj.SetAccess(it, AccessMode.NoAccess);
continue;
}
else
{
throw ex;
}
}
if (obj is IGXDLMSBase)
{
object value = reply.Value;
DataType type;
if (value is byte[] && (type = obj.GetUIDataType(it)) != DataType.None)
{
value = GXDLMSClient.ChangeType((byte[])value, type);
}
client.UpdateValue(obj, it, value);
}
if (OnAfterRead != null)
{
OnAfterRead(obj, it);
}
obj.SetLastReadTime(it, DateTime.Now);
//If only selected attribute is read.
if (attribute != 0)
{
break;
}
}
}
}
public void ExecuteParseCommand(object sender, string command, GXPacket[] packets)
{
GXPacket[] arr = packets;
if (command == "UAReply")
{
UAReply(sender, arr[0]);
}
else if (command == "AAREReply")
{
AAREReply(sender, arr[0]);
}
else if (command == "CheckReplyPacket")
{
//Get data as byte array.
byte[] reply = arr[0].ExtractPacket();
CheckErrors(reply, true);
}
else if (command == "ReadDataReply") //Update property value
{
byte[] data = null;
//Get data as byte array.
foreach (GXPacket it in arr)
{
byte[] reply = it.ExtractPacket();
CheckErrors(reply, false);
parser.GetDataFromPacket(reply, ref data);
}
GXDLMSProperty prop = sender as GXDLMSProperty;
object value;
if (prop.ObjectType == ObjectType.Data ||
prop.ObjectType == ObjectType.Register ||
prop.ObjectType == ObjectType.ExtendedRegister ||
prop.ObjectType == ObjectType.DemandRegister)
{
GXDLMSObject obj = Gurux.DLMS.GXDLMSClient.CreateObject(prop.ObjectType);
if (prop.DLMSType == DataType.None)
{
prop.DLMSType = parser.GetDLMSDataType(data);
}
obj.SetDataType(prop.AttributeOrdinal, prop.DLMSType);
obj.SetUIDataType(prop.AttributeOrdinal, prop.ValueType);
obj.LogicalName = prop.LogicalName;
//Update scaler if register.
if (prop is GXDLMSRegister)
{
GXDLMSRegister r = prop as GXDLMSRegister;
if (obj is GXDLMSDemandRegister)
{
(obj as GXDLMSDemandRegister).Scaler = r.Scaler;
}
else
{
(obj as Gurux.DLMS.Objects.GXDLMSRegister).Scaler = r.Scaler;
}
}
parser.UpdateValue(data, obj, prop.AttributeOrdinal);
value = obj.GetValues()[prop.AttributeOrdinal - 1];
}
else if (prop.Parent.Parent is GXDLMSCategory)
{
GXDLMSCategory cat = prop.Parent.Parent as GXDLMSCategory;
GXDLMSObject obj = Gurux.DLMS.GXDLMSClient.CreateObject(cat.ObjectType);
obj.LogicalName = prop.LogicalName;
parser.UpdateValue(data, obj, prop.AttributeOrdinal);
value = obj.GetValues()[prop.AttributeOrdinal - 1];
}
else
{
throw new Exception("Invalid target.");
}
prop.ReadTime = DateTime.Now;
prop.SetValue(value, false, Gurux.Device.PropertyStates.ValueChangedByDevice);
}
else if (command == "ReadDataTypeReply") //Update property value
{
byte[] data = null;
//Get data as byte array.
foreach (GXPacket it in arr)
{
byte[] reply = it.ExtractPacket();
CheckErrors(reply, false);
parser.GetDataFromPacket(reply, ref data);
}
ObjectDataType = parser.GetDLMSDataType(data);
}
else if (command == "WriteDataReply")
{
//Get data as byte array.
foreach (GXPacket it in arr)
{
byte[] reply = it.ExtractPacket();
CheckErrors(reply, false);
}
Gurux.Device.GXProperty prop = sender as Gurux.Device.GXProperty;
prop.WriteTime = DateTime.Now;
prop.NotifyPropertyChange(Gurux.Device.PropertyStates.ValueChangedByDevice);
}
else if (command == "UpdateTableContent")//Get table columns after all all data is received.
{
TableColumns = parser.ParseColumns(ReceivedData);
GXDLMSTable table = sender as GXDLMSTable;
List<int> values = new List<int>();
int pos = 0;
foreach (var it in TableColumns)
{
foreach (GXDLMSProperty prop in table.Columns)
{
if (string.Compare(prop.LogicalName, it.Key.LogicalName, true) == 0)
{
values.Add(pos);
break;
}
}
++pos;
}
ColumnIndexs = values.ToArray();
}
else if (command == "UpdateTableInfo")//Update read extra info
{
if (this.Extension != null)
{
Dictionary<GXObisCode, object> items = new Dictionary<GXObisCode, object>(ExtraInfo);
this.Extension.UpdateExtraInfo(items);
}
}
else if (command == "UpdateCapturePeriod")//Update Capture Period of the table.
{
GXDLMSTable table = sender as GXDLMSTable;
//Get data as byte array.
foreach (GXPacket it in arr)
{
byte[] allData = null;
byte[] reply = it.ExtractPacket();
CheckErrors(reply, false);
parser.GetDataFromPacket(reply, ref allData);
table.CapturePeriod = Convert.ToInt32(parser.GetValue(allData));
}
}
else if (command == "UpdateTableData")//Get table columns after all all data is received.
{
pg = null;
if (!this.TryParse)
{
//Parse DLMS objexts.
Array reply = (Array)parser.GetValue(ReceivedData);
GXDLMSTable table = sender as GXDLMSTable;
// If there is no data.
if (reply.Length == 0)
{
table.ClearRows();
}
else
{
int count = table.RowCount;
List<object[]> rows = new List<object[]>(reply.Length);
foreach (object row in reply)
{
rows.Add((object[])row);
}
table.AddRows(count, rows, false);
//Get rows back because DeviceValueToUiValue is called.
rows = table.GetRows(count, reply.Length, true);
Gurux.Device.Editor.IGXPartialRead partialRead = table as Gurux.Device.Editor.IGXPartialRead;
//Save latest read time. Note we must add one second or we will read last values again.
if (partialRead.Type == Gurux.Device.Editor.PartialReadType.New)
{
DateTime tm = new DateTime(2000, 1, 1);
foreach (object[] it in rows)
{
if ((DateTime)it[0] > tm)
{
tm = (DateTime)it[0];
}
}
partialRead.Start = tm.AddSeconds(1);
}
}
}
}
else
{
throw new NotImplementedException();
}
}
public GXProfileGenericUpdater(GXDLMSServerBase server, GXDLMSProfileGeneric pg)
{
Server = server;
Target = pg;
}
public void ExecuteSendCommand(object sender, string command, GXPacket packet)
{
if (command != "ReadAARQNext" && command != "ReadNextInfo" && command != "ReadNext")
{
IsMoreDataAvailable = RequestTypes.None;
}
GXDLMSProperty prop = sender as GXDLMSProperty;
if (command == "InitRead")
{
LastNotifiedTransactionProgress = 0;
InitRead(sender, packet);
}
else if (command == "ReadSNRMSend")
{
LastNotifiedTransactionProgress = 0;
ReadSNRMSend(sender, packet);
}
else if (command == "ReadAARQ")
{
LastNotifiedTransactionProgress = 0;
ReadAARQ(sender, packet);
}
else if (command == "ReadAARQNext")
{
LastNotifiedTransactionProgress = 0;
ReadAARQNext(sender, packet);
}
else if (command == "ReadData")
{
LastNotifiedTransactionProgress = 0;
ReadData(prop, packet);
}
else if (command == "ReadDataType")
{
LastNotifiedTransactionProgress = 0;
ReadDataType(prop, packet);
}
else if (command == "WriteData")
{
LastNotifiedTransactionProgress = 0;
WriteData(prop, packet);
}
else if (command == "KeepAliveRequest")
{
LastNotifiedTransactionProgress = 0;
//Network connection don't need this.
if (!SupportNetworkSpecificSettings)
{
packet.AppendData(parser.GetKeepAlive());
}
}
else if (command == "DisconnectRequest")
{
LastNotifiedTransactionProgress = 0;
//Network connection don't need this.
if (!SupportNetworkSpecificSettings)
{
packet.AppendData(parser.DisconnectRequest());
}
}
else if (command == "ReadTableInfo")
{
if (this.Extension != null)
{
ReceivedData = null;
ExtraInfoPos = 0;
ExtraInfo.Clear();
List<GXObisCode> items = new List<GXObisCode>();
this.Extension.ReadExtraInfo(items);
if (items.Count != 0)
{
foreach (GXObisCode it in items)
{
ExtraInfo.Add(it, null);
}
GXObisCode item = items[0];
packet.AppendData(parser.Read(item.LogicalName, item.ObjectType, item.AttributeIndex)[0]);
}
}
}
else if (command == "ReadCapturePeriod")
{
ReceivedData = null;
GXDLMSTable table = sender as GXDLMSTable;
//Capture period is read only once.
if (table.CapturePeriod == 0)
{
if (parser.UseLogicalNameReferencing)
{
packet.AppendData(parser.Read(table.LogicalName, Gurux.DLMS.ObjectType.ProfileGeneric, 4)[0]);
}
else
{
packet.AppendData(parser.Read(table.ShortName, Gurux.DLMS.ObjectType.ProfileGeneric, 4)[0]);
}
}
}
else if (command == "ReadTableContent")
{
//Check start and end times.
DateTime starttm, endtm;
GXDLMSTable table = sender as GXDLMSTable;
(table as IGXPartialRead).GetStartEndTime(out starttm, out endtm);
LastNotifiedTransactionProgress = 0;
ReceivedData = null;
TryParse = false;
if (parser.UseLogicalNameReferencing)
{
packet.AppendData(parser.Read(table.LogicalName, Gurux.DLMS.ObjectType.ProfileGeneric, 3)[0]);
}
else
{
packet.AppendData(parser.Read(table.ShortName, Gurux.DLMS.ObjectType.ProfileGeneric, 3)[0]);
}
}
else if (command == "ReadNextInfo") //Read next part of the data or next item.
{
//Read next extra info.
if (IsMoreDataAvailable == Gurux.DLMS.RequestTypes.None)
{
GXObisCode item = ExtraInfo.Keys.ElementAt(ExtraInfoPos);
object data = parser.Read(item.LogicalName, item.ObjectType, item.AttributeIndex)[0];
packet.AppendData(data);
}
else //Read next part of the data.
{
Gurux.DLMS.RequestTypes readItem = Gurux.DLMS.RequestTypes.Frame;
if ((IsMoreDataAvailable & RequestTypes.Frame) == 0)
{
readItem = Gurux.DLMS.RequestTypes.DataBlock;
}
packet.AppendData(parser.ReceiverReady(readItem));
}
}
else if (command == "ReadNext") //Read next part of data.
{
Gurux.DLMS.RequestTypes readItem = Gurux.DLMS.RequestTypes.Frame;
if ((IsMoreDataAvailable & RequestTypes.Frame) == 0)
{
readItem = Gurux.DLMS.RequestTypes.DataBlock;
}
packet.AppendData(parser.ReceiverReady(readItem));
}
else if (command == "ReadTableData") //Read next part of data.
{
pg = Gurux.DLMS.GXDLMSClient.CreateObject(ObjectType.ProfileGeneric) as Gurux.DLMS.Objects.GXDLMSProfileGeneric;
GXDLMSTable table2 = sender as GXDLMSTable;
pg.CapturePeriod = table2.CapturePeriod;
foreach (GXDLMSProperty col in table2.Columns)
{
GXDLMSObject item = Gurux.DLMS.GXDLMSClient.CreateObject(col.ObjectType);
item.SetDataType(col.AttributeOrdinal, col.DLMSType);
item.SetUIDataType(col.AttributeOrdinal, col.ValueType);
item.LogicalName = col.LogicalName;
//Update scaler for register.
if (col is GXDLMSRegister && col.AttributeOrdinal == 2)
{
GXDLMSRegister r = col as GXDLMSRegister;
if (item.ObjectType == ObjectType.DemandRegister)
{
(item as Gurux.DLMS.Objects.GXDLMSDemandRegister).Scaler = r.Scaler;
}
else
{
(item as Gurux.DLMS.Objects.GXDLMSRegister).Scaler = r.Scaler;
}
}
pg.CaptureObjects.Add(new GXKeyValuePair<GXDLMSObject, GXDLMSCaptureObject>(item, new GXDLMSCaptureObject(col.AttributeOrdinal, 0)));
}
LastNotifiedTransactionProgress = 0;
GXDLMSTable table = sender as GXDLMSTable;
ReceivedRows = 0;
TryParse = true;
ReceivedData = null;
IGXPartialRead partialRead = table as IGXPartialRead;
object name, data;
int EDISType = 0, Version = 0;
if (parser.UseLogicalNameReferencing)
{
name = table.LogicalName;
}
else
{
name = table.ShortName;
}
string ClockLN = "0.0.1.0.0.255";
if (partialRead.Type == PartialReadType.All)
{
data = parser.Read(name, ObjectType.ProfileGeneric, 2)[0];
}
else if (partialRead.Type == PartialReadType.Entry)
{
data = parser.ReadRowsByEntry(name, Convert.ToInt32((table as IGXPartialRead).Start), Convert.ToInt32((table as IGXPartialRead).End));
}
else
{
DateTime starttm = DateTime.MinValue, endtm = DateTime.MaxValue;
if (table.Columns.Count != 0)
{
GXDLMSProperty col = table.Columns[0] as GXDLMSProperty;
EDISType = col.AttributeOrdinal;
Version = col.Version;
}
(table as IGXPartialRead).GetStartEndTime(out starttm, out endtm);
System.Diagnostics.Debug.WriteLine("Reading table between: " + starttm.ToString() + "" + endtm.ToString());
data = parser.ReadRowsByRange(name, ClockLN, Gurux.DLMS.ObjectType.Clock, Version, starttm, endtm);
}
packet.AppendData(data);
}
else
{
throw new NotImplementedException();
}
}
void Init()
{
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 ldn = new GXDLMSData("0.0.42.0.0.255");
ldn.Value = "Gurux123456";
//Set access right. Client can't change Device name.
ldn.SetAccess(2, AccessMode.Read);
//Value is get as Octet String.
ldn.SetDataType(2, DataType.OctetString);
ldn.SetUIDataType(2, DataType.String);
Items.Add(ldn);
//Add firmware version.
GXDLMSData fw = new GXDLMSData("1.0.0.2.0.255");
fw.Value = "Gurux FW 0.0.1";
Items.Add(fw);
//Add Last average.
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 columns.
//Set saved attribute index.
pg.CaptureObjects.Add(new GXKeyValuePair<GXDLMSObject, GXDLMSCaptureObject>(clock, new GXDLMSCaptureObject(2, 0)));
//Set saved attribute index.
pg.CaptureObjects.Add(new GXKeyValuePair<GXDLMSObject, GXDLMSCaptureObject>(r, new GXDLMSCaptureObject(2, 0)));
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.CurrentAverageValue = (uint)10;
dr.LastAverageValue = (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 Activate test mode Script table object.
GXDLMSScriptTable st = new GXDLMSScriptTable("0.1.10.1.101.255");
GXDLMSScript s = new GXDLMSScript();
s.Id = 1;
GXDLMSScriptAction a = new GXDLMSScriptAction();
a.Target = null;
s.Actions.Add(a);
st.Scripts.Add(s);
Items.Add(st);
///////////////////////////////////////////////////////////////////////
//Add action schedule object.
GXDLMSActionSchedule actionS = new GXDLMSActionSchedule();
actionS.LogicalName = "0.0.1.0.0.255";
actionS.Target = st;
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 = AutoAnswerMode.Connected;
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);
///////////////////////////////////////////////////////////////////////
//Add Image transfer object.
GXDLMSImageTransfer i = new GXDLMSImageTransfer();
Items.Add(i);
///////////////////////////////////////////////////////////////////////
//Add IP4 Setup object.
GXDLMSIp4Setup ip4 = new GXDLMSIp4Setup();
//Get local IP address.
var host = Dns.GetHostEntry(Dns.GetHostName());
foreach (var ip in host.AddressList)
{
if (ip.AddressFamily == AddressFamily.InterNetwork)
{
ip4.IPAddress = ip.ToString();
}
}
Items.Add(ip4);
//Add Push Setup. (On Connectivity)
GXDLMSPushSetup push = new GXDLMSPushSetup("0.0.25.9.0.255");
//Send Push messages to this address as default.
push.Destination = ip4.IPAddress + ":7000";
Items.Add(push);
//Add push object itself. This is needed to tell structure of data to the Push listener.
push.PushObjectList.Add(new KeyValuePair<GXDLMSObject, GXDLMSCaptureObject>(push, new GXDLMSCaptureObject(2, 0)));
//Add logical device name.
push.PushObjectList.Add(new KeyValuePair<GXDLMSObject, GXDLMSCaptureObject>(ldn, new GXDLMSCaptureObject(2, 0)));
//Add .0.0.25.1.0.255 Ch. 0 IPv4 setup IP address.
push.PushObjectList.Add(new KeyValuePair<GXDLMSObject, GXDLMSCaptureObject>(ip4, new GXDLMSCaptureObject(3, 0)));
//Add S-FSK objects
Items.Add(new GXDLMSSFSKPhyMacSetUp());
Items.Add(new GXDLMSSFSKActiveInitiator());
Items.Add(new GXDLMSSFSKMacCounters());
Items.Add(new GXDLMSSFSKMacSynchronizationTimeouts());
//Add IEC14908 (OSGB) objects.
Items.Add(new GXDLMSIEC14908Diagnostic());
Items.Add(new GXDLMSIEC14908Identification());
Items.Add(new GXDLMSIEC14908PhysicalSetup());
Items.Add(new GXDLMSIEC14908PhysicalStatus());
///////////////////////////////////////////////////////////////////////
//Server must initialize after all objects are added.
Initialize();
}
public GXProfileGenericUpdater(GXDLMSServer server, GXDLMSProfileGeneric pg)
{
Closing = new AutoResetEvent(false);
Server = server;
Target = pg;
}
void OnUpdateTarget(GXDLMSObject value)
{
m_Target = (GXDLMSProfileGeneric)value;
m_MyPane.GraphPane.CurveList.Clear();
GXDLMSObject obj;
int index = 0;
if (m_Target != null)
{
m_MyPane.GraphPane.Title.Text = m_Target.Description;
DataTable table = ProfileGenericView.DataSource as DataTable;
ProfileGenericView.DataSource = null;
ProfileGenericView.Columns.Clear();
DataTable dt = new DataTable();
foreach (var it in m_Target.CaptureObjects)
{
DataColumn dc = dt.Columns.Add(index.ToString());
dc.Caption = it.Key.Description;
int pos = ProfileGenericView.Columns.Add(index.ToString(), it.Key.Description);
ProfileGenericView.Columns[pos].DataPropertyName = index.ToString();
++index;
}
foreach(object[] it in m_Target.Buffer)
{
dt.LoadDataRow(it, true);
}
ProfileGenericView.DataSource = dt;
if (m_Target.CaptureObjects.Count != 0 && m_Target.CaptureObjects[0].Value.AttributeIndex != 0)
{
//We can show graph only tables that are date based.
if (m_Target.CaptureObjects[0].Key.GetUIDataType(m_Target.CaptureObjects[0].Value.AttributeIndex) == DataType.DateTime)
{
for (int col = 0; col < m_Target.CaptureObjects.Count; ++col)
{
//Do not shown Status' or Events
index = m_Target.CaptureObjects[col].Value.AttributeIndex;
if (index > 0 && ((index & 0x8) != 0 || (m_Target.CaptureObjects[col].Value.AttributeIndex & 0x10) != 0))
{
continue;
}
obj = m_Target.CaptureObjects[col].Key;
GXGraphItem item = GraphItems.Find(obj.LogicalName, index);
if (item != null && item.Enabled && GXHelpers.IsNumeric(obj.GetUIDataType(index)))
{
ZedGraph.DataSourcePointList dspl = new ZedGraph.DataSourcePointList();
dspl.DataSource = m_Target.Buffer;
dspl.XDataMember = m_Target.CaptureObjects[0].Key.Description;
dspl.YDataMember = obj.Description;
ZedGraph.LineItem myCurve = m_MyPane.GraphPane.AddCurve(obj.Description, dspl, item.Color);
}
}
m_MyPane.GraphPane.XAxis.Title.Text = m_Target.CaptureObjects[0].Key.LogicalName;
// Tell ZedGraph to refigure the axes since the data have changed
m_MyPane.AxisChange();
}
}
}
else
{
ProfileGenericView.DataSource = null;
}
//Set initial values...
ReadFromRB.Enabled = ReadLastRB.Enabled = ReadEntryBtn.Enabled = m_Target.CaptureObjects.Count != 0;
ReadFromRB.Checked = ReadLastRB.Checked = ReadEntryBtn.Checked = false;
StartEntry.Value = 0;
EndEntry.Value = 1;
ReadLastTB.Value = 0;
StartPick.Value = ToPick.Value = DateTime.Now;
if (!ReadFromRB.Enabled)
{
return;
}
index = m_Target.CaptureObjects[0].Value.AttributeIndex;
obj = m_Target.CaptureObjects[0].Key;
if (index != 0 &&
obj.GetUIDataType(index) != DataType.DateTime)
{
ReadFromRB.Enabled = ReadLastRB.Enabled = false;
m_Target.AccessSelector = AccessRange.Entry;
m_Target.From = 0;
m_Target.To = 1;
}
else
{
ReadFromRB.Enabled = ReadLastRB.Enabled = true;
}
if (m_Target.AccessSelector == AccessRange.Entry)
{
StartEntry.Value = Convert.ToInt32(m_Target.From);
EndEntry.Value = Convert.ToInt32(m_Target.To);
ReadEntryBtn.Checked = true;
}
else if (m_Target.AccessSelector == AccessRange.Last)
{
TimeSpan diff = (DateTime)m_Target.To - (DateTime)m_Target.From;
ReadLastTB.Value = diff.Days - 1;
ReadLastRB.Checked = true;
}
else if (m_Target.AccessSelector == AccessRange.Range)
{
if ((DateTime)m_Target.From == DateTime.MinValue)
{
StartPick.Checked = false;
}
else
{
StartPick.Value = (DateTime)m_Target.From;
}
if ((DateTime)m_Target.To == DateTime.MaxValue)
{
ToPick.Checked = false;
}
else
{
ToPick.Value = (DateTime)m_Target.To;
}
ReadFromRB.Checked = true;
}
else //All is checked.
{
ReadAllRB.Checked = true;
}
}
public List<GXKeyValuePair<GXDLMSObject, GXDLMSCaptureObject>> Refresh(GXDLMSProfileGeneric item, GXDLMSCommunicator comm)
{
GXReplyData reply = new GXReplyData();
if (item.LogicalName.CompareTo("0.0.99.1.2.255") == 0) // LoadProfile1EndOfRecordingData
{
List<GXKeyValuePair<GXDLMSObject, GXDLMSCaptureObject>> items = new List<GXKeyValuePair<GXDLMSObject, GXDLMSCaptureObject>>();
//Read profile generic columns.
comm.GetProfileGenericColumns(item);
byte[] data = comm.Read(item, 2);
comm.ReadDataBlock(data, "Get profile generic columns...", 1, reply);
object[] values = (object[])reply.Value;
Array info = values[0] as Array;
GXDLMSObject obj = new GXDLMSData();
obj.Description = "DateTime";
obj.SetUIDataType(1, DataType.DateTime);
items.Add(new GXKeyValuePair<GXDLMSObject, GXDLMSCaptureObject>(obj, new GXDLMSCaptureObject(1, 0)));
obj = new GXDLMSData();
obj.Description = "Status";
items.Add(new GXKeyValuePair<GXDLMSObject, GXDLMSCaptureObject>(obj, new GXDLMSCaptureObject(2, 0)));
//Two last items contains Start and end date.
int cnt = 4;
for (int pos = 0; pos < info.Length - 2; pos += 2)
{
obj = new GXDLMSData();
obj.LogicalName = Convert.ToString(GXDLMSClient.ChangeType((byte[])info.GetValue(pos), DataType.OctetString));
object scalerUnit = info.GetValue(pos + 1);
obj.Description = "";
items.Add(new GXKeyValuePair<GXDLMSObject, GXDLMSCaptureObject>(obj, new GXDLMSCaptureObject(++cnt, 0)));
}
LastDateTime = (GXDateTime)GXDLMSClient.ChangeType((byte[]) info.GetValue(info.Length - 1), DataType.DateTime);
return items;
}
return null;
}
public void GetProfileGenericColumns(GXDLMSProfileGeneric item)
{
GXReplyData reply = new GXReplyData();
ReadDataBlock(Read(item, 3), "Get profile generic columns...", reply);
client.UpdateValue(item, 3, reply.Value);
}
/// <summary>
/// Returns collection of manufacturer Obis codes to implement custom read.
/// </summary>
/// <param name="name">Short or Logical Name.</param>
/// <param name="type">Interface type.</param>
/// <returns>True, if data read is handled.</returns>
public bool Read(object sender, GXDLMSObject item, GXDLMSObjectCollection columns, int attribute, GXDLMSCommunicator comm)
{
MainForm = sender as System.Windows.Forms.Form;
if (!(item is GXDLMSProfileGeneric))
{
return false;
}
//Actaris do not support other than index 2.
if (attribute != 0 && attribute != 2)
{
return true;
}
if (comm.OnBeforeRead != null)
{
comm.OnBeforeRead(item, attribute);
}
CurrentProfileGeneric = item as GXDLMSProfileGeneric;
if (item is GXDLMSProfileGeneric)
{
GXDLMSProfileGeneric pg = item as GXDLMSProfileGeneric;
GXReplyData reply = new GXReplyData();
byte[][] data;
try
{
comm.OnDataReceived += new GXDLMSCommunicator.DataReceivedEventHandler(this.OnProfileGenericDataReceived);
//Read profile generic columns.
if (pg.AccessSelector == AccessRange.Range ||
pg.AccessSelector == AccessRange.Last)
{
data = comm.client.ReadRowsByRange(pg, Convert.ToDateTime(pg.From).Date, Convert.ToDateTime(pg.To).Date);
comm.ReadDataBlock(data[0], "Reading profile generic data", 1, reply);
}
else if (pg.AccessSelector == AccessRange.Entry)
{
data = comm.client.ReadRowsByEntry(pg, Convert.ToInt32(pg.From), Convert.ToInt32(pg.To));
comm.ReadDataBlock(data[0], "Reading profile generic data " + pg.Name, 1, reply);
}
else //Read All.
{
data = comm.client.Read(pg, 2);
comm.ReadDataBlock(data[0], "Reading profile generic data " + pg.Name, 1, reply);
}
}
finally
{
CurrentProfileGeneric = null;
comm.OnDataReceived -= new GXDLMSCommunicator.DataReceivedEventHandler(this.OnProfileGenericDataReceived);
}
return true;
}
return false;
}
public void UpdateColumns(GXDLMSProfileGeneric item, GXManufacturer man)
{
if (Comm.ParentForm.InvokeRequired)
{
Comm.ParentForm.Invoke(new UpdateColumnsEventHandler(UpdateColumns), item, man);
return;
}
item.Buffer.Clear();
item.CaptureObjects.Clear();
List<GXKeyValuePair<GXDLMSObject, GXDLMSCaptureObject>> cols = null;
List<DataColumn> columns = new List<DataColumn>();
if (this.Extension != null)
{
cols = this.Extension.Refresh(item, this.Comm);
}
if (cols == null)
{
cols = Comm.GetProfileGenericColumns(item.Name);
}
item.CaptureObjects = cols;
}
/// <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();
}
