Exemplo n.º 1
0
        public SECSMessage Byte_TO_SecsMessage(byte[] aHeader)
        {
            SECSMessage message = new SECSMessage("", "");

            byte[] aBytes = new byte[]
            {
                aHeader[0],
                aHeader[1]
            };
            byte[] buffer2 = new byte[]
            {
                aHeader[6],
                aHeader[7],
                aHeader[8],
                aHeader[9]
            };
            message.SystemBytes = Byte2SecsValue.GetLong(buffer2);
            message.DeviceIdID  = Byte2SecsValue.AdjustDeviceID((short)Byte2SecsValue.GetInt(aBytes));
            message.Stream      = (int)(aHeader[2] & 255);
            int stream = message.Stream;

            if (stream > 128)
            {
                message.Stream = stream - 128;
                message.WBit   = true;
            }
            message.Function = (int)(aHeader[3] & 255);
            return(message);
        }
Exemplo n.º 2
0
 internal void Enqueue(SECSMessage msg)
 {
     lock (this.syncObject)
     {
         this.sendQueue.Enqueue(msg);
     }
 }
Exemplo n.º 3
0
 private bool CheckMsgFormat(SECSMessage msg, IEnumerable <SECSMessage> list)
 {
     foreach (SECSMessage message in list)
     {
         if (msg.Root == null && message.Root == null)
         {
             msg.Name        = message.Name;
             msg.Description = message.Description;
             bool result = true;
             return(result);
         }
         if (msg.Root == null || message.Root == null)
         {
             bool result = false;
             return(result);
         }
         SECSItem root   = msg.Root;
         SECSItem format = message.Root;
         if (this.secsPort.Library.CheckSecsItemFormat(ref root, ref format))
         {
             msg.Name        = message.Name;
             msg.Description = message.Description;
             bool result = true;
             return(result);
         }
     }
     return(false);
 }
Exemplo n.º 4
0
 private void OnSocketWriteComplete(bool IsReply, SECSMessage msg)
 {
     try
     {
         SECSTransaction trans = msg.Transaction;
         if (this.OnHSMSEvent != null)
         {
             if (IsReply)
             {
                 this.OnHSMSEvent(SECSEventType.SecondarySent, trans, SECSErrors.None, SECSErrorsMessage.GetSECSErrorMessage(SECSErrors.None));
             }
             else
             {
                 trans.DeviceID    = msg.DeviceIdID;
                 trans.SystemBytes = msg.SystemBytes;
                 trans.ExpectReply = msg.WBit;
                 this.OnHSMSEvent(SECSEventType.PrimarySent, trans, SECSErrors.None, SECSErrorsMessage.GetSECSErrorMessage(SECSErrors.None));
             }
         }
     }
     catch (Exception exception)
     {
         this.logger.Error("Port#Sending Error", exception);
     }
 }
Exemplo n.º 5
0
 public void EnqueSend(SECSMessage msg)
 {
     lock (this.syncSendObject)
     {
         this.mQueueSend.Enqueue(msg);
     }
 }
Exemplo n.º 6
0
 public void Parse(SECSBlock mHSMSItem)
 {
     try
     {
         SECSDecoding decoding = new SECSDecoding();
         string       str      = ByteStringBuilder.ToLogString(mHSMSItem.Header);
         string       str2     = ByteStringBuilder.ToLogString(mHSMSItem.DataItem);
         SECSMessage  msg      = decoding.Byte_TO_SecsMessage(mHSMSItem.Header);
         msg.Root   = decoding.Byte_TO_SecsItem(mHSMSItem.DataItem);
         msg.Header = mHSMSItem.Header;
         //this.logger.Info(string.Format("[RECV] S{0}F{1} {2} System Bytes={3} {4} {5}", new object[]
         //{
         //	msg.Stream,
         //	msg.Function,
         //	msg.WBit ? "W" : "",
         //	msg.SystemBytes,
         //	str,
         //	str2
         //}));
         //this.logger.Warn("[RECV] " + SecsItem2Str.GetSecsMessageStr(msg));
         if (this.OnReceived != null)
         {
             this.OnReceived(msg);
         }
     }
     catch (Exception exception)
     {
         this.logger.Error("Parser#Parse", exception);
         if (this.OnParseError != null)
         {
             this.OnParseError(string.Format("{0}: {1}", SECSErrorsMessage.GetSECSErrorMessage(SECSErrors.ParseError), exception.Message));
         }
     }
 }
