// Attempt to get the state of all GPIO pins and place
// results into the list
public rfid.Constants.Result load
(
rfid.Linkage transport,
UInt32 readerHandle
)
{
this.Clear( );
// We do each pin ( though could be done by group ) just so we
// can tell if individual pin op fails ~ slower but safer...
foreach
(
rfid.Constants.GpioPin nativePin in
Enum.GetValues(typeof(rfid.Constants.GpioPin))
)
{
Source_GPIO gpio = new Source_GPIO(nativePin, Source_GPIO.OpAccess.GET);
// Errs set in individual gpio objs if they occur
gpio.load(transport, readerHandle);
this.Add(gpio);
}
// For now always consider success... user can look thru list
// to check what pin failures may have occurred...
return(rfid.Constants.Result.OK);
}
//public rfid.Constants.Result load
//(
// rfid.Linkage transport,
// UInt32 readerHandle
//)
//{
// UInt32[ ] buffer = new UInt32[ OEMCFG_AREA_MAP_SIZE_WORDS ];
// uint length = (uint)buffer.Length;
// rfid.Constants.Result Result = transport.MacReadOemData
// (
// ( int ) readerHandle,
// 0,
// ref length,
// buffer
// );
// if ( rfid.Constants.Result.OK == Result )
// {
// buffer.CopyTo( oemDataBuffer, 0 );
// }
// return Result;
//}
//clark 2011.3.23
public rfid.Constants.Result store
(
rfid.Linkage transport,
UInt32 readerHandle
)
{
UInt32[] tmpBuf = new UInt32[OEMCFG_AREA_MAP_SIZE_WORDS];
rfid.Constants.Result Result = rfid.Constants.Result.OK;
Array.Clear(tmpBuf, 0, tmpBuf.Length);
//MacReadOemData only store one ome at one time. Store all ome to buf.
for (ushort index = 0; index < OEMCFG_AREA_MAP_SIZE_WORDS; index++)
{
Result = transport.API_MacWriteOemData(index,
oemDataBuffer[index]);
if (rfid.Constants.Result.OK != Result)
{
return(Result);
}
}
return(Result);
}
// Attempt to load info for all known antennas
public rfid.Constants.Result load
(
rfid.Linkage transport,
UInt32 readerHandle
)
{
this.Clear( );
for (UInt32 band = 0; band < RFID.RFIDInterface.Properties.Settings.Default.MaxFrequencyBands; band++)
{
Source_FrequencyBand freqBand = new Source_FrequencyBand(band);
rfid.Constants.Result Result = freqBand.load(transport, readerHandle);
if (rfid.Constants.Result.OK == Result)
{
this.Add(freqBand);
}
else if (rfid.Constants.Result.INVALID_PARAMETER == Result)
{
break; // in case max bands gets lowered in future e.g. european version
}
else
{
return(Result); // this rcv all other errors
}
}
return(rfid.Constants.Result.OK);
}
public rfid.Constants.Result load
(
rfid.Linkage transport,
UInt32 readerHandle
)
{
rfid.Constants.Result Result = transport.API_AntennaPortGetConfiguration
(
port,
ref this.antennaPortConfig
);
if (Result != rfid.Constants.Result.OK)
{
Console.WriteLine("Error while retrieving global antenna sense threshold");
return(Result);
}
Result = transport.API_AntennaPortGetSenseThreshold
(
ref this.antennaPortConfig.antennaSenseThreshold
);
return(Result);
}
// Attempt to load info for all known antennas
public rfid.Constants.Result load
(
rfid.Linkage transport,
UInt32 readerHandle
)
{
this.Clear( );
for (byte port = 0; port < RFID.RFIDInterface.Properties.Settings.Default.MaxVirtualAntennas; port++)
{
Source_Antenna antenna = new Source_Antenna( port );
rfid.Constants.Result Result = antenna.load( transport, readerHandle );
if ( rfid.Constants.Result.OK == Result )
{
this.Add( antenna );
}
else if ( rfid.Constants.Result.INVALID_PARAMETER == Result )
{
break; // this rcv when portIndex > logical antenna count on radio
}
else
{
Console.WriteLine( "Error while reading antenna information" );
return Result; // this rcv all other errors
}
}
return rfid.Constants.Result.OK;
}
public rfid.Constants.Result store
(
rfid.Linkage transport,
UInt32 readerHandle
)
{
rfid.Constants.Result Result = transport.API_AntennaPortSetSenseThreshold
(
this.antennaPortConfig.antennaSenseThreshold
);
if (rfid.Constants.Result.OK != Result)
{
Console.WriteLine("Error while storing global antenna sense threshold");
}
Result = transport.API_AntennaPortSetConfiguration
(
port,
this.antennaPortConfig
);
if (rfid.Constants.Result.OK != Result)
{
//Console.WriteLine( "Error while storing AntennaPortConfig" ); //clark 2011.2.16 Copied from R1000 Tracer
Console.WriteLine("Error while storing AntennaPortConfig port:" + port);
}
return(Result);
}
public rfid.Constants.Result load
(
rfid.Linkage transport,
UInt32 readerHandle
)
{
return(transport.API_MacGetRegion(ref this.macRegion, ref this.macRegionSupport));
}
public rfid.Constants.Result store
(
rfid.Linkage transport,
UInt32 readerHandle
)
{
return(transport.API_MacSetRegion(this.macRegion));
}
public rfid.Constants.Result store
(
rfid.Linkage transport,
UInt32 readerHandle
)
{
rfid.Constants.Result Result = transport.API_ConfigSetOperationMode(this.radioOperationMode);
return(Result);
}
public rfid.Constants.Result load
(
rfid.Linkage transport,
UInt32 readerHandle
)
{
rfid.Constants.Result Result = transport.API_AntennaPortGetState(this.port,
ref this.antennaPortStatus);
return(Result);
}
// Primary constructor, provide a transport & handle and load
// the list from current link profile information
public Source_LinkProfileList(rfid.Linkage transport, UInt32 readerHandle)
:
base( )
{
this.transport = transport;
this.readerHandle = readerHandle;
// Ignore error at this time ~ rely on console debug msg
this.load( );
}
public rfid.Constants.Result store
(
rfid.Linkage transport,
UInt32 readerHandle
)
{
// TODO : validate that when doin store the given pin has
// access flag in SET mode (?)
// Configure pin to set mode
rfid.Constants.Result result = rfid.Constants.Result.OK;
result = transport.API_GpioSetPinsConfiguration((byte)this.nativePin,
(byte)this.nativePin);
if (rfid.Constants.Result.OK != result)
{
this.status = OpResult.FAILURE;
return(result);
}
//2011.12.30 check state
if (this.state != OpState.HI && this.state != OpState.LO)
{
this.status = OpResult.FAILURE;
return(rfid.Constants.Result.INVALID_ANTENNA);
}
//Set state
result = transport.API_GpioWritePins
((byte)this.nativePin,
(byte)(OpState.LO == this.state ? 0 : this.nativePin));
if (rfid.Constants.Result.OK != result)
{
this.status = OpResult.FAILURE;
}
else
{
this.status = OpResult.SUCCESS;
}
return(result);
}
// Provided just to allow easy copying of existing
// link profile list source(s)
public Source_LinkProfileList(IEnumerable <Source_LinkProfile> enumerable)
:
base(enumerable)
{
this.transport = null;
this.readerHandle = 0; // 0 == invalid radio handle
for (activeProfileIndex = 0; activeProfileIndex < this.Count; ++activeProfileIndex)
{
if (this[activeProfileIndex].Enabled)
{
break;
}
}
}
public rfid.Constants.Result store
(
rfid.Linkage transport,
UInt32 readerHandle
)
{
// Err msgs emitted thru antennaResult & antennaConfig store( )
rfid.Constants.Result Result = this.antennaResult.store(transport, readerHandle);
if (rfid.Constants.Result.OK != Result)
{
return(Result);
}
return(this.antennaConfig.store(transport, readerHandle));
}
// Attempt to save all link profiles currently on the radio
// and mark the active one.
public rfid.Constants.Result store
(
rfid.Linkage transport,
UInt32 readerHandle
)
{
foreach( Source_Antenna antenna in this )
{
rfid.Constants.Result Result = antenna.store( transport, readerHandle );
if ( rfid.Constants.Result.OK != Result )
{
return Result;
}
}
return rfid.Constants.Result.OK;
}
// Attempt to save all link profiles currently on the radio
// and mark the active one.
public rfid.Constants.Result store
(
rfid.Linkage transport,
UInt32 readerHandle
)
{
foreach (Source_FrequencyBand freqBand in this)
{
rfid.Constants.Result Result = freqBand.store(transport, readerHandle);
if (rfid.Constants.Result.OK != Result)
{
return(Result);
}
}
return(rfid.Constants.Result.OK);
}
// Turn all known gpio pins into set mode and attempt to set them
// to their given ( according to property ) state
public rfid.Constants.Result store
(
rfid.Linkage transport,
UInt32 readerHandle
)
{
foreach (Source_GPIO gpio in this)
{
gpio.Access = Source_GPIO.OpAccess.SET;
gpio.store(transport, readerHandle);
}
// For now always consider success... user can look thru list
// to check what pin failures may have occurred...
return(rfid.Constants.Result.OK);
}
public rfid.Constants.Result store
(
rfid.Linkage transport,
UInt32 readerHandle
)
{
Result result;
result = transport.API_l8K6CSetQueryTagGroup(this.nativeTagGroup);
if (Result.OK != result)
{
return(result);
}
SingulationAlgorithm algorithm;
Type algoType = this.nativeSingulationParms.GetType();
if (algoType == typeof(FixedQParms))
{
algorithm = SingulationAlgorithm.FIXEDQ;
}
else if (algoType == typeof(DynamicQParms))
{
algorithm = SingulationAlgorithm.DYNAMICQ;
}
else
{
return(Result.INVALID_PARAMETER);
}
result = transport.API_l8K6CSetCurrentSingulationAlgorithm(algorithm);
if (Result.OK != result)
{
return(result);
}
result = transport.API_l8K6CSetSingulationAlgorithmParameters(algorithm,
this.nativeSingulationParms);
return(result);
}
public rfid.Constants.Result store
(
rfid.Linkage transport,
UInt32 readerHandle
)
{
// There is no save for the antennaPortStatus in lower library but
// there is a set state so use that here!
rfid.Constants.Result Result = transport.API_AntennaPortSetState(this.port,
this.antennaPortStatus.state);
if (rfid.Constants.Result.OK != Result)
{
Console.WriteLine("Error while saving antennaPortStatus.state");
}
return(Result);
}
public rfid.Constants.Result store
(
rfid.Linkage transport,
UInt32 readerHandle
)
{
UInt32 config = ( UInt32 )state;
UInt32 multdiv = ( UInt32 )(this.divider << 16) | ( UInt32 )this.multiplier;
UInt32 pllcc = ( UInt32 )(this.guardBand << 24) |
( UInt32 )(this.maxDACBand << 16) |
( UInt32 )(this.affinityBand << 8) |
( UInt32 )(this.minDACBand);
rfid.Constants.Result result = transport.API_ConfigWriteRegister
(
SELECTOR_ADDRESS,
this.band
);
if (rfid.Constants.Result.OK != result)
{
return(result);
}
result = transport.API_ConfigWriteRegister
(
CONFIG_ADDRESS,
config
);
if (rfid.Constants.Result.OK != result)
{
return(result);
}
result = transport.API_ConfigReadRegister
(
CONFIG_ADDRESS,
ref config
);
if (rfid.Constants.Result.OK != result)
{
return(result);
}
if (BandState.ENABLED == ( BandState )config)
{
result = transport.API_ConfigWriteRegister
(
MULTDIV_ADDRESS,
multdiv
);
if (rfid.Constants.Result.OK != result)
{
return(result);
}
result = transport.API_ConfigReadRegister
(
MULTDIV_ADDRESS,
ref multdiv
);
if (rfid.Constants.Result.OK != result)
{
return(result);
}
result = transport.API_ConfigWriteRegister
(
PLLCC_ADDRESS,
pllcc
);
if (rfid.Constants.Result.OK != result)
{
return(result);
}
result = transport.API_ConfigReadRegister
(
PLLCC_ADDRESS,
ref pllcc
);
if (rfid.Constants.Result.OK != result)
{
return(result);
}
}
this.multiplier = ( UInt16 )((multdiv >> 0) & 0xffff);
this.divider = ( UInt16 )((multdiv >> 16) & 0xff);
this.minDACBand = ( UInt16 )((pllcc >> 0) & 0xff);
this.affinityBand = ( UInt16 )((pllcc >> 8) & 0xff);
this.maxDACBand = ( UInt16 )((pllcc >> 16) & 0xff);
this.guardBand = ( UInt16 )((pllcc >> 24) & 0xff);
return(rfid.Constants.Result.OK);
}
// TODO : Move to locator & communicator class
static LakeChabotReader( )
{
try
{
LakeChabotReader.MANAGED_ACCESS = new rfid.Linkage( );
}
catch ( Exception e )
{
throw e; // TODO: more resolution of error e.g. missing dll
}
if (rfid.Constants.Result.OK != LakeChabotReader.MANAGED_ACCESS.API_Startup(LakeChabotReader.LIBRARY_VERSION, LakeChabotReader.LIBRARY_MODE))
{
throw new rfidException( rfidErrorCode.LibraryFailedToInitialize );
}
LakeChabotReader.LIBRARY_Result = rfid.Constants.Result.OK;
// Track keyed by cookie ~ allow ( later ) to open and close radios
// dynamically during application execution - currently ALL OPEN
rfid.Structures.RadioEnumeration radioEnum = new rfid.Structures.RadioEnumeration( );
//clark 2011.05.20 Show Tracer no matter the device is disconneced.
// Let user to set comport.
LakeChabotReader.MANAGED_ACCESS.API_RetrieveAttachedRadiosList(radioEnum, 0);
//if
//(
// rfid.Constants.Result.OK !=
// LakeChabotReader.MANAGED_ACCESS.API_RetrieveAttachedRadiosList(radioEnum, 0)
//)
//{
// throw new rfidException( rfidErrorCode.LibraryFailedToInitialize );
//}
LakeChabotReader.LOCATED_READERS =
new Dictionary<UInt32, rfid.Structures.RadioInformation>( );
foreach ( rfid.Structures.RadioInformation radioInfo in radioEnum.radioInfo )
{
//clark 2011.3.23 not sure
uint uiUniqueId = BitConverter.ToUInt32( radioInfo.uniqueId, 0);
LakeChabotReader.LOCATED_READERS.Add(uiUniqueId, radioInfo);
//LakeChabotReader.LOCATED_READERS.Add(radioInfo.cookie, radioInfo);
}
LakeChabotReader.OPENED_READERS =
new Dictionary<UInt32, rfid.Structures.RadioInformation>( );
try
{
new PerformanceCounter( "Processor", "% Processor Time", "_Total", "." );
}
catch ( Exception ) { }
}
/// <summary>
/// Constructor for Inventory
/// </summary>
/// <param name="ManagedAccess"></param>
/// <param name="Handle"></param>
/// <param name="WantSinglePackets"></param>
/// <param name="runCount"></param>
public ReaderInterfaceThreadClass(rfid.Linkage ManagedAccess, int Handle, bool WantSinglePackets, RadioOperationMode r_OpMode, TagAccessFlag r_strcTagFlag)
{
if (r_OpMode == RadioOperationMode.UNKNOWN)
{
throw new ArgumentOutOfRangeException("OpMode", "OpMode must be CONTINUE or NON_CONTINUE");
}
_strcTagFlag = r_strcTagFlag;
_OpMode = r_OpMode;
_access = ManagedAccess;
_handle = Handle;
_singlePackets = WantSinglePackets;
_stopRequest = false;
}
private TagAccessReads _tagAccessReadSet;//??把计??//Add LargeRead command
/// <summary>
///
/// </summary>
/// <param name="ManagedAccess"></param>
/// <param name="Handle"></param>
/// <param name="MemoryBank"></param>
/// <param name="?"></param>
public ReaderInterfaceThreadClass(rfid.Linkage ManagedAccess, int Handle, TagAccessData tagAccessData, TagAccessReads tagAccessDataRead)//??把计??//Add LargeRead command
{
_access = ManagedAccess;
_handle = Handle;
_tagAccessData = tagAccessData;
_tagAccessReadSet = tagAccessDataRead;//把计??
}
// 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 rfid.Constants.Result load
(
rfid.Linkage transport,
UInt32 readerHandle
)
{
// TODO : validate that when doin store the given pin has
// access flag in GET mode (?)
// Configure pin to set mode
rfid.Constants.Result result = rfid.Constants.Result.OK;
rfid.Constants.Result resultErr = rfid.Constants.Result.OK;
uint uiCurError = 0;
uint uiLastError = 0;
byte getValue = 0;
//Set access to "Get"
result = transport.API_GpioSetPinsConfiguration((byte)this.nativePin,
0);
if (rfid.Constants.Result.OK != result)
{
//Get error
resultErr = transport.API_MacGetError(ref uiCurError, ref uiLastError);
//Can't get error
if (resultErr != rfid.Constants.Result.OK)
{
this.status = OpResult.FAILURE;
return(resultErr);
}
//If error = 0x2B, it means doesn't support this pin
if (uiCurError == 0x2B)
{
this.status = OpResult.UNSUPPORTED;
return(result);
}
else
{
this.status = OpResult.FAILURE;
return(result);
}
}
//Get GPIO Status
result = transport.API_GpioReadPins((byte)this.nativePin,
ref getValue);
if (rfid.Constants.Result.OK == result)
{
this.state = (( UInt32 )this.nativePin & getValue) == 0 ? OpState.LO : OpState.HI;
this.status = OpResult.SUCCESS;
}
else
{
this.state = OpState.FAILURE;
this.status = OpResult.FAILURE;
}
return(result);
}
// Grabs the values on board for the specified algorithm but leaves
// board in original state - warning - MANY POINTS OF FAILURE - you
// have been warned.
public rfid.Constants.Result loadForAlgorithm
(
rfid.Linkage transport,
UInt32 readerHandle,
rfid.Constants.SingulationAlgorithm algorithm
)
{
// Need to do lower level register manipulation for this one...
UInt32 reg_0x0901 = 0;
Result result = Result.OK;
try
{
// Set the algo on the board ~ maintaining all other fields
result = transport.API_ConfigReadRegister
(
( UInt16 )0x0901, ref reg_0x0901
);
if (rfid.Constants.Result.OK != result)
{
throw new Exception(result.ToString( ));
}
result = transport.API_ConfigWriteRegister
(
( UInt16 )0x0901, (reg_0x0901 & 0xFFFFFFC0) | ( UInt32 )algorithm
);
if (rfid.Constants.Result.OK != result)
{
throw new Exception(result.ToString( ));
}
// Set for the algo register bank on the board
result = transport.API_ConfigWriteRegister
(
( UInt16 )0x0902, ( UInt32 )algorithm
);
if (rfid.Constants.Result.OK != result)
{
throw new Exception(result.ToString( ));
}
result = this.load(transport, readerHandle);
if (rfid.Constants.Result.OK != result)
{
throw new Exception(result.ToString( ));
}
// Restore algo bank reg to original value
result = transport.API_ConfigWriteRegister
(
( UInt16 )0x0901, reg_0x0901
);
if (rfid.Constants.Result.OK != result)
{
throw new Exception(result.ToString( ));
}
}
catch (Exception)
{
// NOP - let fall thru to result check & msg display
}
// If we did ok, our source for the underlying singulation
// parameters must also now be changed here AND grabbed at
// the gui level ...
if (Result.OK == result)
{
switch (algorithm)
{
case SingulationAlgorithm.FIXEDQ:
{
sourceParameters = new Source_SingulationParametersFixedQ
(
(rfid.Structures.FixedQParms) this.nativeSingulationParms
);
}
break;
case SingulationAlgorithm.DYNAMICQ:
{
sourceParameters = new Source_SingulationParametersDynamicQ
(
(rfid.Structures.DynamicQParms) this.nativeSingulationParms
);
}
break;
default:
Console.WriteLine("ERR : Algorithm.Copy( Source_QueryParms from )");
break;
}
;
}
return(result);
}
// Attempt to get the state of all GPIO pins and place
// results into the list
public rfid.Constants.Result load
(
rfid.Linkage transport,
UInt32 readerHandle
)
{
//Mod by FJ for change caption of "Antenna Ports" and "GPIO" GUI for HP SiP, 2015-01-22
this.Clear( );
string[] Str = { "PIN_1", "PIN_2", "PIN_3", "PIN_4" };
int temp = 0;
// We do each pin ( though could be done by group ) just so we
// can tell if individual pin op fails ~ slower but safer...
//Mod by FJ for fix model name judgement bug, 2015-02-02
//rfid.Constants.Result m_result = rfid.Constants.Result.OK;
LakeChabotReader reader = new LakeChabotReader();
if (rfid.Constants.Result.OK != reader.result_major)
{
throw new Exception(reader.result_major.ToString());
//throw new Exception(result.ToString());
//End by FJ for fix model name judgement bug, 2015-02-02
}
if (reader.uiModelNameMAJOR != 0x4D303358)//0x4D303358==M03X
{
foreach
(
rfid.Constants.GpioPin nativePin in
Enum.GetValues(typeof(rfid.Constants.GpioPin))
)
{
Source_GPIO gpio = new Source_GPIO(nativePin, Source_GPIO.OpAccess.GET);
gpio.Pin = nativePin.ToString();
// Errs set in individual gpio objs if they occur
gpio.load(transport, readerHandle);
this.Add(gpio);
}
}
else
{
foreach
(
rfid.Constants.GpioPin nativePin in
Enum.GetValues(typeof(rfid.Constants.GpioPin))
)
{
Source_GPIO gpio = new Source_GPIO(nativePin, Source_GPIO.OpAccess.GET);
gpio.Pin = Str[temp];
// Errs set in individual gpio objs if they occur
gpio.load(transport, readerHandle);
this.Add(gpio);
temp++;
}
}
// For now always consider success... user can look thru list
// to check what pin failures may have occurred...
return(rfid.Constants.Result.OK);
/*
* this.Clear();
*
* // We do each pin ( though could be done by group ) just so we
* // can tell if individual pin op fails ~ slower but safer...
* foreach
* (
* rfid.Constants.GpioPin nativePin in
* Enum.GetValues(typeof(rfid.Constants.GpioPin))
* )
* {
*
* Source_GPIO gpio = new Source_GPIO(nativePin, Source_GPIO.OpAccess.GET);
* // Errs set in individual gpio objs if they occur
* gpio.load(transport, readerHandle);
*
* this.Add(gpio);
* temp++;
* }
*
* // For now always consider success... user can look thru list
* // to check what pin failures may have occurred...
*
* return rfid.Constants.Result.OK;
*/
//End by FJ for change caption of "Antenna Ports" and "GPIO" GUI for HP SiP, 2015-01-22
}
public static bool Mid_API_Serial_Open(uint ComPort)
{
//Mod by FJ for fix linking to incorrect Dll API issue, 2016-12-23
bool result = false;
//bool result = true;
rfid.Linkage lk = new rfid.Linkage();
uint[] DetectBaudRate = new uint[] { (uint)ENUM_BAUD_RATE.CBR_115200, (uint)ENUM_BAUD_RATE.CBR_230400, (uint)ENUM_BAUD_RATE.CBR_460800, (uint)ENUM_BAUD_RATE.CBR_921600 };
uint errcount = 0;
for (int i = 0; i < DetectBaudRate.Length; i++)
{
if (FTDI_API_Serial_Open(DetectBaudRate[i], ref ftHandle) == FTDI.FT_STATUS.FT_OK)
{
Use_FTDI_Dll = true;
if (lk.API_MacgGetDebug(ref errcount) != Result.OK)
{
result = false;
continue;
}
else
{
result = true;
return(result);
}
}
else
{
result = false;
}
}
if (result == false)
{
Use_FTDI_Dll = false;
rfid.DCB pDcb = new rfid.DCB();
pDcb.ByteSize = 8;
pDcb.Parity = 0;
pDcb.StopBits = (byte)ENUM_STOP_BIT.ONESTOPBIT;
pDcb.BaudRate = (uint)ENUM_BAUD_RATE.CBR_115200;
if (clsPacket.TRANS_API_Serial_Open(ComPort, ref pDcb) != TRANS_RESULT.OK)
{
result = false;
}
else
{
result = true;
}
}
////Open COM port by WDK DLL
////Try to open real COM port by baudrate 115200
//Use_FTDI_Dll = false;
//rfid.DCB pDcb = new rfid.DCB();
//pDcb.ByteSize = 8;
//pDcb.Parity = 0;
//pDcb.StopBits = (byte)ENUM_STOP_BIT.ONESTOPBIT;
//pDcb.BaudRate = (uint)ENUM_BAUD_RATE.CBR_115200;
//if (clsPacket.TRANS_API_Serial_Open(ComPort, ref pDcb) != TRANS_RESULT.OK)
//{
// result = false;
//}
////Open COM port by FTDI DLL
//if (result == false) //Try to open virtual COM port by high speed baudrate
//{
// uint[] DetectBaudRate = new uint[] { (uint)ENUM_BAUD_RATE.CBR_115200, (uint)ENUM_BAUD_RATE.CBR_230400, (uint)ENUM_BAUD_RATE.CBR_460800, (uint)ENUM_BAUD_RATE.CBR_921600 };
// uint errcount = 0;
// //Use_FTDI_Dll = true; //Del by FJ for the FWUpdate failure in USB connection, 2016-09-08
// for (int i = 0; i < DetectBaudRate.Length; i++)
// {
// if (FTDI_API_Serial_Open(DetectBaudRate[i], ref ftHandle) == FTDI.FT_STATUS.FT_OK)
// {
// if (lk.API_MacgGetDebug(ref errcount) != Result.OK)
// {
// result = false;
// continue;
// }
// else
// {
// Use_FTDI_Dll = true; //Add by FJ for the FWUpdate failure in USB connection, 2016-09-08
// result = true;
// break;
// }
// }
// else
// {
// result = false;
// }
// }
//}
//End by FJ for fix linking to incorrect Dll API issue, 2016-12-23
return(result);
}
// Load frequency info, actually does Nx calls - any
// of which may fail and cause an error return
public rfid.Constants.Result load
(
rfid.Linkage transport,
UInt32 readerHandle
)
{
UInt32 config = 0;
UInt32 multdiv = 0;
UInt32 pllcc = 0;
rfid.Constants.Result result = transport.API_ConfigWriteRegister
(
SELECTOR_ADDRESS,
this.band
);
if (rfid.Constants.Result.OK != result)
{
return(result);
}
result = transport.API_ConfigReadRegister
(
CONFIG_ADDRESS,
ref config
);
if (rfid.Constants.Result.OK != result)
{
return(result);
}
result = transport.API_ConfigReadRegister
(
MULTDIV_ADDRESS,
ref multdiv
);
if (rfid.Constants.Result.OK != result)
{
return(result);
}
result = transport.API_ConfigReadRegister
(
PLLCC_ADDRESS,
ref pllcc
);
if (rfid.Constants.Result.OK != result)
{
return(result);
}
try
{
this.state = ( BandState )(config == 0 ? 0 : 1);
}
catch (Exception)
{
this.state = BandState.UNKNOWN;
}
this.multiplier = ( UInt16 )((multdiv >> 0) & 0xffff);
this.divider = ( UInt16 )((multdiv >> 16) & 0xff);
this.minDACBand = ( UInt16 )((pllcc >> 0) & 0xff);
this.affinityBand = ( UInt16 )((pllcc >> 8) & 0xff);
this.maxDACBand = ( UInt16 )((pllcc >> 16) & 0xff);
this.guardBand = ( UInt16 )((pllcc >> 24) & 0xff);
return(rfid.Constants.Result.OK);
}
