void InventorySetting()
        {
            BleMvxApplication._reader.rfid.CancelAllSelectCriteria();

            BleMvxApplication._reader.rfid.Options.TagRanging.flags = CSLibrary.Constants.SelectFlags.ZERO;

            // Setting 1
            BleMvxApplication._reader.rfid.SetTagDelayTime((uint)BleMvxApplication._config.RFID_TagDelayTime);
            BleMvxApplication._reader.rfid.SetInventoryDuration(BleMvxApplication._config.RFID_Antenna_Dwell);
            SetPower(BleMvxApplication._rfMicro_Power);

            // Setting 3
            BleMvxApplication._config.RFID_DynamicQParms.toggleTarget = (BleMvxApplication._rfMicro_Target == 2) ? 1U : 0U;
            BleMvxApplication._reader.rfid.SetDynamicQParms(BleMvxApplication._config.RFID_DynamicQParms);

            // Setting 4
            BleMvxApplication._config.RFID_FixedQParms.toggleTarget = (BleMvxApplication._rfMicro_Target == 2) ? 1U : 0U;
            BleMvxApplication._reader.rfid.SetFixedQParms(BleMvxApplication._config.RFID_FixedQParms);

            // Setting 2
            BleMvxApplication._reader.rfid.SetOperationMode(BleMvxApplication._config.RFID_OperationMode);
            BleMvxApplication._reader.rfid.SetTagGroup(CSLibrary.Constants.Selected.ASSERTED, BleMvxApplication._config.RFID_TagGroup.session, (BleMvxApplication._rfMicro_Target != 1) ? CSLibrary.Constants.SessionTarget.A : CSLibrary.Constants.SessionTarget.B);
            BleMvxApplication._reader.rfid.SetCurrentSingulationAlgorithm(BleMvxApplication._config.RFID_Algorithm);
            BleMvxApplication._reader.rfid.SetCurrentLinkProfile(BleMvxApplication._config.RFID_Profile);

            {
                // Set Filter on Xerxesl Tag
                BleMvxApplication._reader.rfid.Options.TagSelected.flags      = CSLibrary.Constants.SelectMaskFlags.ENABLE_TOGGLE;
                BleMvxApplication._reader.rfid.Options.TagSelected.bank       = CSLibrary.Constants.MemoryBank.TID;
                BleMvxApplication._reader.rfid.Options.TagSelected.Mask       = new byte[] { 0xE2, 0x82, 0x40, 0x5B };
                BleMvxApplication._reader.rfid.Options.TagSelected.MaskOffset = 0;
                BleMvxApplication._reader.rfid.Options.TagSelected.MaskLength = 28;
                BleMvxApplication._reader.rfid.StartOperation(CSLibrary.Constants.Operation.TAG_PREFILTER);

                {
                    CSLibrary.Structures.SelectCriterion extraSlecetion = new CSLibrary.Structures.SelectCriterion();

                    extraSlecetion.action = new CSLibrary.Structures.SelectAction(CSLibrary.Constants.Target.SELECTED, CSLibrary.Constants.Action.DSLINVB_NOTHING, 0, BleMvxApplication._xerxes_delay);
                    extraSlecetion.mask   = new CSLibrary.Structures.SelectMask(CSLibrary.Constants.MemoryBank.BANK3, 0x3b0, 8, new byte[] { 0x00 });
                    BleMvxApplication._reader.rfid.SetSelectCriteria(1, extraSlecetion);
                }
            }

            BleMvxApplication._reader.rfid.Options.TagRanging.flags |= CSLibrary.Constants.SelectFlags.SELECT;

            // Multi bank inventory
            BleMvxApplication._reader.rfid.Options.TagRanging.multibanks = 2;
            BleMvxApplication._reader.rfid.Options.TagRanging.bank1      = CSLibrary.Constants.MemoryBank.USER;
            BleMvxApplication._reader.rfid.Options.TagRanging.offset1    = 0x12;
            BleMvxApplication._reader.rfid.Options.TagRanging.count1     = 0x04;
            BleMvxApplication._reader.rfid.Options.TagRanging.bank2      = 0x00;
            BleMvxApplication._reader.rfid.Options.TagRanging.offset2    = 0x0a;
            BleMvxApplication._reader.rfid.Options.TagRanging.count2     = 0x05;

            BleMvxApplication._reader.rfid.Options.TagRanging.compactmode = false;
            BleMvxApplication._reader.rfid.StartOperation(CSLibrary.Constants.Operation.TAG_PRERANGING);

            //ShowDialog("Configuring RFID");
        }