Exemplo n.º 7
0
 public void EnqueReply(SECSMessage msg)
 {
     lock (this.syncReplyObject)
     {
         this.mQueueReply.Enqueue(msg);
     }
 }
Exemplo n.º 8
0
 public override bool Load(string filename)
 {
     this.xmlDoc = null;
     try
     {
         this.xmlDoc = XDocument.Load(filename);
         XElement element = this.xmlDoc.Element("SECSLibrary");
         if (element == null)
         {
             bool result = false;
             return(result);
         }
         this.list.Clear();
         if (element.Attribute("Name") != null)
         {
             base.Name = element.Attribute("Name").Value.Trim();
         }
         if (element.Attribute("Description") != null)
         {
             base.Description = element.Attribute("Description").Value.Trim();
         }
         foreach (XElement element2 in element.Elements("SECSMessage"))
         {
             SECSMessage msg = this.XElementToSECSMessage(element2);
             this.AddMessage(msg);
         }
     }
     catch (Exception)
     {
         bool result = false;
         return(result);
     }
     return(true);
 }
Exemplo n.º 9
0
 public void ReplyMessage(SECSMessage msg)
 {
     msg.DeviceIdID = this.portCfg.DeviceID;
     if (this.mHsmsWriter != null)
     {
         this.mHsmsWriter.EnqueReply(msg);
     }
 }
Exemplo n.º 10
0
 public void WriteSendMessage(SECSMessage msg)
 {
     if (msg == null)
     {
         this.logger.Error("WriteSendMessage msg == null");
         return;
     }
     byte[] bs = null;
     try
     {
         bs = new SECSEncoding(msg).GetEncodingData((int)msg.DeviceIdID, msg.WBit, msg.SystemBytes);
         if (bs.Length > 0 && msg.WBit)
         {
             this.mHsmsTimer.StartT3Timer(msg);
             this.logger.Debug(string.Format("WriteSendMessage: StartT3Timer {0}", msg.SystemBytes));
         }
     }
     catch (Exception exception)
     {
         this.logger.Error("WriteSendMessage: encoder", exception);
         SECSTransaction t = msg.Transaction;
         if (this.OnWriteError != null)
         {
             this.OnWriteError(SECSEventType.PrimarySent, t, string.Format("{0}: Invalid SECS Message Format or Data.", SECSErrorsMessage.GetSECSErrorMessage(SECSErrors.WriteError)));
         }
     }
     if (bs != null && bs.Length > 0)
     {
         try
         {
             this.writer.Write(bs);
             this.writer.Flush();
             //this.logger.Info(string.Format("[SEND] S{0}F{1} {2} SystemBytes={3}\n{4}", new object[]
             //{
             //    msg.Stream,
             //    msg.Function,
             //    msg.WBit ? "W" : "",
             //    msg.SystemBytes,
             //    ByteStringBuilder.ToLogString(bs)
             //}));
             //this.logger.Warn("[SEND] " + SecsItem2Str.GetSecsMessageStr(msg));
             if (this.OnWriteCompleted != null)
             {
                 this.OnWriteCompleted(false, msg);
             }
         }
         catch (Exception exception2)
         {
             this.logger.Error("WriteSendMessage", exception2);
             SECSTransaction transaction = msg.Transaction;
             if (this.OnWriteError != null)
             {
                 this.OnWriteError(SECSEventType.PrimarySent, transaction, string.Format("{0}: Socket Error.", SECSErrorsMessage.GetSECSErrorMessage(SECSErrors.WriteError)));
             }
             this.FireDisconnect(exception2.Message);
         }
     }
 }
Exemplo n.º 11
0
 private void HandleRcvdSecondaryMessage(SECSMessage rcvd, SECSMessage sent)
 {
     if (this.OnHSMSEvent != null)
     {
         SECSTransaction trans = sent.Transaction;
         trans.Secondary = rcvd;
         this.OnHSMSEvent(SECSEventType.SecondaryRcvd, trans, SECSErrors.None, SECSErrorsMessage.GetSECSErrorMessage(SECSErrors.None));
     }
 }
Exemplo n.º 12
0
        private void HandleRcvdAbortMessage(SECSMessage sent, SECSMessage rcvd)
        {
            SECSTransaction trans = sent.Transaction;

            trans.Secondary = rcvd;
            if (this.OnHSMSEvent != null)
            {
                this.OnHSMSEvent(SECSEventType.Error, trans, SECSErrors.RcvdAbortMessage, SECSErrorsMessage.GetSECSErrorMessage(SECSErrors.RcvdAbortMessage));
            }
        }
