/// <summary>
/// </summary>
/// <remarks>
/// 23-Feb-2011, Originally based on following dev jiras...
/// http://svrdevjira/browse/DSHW-120
/// http://svrdevjira/browse/INS-3124
/// </remarks>
/// <param name="dsEvent"></param>
/// <param name="details"></param>
private void ExecuteDiagnostics( DiagnosticEvent dsEvent, DetailsBuilder details )
{
Log.Debug("ExecuteDiagnostics: Self-diagnostics starting.");
InitializeEnvironment(details);
try
{
//#if !DEBUG
TestSystemCurrent( details );
TestCoreVoltage( details );
TestEthernet( details );
TestVacuumSensor( details );
TestFlowSensor( details );
TestForLeak( details );
TestPump( details );
//TestSolenoids( details );
for ( int portNum = 1; portNum <= Configuration.DockingStation.NumGasPorts; portNum++ )
TestFlow( details, portNum );
//#endif
}
catch ( Exception e )
{
Log.Error( e );
throw;
}
finally
{
RestoreEnvironment( details );
}
Log.Debug("ExecuteDiagnostics: Self-diagnostics complete.");
}
/// <summary>
/// Executes a docking station diagnostic operation.
/// </summary>
/// <returns>Docking station event</returns>
public DockingStationEvent Execute()
{
// Initialize resource manager's culture to be same as current configuration culture.
DiagnosticResources.Culture = Configuration.DockingStation.Language.Culture;
// Make the return event and return diagnostic and wire them together.
DiagnosticEvent dsEvent = new DiagnosticEvent( this );
dsEvent.DockingStation = Controller.GetDockingStation(); // Retrieve IDS's complete information.
// Make the builder for the details.
DetailsBuilder details = new DetailsBuilder();
details.AddDockingStation( dsEvent.DockingStation );
// SGF 23-May-2011 INS-1741
ReportDiagnosticDate(details);
GeneralDiagnostic generalDiagnostic = new GeneralDiagnostic( Configuration.DockingStation.SerialNumber, DateTime.UtcNow );
ExecuteDiagnostics( dsEvent, details );
// Retrieve the details.
dsEvent.Details = details.ToString();
// Write the details to a log file.
FlashCard.WriteTextFile( LAST_RUN_DETAILS_FILE_NAME, dsEvent.Details );
dsEvent.Diagnostics.Add( generalDiagnostic );
generalDiagnostic.Items = _gdpList.ToArray();
return dsEvent; // Return the event
}
/// <summary>
/// Read the flow sensor
/// </summary>
/// <remarks>
/// Engineering Notes: This step is to check if the reading of flow sensor is reasonable.
/// With the pump closed and all valves closed, the flow should be lower than a certain level.
/// Failure on this indicates the reading of flow rate is not correct.
/// </remarks>
/// <param name="details">The string to hold details.</param>
private void TestFlowSensor( DetailsBuilder details )
{
Pump.CloseAllValves( true );
Pump.Stop();
Thread.Sleep( 500 ); // Give the valves a chance to finish closing
// Read the flow rate.
ushort rawFlowCount = Pump.GetRawFlow();
ushort flowVolts = Pump.ConvertRawFlowToVolts( rawFlowCount );
ushort vacuumCounts = Pump.GetRawVacuum();
double vacuumInches = Pump.ConvertRawVacuumToInches( vacuumCounts );
int flowRate = Pump.CalculateFlowRate( flowVolts, vacuumCounts );
// Test flow reading
string flowString = BuildFlowString( rawFlowCount, flowRate, flowVolts );
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_FLOW", rawFlowCount.ToString() ) );
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_FLOW_VOLTS", flowVolts.ToString() ) );
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_FLOW_RATE", flowRate.ToString() ) );
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_FLOW_VACUUM", vacuumCounts.ToString() ) );
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_FLOW_VACUUM_INCHES", vacuumInches.ToString() ) );
// Flow value should be in the range of 0 (0mV) to 186 (600 mV), inclusive.
// INS-3067, 6/26/2013, JMP - changer criteria from 43/128 to 0/186.
ReportDiagnostic( details, DiagnosticResources.FLOW, flowString, ( ( rawFlowCount < 0 ) || ( rawFlowCount > 186 ) ) );
}
/// <summary>
/// Report the diagnostic to the debug port and the diagnostic details.
/// </summary>
/// <param name="details">The details to fill in</param>
/// <param name="id">The id of the diagnostic</param>
/// <param name="val">The value of the diagnostic</param>
/// <param name="failed">Whether it failed</param>
private void ReportDiagnostic(DetailsBuilder details, string id, object val, bool failed)
{
Log.Debug(details.Add(" ", id, val.ToString()));
if (failed)
Log.Debug(details.Add(" ", id, DiagnosticResources.FAILED.ToUpper()));
else
Log.Debug(details.Add(" ", id, DiagnosticResources.PASSED.ToUpper()));
}
/// <summary>
/// Read the iNetDS's core voltage.
/// The correct voltage for Atmel AT91SAM9G45 microprocessor used in iNetDS is 1V.
/// </summary>
/// <remarks>
/// Engineering Notes: This step is to check core voltage of microprocessor.
/// The work frequency of microprocessor is controlled by this voltage.
/// The deviation of this voltage could affect the system frequency significantly and
/// make all data operation and communication messed up.
/// In order to make sure the micro works properly, this voltage has to be in a
/// certain tolerated range.
/// The correct voltage for Atmel AT91SAM9G45 microprocessor used on iNetDS is 1V.
/// </remarks>
/// <param name="details">The string to hold details.</param>
private void TestCoreVoltage(DetailsBuilder details)
{
int coreVoltageCount = Controller.GetCoreVoltage();
int coreVoltage = CountToVoltage(coreVoltageCount);
string voltageString = BuildCountAndUnitString(coreVoltageCount, coreVoltage, DiagnosticResources.MILLIVOLTS);
_gdpList.Add(new GeneralDiagnosticProperty("DIAGNOSTIC_CORE_VOLTAGE", coreVoltageCount.ToString()));
ReportDiagnostic(details, DiagnosticResources.CORE_VOLTAGE, voltageString, ((coreVoltageCount < 294 /*294==950mV*/ ) || (coreVoltageCount > 325 /*325==1050mV*/)));
}
/// <summary>
/// Read the iNetDS's system current.
/// </summary>
/// <remarks>
/// Engineering Notes: This step is to check current through 12V main power circuit.
/// This current varies when Docking Station works at different scenarios such as
/// charging or not charging, solenoid on or off.
/// If the current is too low, there is something wrong on the current sensing circuit.
/// Too high current indicates some component is not working properly.
/// </remarks>
/// <param name="details">The string to hold details.</param>
private void TestSystemCurrent(DetailsBuilder details)
{
int rawCurrent = Controller.Get12VCurrent();
int currentInMilliamps = CountToCurrent(rawCurrent);
string currentString = BuildCountAndUnitString(rawCurrent, currentInMilliamps, DiagnosticResources.MILLIAMPS);
_gdpList.Add(new GeneralDiagnosticProperty("DIAGNOSTIC_SYSTEM_CURRENT", rawCurrent.ToString()));
ReportDiagnostic(details, DiagnosticResources.SYSTEM_CURRENT, currentString, ((rawCurrent < 12) || (rawCurrent > 347)));
}
private void RestoreEnvironment(DetailsBuilder details)
{
// Restore flow checking and pressure.
Pump.DoCheckFlow = true;
Pump.Stop();
for ( int i = 1; i <= Configuration.DockingStation.NumGasPorts; i++ ) //Suresh 21-SEPTEMBER-2011 INS-2195
PrepValve( i );
}
/// <summary>
/// Check if gas port solenoids work properly.
/// </summary>
/// <param name="details">The string to hold details.</param>
private void TestSolenoids( DetailsBuilder details )
{
// close all valves and stop pump
Pump.CloseAllValves( true );
for ( int portNum = 1; portNum <= Configuration.DockingStation.NumGasPorts; portNum++ )
{
/* DIAGNOSTIC_SOLENOID_CURRENT */
// give the valves a chance to finish closing
Thread.Sleep( 500 );
// get the closed current counts (c1)
int countsClosed = Controller.Get12VCurrent();
// open valve
Pump.OpenValve( portNum, false );
// wait at least 500 ms
Thread.Sleep( 500 );
// get the open current counts (c2)
int countsOpen = Controller.Get12VCurrent();
// close the valve that was opened
Pump.CloseValve( portNum );
// convert current counts to milliamps (mA)
int currentClosed = CountToCurrent( countsClosed );
int currentOpen = CountToCurrent( countsOpen );
// DSX solenoids are designed to use 180 mA to remain open
int currentSolenoid = currentOpen - currentClosed;
// counts for min limit provided by Engineering (Bryan Pavlisko);
// 20 counts is 160 mA which is approximately 10% below 180 mA
int COUNTS_MIN_LIMIT = 20;
bool solenoidCheckFailed = false;
// fail if c2 - c1 < 20
solenoidCheckFailed = ( countsOpen - countsClosed ) < COUNTS_MIN_LIMIT;
// report the results
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_SOLENOID_" + portNum + "_CURRENT_CLOSED", countsClosed.ToString() ) );
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_SOLENOID_" + portNum + "_CURRENT_OPEN", countsOpen.ToString() ) );
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_SOLENOID_" + portNum + "_CURRENT_MILLIAMPS", currentSolenoid.ToString() ) );
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_SOLENOID_" + portNum + "_CURRENT_PASSED", ( !solenoidCheckFailed ).ToString() ) );
// log the results
ReportDiagnostic( details, details.GetText( "SOLENOID_CURRENT_" + portNum ), countsClosed, countsOpen, solenoidCheckFailed );
}
}
private void InitializeEnvironment(DetailsBuilder details)
{
// Attempting to ensure a consistant beginning state - open all valves and
// close them. Stop the pump, stop the charger, turn off flow checking.
Pump.DoCheckFlow = false;
for ( int i = 1; i <= Configuration.DockingStation.NumGasPorts; i++ ) //Suresh 21-SEPTEMBER-2011 INS-2195
PrepValve(i);
Pump.Stop();
// mx4/mx6... make sure gas goes to diffusion lid, not hose. There might not be an attached
// hose in which case the hose connection point will be closed off.
Controller.SetCradleSolenoid(AccessoryPumpSetting.NotApplicable);
}
/// <summary>
/// Verifies if the MAC address is been properly programmed or not.
/// </summary>
/// <param name="details">The string to hold details.</param>
private void TestEthernet(DetailsBuilder details)
{
string macAddress = Controller.GetWiredNetworkAdapter().MacAddress;
string defaultIscMacAddress = Controller.DEFAULT_MAC_ADDRESS;
string iscOUI = defaultIscMacAddress.Substring(0, 8);
_gdpList.Add(new GeneralDiagnosticProperty("DIAGNOSTIC_ETHERNET", macAddress));
// invalid MAC
// We expect the first half of the MAC address to be "00:0B:D8", which is ISC's registered OUI.
string macOUI = macAddress.Substring(0, 8);
ReportDiagnostic(details, DiagnosticResources.MAC_ADDRESS_OUI, macAddress, iscOUI, (macOUI.CompareTo(iscOUI) != 0));
// default MAC
// We expect the MAC address to be programmed as something other than the ISC default value.
ReportDiagnostic(details, DiagnosticResources.MAC_ADDRESS_DEFAULT, macAddress, defaultIscMacAddress, (macAddress.CompareTo(defaultIscMacAddress) == 0));
}
/// <summary>
/// Check if flow offset has been set.
/// </summary>
/// <param name="details">The string to hold details.</param>
private void TestFlowOffset( DetailsBuilder details )
{
bool isFlowOffsetAssigned = true;
int flowOffset = Configuration.DockingStation.FlowOffset;
// if flowOffset has not been set it will default to int.MinValue;
// 0 is a valid setting for the flowOffset
if ( flowOffset == int.MinValue )
{
isFlowOffsetAssigned = false;
}
// report the results
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_FLOW_OFFSET", flowOffset.ToString() ) );
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_FLOW_OFFSET_PASSED", isFlowOffsetAssigned.ToString() ) );
// log the results
ReportDiagnostic( details, DiagnosticResources.FLOW_OFFSET, flowOffset, !isFlowOffsetAssigned );
}
/// <summary>
/// Check the vacuum sensor.
/// </summary>
/// <remarks>
/// Engineering Notes: This step is to check if the reading of vacuum sensor is reasonable.
/// After the initialization, the vacuum (negative pressure) should be close to zero.
/// Failure on this test indicates possible issues on vacuum sensor, or A2D converter,
/// or some tubing is blocked by something.
/// </remarks>
/// <param name="details">The string to hold details.</param>
private void TestVacuumSensor(DetailsBuilder details)
{
Pump.CloseAllValves( true );
Thread.Sleep(500); // Give the valves a chance to finish closing
Pump.OpenValve(1, false); // Open solenoid 1
Thread.Sleep(500); // Pause at least 500ms.
// Read the vacuum pressure
ushort vacuumCount = Pump.GetRawVacuum();
int vacuumVoltage = CountToVoltage(vacuumCount);
// Test vacuum readings
// Vacuum count value should be in the range of 62 (200mV) to 128 (410 mV), inclusive.
// The normal vacuum count is 77.
// Report results
string vacuumString = BuildCountAndUnitString(vacuumCount, vacuumVoltage, DiagnosticResources.MILLIVOLTS);
_gdpList.Add(new GeneralDiagnosticProperty("DIAGNOSTIC_VACUUM", vacuumCount.ToString()));
ReportDiagnostic(details, DiagnosticResources.VACUUM, vacuumString, ((vacuumCount < 62) || (vacuumCount > 128)));
}
// SGF 23-May-2011 INS-1741
private void ReportDiagnosticDate(DetailsBuilder details)
{
Log.Debug(details.Add(" ", DiagnosticResources.DETAILS_DOCKINGSTATION_SELF_DIAGNOSTICS_DATE, DateTime.Now));
}
/// <summary>
/// Test the specified solenoid
/// </summary>
/// <param name="details">The string to hold details.</param>
private void TestFlow( DetailsBuilder details, int solenoid )
{
// Validate the solenoid number
if ( solenoid < 1 || solenoid > Configuration.DockingStation.NumGasPorts )
{
Log.Debug( "TestFlow: Invalid solenoid value = " + solenoid.ToString() );
return;
}
Log.Debug( "TestFlow: port=" + solenoid.ToString() );
// Determine whether a cylinder is attached to this port.
// If there is one attached, skip this test.
DockingStation ds = Controller.GetDockingStation();
GasEndPoint gasEndPoint = ds.GasEndPoints.Find(m => m.Position == solenoid);
if (gasEndPoint != null && gasEndPoint.Cylinder.IsFreshAir == false)
{
Log.Debug( "TestFlow: Cylinder attached to port " + solenoid.ToString() + "; SKIPPING THIS TEST." );
return;
}
Pump.DoCheckFlow = true;
// Ensure that only the specified solenoid is open.
Pump.CloseAllValves( true );
Thread.Sleep(500); // Give the valves a chance to finish closing
Pump.OpenValve(solenoid, false); // Open the specified solenoid
Thread.Sleep(500); // Pause at least 500ms.
Pump.SetDesiredFlow( Pump.StandardFlowRate);
Pump.Start( Pump.StandardStartVoltage ); // Turn on the pump.
Thread.Sleep( 3000 ); // Wait for it to stabilize the flow before letting CheckFlow take its first reading.
// CheckFlow could enter an infinite loop if it's unable to
// establish the desired flow rate and we don't tell it to time out.
// We therefore give it a time out of a minute which should be more than sufficient.
ushort rawFlowCounts;
ushort rawVacuumCounts;
Pump.FlowStatus flowStatus = Pump.CheckFlow( new TimeSpan( 0, 1, 0 ), out rawFlowCounts, out rawVacuumCounts );
byte pumpVoltage = Pump.GetPumpVoltage(); // obtain and hold onto final voltage of the pump, to report it to inet.
// Get the flow rate.
ushort flowVolts = Pump.ConvertRawFlowToVolts( rawFlowCounts );
int flowRate = Pump.CalculateFlowRate( flowVolts, rawVacuumCounts ); // Convert that value to mL/min
// Report the results.
string flowString = BuildFlowString(flowRate, flowVolts);
// We create a property for every value used to compute the flow rate, and also the flow rate itself.
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_CHECK_FLOW_" + solenoid + "_VACUUM", rawVacuumCounts.ToString() ) );
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_CHECK_FLOW_" + solenoid + "_VACUUM_INCHES", Pump.ConvertRawVacuumToInches( rawVacuumCounts ).ToString() ) );
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_CHECK_FLOW_" + solenoid, rawFlowCounts.ToString() ) );
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_CHECK_FLOW_" + solenoid + "_VOLTS", flowVolts.ToString() ) );
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_CHECK_FLOW_" + solenoid + "_RATE", flowRate.ToString() ) );
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_CHECK_FLOW_" + solenoid + "_PUMP_VOLTS", pumpVoltage.ToString() ) );
// The flow is considered a failure if it's not equal to the StandardFlowRate plus/minus the standardtolerance
bool flowFailed = flowRate < ( Pump.StandardFlowRate - Pump.FLOWRATE_TOLERANCE ) || flowRate > ( Pump.StandardFlowRate + Pump.FLOWRATE_TOLERANCE );
// TODO - we should rename the translation string so that it's prefixed with "CHECK_FLOW" instead of "SOLENOID_FLOW"
ReportDiagnostic( details, details.GetText( "SOLENOID_FLOW_" + solenoid ), flowString, flowFailed );
// Check Pump Error Status -- FAIL IF STATE IS 1
int pumpErrorState = Pump.GetPumpErrorState();
// Report the results.
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_CHECK_FLOW_" + solenoid + "_PUMP_ERROR", pumpErrorState.ToString() ) );
// TODO - we should rename the translation string so that it's prefixed with "CHECK_FLOW" instead of "SOLENOID_FLOW"
ReportDiagnostic(details, details.GetText("SOLENOID_PUMP_ERROR_" + solenoid), pumpErrorState.ToString(), (pumpErrorState == 1));
// Stop the pump and close the solenoid
Pump.CloseValve(solenoid);
Pump.DoCheckFlow = false;
}
/// <summary>
/// Check if pump works properly.
/// </summary>
/// <remarks>
/// Engineering Notes: This step is to check if pump works properly.
/// Run pump at two different control voltages, check the flow rate difference between these two cases.
/// </remarks>
/// <param name="details">The string to hold details.</param>
private void TestPump(DetailsBuilder details)
{
// Find a port without a gas cylinder connected.
// If all ports are connected, skip this test.
DockingStation ds = Controller.GetDockingStation();
// First, see if port one is unconnected or is providing FRESH AIR
// Note: we are trying ports in the order of 3-2-1 so as to avoid pulling air through the filter, if possible.
int testPort = -1;
GasEndPoint gasEndPoint = null;
for ( int solenoid = Configuration.DockingStation.NumGasPorts; solenoid >= 1 && testPort <= 0; solenoid-- )
{
gasEndPoint = ds.GasEndPoints.Find(m => m.Position == solenoid);
if (gasEndPoint == null || gasEndPoint.Cylinder.IsFreshAir)
testPort = solenoid;
}
if (testPort <= 0)
{
Log.Debug("TestPump: could not find open solenoid; this test will be skipped.");
return;
}
// Open solenoid valve determined to be unconnected
Pump.CloseAllValves( true );
Thread.Sleep(500); // Give the valves a chance to finish closing
Pump.OpenValve(testPort, false);
// Start pump with pump voltage of 80
Pump.Start(80);
// Wait 3 seconds
Thread.Sleep(3000);
// Read flow 1
ushort flowCount1 = Pump.GetRawFlow();
ushort flowVolts1 = Pump.ConvertRawFlowToVolts( flowCount1 );
ushort vacuumCounts1 = Pump.GetRawVacuum();
int flowRate1 = Pump.CalculateFlowRate( flowVolts1, vacuumCounts1 );
string flowString1 = BuildFlowString(flowCount1, flowRate1, flowVolts1);
// Increase pump voltage to 240
Pump.SetNewPumpVoltage(240);
// Wait 3 seconds
Thread.Sleep(3000);
// Check Pump Error status
int pumpErrorState = Pump.GetPumpErrorState();
// Fail if state is 1
_gdpList.Add(new GeneralDiagnosticProperty("DIAGNOSTIC_PUMP_ERROR_STATUS", pumpErrorState.ToString()));
ReportDiagnostic(details, DiagnosticResources.PUMP_ERROR_STATUS, pumpErrorState.ToString(), (pumpErrorState == 1));
// Read flow 2
ushort flowCount2 = Pump.GetRawFlow();
ushort flowVolts2 = Pump.ConvertRawFlowToVolts( flowCount2 );
ushort vacuumCounts2 = Pump.GetRawVacuum();
int flowRate2 = Pump.CalculateFlowRate( flowVolts2, vacuumCounts2 );
string flowString2 = BuildFlowString(flowCount2, flowRate2, flowVolts2);
// Fail if f2 - f1 < 100 OR f2 - f1 > 450
_gdpList.Add(new GeneralDiagnosticProperty("DIAGNOSTIC_PUMP_F1", flowCount1.ToString()));
_gdpList.Add(new GeneralDiagnosticProperty("DIAGNOSTIC_PUMP_F2", flowCount2.ToString()));
ReportDiagnostic(details, DiagnosticResources.PUMP, flowString1, flowString2, ( flowCount2 - flowCount1 < 100 ) || ( flowCount2 - flowCount1 > 450 ) );
// Stop the pump and close the port used for this test
Pump.CloseValve(testPort);
Thread.Sleep(500);
}
/// <summary>
/// Check for leaks.
/// </summary>
/// <remarks>
/// This is to check if the components in the closed gas delivery system work properly including
/// tubing, 3 solenoid valves, manifolds, check valves, vacuum sensor, flow sensor and pump.
/// The pump failure to operate could also cause this test to fail.
/// If a leakage is found, flow check will be meaningless.
/// </remarks>
/// <param name="details">The details to fill in.</param>
private void TestForLeak(DetailsBuilder details)
{
Pump.CloseAllValves( true );
Thread.Sleep( 500 ); // Give the valves a chance to finish closing
int pumpVoltage = 80; // initial voltage for leak test
bool leakCheck1Failed = true;
ushort vac1Raw;
double vac1Inches;
string vac1String;
const int maxPumpVoltage = 120;
const ushort rawInches40 = 360;
const int inches40 = 40;
const int pumpVoltageIncrement = 10;
//const ushort rawInches55 = 466;
//const int inches55 = 55;
Pump.Start( pumpVoltage ); // start pump with initial voltage
//Suresh 19-JUNE-2012 INS-3067
do
{
// After changing pump voltage, always wait 1 second before reading
// vacuum sensor to give the sensor time to adjust to the change.
Thread.Sleep( 1000 );
// Take vacuum reading (vac1)
vac1Raw = Pump.GetRawVacuum();
vac1Inches = Pump.ConvertRawVacuumToInches( vac1Raw );
vac1String = BuildCountAndUnitString( vac1Raw, vac1Inches, 1, "\"" );
Log.Debug( string.Format( "Vacuum: {0}, Pump voltage: {1}", vac1String, pumpVoltage ) );
// Check vacuum reading against target pressure. Pass after we reach or exceed target.
if ( vac1Raw >= rawInches40 )
{
// Pass if vac1 >= 40 inches of water
leakCheck1Failed = false;
Log.Debug( string.Format( "Leak Check 1 PASSED. (vacuum exeeds {0}\")", inches40 ) );
break;
}
if ( pumpVoltage + pumpVoltageIncrement >= maxPumpVoltage )// if the pump voltage crests above 120
{
Log.Debug( string.Format( "Leak Check 1 FAILED (pump voltage exeeds {0} but vacuum under {1}\")", maxPumpVoltage, inches40 ) );
break;
}
pumpVoltage += pumpVoltageIncrement;
Pump.SetNewPumpVoltage( (byte)pumpVoltage ); // set the new voltage to pump
} while ( true );
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_LEAK_CHECK_VAC1", vac1Raw.ToString() ) );
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_LEAK_CHECK_VAC1_INCHES", vac1Inches.ToString() ) );
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_LEAK_CHECK_VAC1_PASSED", (!leakCheck1Failed).ToString() ) );
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_LEAK_CHECK_VAC1_PUMP_VOLTAGE", pumpVoltage.ToString() ) );
ReportDiagnostic( details, DiagnosticResources.LEAK_CHECK_1, vac1String, leakCheck1Failed );
int vacuumError = Pump.GetVacuumErrorState(); // Check status of Vacuum Error by calling GetVacuumErrState()
_gdpList.Add( new GeneralDiagnosticProperty( "DIAGNOSTIC_LEAK_CHECK_VAC_ERROR", vacuumError.ToString() ) );
//Pass no matter what the state is [Vacuum Error Status]. The purpose is to keep the data structure of the report same as previous version.
ReportDiagnostic( details, DiagnosticResources.VACUUM_ERROR_STATUS, vacuumError.ToString(), false );
// Stop pump
Pump.Stop();
//Open Solenoid #1 for 1 second to relieve the pressure
Pump.OpenValve( 1, false );
Thread.Sleep( 1000 ); // 1 sec
Pump.CloseValve( 1 );
}