예제 #2
0
        private void PreFilter()
        {
            try
            {
                UInt32 value = 0;

                MacReadRegister(MACREGISTER.HST_TAGACC_DESC_CFG, ref value);
                value |= 0x0001U; // Enable Verify after write
                MacWriteRegister(MACREGISTER.HST_TAGACC_DESC_CFG, value);

                MacReadRegister(MACREGISTER.HST_QUERY_CFG, ref value);
                value &= ~0x0200U; // Enable Ucode Parallel encoding
                MacWriteRegister(MACREGISTER.HST_QUERY_CFG, value);

                SetTagGroup(CSLibrary.Constants.Selected.ASSERTED, CSLibrary.Constants.Session.S0, CSLibrary.Constants.SessionTarget.A);

                CSLibrary.Structures.SelectCriterion[] sel = new CSLibrary.Structures.SelectCriterion[1];
                sel[0]        = new CSLibrary.Structures.SelectCriterion();
                sel[0].action = new CSLibrary.Structures.SelectAction(CSLibrary.Constants.Target.SELECTED,
                                                                      (m_rdr_opt_parms.TagSelected.flags & CSLibrary.Constants.SelectMaskFlags.ENABLE_NON_MATCH) == CSLibrary.Constants.SelectMaskFlags.ENABLE_NON_MATCH ?
                                                                      CSLibrary.Constants.Action.DSLINVB_ASLINVA : CSLibrary.Constants.Action.ASLINVA_DSLINVB, 0);


                if (m_rdr_opt_parms.TagSelected.bank == CSLibrary.Constants.MemoryBank.EPC)
                {
                    sel[0].mask = new CSLibrary.Structures.SelectMask(
                        m_rdr_opt_parms.TagSelected.bank,
                        (uint)((m_rdr_opt_parms.TagSelected.flags & CSLibrary.Constants.SelectMaskFlags.ENABLE_PC_MASK) == CSLibrary.Constants.SelectMaskFlags.ENABLE_PC_MASK ? 16 : 32 + m_rdr_opt_parms.TagSelected.epcMaskOffset),
                        m_rdr_opt_parms.TagSelected.epcMaskLength,
                        m_rdr_opt_parms.TagSelected.epcMask.ToBytes());
                }
                else
                {
                    sel[0].mask = new CSLibrary.Structures.SelectMask(
                        m_rdr_opt_parms.TagSelected.bank,
                        m_rdr_opt_parms.TagSelected.MaskOffset,
                        m_rdr_opt_parms.TagSelected.MaskLength,
                        m_rdr_opt_parms.TagSelected.Mask);
                }
                if ((m_Result = SetSelectCriteria(sel)) != CSLibrary.Constants.Result.OK)
                {
                    //goto EXIT;
                }
            }
            catch (System.Exception ex)
            {
#if DEBUG
                //CSLibrary.Diagnostics.CoreDebug.Logger.ErrorException("HighLevelInterface.TagSelected()", ex);
#endif
                m_Result = CSLibrary.Constants.Result.SYSTEM_CATCH_EXCEPTION;
            }
        }
예제 #3
0
        void ResistorMeasurementsPort2()
        {
            CSLibrary.Structures.SelectCriterion extraSlecetion = new CSLibrary.Structures.SelectCriterion();

            extraSlecetion.action = new CSLibrary.Structures.SelectAction(CSLibrary.Constants.Target.SELECTED, CSLibrary.Constants.Action.ASLINVA_DSLINVB, 0, delay);
            extraSlecetion.mask   = new CSLibrary.Structures.SelectMask(CSLibrary.Constants.MemoryBank.BANK3, 0x3f0, 8, new byte[1] {
                0x00
            });
            BleMvxApplication._reader.rfid.SetSelectCriteria(1, extraSlecetion);

            BleMvxApplication._reader.rfid.Options.TagRead.accessPassword = 0x00000000;
            BleMvxApplication._reader.rfid.Options.TagRead.bank           = 0x00;
            BleMvxApplication._reader.rfid.Options.TagRead.offset         = 0x0b;
            BleMvxApplication._reader.rfid.Options.TagRead.count          = 0x01;
            BleMvxApplication._reader.rfid.StartOperation(CSLibrary.Constants.Operation.TAG_READ);
        }
