/// <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); } }