/// <summary>
/// Allows an application to specify whether or not a radio module's
/// logical antenna port is enabled for subsequent tag operations. The
/// antenna-port state cannot be set while a radio module is executing
/// a tag-protocol operation.
/// </summary>
/// <param name="portState">The new state of the logical antenna port. </param>
/// <returns></returns>
public Result SetAntennaPortState(AntennaPortState portState)
{
if (portState == AntennaPortState.UNKNOWN)
{
return(Result.INVALID_PARAMETER);
}
return(m_Result = AntennaPortSetState(0, portState));
}
/// <summary>
/// Converts the given object to the type of this converter, using the specified
/// context and culture information.
/// </summary>
/// <param name="context">An System.ComponentModel.ITypeDescriptorContext that provides a format context.</param>
/// <param name="culture">The System.Globalization.CultureInfo to use as the current culture.</param>
/// <param name="value">The System.Object to convert.</param>
/// <returns>An System.Object that represents the converted value.</returns>
public override object ConvertFrom
(
System.ComponentModel.ITypeDescriptorContext context,
System.Globalization.CultureInfo culture,
Object value
)
{
if (String.IsNullOrEmpty(value as string))
{
return(null); // TODO : supply err msg
}
String[] antennaData = (value as String).Split(new Char[] { ',' });
if (null == antennaData)
{
return(null); // TODO : supply err msg ~ improper arg
}
if (8 != antennaData.Length)
{
return(null); // TODO : supply err msg ~ improper arg count
}
try
{
// TODO : split out parsing ? to better define which parms bad...
Antenna antenna = new Antenna(UInt32.Parse(antennaData[0]));
AntennaPortState state =
(AntennaPortState)Enum.Parse
(
typeof(AntennaPortState),
antennaData[1].ToUpper()
);
antenna.State = state;
antenna.PowerLevel = UInt32.Parse(antennaData[2]);
antenna.DwellTime = UInt32.Parse(antennaData[3]);
antenna.NumberInventoryCycles = UInt32.Parse(antennaData[4]);
antenna.PhysicalTxPort = UInt32.Parse(antennaData[5]);
// Currently Rx is explicitly tied to Tx so cannot be set - ignore val
antenna.PhysicalRxPort = UInt32.Parse(antennaData[6]);
antenna.AntennaSenseThreshold = UInt32.Parse(antennaData[7]);
return(antenna);
}
catch (Exception)
{
// TODO : supply err msg ~ bad arg
return(null);
}
}
/// <summary>
/// Allows an application to specify whether or not a radio module's
/// logical antenna port is enabled for subsequent tag operations. The
/// antenna-port state cannot be set while a radio module is executing
/// a tag-protocol operation.
/// </summary>
/// <param name="port">antenna port</param>
/// <param name="portState">The new state of the logical antenna port.</param>
/// <returns></returns>
public Result SetAntennaPortState(uint port, AntennaPortState portState)
{
if (portState == AntennaPortState.UNKNOWN)
{
return(Result.INVALID_PARAMETER);
}
m_AntennaList[(int)port].State = portState;
return(m_Result = AntennaPortSetState(port, portState));
}
public Result AntennaPortSetState(UInt32 antennaPort, AntennaPortState state)
{
uint registerValue = 0;
// First, tell the MAC which antenna descriptors we'll be reading and
// verify that it was a valid selector
MacWriteRegister(MACREGISTER.HST_ANT_DESC_SEL, antennaPort);
/*
* MacReadRegister(MACREGISTER.MAC_ERROR, ref registerValue);
*
* if (registerValue == HOSTIF_ERR_SELECTORBNDS)
* {
* MacClearError();
* return Result.INVALID_PARAMETER;
* }
*/
// Read the current value of the anteann port configuration
MacReadRegister(MACREGISTER.HST_ANT_DESC_CFG, ref registerValue);
// Now set the enabled bit appropriately
switch (state)
{
case AntennaPortState.DISABLED:
{
registerValue &= ~((uint)1);
break;
} // case RFID_ANTENNA_PORT_STATE_DISABLED
case AntennaPortState.ENABLED:
{
registerValue |= 1;
break;
} // case RFID_ANTENNA_PORT_STATE_ENABLED
default:
return(Result.INVALID_PARAMETER);
} // switch (state)
// Write back the configuration register
MacWriteRegister(MACREGISTER.HST_ANT_DESC_CFG, registerValue);
return(Result.OK);
} // Radio::SetAntennaPortState
/// <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 static extern Result RFID_AntennaPortSetState
(
[In] Int32 handle,
[In] UInt32 port,
[In] AntennaPortState state
);
private void SetAntennaPortStatus(int radioHandle, AntennaPortState portState)
{
Result result = link.AntennaPortSetState(radioHandle, 0, portState);
logger.Information("link.AntennaPortSetStatus ( {PortState} ) => {Result}", portState, result);
}
private bool SetConfig()
{
if (m_reader == null || m_mainForm == null)
{
return(false);
}
//Set Frequency Configuration
m_btChannelFlag = (rdoBtnMultiChannel.Checked == true) ? (byte)0 : (byte)1;
//Get value from cmbBoxFreq
try
{
m_uiExactFrequecny = (uint)(Convert.ToDouble(cmbBoxFreq.Text) * 1000);
}
catch (Exception exception)
{
ShowErrMsg("Please enter valid value!");
return(false);
}
//m_uiExactFrequecny = (uint)(Convert.ToDouble(cmbBoxFreq.Text) * 1000);
if (Result.OK != m_reader.API_TestSetFrequencyConfiguration(m_btChannelFlag, m_uiExactFrequecny))
{
ShowErrMsg("Set channel and frequecny unsuccessfully!");
return(false);
}
//Set Logic-Antenna Port and Test-Antenna Port
{
AntennaPortConfig config = new AntennaPortConfig();
AntennaPortState State = AntennaPortState.DISABLED;
for (byte Port = 0; Port <= Source_Antenna.LOGICAL_MAXIMUM; Port++)
{
if (Result.OK != m_reader.API_AntennaPortGetConfiguration(Port, ref config))
{
ShowErrMsg("Get logic antenna port State unsuccessfully!");
return(false);
}
}
/*
* //Close Logic antenna port 1~15. Only use Logic antenna port 0
* for (byte Port = 1; Port <= Source_Antenna.LOGICAL_MAXIMUM; Port++)
* {
* if (Result.OK != m_reader.API_AntennaPortSetState(Port, State))
* {
* ShowErrMsg("Set logic antenna port State unsuccessfully!");
* return false;
* }
* }
*/
//Set Test Antenna Port
m_usPowerLevel = (UInt16)numPowerLevel.Value;
m_btPhysicalPort = (byte)cmbAntPort.SelectedItem;
if (Result.OK != m_reader.API_TestSetAntennaPortConfiguration(m_btPhysicalPort, m_usPowerLevel))
{
return(false);
}
//Get Logic Port 0
if (m_reader.API_AntennaPortGetConfiguration(0, ref config) != Result.OK)
{
ShowErrMsg("Get antenna port0 unsuccessfully!");
return(false);
}
config.powerLevel = m_usPowerLevel;
config.physicalPort = m_btPhysicalPort;
//Set Logic Port 0
if (m_reader.API_AntennaPortSetConfiguration(0, config) != Result.OK)
{
ShowErrMsg("Set antenna port0 unsuccessfully!");
return(false);
}
}
//Set Pulse Time
m_uiPulseOnTime = (UInt16)(numPulseOnTime.Value * 1000); //ms to us
m_uiPulseOffTime = (UInt16)(numPulseOffTime.Value * 1000);
if (Result.OK != m_reader.API_TestSetRandomDataPulseTime(m_uiPulseOnTime, m_uiPulseOffTime))
{
ShowErrMsg("Set pulse time unsuccessfully!");
return(false);
}
return(true);
}
//Antenna
public Result API_AntennaPortSetState
(
byte r_Port,
AntennaPortState r_State
)
{
return LakeChabotReader.MANAGED_ACCESS.API_AntennaPortSetState(r_Port, r_State);
}