예제 #4
0
        void ReadingTemperatureinMASTERMOD()
        {
            CSLibrary.Structures.SelectCriterion extraSlecetion = new CSLibrary.Structures.SelectCriterion();

            extraSlecetion.action = new CSLibrary.Structures.SelectAction(CSLibrary.Constants.Target.SELECTED, CSLibrary.Constants.Action.DSLINVB_NOTHING, 0, delay);
            extraSlecetion.mask   = new CSLibrary.Structures.SelectMask(CSLibrary.Constants.MemoryBank.BANK3, 0x3b0, 8, new byte[] { 0x00 });
            BleMvxApplication._reader.rfid.SetSelectCriteria(1, extraSlecetion);

            //extraSlecetion.action = new CSLibrary.Structures.SelectAction(CSLibrary.Constants.Target.SELECTED, CSLibrary.Constants.Action.ASLINVA_DSLINVB, 0, 0);
            //extraSlecetion.mask = new CSLibrary.Structures.SelectMask(CSLibrary.Constants.MemoryBank.EPC, BleMvxApplication._reader.rfid.Options.TagSelected.epcMaskOffset, BleMvxApplication._reader.rfid.Options.TagSelected.epcMaskLength, BleMvxApplication._reader.rfid.Options.TagSelected.epcMask.ToBytes());
            //BleMvxApplication._reader.rfid.SetSelectCriteria(1, extraSlecetion);

            BleMvxApplication._reader.rfid.Options.TagRead.accessPassword = 0x00000000;
            BleMvxApplication._reader.rfid.Options.TagRead.bank           = 0x00;
            BleMvxApplication._reader.rfid.Options.TagRead.offset         = 0x0a;
            BleMvxApplication._reader.rfid.Options.TagRead.count          = 0x05;
            BleMvxApplication._reader.rfid.StartOperation(CSLibrary.Constants.Operation.TAG_READ);
        }
