// A Copy( ), load( ), loadForAlgorithm( ) operation MUST BE
// performed after construction but prior to first use !!!
public Source_QueryParms( )
:
base( )
{
this.nativeTagGroup = new TagGroup();
this.nativeSingulationParms = new SingulationAlgorithmParms();
}
/// <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);
}
/*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));
}
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;
}
}
public Singulation_FixedQ(SingulationAlgorithmParms fixedQ)
{
InitializeComponent();
if (fixedQ.GetType() == typeof(FixedQParms))
{
FixedQ = (FixedQParms)fixedQ;
}
else
{
FixedQ.qValue = 7;
FixedQ.retryCount = 0;
FixedQ.toggleTarget = 1;
FixedQ.repeatUntilNoTags = 0;
}
Refresh();
}
public Singulation_FixedQ(SingulationAlgorithmParms fixedQ)
{
InitializeComponent();
if (fixedQ.GetType() == typeof(FixedQParms))
{
FixedQ = (FixedQParms)fixedQ;
}
else
{
FixedQ.qValue = 7;
FixedQ.retryCount = 0;
FixedQ.toggleTarget = 1;
FixedQ.repeatUntilNoTags = 0;
}
Refresh();
}
public virtual bool ConnectReader()
{
bool re = true;
try
{
if (rfid.ConnectRadio(mComPort, 115200) == operateResult.ok)
{
// 这里演示初始化参数
// 配置天线功率
AntennaPortConfiguration portConfig = new AntennaPortConfiguration();
portConfig.powerLevel = mPower * 10; // 23dbm
portConfig.numberInventoryCycles = 8192;
portConfig.dwellTime = 2000;
rfid.SetAntennaPortConfiguration(mComPort, 0, portConfig);
rfid.SetCurrentLinkProfile(mComPort, 1);
// 配置单化算法
SingulationAlgorithmParms singParm = new SingulationAlgorithmParms();
singParm.singulationAlgorithmType = SingulationAlgorithm.Dynamicq;
singParm.startQValue = 4;
singParm.minQValue = 0;
singParm.maxQValue = 15;
singParm.thresholdMultiplier = 4;
singParm.toggleTarget = 1;
rfid.SetCurrentSingulationAlgorithm(mComPort, singParm);
rfid.SetTagGroupSession(mComPort, Session.S0);
}
else
{
re = false;
}
}
catch (Exception)
{
re = false;
}
return(re);
}
public void Copy(Source_QueryParms from)
{
// Val parm
this.TagGroupSelected = from.TagGroupSelected;
this.TagGroupSession = from.TagGroupSession;
this.TagGroupTarget = from.TagGroupTarget;
if (from.SingulationAlgorithm == SingulationAlgorithm.FIXEDQ)
{
this.nativeSingulationParms = new rfid.Structures.FixedQParms( );
this.sourceParameters = new Source_SingulationParametersFixedQ
(
(rfid.Structures.FixedQParms) this.nativeSingulationParms
);
(( Source_SingulationParametersFixedQ )this.sourceParameters).Copy
(
( Source_SingulationParametersFixedQ )from.SingulationAlgorithmParameters
);
}
else if (from.SingulationAlgorithm == SingulationAlgorithm.DYNAMICQ)
{
this.nativeSingulationParms = new rfid.Structures.DynamicQParms( );
this.sourceParameters = new Source_SingulationParametersDynamicQ
(
(rfid.Structures.DynamicQParms) this.nativeSingulationParms
);
(( Source_SingulationParametersDynamicQ )this.sourceParameters).Copy
(
( Source_SingulationParametersDynamicQ )from.SingulationAlgorithmParameters
);
}
else
{
Console.WriteLine("ERR : Algorithm.Copy( Source_QueryParms from )");
}
}
public bool connect()
{
#if DEBUG
return(false);
#endif
bool re = false;
if (mReaderType == READER_TYPE.READER_IMP)
{
try
{
mReaderIMP = new ImpinjReader();
mReaderIMP.TagsReported += this.tagsReportedIMP;
mReaderIMP.Connect(mIp);
mReaderIMP.ApplyDefaultSettings();
configIMP(mPower);
re = true;
}
catch (Exception)
{
re = false;
}
}
if (mReaderType == READER_TYPE.READER_TM)
{
try
{
Reader.SetSerialTransport("tcp", SerialTransportTCP.CreateSerialReader);
mReaderTM = Reader.Create(string.Format("tcp://{0}", mIp));
mReaderTM.TagRead += tagsReportedTM;
mReaderTM.Connect();
configTM(mPower);
re = true;
}
catch (Exception)
{
re = false;
}
}
if (mReaderType == READER_TYPE.READER_DLX_PM)
{
try
{
mReaderDLXPM = new RfidUARTLinkExtend();
mReaderDLXPM.RadioInventory += tagsReportedDLXPM;
if (mReaderDLXPM.ConnectRadio(mComPort, 115200) == operateResult.ok)
{
AntennaPortConfiguration portConfig = new AntennaPortConfiguration();
portConfig.powerLevel = (uint)mPower;
portConfig.numberInventoryCycles = 8192;
portConfig.dwellTime = 2000;
mReaderDLXPM.SetAntennaPortConfiguration(mComPort, 0, portConfig);
mReaderDLXPM.SetCurrentLinkProfile(mComPort, 1);
SingulationAlgorithmParms singParm = new SingulationAlgorithmParms();
singParm.singulationAlgorithmType = SingulationAlgorithm.Dynamicq;
singParm.startQValue = 4;
singParm.minQValue = 0;
singParm.maxQValue = 15;
singParm.thresholdMultiplier = 4;
singParm.toggleTarget = 1;
mReaderDLXPM.SetCurrentSingulationAlgorithm(mComPort, singParm);
mReaderDLXPM.SetTagGroupSession(mComPort, Session.S0);
re = true;
}
}
catch (Exception)
{
re = false;
}
}
if (mReaderType == READER_TYPE.READER_DLX_PM)
{
try
{
mReaderXDPM = new RfidReader();
mReaderXDPM.OnTagsReported += tagsReportedXDPM;
re = mReaderXDPM.OpenReader(mIp, 2048, SynchronizationContext.Current, "M6E").Success;
configXDPM(mPower);
}
catch (Exception)
{
re = false;
}
}
return(re);
}
// A Copy( ), load( ), loadForAlgorithm( ) operation MUST BE
// performed after construction but prior to first use !!!
public Source_QueryParms( )
: base()
{
this.nativeTagGroup = new TagGroup();
this.nativeSingulationParms = new SingulationAlgorithmParms();
}
// 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;
}
public void Copy( Source_QueryParms from )
{
// Val parm
this.TagGroupSelected = from.TagGroupSelected;
this.TagGroupSession = from.TagGroupSession;
this.TagGroupTarget = from.TagGroupTarget;
if (from.SingulationAlgorithm == SingulationAlgorithm.FIXEDQ)
{
this.nativeSingulationParms = new rfid.Structures.FixedQParms( );
this.sourceParameters = new Source_SingulationParametersFixedQ
(
( rfid.Structures.FixedQParms ) this.nativeSingulationParms
);
( ( Source_SingulationParametersFixedQ ) this.sourceParameters ).Copy
(
( Source_SingulationParametersFixedQ ) from.SingulationAlgorithmParameters
);
}
else if (from.SingulationAlgorithm == SingulationAlgorithm.DYNAMICQ)
{
this.nativeSingulationParms = new rfid.Structures.DynamicQParms( );
this.sourceParameters = new Source_SingulationParametersDynamicQ
(
( rfid.Structures.DynamicQParms ) this.nativeSingulationParms
);
( ( Source_SingulationParametersDynamicQ ) this.sourceParameters ).Copy
(
( Source_SingulationParametersDynamicQ ) from.SingulationAlgorithmParameters
);
}
else
{
Console.WriteLine( "ERR : Algorithm.Copy( Source_QueryParms from )" );
}
}
// 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);
}
