public class CardReaderDevice : IDisposable
    {
        private static readonly byte[] _password = new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };

        private SerialPort _port = new SerialPort();
        private ByteCounter _frameIDGenerator = new ByteCounter();

        private CardReaderByteStaffing _byteStaffing = new CardReaderByteStaffing(
            FRAME_STAFFED_BYTE, 
            STAFFED_FRAME_STAFFED_BYTE
        );

        public CardReaderDevice()
        {
            _byteStaffing.AddToMap(FRAME_START, STAFFED_FRAME_START);
            _byteStaffing.AddToMap(FRAME_STOP, STAFFED_FRAME_STOP);
            DeviceInfo = null;
            Active = false;
        }

        public virtual void Dispose()
        {
            Close();
            _port.Dispose();
        }

        #region Open / Close

        public bool Active { get; private set; }
        public CardReaderDeviceInfo DeviceInfo { get; private set; }

        private void InitializePort(string portName)
        {
            _port.PortName = portName;
            _port.BaudRate = 9600;
            _port.DataBits = 8;
            _port.StopBits = StopBits.One;
            _port.Parity = Parity.None;
            _port.Handshake = Handshake.None;
            _port.ReadTimeout = 200;
        }

        public void Open(string portName)
        {
            Close();
            InitializePort(portName);
            CardReaderDeviceInfo deviceInfo;
            _port.Open();
            try
            {
                deviceInfo = ReadDeviceInfo();
                SwitchSignals(CardReaderSignals.BeeperDouble | CardReaderSignals.GreenBeeper);
            }
            catch
            {
                _port.Close();
                throw;
            }
            DeviceInfo = deviceInfo;
            Active = true;
        }

        public void Close()
        {
            if (Active == false)
                return;
            try
            {
                _port.Close();
            }
            catch { }
            DeviceInfo = null;
            Active = false;
        }

        public void Open()
        {
            StringBuilder err = new StringBuilder();
            foreach (string portName in SerialPort.GetPortNames())
            {
                try
                {
                    Open(portName);
                    break;
                }
                catch (Exception E)
                {
                    err.AppendLine(portName + ": " + E.Message);
                }
            }
            if (Active == false)
                throw new InvalidOperationException(
                    "Ошибка открытия считывателя электронных карт:" + 
                    Environment.NewLine + 
                    err.ToString()
                );
        }

        #endregion

        #region Read / Write Utils

        private const int BLOCKS_IN_SECTOR = 4;
        internal const int BLOCK_SIZE = 16;
        internal const int FIRST_USED_BLOCK = 4;        

        private static bool IsSystemBlock(int nBlock)
        {
            return
                nBlock == 0 ||
                (nBlock + 1) % BLOCKS_IN_SECTOR == 0;
        }

        internal static void IncrementBlock(ref int currentBlock)
        {
            do
            {
                currentBlock++;
            }
            while (IsSystemBlock(currentBlock));
        }

        #endregion

        #region Commands

        private CardReaderDeviceInfo ReadDeviceInfo()
        {
            byte[] response = ExecuteCommand(0x00, null);
            string deviceName = Encoding.GetEncoding(1251).GetString(response, 3, 20).TrimEnd('\0').Trim();
            return new CardReaderDeviceInfo() { DeviceName = deviceName };
        }

        public void SwitchSignalsStartCommand()
        {
            SwitchSignals(CardReaderSignals.GreenBeeper | CardReaderSignals.BeeperOne);
        }

        public void SwitchSignalsEndCommand()
        {
            SwitchSignals(CardReaderSignals.GreenBeeper | CardReaderSignals.BeeperOne);
        }

        private void SwitchSignals(CardReaderSignals signal)
        {
            byte[] response = ExecuteCommand(0x21, new byte[] { (byte)signal });
            ValidateAck(response);
        }

        public void InitializeCard()
        {
            ResetCard();
            SelectCard();
        }

        private void ResetCard()
        {
            ValidateAck(ExecuteCommand(0x22, null));
        }

        private void SelectCard()
        {
            ExecuteCommand(0x45, new byte[] { 0 });
        }

        public void AuthorizeBlockOnce(byte nBlock)
        {
            if (nBlock % BLOCKS_IN_SECTOR == 0)
                AuthorizeBlock(nBlock);
        }

        public void AuthorizeBlock(byte nBlock)
        {
            if (_password.Length != 6)
                throw new ArgumentException("g_Password.Length != 6");
            byte[] cmdData = new byte[8];
            cmdData[0] = 0x02; // ключ содержится в команде
            cmdData[1] = nBlock;
            _password.CopyTo(cmdData, 2);
            ExecuteCommand(0x50, cmdData);
        }

        public byte[] ReadBlock(byte nBlock)
        {
            if (IsSystemBlock(nBlock))
                throw new InvalidOperationException("Попытка чтения из системного блока сектора. Адрес блока: " + nBlock.ToString());
            byte[] response = ExecuteCommand(0x51, new byte[] { nBlock });
            byte[] result = new byte[BLOCK_SIZE];
            Array.Copy(response, 3, result, 0, BLOCK_SIZE);
            return result;
        }

        public void WriteBlock(byte nBlock, byte[] data)
        {
            if (IsSystemBlock(nBlock))
                throw new InvalidOperationException("Попытка записи в системный блок сектора. Адрес блока: " + nBlock.ToString());
            if (data.Length != BLOCK_SIZE)
                throw new ArgumentException("data.Length != BLOCK_SIZE");
            byte[] cmdData = new byte[BLOCK_SIZE + 1];
            cmdData[0] = nBlock;
            data.CopyTo(cmdData, 1);
            byte[] response = ExecuteCommand(0x52, cmdData);
            ValidateAck(response);
        }

        #endregion

        #region Command Management

        private byte[] ExecuteCommand(byte cmd, byte[] data)
        {
            WriteRequest(cmd, data);
            byte[] response = ReadResponse();
            ValidateFrameID(response);
            ValidateNack(response);
            return response;
        }

        private void ValidateFrameID(byte[] response)
        {
            if (response[1] != _frameIDGenerator.CurrentValue)
                throw new FormatException("response[1] != _FrameID");
        }

        private void ValidateNack(byte[] response)
        {
            if (response[2] == REPLY_ACK_NACK)
            {
                byte result = response[3];
                if (result != REPLY_ACK)
                    throw new FormatException("Error NACK" + result.ToString());
            }
        }

        private void ValidateAck(byte[] response)
        {
            if (response[2] != REPLY_ACK_NACK)
                throw new FormatException("Response type must be REPLY_ACK_NACK");
        }

        #endregion

        #region Transport

        #region Write Request

        private void WriteRequest(byte cmd, byte[] data)
        {
            byte[] req = GetRequest(cmd, data);
            _port.Write(req, 0, req.Length);
        }        

        private byte[] GetRequest(byte command, byte[] data)
        {
            MemoryStream msDest = new MemoryStream();

            msDest.WriteByte(FRAME_START); // стартовое условие            
            msDest.WriteByte(_frameIDGenerator.GetNextValue()); // идентификатор кадра
            msDest.WriteByte(command); // код комманды
            if (data != null)
                msDest.Write(data, 0, data.Length);
            msDest.WriteByte(0x00); // FCS, 2 байта
            msDest.WriteByte(0x00); // 
            msDest.WriteByte(FRAME_STOP); // стоповое условие

            byte[] result = msDest.ToArray();

            BitConverter.GetBytes(GetFCS(result)).CopyTo(result, result.Length - 3);

            return _byteStaffing.Encode(result);
        }

        #endregion

        #region Read Response

        private byte ReadByteFromPort()
        {
            return (byte)_port.ReadByte();
        }

        private byte[] ReadResponse()
        {
            while (ReadByteFromPort() != FRAME_START)
            { }

            MemoryStream msDest = new MemoryStream();

            msDest.WriteByte(FRAME_START);
            byte receivedByte;
            do
            {
                receivedByte = ReadByteFromPort();
                msDest.WriteByte(receivedByte);
            }
            while (receivedByte != FRAME_STOP);

            byte[] receivedBytes = _byteStaffing.Decode(msDest.ToArray());

            if (GetFCS(receivedBytes) != BitConverter.ToUInt16(receivedBytes, receivedBytes.Length - 3))
                throw new FormatException("FCS error");

            return receivedBytes;
        }

        #endregion

        private UInt16 GetFCS(byte[] data)
        {
            UInt32 fcs = 0xFFFF;
            for (int i = 1; i < data.Length - 3; i++)
            {
                UInt32 cb = data[i];
                UInt32 w = (cb ^ fcs) & 0xFF;
                for (int j = 0; j < 8; j++)
                {
                    if ((w & 1) != 0)
                    {
                        w >>= 1;
                        w ^= 0x8408;
                    }
                    else
                        w >>= 1;
                }
                fcs = w ^ (fcs >> 8);
            }
            fcs ^= 0xFFFFFFFF;
            return (UInt16)fcs;
        }

        #endregion

        #region Device Constants

        private const byte FRAME_START = 0xFD;
        private const byte FRAME_STOP = 0xFE;
        private const byte FRAME_STAFFED_BYTE = 0xFF;

        private const byte STAFFED_FRAME_STAFFED_BYTE = 0x00;
        private const byte STAFFED_FRAME_START = 0x02;
        private const byte STAFFED_FRAME_STOP = 0x01;

        private const byte REPLY_ACK_NACK = 0x2A;
        private const byte REPLY_ACK = 0x55;

        [Flags]
        private enum CardReaderSignals : byte
        {
            AllOff = 0x00,
            GreenOff = 0x00,
            GreenOn = 0x01,
            GreenBlink = 0x02,
            GreenBeeper = 0x03,
            RedOff = 0x00,
            RedOn = 0x04,
            RedBlink = 0x08,
            RedBeeper = 0x0C,
            BeeperOff = 0x00,
            BeeperOne = 0x10,
            BeeperDouble = 0x20,
            BeeperLong = 0x30,
            Default = 0x80
        }

        #endregion
    }

    public class CardReaderDeviceInfo
    {
        public string DeviceName { get; set; }
    }