/// <summary>
/// Add a given AdcpSubsystemConfig to the dictionary. This will determine
/// how many of the given subsystem type have already been added to the dictionary
/// and generate a new index value. It will then set the index value to the SubsysteConfiguration.
/// It will then add the AdcpSubsystemConfig to the dictionary.
/// </summary>
/// <param name="asConfig">AdcpSubsystemConfig to add to the dictionary.</param>
private void AddConfig(AdcpSubsystemConfig asConfig)
{
// Determine how many of the given subsystem have been added to the dictionary
// We need to generate SubsystemConfiguration index value.
// SubsystemConfiguration index is based off the number of SubsystemConfigurations already
// in the dictionary before this configuration is added.
ushort ssCount = 0;
foreach (AdcpSubsystemConfig configuration in SubsystemConfigDict.Values)
{
// If the subsystems are the same, then increment the value
if (configuration.SubsystemConfig.SubSystem.Code == asConfig.SubsystemConfig.SubSystem.Code)
{
ssCount++;
}
}
// Set the new Configuration index
asConfig.SubsystemConfig.SubsystemConfigIndex = (byte)ssCount;
// Set the new CEPO index
// This is the last index for the CEPO command
asConfig.SubsystemConfig.CepoIndex = Convert.ToByte(SubsystemConfigDict.Values.Count);
// Add it to the dictionary
SubsystemConfigDict.Add(asConfig.ToString(), asConfig);
}
/// <summary>
/// Add a configuration to the dictionary. This will create an AdcpSubsystemConfig based
/// off the Subsystem and CEPO index given. It will then add it to the dictionary. It will
/// then return the created AdcpSubsystemConfig. If the AdcpSubsystemConfig could not be
/// created, null will be returned.
/// </summary>
/// <param name="ss">Subsystem to add a configuration.</param>
/// <param name="cepoIndex">CEPO index.</param>
/// <returns>AdcpSubsystemConfig created with the given settings or null if one could not be created.</returns>
private AdcpSubsystemConfig AddConfig(Subsystem ss, int cepoIndex)
{
AdcpSubsystemConfig asConfig = null;
// If a bad Subsystem is given, we cannot use it
if (!ss.IsEmpty())
{
// Determine how many of the given subsystem have been added to the dictionary
// We need to generate SubsystemConfiguration index value.
// SubsystemConfiguration index is based off the number of SubsystemConfigurations already
// in the dictionary before this configuration is added.
ushort ssCount = 0;
foreach (AdcpSubsystemConfig configuration in SubsystemConfigDict.Values)
{
// If the subsystems are the same, then increment the value
if (configuration.SubsystemConfig.SubSystem.Code == ss.Code)
{
ssCount++;
}
}
// Create all the subsystem configurations and add to the dictionary
SubsystemConfiguration ssConfig = new SubsystemConfiguration(ss, (byte)cepoIndex, (byte)ssCount); // SubsystemConfiguration with the Index of the SubsystemConfiguration
asConfig = new AdcpSubsystemConfig(ssConfig); // AdcpSubsystemConfig with the Subsystem, SubsystemConfig and CEPO index
if (!SubsystemConfigDict.ContainsKey(asConfig.ToString()))
{
SubsystemConfigDict.Add(asConfig.ToString(), asConfig);
}
}
return(asConfig);
}
/// <summary>
/// Get the CEPO configuration character and index within the CEPO command.
/// The configuration character is the Subsystem code for the configuration. It
/// represents the system type. The Index represents where in teh CEPO command
/// the configuration was located. This determines the ping order of the configurations.
/// It also make the configuration unique for a SubsystemConfiguration for a Subsystem.
/// Get the Subsystem using the serial number and subsystem code.
///
/// SubsystemConfiguaration CommandSetup: Index of the Configuration within Subsystem. (Based off counting configurations for a subsystem)
/// index: Location in CEPO for the Subsystem configuration.
/// </summary>
/// <param name="ssCode">Subsystem Code from the CEPO command.</param>
/// <param name="cepoIndex">Location in the CEPO command of the Subsystem Code.</param>
/// <param name="serial">Serial number for the ADCP.</param>
/// <returns>Return the AdcpSubsystemConfig created or null if one could not be created.</returns>
private AdcpSubsystemConfig AddConfig(byte ssCode, int cepoIndex, SerialNumber serial)
{
AdcpSubsystemConfig asConfig = null;
// Get the Subsystem index from the serial number
// If it cannot be found in the serial number, then it is
// a bad Subsystem and we can not use the command.
Subsystem ss = serial.GetSubsystem(ssCode);
if (!ss.IsEmpty())
{
// Determine how many of the given subsystem have been added to the dictionary
// We need to generate SubsystemConfiguration index value.
// SubsystemConfiguration index is based off the number of SubsystemConfigurations already
// in the dictionary before this configuration is added.
ushort ssCount = 0;
foreach (AdcpSubsystemConfig configuration in SubsystemConfigDict.Values)
{
// If the subsystems are the same, then increment the value
if (configuration.SubsystemConfig.SubSystem.Code == ssCode)
{
ssCount++;
}
}
// Create all the subsystem configurations and add to the dictionary
SubsystemConfiguration ssConfig = new SubsystemConfiguration(ss, (byte)cepoIndex, (byte)ssCount); // SubsystemConfiguration with the CEPO index and Index of the SubsystemConfiguration
asConfig = new AdcpSubsystemConfig(ssConfig); // AdcpSubsystemConfig with the Subsystem, SubsystemConfig and CEPO index
SubsystemConfigDict.Add(asConfig.ToString(), asConfig); // Add to the dictionary the configuration with the string as the key
}
return(asConfig);
}
/// <summary>
/// Determine if the AdcpSubsystemConfig exist in the dictionary. This will generate
/// a key based off the Subsystem and SubsystemConfiguration given. It will then
/// check if the key exist in the dictionary.
/// </summary>
/// <param name="ssConfig">SubsystemConfiguration.</param>
/// <returns>TRUE = Subsystem and SubsystemConfiguration key found. / FALSE = No AdcpSubsystemConfig key.</returns>
public bool AdcpSubsystemConfigExist(SubsystemConfiguration ssConfig)
{
// Check for null
if (ssConfig == null)
{
return(false);
}
string str = ssConfig.DescString();
//return SubsystemConfigDict.ContainsKey(AdcpSubsystemConfig.GetString(ssConfig));
return(SubsystemConfigDict.ContainsKey(str));
}
/// <summary>
/// Decode the CEPO command and populate the dictionary.
///
/// Ex:
/// CEPO 222
/// 1 Subsystem
/// 3 SubsystemConfigurations for Subsystem 2
///
/// CEPO 232
/// 2 Subsystems
/// 2 SubsystemConfigurations for Subsystem 2 and
/// 1 SubsystemConfiguration for Subsystem 3
///
/// </summary>
/// <param name="cepo">CEPO command to decode.</param>
/// <param name="serial">Serial number to determine the system type.</param>
/// <returns>Dictionary of all subsystem configurations found.</returns>
private Dictionary <string, AdcpSubsystemConfig> DecodeCepo(string cepo, SerialNumber serial)
{
// Clear the current dictionary
SubsystemConfigDict.Clear();
// Add each configuration in the command
for (int x = 0; x < cepo.Length; x++)
{
AddConfig(Subsystem.ConvertSubsystemCode(cepo, x), x, serial);
}
// Return the populated dictionary
return(SubsystemConfigDict);
}
/// <summary>
/// Get the AdcpSubsystemConfig from the dictionary if it exist. If it does not
/// exist in the dictionary, null will be returned.
/// </summary>
/// <param name="ssConfig">SubsystemConfiguration.</param>
/// <returns>If the AdcpSubystemConfig is found, it will return the AdcpSubsystemConfig. If it is not found, it will return null.</returns>
public AdcpSubsystemConfig GetAdcpSubsystemConfig(SubsystemConfiguration ssConfig)
{
// Check for null
if (ssConfig == null)
{
return(null);
}
// Generate the key for the Subsystem and SubsystemConfiguration
string key = AdcpSubsystemConfig.GetString(ssConfig);
// If the key exist, return the object
if (SubsystemConfigDict.ContainsKey(key))
{
return(SubsystemConfigDict[key]);
}
// The key did not exist so return null
return(null);
}
/// <summary>
/// Remove the AdcpSubsystemConfig from the dictionary. If it exist in the
/// dictionary, the AdcpSubsystemConfigs in the dictionary have to reordered.
/// If it did not exist in the dictionary, do nothing and return false.
///
/// Create a temporary list of all the configurations in the order
/// of the CEPO command. Then add the configurations back to the dictonary
/// and create a new CEPO command.
/// </summary>
/// <param name="config">AdcpSubsystemConfig to remove.</param>
/// <returns>TRUE = Config removed / FALSE = Config did not exist in the dictonary. Nothing done.</returns>
public bool RemoveAdcpSubsystemConfig(AdcpSubsystemConfig config)
{
if (config != null)
{
// Remove the AdcpSubsystemConfig from the dict
// If it is removed, all the remaining configurations needed
// to be renumbered
if (SubsystemConfigDict.Remove(config.ToString()))
{
// Remove all the configurations from the dictionary and put in an sorted list by CEPO index
SortedList <int, AdcpSubsystemConfig> tempList = new SortedList <int, AdcpSubsystemConfig>();
//List<AdcpSubsystemConfig> tempList = new List<AdcpSubsystemConfig>();
foreach (AdcpSubsystemConfig asConfig in SubsystemConfigDict.Values)
{
tempList.Add(asConfig.SubsystemConfig.CepoIndex, asConfig);
//tempList.Add(asConfig);
}
// Clear the dictionary and the CEPO command
//CEPO = "";
Commands.CEPO = AdcpCommands.DEFAULT_CEPO;
SubsystemConfigDict.Clear();
// Redo the CEPO command
// and add the configuration back to the dictionary
for (int x = 0; x < tempList.Count; x++)
{
// Redo the cepo value
Commands.CEPO += Convert.ToChar(tempList.Values[x].SubsystemConfig.SubSystem.Code);
// Add config to the dictionary
AddConfig(tempList.Values[x]);
}
return(true);
}
}
// Config was not in the list so the configuration was not reordered
return(false);
}