Exemplo n.º 13
0
        public object Clone()
        {
            SECSMessage message = (SECSMessage)base.MemberwiseClone();

            if (this.root != null)
            {
                message.root = (SECSItem)this.root.Clone();
            }
            return(message);
        }
Exemplo n.º 14
0
        private void HandleRcvdUnknownMessage(SECSMessage rcvd)
        {
            SECSTransaction trans = new SECSTransaction
            {
                Primary   = null,
                Secondary = rcvd
            };

            if (this.OnHSMSEvent != null)
            {
                this.OnHSMSEvent(SECSEventType.Error, trans, SECSErrors.RcvdUnknownMessage, SECSErrorsMessage.GetSECSErrorMessage(SECSErrors.RcvdUnknownMessage));
            }
        }
Exemplo n.º 15
0
        public void ReplyAsync(SECSTransaction t, XElement xmlSecondaryMessage)
        {
            SECSMessage message = new SECSMessage
            {
                Stream      = t.Primary.Stream,
                Function    = t.Primary.Function + 1,
                SystemBytes = t.Primary.SystemBytes,
                DeviceIdID  = t.DeviceID,
                Root        = this.Library.XElementToSECSItem(xmlSecondaryMessage)
            };

            t.Secondary = message;
            this.Reply(t);
        }
Exemplo n.º 16
0
        internal XElement SECSMessageToXElement(SECSMessage msg)
        {
            XElement element = new XElement("SECSMessage");

            element.SetAttributeValue("Name", msg.Name);
            element.Add(new XElement("MessageName", msg.Name));
            element.Add(new XElement("Description", msg.Description));
            element.Add(new XElement("Stream", msg.Stream.ToString(CultureInfo.InvariantCulture)));
            element.Add(new XElement("Function", msg.Function.ToString(CultureInfo.InvariantCulture)));
            element.Add(new XElement("Direction", msg.IsHost ? "H->E" : "E->H"));
            element.Add(new XElement("Wait", msg.WBit ? "True" : "False"));
            element.Add(new XElement("DataItem", this.SECSItemToXElement(msg.Root)));
            return(element);
        }
Exemplo n.º 17
0
        public static SECSMessage DeepCopy(SECSMessage msg)
        {
            object obj2;

            using (MemoryStream stream = new MemoryStream())
            {
                BinaryFormatter formatter = new BinaryFormatter();
                formatter.Serialize(stream, msg);
                stream.Seek(0L, SeekOrigin.Begin);
                obj2 = formatter.Deserialize(stream);
                stream.Close();
            }
            return((SECSMessage)obj2);
        }
Exemplo n.º 18
0
 protected override void Run()
 {
     while (this.running)
     {
         try
         {
             if (this.mQueueReply.Count > 0)
             {
                 SECSMessage msg = null;
                 lock (this.syncReplyObject)
                 {
                     msg = this.mQueueReply.Dequeue();
                 }
                 if (msg != null)
                 {
                     this.logger.Debug("Writer#Run Send Secondary Message " + msg.SystemBytes.ToString());
                     this.WriteReplyMessage(msg);
                 }
             }
             if (this.mQueueSend.Count > 0)
             {
                 SECSMessage message2 = null;
                 lock (this.syncSendObject)
                 {
                     message2 = this.mQueueSend.Dequeue();
                 }
                 if (message2 != null)
                 {
                     this.logger.Debug("Writer#Run Send Primary Message " + message2.SystemBytes.ToString());
                     this.WriteSendMessage(message2);
                 }
             }
             if (this.mQueueSend.Count > 0 || this.mQueueReply.Count > 0)
             {
                 continue;
             }
         }
         catch (Exception exception)
         {
             this.logger.Error("Writer#Run: ", exception);
             if (this.OnWriteError != null)
             {
                 this.OnWriteError(SECSEventType.Error, null, string.Format("{0}: {1}", SECSErrorsMessage.GetSECSErrorMessage(SECSErrors.WriteError), exception.Message));
             }
             this.FireDisconnect(exception.Message);
         }
         Thread.Sleep(50);
     }
 }
Exemplo n.º 19
0
 private void HandleRcvdPrimaryMessage(SECSMessage rcvd)
 {
     if (this.OnHSMSEvent != null)
     {
         SECSTransaction trans = new SECSTransaction
         {
             Primary     = rcvd,
             SystemBytes = rcvd.SystemBytes,
             Secondary   = null,
             ExpectReply = rcvd.WBit,
             DeviceID    = rcvd.DeviceIdID
         };
         this.OnHSMSEvent(SECSEventType.PrimaryRcvd, trans, SECSErrors.None, SECSErrorsMessage.GetSECSErrorMessage(SECSErrors.None));
     }
 }