예제 #5
0
        void InventorySetting()
        {
            switch (BleMvxApplication._config.RFID_FrequenceSwitch)
            {
            case 0:
                BleMvxApplication._reader.rfid.SetHoppingChannels(BleMvxApplication._config.RFID_Region);
                break;

            case 1:
                BleMvxApplication._reader.rfid.SetFixedChannel(BleMvxApplication._config.RFID_Region, BleMvxApplication._config.RFID_FixedChannel);
                break;

            case 2:
                BleMvxApplication._reader.rfid.SetAgileChannels(BleMvxApplication._config.RFID_Region);
                break;
            }

            BleMvxApplication._reader.rfid.Options.TagRanging.flags = CSLibrary.Constants.SelectFlags.ZERO;

            // Setting 1
            SetPower(BleMvxApplication._rfMicro_Power);

            // Setting 3  // MUST SET for RFMicro
            BleMvxApplication._config.RFID_DynamicQParms.toggleTarget = (BleMvxApplication._rfMicro_Target == 2) ? 1U : 0U;
            BleMvxApplication._config.RFID_DynamicQParms.retryCount   = 5; // for RFMicro special setting
            BleMvxApplication._reader.rfid.SetDynamicQParms(BleMvxApplication._config.RFID_DynamicQParms);
            BleMvxApplication._config.RFID_DynamicQParms.retryCount = 0;   // reset to normal

            // Setting 4
            BleMvxApplication._config.RFID_FixedQParms.toggleTarget = (BleMvxApplication._rfMicro_Target == 2) ? 1U : 0U;
            BleMvxApplication._config.RFID_FixedQParms.retryCount   = 5; // for RFMicro special setting
            BleMvxApplication._reader.rfid.SetFixedQParms(BleMvxApplication._config.RFID_FixedQParms);
            BleMvxApplication._config.RFID_FixedQParms.retryCount = 0;   // reset to normal

            // Setting 2
            BleMvxApplication._reader.rfid.SetOperationMode(BleMvxApplication._config.RFID_OperationMode);
            BleMvxApplication._reader.rfid.SetTagGroup(CSLibrary.Constants.Selected.ASSERTED, BleMvxApplication._config.RFID_TagGroup.session, (BleMvxApplication._rfMicro_Target != 1) ? CSLibrary.Constants.SessionTarget.A : CSLibrary.Constants.SessionTarget.B);
            BleMvxApplication._reader.rfid.SetCurrentSingulationAlgorithm(BleMvxApplication._config.RFID_Algorithm);
            BleMvxApplication._reader.rfid.SetCurrentLinkProfile(BleMvxApplication._config.RFID_Profile);

            // Select RFMicro S3 filter
            {
                CSLibrary.Structures.SelectCriterion extraSlecetion = new CSLibrary.Structures.SelectCriterion();

                extraSlecetion.action = new CSLibrary.Structures.SelectAction(CSLibrary.Constants.Target.SELECTED, CSLibrary.Constants.Action.ASLINVA_DSLINVB, 0);
                extraSlecetion.mask   = new CSLibrary.Structures.SelectMask(CSLibrary.Constants.MemoryBank.TID, 0, 28, new byte[] { 0xe2, 0x82, 0x40, 0x30 });
                BleMvxApplication._reader.rfid.SetSelectCriteria(0, extraSlecetion);

                // Set OCRSSI Limit
                extraSlecetion.action = new CSLibrary.Structures.SelectAction(CSLibrary.Constants.Target.SELECTED, CSLibrary.Constants.Action.NOTHING_DSLINVB, 0);
                extraSlecetion.mask   = new CSLibrary.Structures.SelectMask(CSLibrary.Constants.MemoryBank.BANK3, 0xd0, 8, new byte[] { (byte)(0x20 | BleMvxApplication._rfMicro_minOCRSSI) });
                BleMvxApplication._reader.rfid.SetSelectCriteria(1, extraSlecetion);

                extraSlecetion.action = new CSLibrary.Structures.SelectAction(CSLibrary.Constants.Target.SELECTED, CSLibrary.Constants.Action.NOTHING_DSLINVB, 0);
                extraSlecetion.mask   = new CSLibrary.Structures.SelectMask(CSLibrary.Constants.MemoryBank.BANK3, 0xd0, 8, new byte[] { (byte)(BleMvxApplication._rfMicro_maxOCRSSI) });
                BleMvxApplication._reader.rfid.SetSelectCriteria(2, extraSlecetion);

                // Temperature and Sensor code
                extraSlecetion.action = new CSLibrary.Structures.SelectAction(CSLibrary.Constants.Target.SELECTED, CSLibrary.Constants.Action.NOTHING_DSLINVB, 0);
                extraSlecetion.mask   = new CSLibrary.Structures.SelectMask(CSLibrary.Constants.MemoryBank.BANK3, 0xe0, 0, new byte[] { 0x00 });
                BleMvxApplication._reader.rfid.SetSelectCriteria(3, extraSlecetion);

                BleMvxApplication._reader.rfid.Options.TagRanging.flags |= CSLibrary.Constants.SelectFlags.SELECT;
            }

            // Multi bank inventory
            BleMvxApplication._reader.rfid.Options.TagRanging.multibanks  = 2;
            BleMvxApplication._reader.rfid.Options.TagRanging.bank1       = CSLibrary.Constants.MemoryBank.BANK0;
            BleMvxApplication._reader.rfid.Options.TagRanging.offset1     = 12; // address C
            BleMvxApplication._reader.rfid.Options.TagRanging.count1      = 3;
            BleMvxApplication._reader.rfid.Options.TagRanging.bank2       = CSLibrary.Constants.MemoryBank.USER;
            BleMvxApplication._reader.rfid.Options.TagRanging.offset2     = 8;
            BleMvxApplication._reader.rfid.Options.TagRanging.count2      = 4;
            BleMvxApplication._reader.rfid.Options.TagRanging.compactmode = false;

            BleMvxApplication._reader.rfid.StartOperation(CSLibrary.Constants.Operation.TAG_PRERANGING);
        }
