public appSettings() { //inital here m_tagGroup.selected = Selected.ALL; m_tagGroup.session = Session.S0; m_tagGroup.target = SessionTarget.A; m_dynQ.thresholdMultiplier = 0; m_dynQ.maxQValue = 15; m_dynQ.minQValue = 0; m_dynQ.retryCount = 0; m_dynQ.startQValue = 7; m_dynQ.toggleTarget = 1; /*m_dynQA.maxQueryRepCount = 0; * m_dynQA.maxQValue = 15; * m_dynQA.minQValue = 0; * m_dynQA.retryCount = 0; * m_dynQA.startQValue = 7; * m_dynQA.toggleTarget = 1; * * m_dynQT.thresholdMultiplier = 0; * m_dynQT.maxQValue = 15; * m_dynQT.minQValue = 0; * m_dynQT.retryCount = 0; * m_dynQT.startQValue = 7; * m_dynQT.toggleTarget = 1;*/ m_fixedQ.qValue = 7; m_fixedQ.repeatUntilNoTags = 0; m_fixedQ.retryCount = 0; m_fixedQ.toggleTarget = 1; m_singulation = SingulationAlgorithm.DYNAMICQ; }
/// <summary> /// GetSingulationAlgorithmParms /// </summary> /// <param name="alg"></param> /// <param name="parms"></param> /// <returns></returns> public Result GetSingulationAlgorithmParms(SingulationAlgorithm alg, SingulationAlgorithmParms parms) { const int RFID_18K6C_SINGULATION_ALGORITHM_FIXEDQ = 0; const int RFID_18K6C_SINGULATION_ALGORITHM_DYNAMICQ = 3; UInt32 parm0Register = 0; UInt32 parm1Register = 0; UInt32 parm2Register = 0; switch (alg) { case SingulationAlgorithm.FIXEDQ: { FixedQParms m_fixedQ = (FixedQParms)parms; // Tell the MAC which singulation algorithm selector to use and then // read the singulation algorithm registers MacWriteRegister(MACREGISTER.HST_INV_SEL, RFID_18K6C_SINGULATION_ALGORITHM_FIXEDQ); MacReadRegister(MACREGISTER.HST_INV_ALG_PARM_0, ref parm0Register); MacReadRegister(MACREGISTER.HST_INV_ALG_PARM_1, ref parm1Register); MacReadRegister(MACREGISTER.HST_INV_ALG_PARM_2, ref parm2Register); // Set up the fixed Q singulation algorithm structure //m_fixedQ.length = sizeof(FixedQParms); m_fixedQ.qValue = parm0Register & 0x0f; m_fixedQ.retryCount = parm1Register & 0xff; m_fixedQ.toggleTarget = (parm2Register & 0x01) != 0 ? (uint)1 : (uint)0; m_fixedQ.repeatUntilNoTags = (parm2Register & 0x02) != 0 ? (uint)1 : (uint)0; } break; case SingulationAlgorithm.DYNAMICQ: { DynamicQParms m_dynQ = (DynamicQParms)parms; // Tell the MAC which singulation algorithm selector to use and then // read the singulation algorithm registers MacWriteRegister(MACREGISTER.HST_INV_SEL, RFID_18K6C_SINGULATION_ALGORITHM_DYNAMICQ); MacReadRegister(MACREGISTER.HST_INV_ALG_PARM_0, ref parm0Register); MacReadRegister(MACREGISTER.HST_INV_ALG_PARM_1, ref parm1Register); MacReadRegister(MACREGISTER.HST_INV_ALG_PARM_2, ref parm2Register); // Extract the dynamic-Q with Q-adjustment threshold singulation algorithm // parameters //m_dynQ.length = sizeof(DynamicQParms); m_dynQ.startQValue = parm0Register & 0x0f; m_dynQ.minQValue = (parm0Register >> 8) & 0x0f; m_dynQ.maxQValue = (parm0Register >> 4) & 0x0f; m_dynQ.thresholdMultiplier = (parm0Register >> 12) & 0x3f; m_dynQ.retryCount = parm1Register; m_dynQ.toggleTarget = (parm2Register & 0x01) != 0 ? (uint)1 : (uint)0; } break; default: return(Result.INVALID_PARAMETER); } return(Result.OK); }
// For retrieving params for a specific algorithm bypassing // the normal lib function(s) - none exist for performing // this action... on success updates gui with new info... public void retrieveData(SingulationAlgorithm algorithm) { Result result = this.parmsMaster.loadForAlgorithm ( LakeChabotReader.MANAGED_ACCESS, this.reader.ReaderHandle, algorithm ); if (Result.OK == result) { setSource(this.parmsMaster); displayData( ); } else { // ERR MessageBox.Show ( "Reader Error.\n\nThe Reader was unable to load the current algorithm settings.\n\nThe follow error occurred: " + result.ToString( ), "Configure Algorithm Error", MessageBoxButtons.OK, MessageBoxIcon.Error ); } }
/// <summary> /// Get Current Singulation Algorithm /// </summary> /// <param name="SingulationAlgorithm"></param> /// <returns></returns> public Result GetCurrentSingulationAlgorithm(ref SingulationAlgorithm SingulationAlgorithm) { UInt32 value = 0; MacReadRegister(MACREGISTER.HST_INV_CFG, ref value); value &= 0x3fU; SingulationAlgorithm = (SingulationAlgorithm)value; return(Result.OK); }
/*public DynamicQThresholdParms DynamicQThreshold * { * get { return dynQThreshold; } * set { dynQThreshold = value; } * }*/ public Singulation_DynamicQ(SingulationAlgorithmParms parms, SingulationAlgorithm alg) { switch (current = alg) { case SingulationAlgorithm.DYNAMICQ: if (parms.GetType() == typeof(DynamicQParms)) { dynQ = parms as DynamicQParms; } else { dynQ.startQValue = 7; dynQ.minQValue = 0; dynQ.maxQValue = 15; dynQ.thresholdMultiplier = 0; dynQ.retryCount = 0; dynQ.toggleTarget = 1; } break; /*case SingulationAlgorithm.DYNAMICQ_ADJUST: * if (parms.GetType() == typeof(DynamicQAdjustParms)) * { * dynQAdjust = parms as DynamicQAdjustParms; * } * else * { * dynQAdjust.startQValue = 7; * dynQAdjust.minQValue = 0; * dynQAdjust.maxQValue = 15; * dynQAdjust.maxQueryRepCount = 0; * dynQAdjust.retryCount = 0; * dynQAdjust.toggleTarget = 1; * } * break; * case SingulationAlgorithm.DYNAMICQ_THRESH: * if (parms.GetType() == typeof(DynamicQThresholdParms)) * { * dynQThreshold = parms as DynamicQThresholdParms; * } * else * { * dynQThreshold.startQValue = 7; * dynQThreshold.minQValue = 0; * dynQThreshold.maxQValue = 15; * dynQThreshold.thresholdMultiplier = 0; * dynQThreshold.retryCount = 0; * dynQThreshold.toggleTarget = 1; * } * break;*/ } InitializeComponent(); Refresh(); }
public Singulation_DynamicQ(SingulationAlgorithmParms parms, SingulationAlgorithm alg) { switch (current = alg) { case SingulationAlgorithm.DYNAMICQ: if (parms.GetType() == typeof(DynamicQParms)) { dynQ = parms as DynamicQParms; } else { dynQ.startQValue = 7; dynQ.minQValue = 0; dynQ.maxQValue = 15; dynQ.maxQueryRepCount = 0; dynQ.retryCount = 0; dynQ.toggleTarget = 1; } break; case SingulationAlgorithm.DYNAMICQ_ADJUST: if (parms.GetType() == typeof(DynamicQAdjustParms)) { dynQAdjust = parms as DynamicQAdjustParms; } else { dynQAdjust.startQValue = 7; dynQAdjust.minQValue = 0; dynQAdjust.maxQValue = 15; dynQAdjust.maxQueryRepCount = 0; dynQAdjust.retryCount = 0; dynQAdjust.toggleTarget = 1; } break; case SingulationAlgorithm.DYNAMICQ_THRESH: if (parms.GetType() == typeof(DynamicQThresholdParms)) { dynQThreshold = parms as DynamicQThresholdParms; } else { dynQThreshold.startQValue = 7; dynQThreshold.minQValue = 0; dynQThreshold.maxQValue = 15; dynQThreshold.thresholdMultiplier = 0; dynQThreshold.retryCount = 0; dynQThreshold.toggleTarget = 1; } break; } InitializeComponent(); Refresh(); }
/// <summary> /// SetSingulationAlgorithmParms /// </summary> /// <param name="alg"></param> /// <param name="parms"></param> /// <returns></returns> public Result SetSingulationAlgorithmParms(SingulationAlgorithm alg, SingulationAlgorithmParms parms) { const uint RFID_18K6C_SINGULATION_ALGORITHM_FIXEDQ = 0; const uint RFID_18K6C_SINGULATION_ALGORITHM_DYNAMICQ = 3; if (alg == SingulationAlgorithm.UNKNOWN) { return(Result.INVALID_PARAMETER); } try { switch (alg) { case SingulationAlgorithm.FIXEDQ: { FixedQParms p = (FixedQParms)parms; // Write the inventory algorithm parameter registers MacWriteRegister(MACREGISTER.HST_INV_SEL, RFID_18K6C_SINGULATION_ALGORITHM_FIXEDQ); MacWriteRegister(MACREGISTER.HST_INV_ALG_PARM_0, p.qValue); MacWriteRegister(MACREGISTER.HST_INV_ALG_PARM_1, p.retryCount); MacWriteRegister(MACREGISTER.HST_INV_ALG_PARM_2, (uint)(p.toggleTarget != 0 ? 1 : 0) | (uint)(p.repeatUntilNoTags != 0 ? 2 : 0)); MacWriteRegister(MACREGISTER.HST_INV_ALG_PARM_3, 0); } break; case SingulationAlgorithm.DYNAMICQ: { DynamicQParms p = (DynamicQParms)parms; // Write the inventory algorithm parameter registers. For register // zero, remember to preserve values that we aren't exposing MacWriteRegister(MACREGISTER.HST_INV_SEL, RFID_18K6C_SINGULATION_ALGORITHM_DYNAMICQ); MacWriteRegister(MACREGISTER.HST_INV_ALG_PARM_0, p.startQValue | (p.maxQValue << 4) | (p.minQValue << 8) | (p.thresholdMultiplier << 12)); MacWriteRegister(MACREGISTER.HST_INV_ALG_PARM_1, p.retryCount); MacWriteRegister(MACREGISTER.HST_INV_ALG_PARM_2, (uint)(p.toggleTarget != 0 ? 1 : 0)); MacWriteRegister(MACREGISTER.HST_INV_ALG_PARM_3, 0); } break; default: return(Result.INVALID_PARAMETER); } // switch (algorithm) } catch (Exception ex) { } return(m_Result = SetCurrentSingulationAlgorithm(alg)); }
private static bool LoadDefaultSettings() { uint power = 0, linkProfile = 0; SingulationAlgorithm sing = SingulationAlgorithm.UNKNOWN; appSetting.SerialNum = SerialNumber; if (ReaderXP.GetPowerLevel(ref power) != Result.OK) { MessageBox.Show(String.Format("SetPowerLevel rc = {0}", ReaderXP.LastResultCode)); Application.Exit(); return(false); } appSetting.Power = power; if (ReaderXP.GetCurrentLinkProfile(ref linkProfile) != Result.OK) { MessageBox.Show(String.Format("SetCurrentLinkProfile rc = {0}", ReaderXP.LastResultCode)); Application.Exit(); return(false); } appSetting.Link_profile = linkProfile; if (appSetting.FixedChannel = ReaderXP.IsFixedChannel) { appSetting.Region = ReaderXP.SelectedRegionCode; appSetting.Channel_number = ReaderXP.SelectedChannel; appSetting.Lbt = ReaderXP.LBT_ON == LBT.ON; } else { appSetting.Region = ReaderXP.SelectedRegionCode; } if (ReaderXP.GetCurrentSingulationAlgorithm(ref sing) != Result.OK) { MessageBox.Show(String.Format("GetCurrentSingulationAlgorithm rc = {0}", ReaderXP.LastResultCode)); Application.Exit(); return(false); } appSetting.Singulation = sing; if (ReaderXP.GetSingulationAlgorithmParms(appSetting.Singulation, appSetting.SingulationAlg) != Result.OK) { MessageBox.Show(String.Format("GetCurrentSingulationAlgorithm rc = {0}", ReaderXP.LastResultCode)); Application.Exit(); return(false); } appSetting.AntennaList = AntennaList.DEFAULT_ANTENNA_LIST; return(true); }
public Singulation_DynamicQ(SingulationAlgorithmParms parms, SingulationAlgorithm alg) { InitializeComponent(); switch (current = alg) { case SingulationAlgorithm.DYNAMICQ: DynamicQ = parms as DynamicQParms; break; case SingulationAlgorithm.DYNAMICQ_ADJUST: DynamicQAdjust = parms as DynamicQAdjustParms; break; case SingulationAlgorithm.DYNAMICQ_THRESH: DynamicQThreshold = parms as DynamicQThresholdParms; break; } }
/// <summary> /// Allows the application to set the currently-active singulation /// algorithm (i.e., the one that is used when performing a tag- /// protocol operation (e.g., inventory, tag read, etc.)). The /// currently-active singulation algorithm may not be changed while a /// radio module is executing a tag-protocol operation. /// </summary> /// <param name="SingulationAlgorithm"> /// The singulation algorithm that is to be used for /// subsequent tag-access operations. If this /// parameter does not represent a valid /// singulation algorithm, /// RFID_ERROR_INVALID_PARAMETER is returned. </param> public Result SetCurrentSingulationAlgorithm(SingulationAlgorithm SingulationAlgorithm) { UInt32 value = 0; if (SingulationAlgorithm == SingulationAlgorithm.UNKNOWN) { return(Result.INVALID_PARAMETER); } MacReadRegister(MACREGISTER.HST_INV_CFG, ref value); value &= ~0x3fU; value |= (UInt32)SingulationAlgorithm; MacWriteRegister(MACREGISTER.HST_INV_CFG, value); return(Result.OK); }
/// <summary> /// Constructor /// </summary> /// <param name="port"></param> /// <param name="state"></param> /// <param name="powerLevel"></param> /// <param name="dwellTime"></param> /// <param name="numberInventoryCycles"></param> /// <param name="antennaSenseThreshold"></param> public Antenna ( UInt32 port, AntennaPortState state, UInt32 powerLevel, UInt32 dwellTime, UInt32 numberInventoryCycles, Boolean easAlarm, Boolean enableLocalInv, SingulationAlgorithm invAlgo, UInt32 startQ, Boolean enableLocalProfile, UInt32 linkProfile, Boolean enableLocalFreq, UInt32 freqChannel, UInt32 antennaSenseThreshold ) : base() { this.port = port; this.antennaStatus = new AntennaPortStatus(); this.antennaConfig = new AntennaPortConfig(); this.State = state; this.EnableLocalFreq = enableLocalFreq; this.EASAlarm = easAlarm; this.EnableLocalInv = enableLocalInv; this.EnableLocalProfile = enableLocalProfile; this.InventoryAlgorithm = invAlgo; this.StartQ = startQ; this.LinkProfile = linkProfile; this.FreqChannel = freqChannel; this.PowerLevel = powerLevel; this.DwellTime = dwellTime; this.NumberInventoryCycles = numberInventoryCycles; this.AntennaSenseThreshold = antennaSenseThreshold; }
public appSettings() { //inital here m_tagGroup.selected = Selected.ALL; m_tagGroup.session = Session.S0; m_tagGroup.target = SessionTarget.A; m_dynQ.thresholdMultiplier = 0; m_dynQ.maxQValue = 15; m_dynQ.minQValue = 0; m_dynQ.retryCount = 0; m_dynQ.startQValue = 7; m_dynQ.toggleTarget = 1; m_fixedQ.qValue = 7; m_fixedQ.repeatUntilNoTags = 0; m_fixedQ.retryCount = 0; m_fixedQ.toggleTarget = 1; m_singulation = SingulationAlgorithm.DYNAMICQ; m_power = Program.ReaderCE.GetActiveMaxPowerLevel (); }
public appSettings() { //inital here m_tagGroup.selected = Selected.ALL; m_tagGroup.session = Session.S0; m_tagGroup.target = SessionTarget.A; m_dynQ.maxQueryRepCount = 0; m_dynQ.maxQValue = 15; m_dynQ.minQValue = 0; m_dynQ.retryCount = 0; m_dynQ.startQValue = 7; m_dynQ.toggleTarget = 1; m_dynQA.maxQueryRepCount = 0; m_dynQA.maxQValue = 15; m_dynQA.minQValue = 0; m_dynQA.retryCount = 0; m_dynQA.startQValue = 7; m_dynQA.toggleTarget = 1; m_dynQT.thresholdMultiplier = 0; m_dynQT.maxQValue = 15; m_dynQT.minQValue = 0; m_dynQT.retryCount = 0; m_dynQT.startQValue = 7; m_dynQT.toggleTarget = 1; m_fixedQ.qValue = 7; m_fixedQ.repeatUntilNoTags = 0; m_fixedQ.retryCount = 0; m_fixedQ.toggleTarget = 1; m_singulation = SingulationAlgorithm.DYNAMICQ; }
public static extern Result RFID_18K6CGetSingulationAlgorithmParameters ( [In] Int32 handle, [In] SingulationAlgorithm algorithm, [In, Out] IntPtr pParms );
public static extern Result RFID_18K6CGetCurrentSingulationAlgorithm ( [In] Int32 handle, [In, Out] ref SingulationAlgorithm algorithm );
// For retrieving params for a specific algorithm bypassing // the normal lib function(s) - none exist for performing // this action... on success updates gui with new info... public void retrieveData( SingulationAlgorithm algorithm ) { Result result = this.parmsMaster.loadForAlgorithm ( LakeChabotReader.MANAGED_ACCESS, this.reader.ReaderHandle, algorithm ); if ( Result.OK == result ) { setSource( this.parmsMaster ); displayData( ); } else { // ERR MessageBox.Show ( "Reader Error.\n\nThe Reader was unable to load the current algorithm settings.\n\nThe follow error occurred: " + result.ToString( ), "Configure Algorithm Error", MessageBoxButtons.OK, MessageBoxIcon.Error ); } }
// This load for basic grab current fields on board public rfid.Constants.Result load ( rfid.Linkage transport, UInt32 readerHandle ) { Result result; result = transport.API_l8K6CGetQueryTagGroup(ref this.nativeTagGroup); if (Result.OK != result) { return(result); } SingulationAlgorithm algorithm = SingulationAlgorithm.UNKNOWN; result = transport.API_l8K6CGetCurrentSingulationAlgorithm(ref algorithm); if (Result.OK != result) { return(result); } switch (algorithm) { case SingulationAlgorithm.FIXEDQ: { this.nativeSingulationParms = new FixedQParms(); } break; case SingulationAlgorithm.DYNAMICQ: { this.nativeSingulationParms = new DynamicQParms(); } break; //case SingulationAlgorithm.DYNAMICQ_ADJUST: // { // } // break; //case SingulationAlgorithm.DYNAMICQ_THRESHOLD: // { // } // break; default: { return(Result.DRIVER_MISMATCH); } } result = transport.API_l8K6CGetSingulationAlgorithmParameters ( algorithm, ref this.nativeSingulationParms ); if (Result.OK == result) { Type algoType = this.nativeSingulationParms.GetType(); if (algoType == typeof(rfid.Structures.FixedQParms)) { this.sourceParameters = new Source_SingulationParametersFixedQ ( (rfid.Structures.FixedQParms) this.nativeSingulationParms ); } else if (algoType == typeof(rfid.Structures.DynamicQParms)) { this.sourceParameters = new Source_SingulationParametersDynamicQ ( (rfid.Structures.DynamicQParms) this.nativeSingulationParms ); } else { System.Windows.Forms.MessageBox.Show("ERR : Algorithm.Copy( Source_QueryParms from )"); Console.WriteLine("ERR : Algorithm.Copy( Source_QueryParms from )"); } } return(result); }