/// <summary>
/// Client has send data for the meters that are using the same port.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public static void OnExclusiveReceived(object sender, Gurux.Common.ReceiveEventArgs e)
{
try
{
lock (buffers)
{
GXByteBuffer bb;
if (!buffers.ContainsKey(e.SenderInfo))
{
bb = new GXByteBuffer();
buffers[e.SenderInfo] = bb;
}
else
{
bb = buffers[e.SenderInfo];
}
bb.Set((byte[])e.Data);
int target, source;
//All simulated meters are using the same interface type.
GXDLMSTranslator.GetAddressInfo(interfaceType, bb, out target, out source);
if (target != 0 && meters.ContainsKey(target))
{
GXDLMSMeter m = meters[target];
if (Trace > TraceLevel.Info)
{
Console.WriteLine("RX:\t" + Gurux.Common.GXCommon.ToHex((byte[])e.Data, true));
}
GXServerReply sr = new GXServerReply(bb.Data);
do
{
m.HandleRequest(sr);
//Reply is null if we do not want to send any data to the client.
//This is done if client try to make connection with wrong device ID.
if (sr.Reply != null)
{
if (Trace > TraceLevel.Info)
{
Console.WriteLine("TX:\t" + Gurux.Common.GXCommon.ToHex(sr.Reply, true));
}
bb.Clear();
m.Media.Send(sr.Reply, e.SenderInfo);
sr.Data = null;
}
}while (sr.IsStreaming);
}
}
}
catch (Exception ex)
{
if (!(ex is SocketException))
{
Console.WriteLine(ex.Message);
}
}
}
/// <summary>
/// Client has send data.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void OnReceived(object sender, Gurux.Common.ReceiveEventArgs e)
{
try
{
lock (this)
{
//Show trace only for connected meters.
if (Trace > TraceLevel.Info && this.ConnectionState != ConnectionState.None)
{
Console.WriteLine("RX:\t" + Gurux.Common.GXCommon.ToHex((byte[])e.Data, true));
}
GXServerReply sr = new GXServerReply((byte[])e.Data);
do
{
HandleRequest(sr);
//Reply is null if we do not want to send any data to the client.
//This is done if client try to make connection with wrong device ID.
if (sr.Reply != null)
{
if (Trace > TraceLevel.Info)
{
Console.WriteLine("TX:\t" + Gurux.Common.GXCommon.ToHex(sr.Reply, true));
}
Media.Send(sr.Reply, e.SenderInfo);
sr.Data = null;
}
}while (sr.IsStreaming);
}
}
catch (Exception ex)
{
if (!(ex is SocketException))
{
Console.WriteLine(ex.Message);
}
}
}
/// <summary>
/// Client has send data.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void OnReceived(object sender, Gurux.Common.ReceiveEventArgs e)
{
try
{
lock (this)
{
if (trace)
{
Console.WriteLine("<- " + Gurux.Common.GXCommon.ToHex((byte[])e.Data, true));
}
reply.Set((byte[])e.Data);
//Example handles only notify messages.
GXReplyData data = new GXReplyData();
client.GetData(reply, data, notify);
// If all data is received.
if (notify.IsComplete && !notify.IsMoreData)
{
try
{
//Show data as XML.
string xml;
GXDLMSTranslator t = new GXDLMSTranslator(TranslatorOutputType.SimpleXml);
t.DataToXml(notify.Data, out xml);
Console.WriteLine(xml);
// Print received data.
PrintData(notify.Value, 0);
//Example is sending list of push messages in first parameter.
if (notify.Value is object[])
{
object[] tmp = notify.Value as object[];
List <KeyValuePair <GXDLMSObject, int> > objects = client.ParsePushObjects((object[])tmp[0]);
//Remove first item because it's not needed anymore.
objects.RemoveAt(0);
//Update clock.
int Valueindex = 1;
foreach (KeyValuePair <GXDLMSObject, int> it in objects)
{
client.UpdateValue(it.Key, it.Value, tmp[Valueindex]);
++Valueindex;
//Print value
Console.WriteLine(it.Key.ObjectType + " " + it.Key.LogicalName + " " + it.Value + ":" + it.Key.GetValues()[it.Value - 1]);
}
}
Console.WriteLine("Server address:" + notify.ServerAddress + " Client Address:" + notify.ClientAddress);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
notify.Clear();
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Show received data.
/// </summary>
private void gxTerminal1_OnReceived(object sender, ReceiveEventArgs e)
{
try
{
if (this.InvokeRequired)
{
this.BeginInvoke(new ReceivedEventHandler(OnReceived), sender, e);
}
else
{
OnReceived(sender, e);
}
}
catch (Exception Ex)
{
MessageBox.Show(Ex.Message);
}
}
/// <summary>
/// Client has send data for for the gateway.
/// </summary>
/// <remarks>
/// GW finds the correct client and sends data for it.
/// </remarks>
/// <param name="sender"></param>
/// <param name="e"></param>
public static void OnGatewayReceived(object sender, Gurux.Common.ReceiveEventArgs e)
{
try
{
lock (buffers)
{
GXByteBuffer bb;
if (!buffers.ContainsKey(e.SenderInfo))
{
bb = new GXByteBuffer();
buffers[e.SenderInfo] = bb;
}
else
{
bb = buffers[e.SenderInfo];
}
bb.Set((byte[])e.Data);
GXServerReply sr = new GXServerReply(bb.Data);
GatewayServer.Reset();
try
{
GatewayServer.HandleRequest(sr);
if (sr.Reply != null)
{
if (Trace > TraceLevel.Info)
{
Console.WriteLine("TX:\t" + Gurux.Common.GXCommon.ToHex(sr.Reply, true));
}
((IGXMedia)sender).Send(sr.Reply, e.SenderInfo);
return;
}
}
catch (Exception)
{
//Return error.
sr.Reply = GatewayServer.ReportError(sr.Command, ErrorCode.HardwareFault);
}
if (sr.Gateway != null && sr.Data != null)
{
GXByteBuffer pdu = new GXByteBuffer(sr.Data);
InterfaceType type = (InterfaceType)sr.Gateway.NetworkId;
GXByteBuffer address = new GXByteBuffer();
address.Set(sr.Gateway.PhysicalDeviceAddress);
int addr = address.GetUInt8();
//Find correct meter using GW information.
if (meters.ContainsKey(addr))
{
//Find client for the server or create a new one.
GXDLMSClient cl;
if (!clients.ContainsKey(addr))
{
//Set client address if data is send without framing.
if (GatewayServer.Settings.ClientAddress == 0)
{
GatewayServer.Settings.ClientAddress = 0x10;
}
cl = new GXDLMSClient(true, GatewayServer.Settings.ClientAddress, addr, GatewayServer.Authentication, null, type);
clients.Add(addr, cl);
}
else
{
cl = clients[addr];
}
GXReplyData data = new GXReplyData();
GXReplyData notify = new GXReplyData();
GXDLMSMeter m = meters[addr];
//Send SNRM if needed.
if (sr.Command == Command.Aarq && (type == InterfaceType.HDLC || type == InterfaceType.HdlcWithModeE))
{
GXServerReply sr2 = new GXServerReply(cl.SNRMRequest());
m.HandleRequest(sr2);
if (cl.GetData(sr2.Reply, data, notify))
{
data.Clear();
notify.Clear();
}
else
{
//If the meter doesn't reply.
bb.Clear();
return;
}
}
byte[][] frames = cl.CustomFrameRequest(Command.None, pdu);
foreach (byte[] it in frames)
{
sr.Data = it;
m.HandleRequest(sr);
if (Trace > TraceLevel.Info)
{
Console.WriteLine("RX:\t" + Gurux.Common.GXCommon.ToHex(sr.Reply, true));
}
data.RawPdu = true;
if (cl.GetData(sr.Reply, data, notify))
{
while (data.IsMoreData)
{
sr.Data = cl.ReceiverReady(data);
m.HandleRequest(sr);
if (Trace > TraceLevel.Info)
{
Console.WriteLine("RX:\t" + Gurux.Common.GXCommon.ToHex(sr.Reply, true));
}
cl.GetData(sr.Reply, data, notify);
}
byte[] reply = sr.Reply;
try
{
GXByteBuffer tmp = new GXByteBuffer();
tmp.Set(data.Data);
GatewayServer.Gateway = sr.Gateway;
reply = GatewayServer.CustomFrameRequest(Command.None, tmp);
}
finally
{
GatewayServer.Gateway = null;
}
if (Trace > TraceLevel.Info)
{
Console.WriteLine("TX:\t" + Gurux.Common.GXCommon.ToHex(reply, true));
}
((IGXMedia)sender).Send(reply, e.SenderInfo);
}
}
}
bb.Clear();
}
}
}
catch (Exception ex)
{
if (!(ex is SocketException))
{
Console.WriteLine(ex.Message);
}
}
}
/// <summary>
/// Show received data.
/// </summary>
private void OnReceived(object sender, ReceiveEventArgs e)
{
try
{
//We receive byte array from GXSerial and this must be changed to chars.
if (HexCB.Checked)
{
ReceivedText.Text += BitConverter.ToString((byte[])e.Data);
}
else
{
//Get received data as string.
ReceivedText.Text += System.Text.Encoding.ASCII.GetString((byte[])e.Data);
}
}
catch (Exception Ex)
{
MessageBox.Show(Ex.Message);
}
}
void OnReceived(object sender, ReceiveEventArgs data)
{
try
{
byte[] buff = (byte[])data.Data;
string str = Gurux.Common.GXCommon.ToHex(buff, true);
foreach (GXClient cl in Clients)
{
cl.NotifyVerbose(sender, Gurux.Common.TraceTypes.Received, str);
}
GXClient client = null;
lock (Clients.SyncRoot)
{
if (Clients.Count == 0)
{
return;
}
client = Clients[0] as GXClient;
}
GXReceiveDataEventArgs args = new GXReceiveDataEventArgs(buff, data.SenderInfo);
client.NotifyReceiveData(args);
//If data is not accepted ignore it.
if (!args.Accept)
{
if (this.m_Media.Trace >= System.Diagnostics.TraceLevel.Info)
{
client.NotifyVerbose(client, Resources.ClientToNotAcceptData + BitConverter.ToString(buff).Replace('-', ' '));
}
return;
}
int cnt = 0;
//Add received data to the buffer.
lock (m_syncRoot)
{
m_replyBuffer.AddRange(buff);
cnt = m_replyBuffer.Count;
}
while (cnt != 0)
{
m_ReplyPacket.ClearData();
m_ReplyPacket.Status = PacketStates.Ok;
//If end applications are parsing data itself.
if (m_bParseReceivedPacket)
{
GXParsePacketEventArgs e;
lock (m_syncRoot)
{
e = new GXParsePacketEventArgs(m_replyBuffer.ToArray(), m_ReplyPacket);
}
client.NotifyParsePacketFromData(e);
//If packet is not ready yet.
if (e.PacketSize == 0)
{
return;
}
//Remove parsed data.
lock (m_syncRoot)
{
m_replyBuffer.RemoveRange(0, e.PacketSize);
}
}
else
{
int start;
byte[] tmp;
int packetSize = 0;
lock (m_syncRoot)
{
tmp = m_replyBuffer.ToArray();
}
try
{
m_ReplyPacket.Sender = client;
m_ReplyPacket.ParsePacket(tmp, out start, out packetSize);
}
finally
{
m_ReplyPacket.Sender = null;
}
//If packet is not ready yet.
if (packetSize == 0)
{
return;
}
GXVerifyPacketEventArgs e = new GXVerifyPacketEventArgs(tmp, m_ReplyPacket);
client.NotifyVerifyPacket(e);
do
{
if (e.State == ParseStatus.CorruptData)
{
//Remove parsed data.
lock (m_syncRoot)
{
m_replyBuffer.Clear();
}
client.NotifyVerbose(client, Resources.CorruptedData);
Gurux.Common.GXCommon.TraceWriteLine(Resources.CorruptedData);
return;
}
else if (e.State == ParseStatus.Incomplete)
{
m_ReplyPacket.ParsePacket(tmp, out start, out packetSize);
e = new GXVerifyPacketEventArgs(tmp, m_ReplyPacket);
client.NotifyVerifyPacket(e);
}
}
while (e.State != ParseStatus.Complete);
//Remove parsed data.
lock (m_syncRoot)
{
m_replyBuffer.RemoveRange(0, packetSize);
}
}
lock (m_syncRoot)
{
cnt = m_replyBuffer.Count;
}
//Data parsing succeeded. Handle reply.
//Clear transaction time flag.
m_ReplyPacket.Status &= ~PacketStates.TransactionTimeReset;
bool acceptPacket = true;
GXPacket replyPacket = null;
lock (m_SendPackets.SyncRoot)
{
// Find the send packet from the send list
foreach (GXPacket it in m_SendPackets)
{
lock (it.SyncRoot)
{
//If packet is send as a broadcast message.
if (it.ResendCount == -1)
{
continue;
}
GXReplyPacketEventArgs e = new GXReplyPacketEventArgs(it, m_ReplyPacket);
try
{
client.NotifyIsReplyPacket(e);
}
catch (Exception ex)
{
it.Status = PacketStates.SendFailed;
it.SenderInfo = ex.Message;
acceptPacket = true;
replyPacket = it;
break;
}
acceptPacket = e.Accept;
if (!acceptPacket)
{
if (this.m_Media.Trace >= System.Diagnostics.TraceLevel.Info)
{
if (!string.IsNullOrEmpty(e.Description))
{
client.NotifyVerbose(client, e.Description);
}
else
{
client.NotifyVerbose(client, Resources.ReceivedPacketIsNotAccepted +
" " + m_ReplyPacket.ToString());
}
}
break;
}
//If the packet is old, don't do anything
if ((it.Status & PacketStates.Timeout) != 0)
{
continue;
}
//Mark the packet as received so the sender do not remove it.
it.Status = PacketStates.Received;
//Copy content if the received packet is a reply packet...
it.ClearData();
it.AppendData(m_ReplyPacket.ExtractData(typeof(byte[]), 0, -1));
it.Bop = m_ReplyPacket.Bop;
it.Eop = m_ReplyPacket.Eop;
it.ChecksumSettings.Copy(m_ReplyPacket.ChecksumSettings);
}
replyPacket = it;
}
}
if (acceptPacket)
{
///////////////////////////////////////////////////////////////
//If packet sender not found, send packet to all clients.
if (replyPacket == null)
{
GXReplyPacketEventArgs e;
lock (Handlers)
{
GXNotifyEventArgs fc = new GXNotifyEventArgs(m_ReplyPacket, data.SenderInfo);
foreach (var it in Handlers)
{
it.Key.NorifyEvent(fc);
if (fc.Handled)
{
if (fc.Client != null)
{
e = new GXReplyPacketEventArgs(null, m_ReplyPacket);
fc.Client.NotifyAcceptNotify(e);
if (!e.Accept)
{
return;
}
fc.Client.NotifyReceived(new GXReceivedPacketEventArgs(m_ReplyPacket, false));
}
m_ReplyPacket.ClearData();
if (fc.Reply != null)
{
Send(fc.Reply);
}
return;
}
}
}
e = new GXReplyPacketEventArgs(null, m_ReplyPacket);
client.NotifyAcceptNotify(e);
if (!e.Accept)
{
continue;
}
foreach (GXClient it in Clients)
{
it.NotifyReceived(new GXReceivedPacketEventArgs(m_ReplyPacket, false));
}
}
else //Sender found.
{
System.Diagnostics.Debug.Assert((replyPacket.Status & PacketStates.Sent) == 0);
AddPacketToReceivedBuffer(replyPacket);
}
}
}
}
catch (Exception Ex)
{
foreach (GXClient it in Clients)
{
it.NotifyError(m_ReplyPacket, Ex);
}
}
}
private void OnReceived(object sender, ReceiveEventArgs e)
{
try
{
// Byte array received from GXSerial, and must be changed to chars.
if (HexCB.Checked)
{
//Show only last data in echo.
if (EchoCB.Checked)
{
ReceivedText.Text = BitConverter.ToString((byte[])e.Data);
}
else
{
ReceivedText.Text += BitConverter.ToString((byte[])e.Data);
}
}
else // Gets received data as string.
{
//Show only last data in echo.
if (EchoCB.Checked)
{
ReceivedText.Text = System.Text.Encoding.ASCII.GetString((byte[])e.Data);
}
else
{
ReceivedText.Text += System.Text.Encoding.ASCII.GetString((byte[])e.Data);
}
}
if (EchoCB.Checked)
{
gxSerial1.Send(e.Data);
}
}
catch (Exception Ex)
{
MessageBox.Show(Ex.Message);
}
}
void media_OnReceived(object sender, ReceiveEventArgs e)
{
IGXMedia media = sender as IGXMedia;
DC.MediaWrite(DC.DataCollectorGuid, media.MediaType, media.Name, (byte[])e.Data, null);
}
/// <summary>
/// Show received data.
/// </summary>
private void Net1_OnReceived(object sender, ReceiveEventArgs e)
{
try
{
if (this.InvokeRequired)
{
this.BeginInvoke(new ReceivedEventHandler(Net1_OnReceived), new object[] { sender, e });
}
else
{
//Echo received text.
if (EchoCB.Checked)
{
Net1.Send(e.Data, e.SenderInfo);
ReceivedText.Text = "";
}
//We receive byte array from Gurux.Net and this must be changed to chars.
if (HexCB.Checked)
{
++cnt;
ReceivedText.Text += BitConverter.ToString((byte[])e.Data);
}
else
{
// Gets received data as string.
ReceivedText.Text += System.Text.Encoding.ASCII.GetString((byte[])e.Data);
}
}
}
catch (Exception Ex)
{
ErrorList.Items.Add(Ex.Message);
}
}