예제 #6
0
        private void TagSelectedDYNQ()
        {
            try
            {
                _tagSelectedParms = (Structures.TagSelectedParms)m_rdr_opt_parms.TagSelected.Clone();

                UInt32 value = 0;

                MacReadRegister(MACREGISTER.HST_TAGACC_DESC_CFG, ref value);
                value |= 0x0001U; // Enable Verify after write
                MacWriteRegister(MACREGISTER.HST_TAGACC_DESC_CFG, value);

                MacReadRegister(MACREGISTER.HST_QUERY_CFG, ref value);
                value &= ~0x0200U; // Enable Ucode Parallel encoding
                MacWriteRegister(MACREGISTER.HST_QUERY_CFG, value);

                SetOperationMode(CSLibrary.Constants.RadioOperationMode.NONCONTINUOUS);
                SetTagGroup(CSLibrary.Constants.Selected.ASSERTED, CSLibrary.Constants.Session.S0, CSLibrary.Constants.SessionTarget.A);
                {
                    CSLibrary.Structures.DynamicQParms param = new CSLibrary.Structures.DynamicQParms();

                    param.startQValue  = m_rdr_opt_parms.TagSelected.Qvalue;
                    param.toggleTarget = (uint)((m_rdr_opt_parms.TagSelected.flags & CSLibrary.Constants.SelectMaskFlags.ENABLE_TOGGLE) == CSLibrary.Constants.SelectMaskFlags.ENABLE_TOGGLE ? 1 : 0);
                    param.retryCount   = 0x05;

                    SetSingulationAlgorithmParms(CSLibrary.Constants.SingulationAlgorithm.DYNAMICQ, param);
                }

                CSLibrary.Structures.SelectCriterion[] sel = new CSLibrary.Structures.SelectCriterion[1];
                sel[0]        = new CSLibrary.Structures.SelectCriterion();
                sel[0].action = new CSLibrary.Structures.SelectAction(CSLibrary.Constants.Target.SELECTED,
                                                                      (m_rdr_opt_parms.TagSelected.flags & CSLibrary.Constants.SelectMaskFlags.ENABLE_NON_MATCH) == CSLibrary.Constants.SelectMaskFlags.ENABLE_NON_MATCH ?
                                                                      CSLibrary.Constants.Action.DSLINVB_ASLINVA : CSLibrary.Constants.Action.ASLINVA_DSLINVB, 0);


                if (m_rdr_opt_parms.TagSelected.bank == CSLibrary.Constants.MemoryBank.EPC)
                {
                    sel[0].mask = new CSLibrary.Structures.SelectMask(
                        m_rdr_opt_parms.TagSelected.bank,
                        (uint)((m_rdr_opt_parms.TagSelected.flags & CSLibrary.Constants.SelectMaskFlags.ENABLE_PC_MASK) == CSLibrary.Constants.SelectMaskFlags.ENABLE_PC_MASK ? 16 : 32 + m_rdr_opt_parms.TagSelected.epcMaskOffset),
                        m_rdr_opt_parms.TagSelected.epcMaskLength,
                        m_rdr_opt_parms.TagSelected.epcMask.ToBytes());
                }
                else
                {
                    sel[0].mask = new CSLibrary.Structures.SelectMask(
                        m_rdr_opt_parms.TagSelected.bank,
                        m_rdr_opt_parms.TagSelected.MaskOffset,
                        m_rdr_opt_parms.TagSelected.MaskLength,
                        m_rdr_opt_parms.TagSelected.Mask);
                }
                if ((m_Result = SetSelectCriteria(sel)) != CSLibrary.Constants.Result.OK)
                {
                    //goto EXIT;
                }
            }
            catch (System.Exception ex)
            {
#if DEBUG
                //CSLibrary.Diagnostics.CoreDebug.Logger.ErrorException("HighLevelInterface.TagSelected()", ex);
#endif
                m_Result = CSLibrary.Constants.Result.SYSTEM_CATCH_EXCEPTION;
            }
        }