Exemplo n.º 20
0
 public void SendMessages(SECSMessage msg)
 {
     msg.DeviceIdID  = this.portCfg.DeviceID;
     msg.SystemBytes = this.SystemBytesCountUp();
     if (msg.WBit)
     {
         lock (this.syncNeedReplyObject)
         {
             this.mNeedReplyMsg.Add(msg.SystemBytes, msg);
         }
     }
     if (this.mHsmsWriter != null)
     {
         this.mHsmsWriter.EnqueSend(msg);
     }
 }
Exemplo n.º 21
0
        private void SendS9Fx(int aFx, byte[] hdr)
        {
            SECSTransaction trans   = new SECSTransaction();
            SECSMessage     message = new SECSMessage();

            trans.Primary       = message;
            message.Transaction = trans;
            message.DeviceIdID  = this.secsPort.DeviceID;
            message.Stream      = 9;
            message.Function    = aFx;
            message.WBit        = false;
            trans.DeviceID      = message.DeviceIdID;
            trans.ExpectReply   = message.WBit;
            SECSItem item = (aFx == 9) ? new SECSItem(eSECS_FORMAT.BINARY, "SHEAD") : new SECSItem(eSECS_FORMAT.BINARY, "MHEAD");

            item.Value   = hdr;
            message.Root = item;
            this.secsPort.Send(trans);
        }
Exemplo n.º 22
0
 public SECSMessage FindMessage(int stream, int function, string direction)
 {
     foreach (SECSMessage message in from t in this.list
              where t.Stream == stream && t.Function == function
              select t)
     {
         if (message.IsHost && direction == "H->E")
         {
             SECSMessage result = MessageAbstractSECSLibrary.DeepCopy(message);
             return(result);
         }
         if (!message.IsHost && direction == "E->H")
         {
             SECSMessage result = MessageAbstractSECSLibrary.DeepCopy(message);
             return(result);
         }
     }
     return(null);
 }
Exemplo n.º 23
0
        internal override List <SECSMessage> FindMessage(int stream, int function)
        {
            List <SECSMessage> list = new List <SECSMessage>();

            foreach (KeyValuePair <string, SECSTransaction> pair in this.transdic)
            {
                if (pair.Value.Primary != null && pair.Value.Primary.Stream == stream && pair.Value.Primary.Function == function)
                {
                    SECSMessage message = pair.Value.Primary.Clone() as SECSMessage;
                    list.Add(message);
                }
                else if (pair.Value.Secondary != null && pair.Value.Secondary.Stream == stream && pair.Value.Secondary.Function == function)
                {
                    SECSMessage message2 = pair.Value.Secondary.Clone() as SECSMessage;
                    list.Add(message2);
                }
            }
            return(list);
        }
Exemplo n.º 24
0
        internal SECSMessage XElementToSECSMessage(XElement element)
        {
            SECSMessage message = new SECSMessage("", "");

            foreach (XElement element2 in element.Elements())
            {
                string str = element2.Name.ToString().Trim();
                if (str == "MessageName")
                {
                    message.Name = element2.Value.Trim();
                }
                else if (str == "Description")
                {
                    message.Description = element2.Value.Trim();
                }
                else if (str == "Stream")
                {
                    message.Stream = int.Parse(element2.Value.Trim());
                }
                else if (str == "Function")
                {
                    message.Function = int.Parse(element2.Value.Trim());
                }
                else if (str == "Wait")
                {
                    message.WBit = (element2.Value.Trim().ToUpper() == "TRUE");
                }
                else if (str == "Direction")
                {
                    message.IsHost = (element2.Value.Trim().ToUpper() == "H->E");
                }
                else if (str == "DataItem" && element2.HasElements)
                {
                    SECSItem item = this.XElementToSECSItem(element2.Elements().First <XElement>());
                    if (item != null)
                    {
                        message.Root = item;
                    }
                }
            }
            return(message);
        }
