private void OnReadData(object sender, FAGenericEventArgs<string> e)
 {
     if (ScanAble)
     {
         ScanData = e.Value;
     }
 }
        public virtual void Read(object sender, FAGenericEventArgs<byte[]> e)
        {
            try
            {
                _sumReceivedData.AddRange(e.Value);

                if (_sumReceivedData.Count >= 82)
                {
                    string s = StreamEncoding.GetString(e.Value);

                    int stxIndex = 0;
                    for (stxIndex = 0; stxIndex < _sumReceivedData.Count; stxIndex++)
                    {
                        if (_sumReceivedData[stxIndex] == STX) break;
                    }

                    if (_sumReceivedData[stxIndex] == STX &&
                        _sumReceivedData[stxIndex + 36] == STX &&
                        _sumReceivedData[stxIndex + 69] == STX &&
                        _sumReceivedData[stxIndex + 72] == STX &&
                        _sumReceivedData[stxIndex + 79] == STX)
                    {
                    }

                    string[] buffer = s.Split(',');

                    if (buffer[1] == "1")
                        StatusPaperOutError = true;
                    else
                        StatusPaperOutError = false;

                    if (buffer[2] == "1")
                        StatusOnlineError = true;
                    else
                        StatusOnlineError = false;

                    if (buffer[5] == "1")
                        StatusBufferOverflow = true;
                    else
                        StatusBufferOverflow = false;

                    if (buffer[13] == "1")
                        StatusHeadOpenError = true;
                    else
                        StatusHeadOpenError = false;

                    if (buffer[14] == "1")
                        StatusRibbonOut = true;
                    else
                        StatusRibbonOut = false;

                    _sumReceivedData.Clear();
                }
            }
            catch
            {
            }
        }
 private void Write(object sender, FAGenericEventArgs<string> e)
 {
 }
 private void OnReceivedData(object sender, FAGenericEventArgs<FAExtendServerECPart.ECReceivedData> e)
 {
     _ecCommandPages.SelectedCommandName = e.Value.CommandType;
 }
        private void EventHandlerDataReceived(object sender, FAGenericEventArgs<byte[]> e)
        {
            try
            {
                _readData.AddRange(e.Value);

                int stxPos = _readData.IndexOf(STX);
                if (stxPos < 0) return;

                int etxPos = _readData.IndexOf(ETX, stxPos);
                if (stxPos < 0) return;

                int dataSize = etxPos - stxPos + 1;
                byte[] stxToEtxData = new byte[dataSize];
                _readData.CopyTo(stxPos, stxToEtxData, 0, dataSize);
                byte[] dataBlock = GetDataBlock(stxToEtxData);
                Channel1Tag = BytesToAsciiString(dataBlock);
            }
            catch
            {
            }
        }
 private void Read(object sender, FAGenericEventArgs<byte[]> e)
 {
     string temp = Device.StreamEncoding.GetString(e.Value);
     string[] splitData = temp.Split('\n');
     if (splitData.Length > 0)
     {
         ECString = splitData[0];
         ReceivedData(ECString);
     }
 }
 private void ReadStatus(object sender, FAGenericEventArgs<byte[]> e)
 {
     if (OnReadStatus != null)
         OnReadStatus(sender, e);
 }
        private void ReadStatus(object sender, FAGenericEventArgs<byte[]> e)
        {
            string str;
            try
            {
                str = Encoding.ASCII.GetString(e.Value);
            }
            catch
            {
                return;
            }

            if (OnReadData != null)
                OnReadData(sender, new FAGenericEventArgs<string>(str));
        }
 public virtual void ReceivedData(object sender, FAGenericEventArgs<string> e)
 {
     ReceivedString = e.Value;
 }
 private void OnReadEventHandler(object sender, FAGenericEventArgs<string[]> e)
 {
     OnReadData(e.Value);
 }
        private void SimulationModeChangedEventHandler(object sender, FAGenericEventArgs<bool> e)
        {
            foreach (FAPartInputIOInfo item in InputIO)
                item.SimulationMode = e.Value;

            foreach (FAPartOutputIOInfo item in OutputIO)
                try
                {
                    item.SimulationMode = e.Value;
                }
                catch
                {
                }
        }
 private void Read(object sender, FAGenericEventArgs<byte[]> e)
 {
     ReceivedString = Device.StreamEncoding.GetString(e.Value);
     ReceiveData(ReceivedString);
 }
 private void ReadStatus(object sender, FAGenericEventArgs<byte[]> e)
 {
     ZPL.PrinterStatus status = ZPL.ParsingPrinterStatus(e.Value);
     if (status != null)
     {
         StatusOnline = true;
         StatusPaperOutError = status.PaperOut;
         StatusHeadOpenError = status.HeadUp;
         StatusBufferOverflow = status.BufferFull;
         StatusRibbonOut = status.RibbonOut;
     }
 }
 private void SimulationModeChangedEventHandler(object sender, FAGenericEventArgs<bool> e)
 {
 }
        private void ReadStatus(object sender, FAGenericEventArgs<byte[]> e)
        {
            string readData = Encoding.ASCII.GetString(e.Value);
            if (readData != null)
            {
                ReceiveData = readData;

                if (readData.Length > 0)
                {
                    string[] splitReadData = readData.Split(new char[] {ResultSeperator}, StringSplitOptions.RemoveEmptyEntries);
                    if (OnRead != null)
                        OnRead(this, new FAGenericEventArgs<string[]>(splitReadData));
                }
            }
        }
Example #16
0
 private void StatusChangedEventHandler(object sender, FAGenericEventArgs<EquipmentStatus> e)
 {
     try
     {
         if (Status == EquipmentStatus.RUN_DOWN)
         {
             //InterfaceUnit.ECPart.SendRunDownInfo(Manager.ConfigManager.Instance.Config.EquipmentID,
             //    OperatorID);
             // TODO
         }
         else if (Status == EquipmentStatus.AUTO_RUNNING)
         {
             //InterfaceUnit.ECPart.SendStartInfo(Manager.ConfigManager.Instance.Config.EquipmentID,
             //    OperatorID);
             // TODO
         }
         else if (Status == EquipmentStatus.AUTO_STOP)
         {
             if (e.Value == EquipmentStatus.AUTO_RUNNING)
             {
             }
         }
     }
     catch
     {
     }
 }