예제 #7
0
        void InventorySetting()
        {
            switch (BleMvxApplication._config.RFID_FrequenceSwitch)
            {
            case 0:
                BleMvxApplication._reader.rfid.SetHoppingChannels(BleMvxApplication._config.RFID_Region);
                break;

            case 1:
                BleMvxApplication._reader.rfid.SetFixedChannel(BleMvxApplication._config.RFID_Region, BleMvxApplication._config.RFID_FixedChannel);
                break;

            case 2:
                BleMvxApplication._reader.rfid.SetAgileChannels(BleMvxApplication._config.RFID_Region);
                break;
            }

            BleMvxApplication._reader.rfid.Options.TagRanging.flags = CSLibrary.Constants.SelectFlags.ZERO;

            // Setting 1
            if (BleMvxApplication._reader.rfid.GetModelName() == "CS108")
            {
                if (BleMvxApplication._config.RFID_PowerSequencing_NumberofPower == 0)
                {
                    BleMvxApplication._reader.rfid.SetPowerSequencing(0);
                    BleMvxApplication._reader.rfid.SetPowerLevel((uint)BleMvxApplication._config.RFID_Power);
                }
                else
                {
                    BleMvxApplication._reader.rfid.SetPowerSequencing(BleMvxApplication._config.RFID_PowerSequencing_NumberofPower, BleMvxApplication._config.RFID_PowerSequencing_Level, BleMvxApplication._config.RFID_PowerSequencing_DWell);
                }
            }

            // Setting 3  // MUST SET for RFMicro
            if (BleMvxApplication._reader.rfid.Options.TagRanging.focus)
            {
                BleMvxApplication._config.RFID_DynamicQParms.toggleTarget = 0;
            }
            else
            {
                BleMvxApplication._config.RFID_DynamicQParms.toggleTarget = BleMvxApplication._config.RFID_ToggleTarget ? 1U : 0;
            }
            BleMvxApplication._reader.rfid.SetDynamicQParms(BleMvxApplication._config.RFID_DynamicQParms);

            // Setting 4
            if (BleMvxApplication._reader.rfid.Options.TagRanging.focus)
            {
                BleMvxApplication._config.RFID_FixedQParms.toggleTarget = 0;
            }
            else
            {
                BleMvxApplication._config.RFID_FixedQParms.toggleTarget = BleMvxApplication._config.RFID_ToggleTarget ? 1U : 0;
            }
            BleMvxApplication._reader.rfid.SetFixedQParms(BleMvxApplication._config.RFID_FixedQParms);

            // Setting 2
            if (BleMvxApplication._reader.rfid.Options.TagRanging.focus)
            {
                BleMvxApplication._reader.rfid.SetTagGroup(CSLibrary.Constants.Selected.ASSERTED, CSLibrary.Constants.Session.S1, CSLibrary.Constants.SessionTarget.A);
            }

            BleMvxApplication._reader.rfid.SetOperationMode(BleMvxApplication._config.RFID_OperationMode);
            //BleMvxApplication._reader.rfid.SetTagGroup(CSLibrary.Constants.Selected.ASSERTED, CSLibrary.Constants.Session.S1, CSLibrary.Constants.SessionTarget.A);
            BleMvxApplication._reader.rfid.SetCurrentSingulationAlgorithm(BleMvxApplication._config.RFID_Algorithm);
            BleMvxApplication._reader.rfid.SetCurrentLinkProfile(BleMvxApplication._config.RFID_Profile);

            // Set Post Filter
            {
                BleMvxApplication._reader.rfid.Options.TagSelected.flags      = CSLibrary.Constants.SelectMaskFlags.ENABLE_TOGGLE;
                BleMvxApplication._reader.rfid.Options.TagSelected.bank       = CSLibrary.Constants.MemoryBank.TID;
                BleMvxApplication._reader.rfid.Options.TagSelected.Mask       = new byte [] { 0xE2, 0x03, 0x51, 0x06 };
                BleMvxApplication._reader.rfid.Options.TagSelected.MaskOffset = 0;
                BleMvxApplication._reader.rfid.Options.TagSelected.MaskLength = 28;
                BleMvxApplication._reader.rfid.StartOperation(CSLibrary.Constants.Operation.TAG_PREFILTER);

                BleMvxApplication._reader.rfid.Options.TagRanging.flags |= CSLibrary.Constants.SelectFlags.SELECT;
            }

            {
                CSLibrary.Structures.SelectCriterion extraSlecetion = new CSLibrary.Structures.SelectCriterion();

                extraSlecetion.action = new CSLibrary.Structures.SelectAction(CSLibrary.Constants.Target.CTESIUS, CSLibrary.Constants.Action.DSLINVB_ASLINVA, 0);
                extraSlecetion.mask   = new CSLibrary.Structures.SelectMask(CSLibrary.Constants.MemoryBank.USER, 0x40, 0, new byte[] {});
                BleMvxApplication._reader.rfid.SetSelectCriteria(1, extraSlecetion);
            }

            // Multi bank inventory
            BleMvxApplication._reader.rfid.Options.TagRanging.multibanks  = 1;
            BleMvxApplication._reader.rfid.Options.TagRanging.bank1       = CSLibrary.Constants.MemoryBank.USER;
            BleMvxApplication._reader.rfid.Options.TagRanging.offset1     = 6;
            BleMvxApplication._reader.rfid.Options.TagRanging.count1      = 4;
            BleMvxApplication._reader.rfid.Options.TagRanging.compactmode = false;

            BleMvxApplication._reader.rfid.StartOperation(CSLibrary.Constants.Operation.TAG_PRERANGING);
        }
        bool SetParameters()
        {
            switch (_readProcedure)
            {
            case 0:     //
                if (!switchRWTagIDIsToggled)
                {
                    _readProcedure++;
                    return(SetParameters());
                }
                BleMvxApplication._reader.rfid.Options.TagRead.bank   = (CSLibrary.Constants.MemoryBank)_dataBank[0];
                BleMvxApplication._reader.rfid.Options.TagRead.offset = _dataOffset[0];
                BleMvxApplication._reader.rfid.Options.TagRead.count  = _dataCount[0];
                BleMvxApplication._reader.rfid.StartOperation(CSLibrary.Constants.Operation.TAG_SELECTED);
                BleMvxApplication._reader.rfid.SetSelectCriteria(1, null);
                break;

            case 1:
                if (!switchCalibrationIsToggled)
                {
                    _readProcedure++;
                    return(SetParameters());
                }
                BleMvxApplication._reader.rfid.Options.TagRead.bank   = _dataBank[1];
                BleMvxApplication._reader.rfid.Options.TagRead.offset = _dataOffset[1];
                BleMvxApplication._reader.rfid.Options.TagRead.count  = _dataCount[1];
                BleMvxApplication._reader.rfid.StartOperation(CSLibrary.Constants.Operation.TAG_SELECTED);
                BleMvxApplication._reader.rfid.SetSelectCriteria(1, null);
                break;

            case 2:
                if (!switchSensorCodeIsToggled)
                {
                    _readProcedure++;
                    return(SetParameters());
                }
                BleMvxApplication._reader.rfid.Options.TagRead.bank   = _dataBank[_tagMode + 1];
                BleMvxApplication._reader.rfid.Options.TagRead.offset = _dataOffset[_tagMode + 1];
                BleMvxApplication._reader.rfid.Options.TagRead.count  = _dataCount[_tagMode + 1];
                {
                    BleMvxApplication._reader.rfid.StartOperation(CSLibrary.Constants.Operation.TAG_SELECTED);
                    BleMvxApplication._reader.rfid.SetTagGroup(CSLibrary.Constants.Selected.ASSERTED, CSLibrary.Constants.Session.S1, CSLibrary.Constants.SessionTarget.A);     // better for read rangage

                    CSLibrary.Structures.SelectCriterion extraSlecetion = new CSLibrary.Structures.SelectCriterion();

                    extraSlecetion.action = new CSLibrary.Structures.SelectAction(CSLibrary.Constants.Target.SELECTED, CSLibrary.Constants.Action.ASLINVA_DSLINVB, 0);
                    extraSlecetion.mask   = new CSLibrary.Structures.SelectMask(CSLibrary.Constants.MemoryBank.BANK3, 0xe0, 0, new byte[1]);
                    BleMvxApplication._reader.rfid.SetSelectCriteria(0, extraSlecetion);

                    extraSlecetion.action = new CSLibrary.Structures.SelectAction(CSLibrary.Constants.Target.SELECTED, CSLibrary.Constants.Action.ASLINVA_DSLINVB, 0);
                    extraSlecetion.mask   = new CSLibrary.Structures.SelectMask(CSLibrary.Constants.MemoryBank.EPC, 0x20, 0x60, CSLibrary.Tools.Hex.ToBytes(entrySelectedEPC));
                    BleMvxApplication._reader.rfid.SetSelectCriteria(1, extraSlecetion);
                }
                break;

            case 3:
                if (!switchRssiCodeIsToggled)
                {
                    _readProcedure++;
                    return(SetParameters());
                }
                if (_tagMode == 1)
                {
                    BleMvxApplication._reader.rfid.Options.TagRead.bank   = _dataBank[5];
                    BleMvxApplication._reader.rfid.Options.TagRead.offset = _dataOffset[5];
                    BleMvxApplication._reader.rfid.Options.TagRead.count  = _dataCount[5];
                }
                else
                {
                    BleMvxApplication._reader.rfid.Options.TagRead.bank   = _dataBank[6];
                    BleMvxApplication._reader.rfid.Options.TagRead.offset = _dataOffset[6];
                    BleMvxApplication._reader.rfid.Options.TagRead.count  = _dataCount[6];
                }
                {
                    BleMvxApplication._reader.rfid.StartOperation(CSLibrary.Constants.Operation.TAG_SELECTED);
                    BleMvxApplication._reader.rfid.SetTagGroup(CSLibrary.Constants.Selected.ASSERTED, CSLibrary.Constants.Session.S1, CSLibrary.Constants.SessionTarget.A);     // better for read rangage

                    CSLibrary.Structures.SelectCriterion extraSlecetion = new CSLibrary.Structures.SelectCriterion();

                    extraSlecetion.action = new CSLibrary.Structures.SelectAction(CSLibrary.Constants.Target.SELECTED, CSLibrary.Constants.Action.ASLINVA_DSLINVB, 0);
                    extraSlecetion.mask   = new CSLibrary.Structures.SelectMask(CSLibrary.Constants.MemoryBank.BANK3, 0xd0, 8, new byte[] { 0x20 });
                    BleMvxApplication._reader.rfid.SetSelectCriteria(0, extraSlecetion);

                    extraSlecetion.action = new CSLibrary.Structures.SelectAction(CSLibrary.Constants.Target.SELECTED, CSLibrary.Constants.Action.ASLINVA_DSLINVB, 0);
                    extraSlecetion.mask   = new CSLibrary.Structures.SelectMask(CSLibrary.Constants.MemoryBank.EPC, 0x20, 0x60, CSLibrary.Tools.Hex.ToBytes(entrySelectedEPC));

                    BleMvxApplication._reader.rfid.SetSelectCriteria(1, extraSlecetion);
                }

                break;

            case 4:
                if (!switchTemperatureCodeIsToggled)
                {
                    _readProcedure++;
                    return(SetParameters());
                }
                BleMvxApplication._reader.rfid.Options.TagRead.bank   = _dataBank[7];
                BleMvxApplication._reader.rfid.Options.TagRead.offset = _dataOffset[7];
                BleMvxApplication._reader.rfid.Options.TagRead.count  = _dataCount[7];

                {
                    BleMvxApplication._reader.rfid.StartOperation(CSLibrary.Constants.Operation.TAG_SELECTED);
                    BleMvxApplication._reader.rfid.SetTagGroup(CSLibrary.Constants.Selected.ASSERTED, CSLibrary.Constants.Session.S1, CSLibrary.Constants.SessionTarget.A);    // better for read rangage

                    CSLibrary.Structures.SelectCriterion extraSlecetion = new CSLibrary.Structures.SelectCriterion();

                    extraSlecetion.action = new CSLibrary.Structures.SelectAction(CSLibrary.Constants.Target.SELECTED, CSLibrary.Constants.Action.ASLINVA_DSLINVB, 0);
                    extraSlecetion.mask   = new CSLibrary.Structures.SelectMask(CSLibrary.Constants.MemoryBank.BANK3, 0xe0, 0, new byte[] { 0x00 });
                    BleMvxApplication._reader.rfid.SetSelectCriteria(0, extraSlecetion);

                    extraSlecetion.action = new CSLibrary.Structures.SelectAction(CSLibrary.Constants.Target.SELECTED, CSLibrary.Constants.Action.ASLINVA_DSLINVB, 0);
                    extraSlecetion.mask   = new CSLibrary.Structures.SelectMask(CSLibrary.Constants.MemoryBank.EPC, 0x20, 0x60, CSLibrary.Tools.Hex.ToBytes(entrySelectedEPC));
                    BleMvxApplication._reader.rfid.SetSelectCriteria(1, extraSlecetion);
                }
                break;

            default:
                BleMvxApplication._reader.rfid.CancelAllSelectCriteria();                    // Confirm cancel all filter
                return(false);

                break;
            }

            readRetryCnt = 7;
            return(true);
        }