Exemplo n.º 25
0
        internal static string GetSecsMessageStr(SECSMessage msg)
        {
            StringBuilder builder = new StringBuilder();

            builder.AppendFormat("S{0}F{1}", msg.Stream, msg.Function);
            if (msg.WBit)
            {
                builder.Append(" W");
            }
            builder.Append(" System Bytes=");
            builder.Append(msg.SystemBytes);
            builder.Append("\n");
            SECSItem root = msg.Root;

            if (root != null)
            {
                builder.Append(SecsItem2Str.GetSecsItemStr(0, root));
                builder.Append(".\n");
            }
            return(builder.ToString());
        }
Exemplo n.º 26
0
 public void StopT3Timer(SECSMessage msg)
 {
     if (msg != null)
     {
         try
         {
             lock (this.syncTimeout)
             {
                 if (this.mTimerMsg.ContainsKey(msg.SystemBytes))
                 {
                     this.mTimerMsg.Remove(msg.SystemBytes);
                 }
             }
             this.logger.Debug(string.Format("Stop T3 Timer, SystemBytes={0}", msg.SystemBytes));
         }
         catch (Exception exception)
         {
             this.logger.Error("SECS1Timer::StopT3Timer ", exception);
         }
     }
 }
Exemplo n.º 27
0
 internal void NotifyERROR(SECSErrors err, SECSMessage msg)
 {
     lock (this.syncObject)
     {
         SECS1EventArgs args = new SECS1EventArgs
         {
             EventType = SECSEventType.Error,
             ErrorCode = err,
             ErrorMsg  = SECSErrorsMessage.GetSECSErrorMessage(err)
         };
         if (msg != null)
         {
             args.Trans = msg.Transaction;
         }
         else
         {
             args.Trans = null;
         }
         this.eventQueue.Enqueue(args);
     }
 }
Exemplo n.º 28
0
 private void OnReceived(SECSMessage msg)
 {
     try
     {
         if (msg.Function % 2 == 0)
         {
             SECSMessage message = null;
             if (this.mNeedReplyMsg.ContainsKey(msg.SystemBytes))
             {
                 message = this.mNeedReplyMsg[msg.SystemBytes];
                 this.mHsmsTimer.StopT3Timer(message);
                 lock (this.syncNeedReplyObject)
                 {
                     this.mNeedReplyMsg.Remove(msg.SystemBytes);
                 }
                 if (msg.Stream < 1 || msg.Function < 1)
                 {
                     this.HandleRcvdAbortMessage(message, msg);
                 }
                 else
                 {
                     this.HandleRcvdSecondaryMessage(msg, message);
                 }
             }
             else
             {
                 this.HandleRcvdUnknownMessage(msg);
             }
         }
         else
         {
             this.HandleRcvdPrimaryMessage(msg);
         }
     }
     catch (Exception exception)
     {
         this.logger.Error("Port::OnReceived Error.", exception);
     }
 }
Exemplo n.º 29
0
 public void StartT3Timer(SECSMessage msg)
 {
     if (msg != null)
     {
         try
         {
             lock (this.syncTimeout)
             {
                 SECS1Timer.CheckTimerPara para;
                 para.SystemBytes = msg.SystemBytes;
                 para.msg         = msg;
                 para.StartTime   = DateTime.Now;
                 this.mTimerMsg.Add(para.SystemBytes, para);
             }
             this.logger.Debug(string.Format("Start T3 Timer, SystemBytes={0}", msg.SystemBytes));
         }
         catch (Exception exception)
         {
             this.logger.Error("SECS1Timer::StartT3Timer ", exception);
         }
     }
 }
Exemplo n.º 30
0
        internal void SendBody()
        {
            SECSMessage sendMsg = this.writer.SendMsg;

            this.commport.SendByte((byte)this.writer.SendBlock.Length);
            this.commport.SendByte(this.writer.SendBlock.Header);
            if (this.writer.SendBlock.DataItem.Length > 0)
            {
                this.commport.SendByte(this.writer.SendBlock.DataItem);
            }
            this.commport.SendByte(this.writer.SendBlock.CheckSum);
            //this.Logger.Info(string.Format("[SEND] S{0}F{1} {2} SystemBytes = {3} Length = {4} HDR = {5}\nDATA = {6}\nCSUM = {7}", new object[]
            //{
            //	sendMsg.Stream,
            //	sendMsg.Function,
            //	sendMsg.WBit ? "W" : "",
            //	sendMsg.SystemBytes,
            //	this.writer.SendBlock.Length,
            //	ByteStringBuilder.ToLogString(this.writer.SendBlock.Header),
            //	ByteStringBuilder.ToLogString(this.writer.SendBlock.DataItem),
            //	ByteStringBuilder.ToLogString(this.writer.SendBlock.CheckSum)
            //}));
        }