public CswNbtBalanceReturn registerBalanceConfiguration(BalanceConfiguration Request)
{
//delegate has to be static because you can't create an instance yet: you don't have resources until the delegate is actually called
CswNbtBalanceReturn Ret = new CswNbtBalanceReturn();
var SvcDriver = new CswWebSvcDriver <CswNbtBalanceReturn, BalanceConfiguration>(
CswWebSvcResourceInitializer: new CswWebSvcResourceInitializerNbt(_Context, null),
ReturnObj: Ret,
WebSvcMethodPtr: CswNbtWebServiceSerialBalance.registerBalanceConfiguration,
ParamObj: Request
);
SvcDriver.run();
return(Ret);
}
public Balance(string COM, string Manufacturer, string Description)
{
_isEnabled = false;
_updateInProgress = false;
_stableReadsOnly = false;
_balanceData = new SerialBalance();
_balanceData.NbtName = "";
_balanceData.CurrentWeight = 0;
_balanceData.UnitOfMeasurement = "";
_balanceData.Manufacturer = Manufacturer;
_balanceData.DeviceDescription = Description;
_balanceData.Operational = false;
_driftThreshold = 0;
_pendingReadRequests = 0;
_serialPortConfiguration = new BalanceConfiguration();
_balanceConnection = new SerialPort();
_balanceConnection.PortName = COM;
_balanceConnection.DataReceived += parseWeightResult;
}//constructor
/// <summary>
/// Attached to Save button on Configuration tab.
/// Attempt to send current form values to NBT as a new balance config.
/// On success: if the balance is new, append to the hardware grid
/// On failure: switch to NBT tab and print error to output box.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void saveTemplateButton_Click(object sender, EventArgs e)
{
NbtAuth.SessionCompleteEvent sendConfiguration = delegate(NbtPublicClient Client)
{
string StatusText = "";
BalanceConfiguration ConfigurationToSend = new BalanceConfiguration();
ConfigurationToSend.Name = templateNameBox.Text;
ConfigurationToSend.RequestFormat = templateRequestBox.Text;
ConfigurationToSend.ResponseFormat = templateExpressionBox.Text;
templateBaudRateBox.Invoke((Action)(() => { ConfigurationToSend.BaudRate = (int)templateBaudRateBox.SelectedItem; }));
templateDataBitsBox.Invoke((Action)(() => { ConfigurationToSend.DataBits = (int)templateDataBitsBox.SelectedItem; }));
templateParityBitBox.Invoke((Action)(() => { ConfigurationToSend.ParityBit = templateParityBitBox.SelectedValue.ToString(); }));
templateStopBitsBox.Invoke((Action)(() => { ConfigurationToSend.StopBits = templateStopBitsBox.SelectedValue.ToString(); }));
templateHandshakeBox.Invoke((Action)(() => { ConfigurationToSend.Handshake = templateHandshakeBox.SelectedValue.ToString(); }));
StatusText = Client.registerBalanceConfiguration(ConfigurationToSend).Authentication.AuthenticationStatus;
if (StatusText == "Authenticated")
{
saveUserSettings(this, new EventArgs());
refreshConfigurationList();
}
else if (StatusText != "NonExistentSession")
{
tabControl1.BeginInvoke((Action)(() => { tabControl1.SelectedTab = NBTTab; }));
}
return(StatusText);
}; //SessionCompleteEvent fetchConfigurations
//Perform a test connection asynchronously, using the managed thread pool
BackgroundWorker NbtTask = new BackgroundWorker();
NbtTask.DoWork += _authenticationClient.PerformActionAsync;
NbtTask.RunWorkerAsync(sendConfiguration);
}//saveTemplateButton_Click()
public static void registerBalanceConfiguration( ICswResources CswResources, CswNbtBalanceReturn Return, BalanceConfiguration Request )
{
CswNbtResources NbtResources = (CswNbtResources) CswResources;
CswNbtMetaDataObjectClass BalanceConfigurationOC = NbtResources.MetaData.getObjectClass( CswEnumNbtObjectClass.BalanceConfigurationClass );
if( null != BalanceConfigurationOC )
{
Return.Data.ConfigurationList = new Collection<BalanceConfiguration>();
CswNbtObjClassBalanceConfiguration BalanceConfiguration = _findConfigurationWithName( NbtResources, Request.Name );
Action<CswNbtNode> AfterBalanceConfig = delegate( CswNbtNode NewNode )
{
CswNbtObjClassBalanceConfiguration thisBalanceConfig = NewNode;
thisBalanceConfig.Name.Text = Request.Name;
thisBalanceConfig.RequestFormat.Text = Request.RequestFormat;
thisBalanceConfig.ResponseFormat.Text = Request.ResponseFormat;
thisBalanceConfig.BaudRate.Value = Request.BaudRate;
thisBalanceConfig.ParityBit.Text = Request.ParityBit;
thisBalanceConfig.DataBits.Value = Request.DataBits;
thisBalanceConfig.StopBits.Text = Request.StopBits;
thisBalanceConfig.Handshake.Text = Request.Handshake;
};
if( null == BalanceConfiguration )
{
//there is no configuration with this name yet. Make a new one.
CswNbtMetaDataNodeType ConfigNT = BalanceConfigurationOC.FirstNodeType;
BalanceConfiguration = NbtResources.Nodes.makeNodeFromNodeTypeId( ConfigNT.NodeTypeId, AfterBalanceConfig );
}
else
{
AfterBalanceConfig( BalanceConfiguration.Node );
BalanceConfiguration.postChanges( false );
}
Return.Data.ConfigurationList.Add( Request );
}//if ( null != BalanceConfigurationOC )
} // registerBalanceConfiguration()
}//parseWeightResult()
/// <summary>
/// Update Balance properties from data changed in grid
/// </summary>
/// <param name="Field">The column name of the parameter changed</param>
/// <param name="Value">The value of the column's cell</param>
public void updateField(string Field, object Value)
{
switch (Field)
{
case "NBTName":
_balanceData.NbtName = (string)Value;
break;
case "StableOnly":
_stableReadsOnly = (bool)Value;
break;
case "Enabled":
if (true == (bool)Value)
{
BalanceAsynchronousTask EnableBalance = delegate()
{
if (false == _balanceConnection.IsOpen)
{
if (string.IsNullOrEmpty(_balanceData.NbtName))
{
InterfaceRow.Cells["Enabled"].Value = false;
InterfaceRow.Cells["NBTName"].Selected = true;
}
else if (string.IsNullOrEmpty(_balanceData.Configuration))
{
InterfaceRow.Cells["Enabled"].Value = false;
InterfaceRow.Cells["Configuration"].Selected = true;
}
else
{
_isEnabled = true;
InterfaceRow.Cells["NBTName"].ReadOnly = true;
InterfaceRow.Cells["NBTName"].Style.BackColor = Color.LightGray;
InterfaceRow.Cells["Configuration"].ReadOnly = true;
InterfaceRow.Cells["Configuration"].Style.BackColor = Color.LightGray;
_balanceConnection.Open();
}
}
announceBalance();
};
EnableBalance.BeginInvoke(null, null);
} //if true == Value
else
{
BalanceAsynchronousTask DisableBalance = delegate()
{
_isEnabled = false;
InterfaceRow.Cells["NBTName"].ReadOnly = false;
InterfaceRow.Cells["NBTName"].Style.BackColor = InterfaceRow.DefaultCellStyle.BackColor;
InterfaceRow.Cells["Configuration"].ReadOnly = false;
InterfaceRow.Cells["Configuration"].Style.BackColor = InterfaceRow.DefaultCellStyle.BackColor;
_balanceConnection.Close();
};
DisableBalance.BeginInvoke(null, null);
} //else -- if true == Value
break;
case "Configuration":
_serialPortConfiguration = (BalanceConfiguration)Value;
_balanceConnection.BaudRate = _serialPortConfiguration.BaudRate;
_balanceConnection.DataBits = _serialPortConfiguration.DataBits;
_balanceConnection.Handshake = (Handshake)Enum.Parse(typeof(Handshake), _serialPortConfiguration.Handshake);
_balanceConnection.Parity = (Parity)Enum.Parse(typeof(Parity), _serialPortConfiguration.ParityBit);
_balanceConnection.StopBits = (StopBits)Enum.Parse(typeof(StopBits), _serialPortConfiguration.StopBits);
_balanceData.Configuration = _serialPortConfiguration.Name;
break;
case "DriftThreshold":
if (false == double.TryParse((string)Value, out _driftThreshold))
{ //when the user entered an invalid threshold, clear the field
InterfaceRow.Cells["DriftThreshold"].Value = "";
}
break;
} //switch( Field )
} //updateField()
