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);
}
