/// <summary> /// Clears the SiteScan Diag counters /// </summary> // Revision History // MM/DD/YY Who Version ID Number Description // -------- --- ------- -- ------ ------------------------------------------- // 09/17/09 RCG 2.30.00 Created // 09/19/14 jrf 4.00.63 WR 534158 Modified way the test details are set. private void ClearSiteScanDiagCounts() { ItronDeviceResult Result = ItronDeviceResult.ERROR; ISiteScan SiteScanDevice = m_AmiDevice as ISiteScan; bool bSkipped = SiteScanDevice == null; string strReason = ""; string strDetails = ""; if (IsAborted == false) { if (bSkipped == false) { Result = SiteScanDevice.ResetDiagCounters(); strReason = DetermineReason(Result); strDetails = GetClearDetails(Result == ItronDeviceResult.SUCCESS); } else { strReason = TestResources.ReasonSiteScanNotSupported; strDetails = TestResources.ReasonSiteScanNotSupported; } AddTestDetail(TestResources.ClearSiteScanDiagnosticCounts, GetResultString(bSkipped, Result == ItronDeviceResult.SUCCESS), strDetails, strReason); } }
/// <summary> /// This method a 4 byte floating point BCD value from an SCS device. /// </summary> /// <exception cref="SCSException"> /// Thrown when the value cannot be retreived from the meter. /// </exception> /// <remarks > /// MM/DD/YY who Version Issue# Description /// -------- --- ------- ------ --------------------------------------- /// 01/26/07 KRC 8.00.09 Adding Edit Registers /// </remarks> virtual internal ItronDeviceResult SetFloatingBCDValue(int nBasepageAddress, int nLength, string strValue) { ItronDeviceResult Result = ItronDeviceResult.SUCCESS; byte[] byBCDValue; double dblValue; // Get the double out of the string (This allows us to format the value as needed when doing the conversion) dblValue = double.Parse(strValue, CultureInfo.CurrentCulture); byBCDValue = BCD.DoubleToFloatingBCD(dblValue, nLength); // Now that we have the byte array, we can send it to the meter. SCSProtocolResponse ProtocolResponse = m_SCSProtocol.Download(nBasepageAddress, nLength, ref byBCDValue); if (SCSProtocolResponse.SCS_CAN == ProtocolResponse) { Result = ItronDeviceResult.SECURITY_ERROR; } else if (SCSProtocolResponse.SCS_NAK == ProtocolResponse) { Result = ItronDeviceResult.ERROR; } return(Result); }
/// <summary> /// This method sets the RFLAN utility ID without writing to mfg. table 13 and /// causing a 3-button reset. /// </summary> // Revision History // MM/DD/YY who Version Issue# Description // -------- --- ------- ------ --------------------------------------- // 07/10/13 jrf 2.71.01 417021 Created // public ItronDeviceResult SetRFLANUtilityID(byte byUtilityID) { ItronDeviceResult Result = ItronDeviceResult.ERROR; bool blnUtilityIDSet = false; //Either or both mfg. table 65/73 must be updated if (null != Table2113) { Table2113.UtilityID = byUtilityID; blnUtilityIDSet = true; } if (null != Table2121) { Table2121.UtilityID = byUtilityID; blnUtilityIDSet = true; } //Utility ID portion of native address must be updated. if (null != Table122) { Table122.UtilityID = byUtilityID; } else { blnUtilityIDSet = false; } if (true == blnUtilityIDSet) { Result = m_AMIDevice.ResetRFLAN(); } return(Result); }
/// <summary> /// Clears the demand reset count /// </summary> // Revision History // MM/DD/YY Who Version ID Number Description // -------- --- ------- -- ------ ------------------------------------------- // 09/17/09 RCG 2.30.00 Created // 09/19/14 jrf 4.00.63 WR 534158 Modified way the test details are set. private void ClearDemandResetCount() { ItronDeviceResult Result = m_AmiDevice.ResetNumberDemandResets(); if (IsAborted == false) { AddTestDetail(TestResources.ClearDemandResetCount, GetResultString(Result == ItronDeviceResult.SUCCESS), GetClearDetails(Result == ItronDeviceResult.SUCCESS), DetermineReason(Result)); } }
/// <summary> /// Writes a Cum Value to the meter /// </summary> /// <param name="device">Device we are talking to</param> /// <param name="strValue">The value to set into the meter</param> /// <returns>ItronDeviceResult</returns> /// <remarks > /// MM/DD/YY who Version Issue# Description /// -------- --- ------- ------ --------------------------------------- /// 01/30/07 KRC 8.09.00 N/A Getting Edit Registers working /// </remarks> protected ItronDeviceResult SetCumulativeValue(ref SCSDevice device, string strValue) { ItronDeviceResult Result = ItronDeviceResult.SUCCESS; if (RegisterType == 0x00 || RegisterType == 0x02 || RegisterType == 0x03) { Result = device.SetFloatingBCDValue(device.TranslateDisplayAddress(this), 4, strValue); } else if (RegisterType == 0x07) { Result = device.SetFloatingBCDValue(device.TranslateDisplayAddress(this), 3, strValue); } return(Result); }
/// <summary> /// Writes an Energy Value to the meter /// </summary> /// <param name="device">Device we are talking to</param> /// <param name="strValue">The value to set into the meter</param> /// <returns>ItronDeviceResult</returns> /// <remarks > /// MM/DD/YY who Version Issue# Description /// -------- --- ------- ------ --------------------------------------- /// 01/30/07 KRC 8.09.00 N/A Getting Edit Registers working /// </remarks> protected ItronDeviceResult SetEnergyValue(ref SCSDevice device, string strValue) { ItronDeviceResult Result = ItronDeviceResult.SUCCESS; if (RegisterType == 0x00 || RegisterType == 0x02 || RegisterType == 0x03) { Result = device.SetFixedBCDValue(device.TranslateDisplayAddress(this), 4, 7, strValue); } else { Result = ItronDeviceResult.ERROR; } return(Result); }
/// <summary> /// Writes a new values to the meter for registers that appear on the display. /// </summary> /// <param name="device"></param> /// <returns>ItronDeviceResult</returns> public ItronDeviceResult WriteNewValue(SCSDevice device) { ItronDeviceResult Result = ItronDeviceResult.SUCCESS; if (true == Editable) { // The value is editable so there may be a value. If the value is null or empty then don't bother if (null != Value && "" != Value) { Result = SetDisplayItemValue(ref device); } } return(Result); }
/// <summary> /// Writes a Cum Value to the meter /// </summary> /// <param name="device">Device we are talking to</param> /// <param name="strValue">The value to set into the meter</param> /// <returns>ItronDeviceResult</returns> /// <remarks > /// MM/DD/YY who Version Issue# Description /// -------- --- ------- ------ --------------------------------------- /// 01/31/07 KRC 8.00.10 N/A Getting Edit Registers working /// </remarks> override protected ItronDeviceResult SetCCumValue(ref SCSDevice device, string strValue) { ItronDeviceResult Result = ItronDeviceResult.SUCCESS; if (RegisterType == 0) // current season { Result = device.SetFloatingBCDValue(device.TranslateDisplayAddress(this), 4, strValue); } else if (RegisterType == 7) // last season { Result = device.SetFloatingBCDValue(device.TranslateDisplayAddress(this), 3, strValue); } return(Result); }
/// <summary> /// SetDisplayvalue - Determines the type of register this display item is /// and writes the updated value to the meter. /// </summary> /// <param name="device"></param> /// <returns>ItronDeviceResult</returns> /// <remarks > /// MM/DD/YY who Version Issue# Description /// -------- --- ------- ------ --------------------------------------- /// 01/30/07 KRC 8.09.00 N/A Supporting Edit Registers /// </remarks> private ItronDeviceResult SetDisplayItemValue(ref SCSDevice device) { ItronDeviceResult Result = ItronDeviceResult.SUCCESS; switch (RegisterClass) { case SCSDisplayClass.EnergyValue: { if (device.EnergyFormat.Units == SCSDisplayFormat.DisplayUnits.Units) { m_strValue = MoveDecimalToTheLeft(m_strValue, 3, device.EnergyFormat.NumDecimalDIgits); } Result = SetEnergyValue(ref device, m_strValue); break; } case SCSDisplayClass.MaxDemandValue: { if (device.DemandFormat.Units == SCSDisplayFormat.DisplayUnits.Units) { m_strValue = MoveDecimalToTheLeft(m_strValue, 3, device.DemandFormat.NumDecimalDIgits); } Result = SetMaxDemandValue(ref device, m_strValue); break; } case SCSDisplayClass.CumulativeValue: case SCSDisplayClass.TotalContinuousCumulativeValue: case SCSDisplayClass.TOUContinuousCumulativeValue: { if (device.CumulativeFormat.Units == SCSDisplayFormat.DisplayUnits.Units) { m_strValue = MoveDecimalToTheLeft(m_strValue, 3, device.CumulativeFormat.NumDecimalDIgits); } Result = SetCumulativeValue(ref device, m_strValue); break; } default: // We need to investigate why this got called. Result = ItronDeviceResult.UNSUPPORTED_OPERATION; break; } return(Result); }
/// <summary> /// Sets the cell switch parameter selection in the expansion control bits of mfg table 73. /// We want to set bits 4 and 5 in the expansion control bits byte and leave the rest of the /// bits unchanged. Of the 4 possible combinations, only 2 and 3 should be allowed. Other /// values have not been tested. /// Hysteresis=400;Level=0;GPD=0;CSI=128 (00) /// Hysteresis=500;Level=64;GPD=1;CSI=128 (01) /// Hysteresis=400;Level=64;GPD=1;CSI=128 (10) /// Hysteresis=400;Level=0;GPD=1;CSI=128 (11) /// </summary> /// <param name="byCellSwitchParamByte">cell switch parameter value. Only 2 and 3 are allowed</param> /// <returns></returns> // Revision History // MM/DD/YY Who Version ID Issue# Description // -------- --- ------- -- ------ ------------------------------------------- // 06/30/14 AF 3.51.01 WR 518450 Created // public ItronDeviceResult SetRFLANLevel(byte byCellSwitchParamByte) { ItronDeviceResult Result = ItronDeviceResult.ERROR; byte byExpansionControlBitsMask = 0xCF; // 11001111 byte byExpansionControlBits = 0; if (null != Table2121) { byExpansionControlBits = Table2121.ExpansionControlBits; byExpansionControlBits &= byExpansionControlBitsMask; // Clear out the cell switch parameter selection byExpansionControlBits |= (byte)(byCellSwitchParamByte << 4); // Replace the cell switch parameter selection with the desired value Table2121.ExpansionControlBits = byExpansionControlBits; Result = m_AMIDevice.ResetRFLAN(); } return(Result); }
/// <summary> /// Determines the reason for a failure /// </summary> /// <param name="result">The result</param> /// <returns>The reason for the failure</returns> // Revision History // MM/DD/YY Who Version Issue# Description // -------- --- ------- ------ ------------------------------------------- // 09/17/09 RCG 2.30.00 Created protected string DetermineReason(ItronDeviceResult result) { string strResult = ""; switch (result) { case ItronDeviceResult.SECURITY_ERROR: { strResult = TestResources.ReasonSecurityError; break; } case ItronDeviceResult.UNSUPPORTED_OPERATION: { strResult = TestResources.ReasonOperationNotSupported; break; } } return(strResult); }
/// <summary> /// Clears the sitescan snapshots in the meter. This is not supported by /// the Vectron. /// </summary> /// <returns>A ItronDeviceResult</returns> // Revision History // MM/DD/YY Who Version Issue# Description // -------- --- ------- ------ --------------------------------------------- // 02/21/07 mrj 8.00.13 Created // ItronDeviceResult ISiteScan.ClearSiteScanSnapshots() { ItronDeviceResult Result = ItronDeviceResult.SUCCESS; ProcedureResultCodes ProcResult = ProcedureResultCodes.INVALID_PARAM; byte[] ProcParam; byte[] ProcResponse; ProcParam = new byte[0]; // No parameters for this procedure ProcResult = ExecuteProcedure(Procedures.CLEAR_SITESCAN_SNAPSHOTS, ProcParam, out ProcResponse); switch (ProcResult) { case ProcedureResultCodes.COMPLETED: { //Success Result = ItronDeviceResult.SUCCESS; break; } case ProcedureResultCodes.NO_AUTHORIZATION: { //Isc error Result = ItronDeviceResult.SECURITY_ERROR; break; } default: { //General Error Result = ItronDeviceResult.ERROR; break; } } return(Result); }
/// <summary> /// Implements the ISiteScan interface. Resets the diagnostic counters /// </summary> /// Revision History /// MM/DD/YY who Version Issue# Description /// -------- --- ------- ------ --------------------------------------- /// 05/24/06 mrj 7.30.00 N/A Created /// ItronDeviceResult ISiteScan.ResetDiagCounters() { ItronDeviceResult Result = ItronDeviceResult.ERROR; byte[] ProcResponse; ProcedureResultCodes ProcResult = ProcedureResultCodes.INVALID_PARAM; //Execute the reset conters MFG procedure byte[] byParameter = BitConverter.GetBytes((uint)Reset_Counter_Types.RESET_NUM_DIAG_COUNTERS); ProcResult = ExecuteProcedure(Procedures.RESET_COUNTERS, byParameter, out ProcResponse); switch (ProcResult) { case ProcedureResultCodes.COMPLETED: { //Success Result = ItronDeviceResult.SUCCESS; break; } case ProcedureResultCodes.NO_AUTHORIZATION: { //Isc error Result = ItronDeviceResult.SECURITY_ERROR; break; } default: { //General Error Result = ItronDeviceResult.ERROR; break; } } return(Result); }
/// <summary> /// This method sets a continuous cummulative demand value to the meter /// /// </summary> /// <returns></returns> /// <remarks > /// MM/DD/YY who Version Issue# Description /// -------- --- ------- ------ --------------------------------------- /// 01/31/07 KRC 8.00.10 N/A Support for Edit Registers /// </remarks> virtual protected ItronDeviceResult SetCCumValue(ref SCSDevice device, string strValue) { ItronDeviceResult Result = ItronDeviceResult.SUCCESS; return(Result); }
/// <summary> /// This method updates the IO configuration in the meter. /// </summary> /// <param name="IOConfig">KYZ configuration data object.</param> /// <returns>The result of the configuration.</returns> // Revision History // MM/DD/YY who Version Issue# Description // -------- --- ------- ------ --------------------------------------- // 04/22/09 jrf 2.20.02 n/a Created // 04/19/10 AF 2.40.39 Made virtual for M2 Gateway override // 07/08/10 jrf 2.42.02 157552 Setting the CPC reset bit on close config to fix // LED lock issue. // public virtual ItronDeviceResult ConfigureIO(KYZData IOConfig) { byte[] ProcParam = new byte[0]; byte[] ProcResponse; ProcedureResultCodes ProcResult = ProcedureResultCodes.INVALID_PARAM; PSEMResponse Result = PSEMResponse.Err; ItronDeviceResult ConfigResult = ItronDeviceResult.ERROR; CTable2048_OpenWay OW2048 = Table2048 as CTable2048_OpenWay; CENTRON_AMI_IOConfig IOTable = OW2048.IOConfig as CENTRON_AMI_IOConfig; // Open the Config ProcResult = ExecuteProcedure(Procedures.OPEN_CONFIG_FILE, ProcParam, out ProcResponse); // Execute Write of IO Table in 2048 if (ProcedureResultCodes.COMPLETED == ProcResult) { IOTable.IOData = IOConfig; Result = IOTable.Write(); } else if (ProcedureResultCodes.NO_AUTHORIZATION == ProcResult) { Result = PSEMResponse.Isc; } else { m_Logger.WriteLine(Logger.LoggingLevel.Detailed, "Open config procedure failed with result = " + ProcResult); Result = PSEMResponse.Err; } if (Result == PSEMResponse.Ok) { // Close the Config // Data reset bits - we don't want to reset any data, so // just initialize them to 0 ProcParam = new byte[4]; ProcParam.Initialize(); // Okay we do want to reset data if we are a HW2.0 Poly. Need to do this to // prevent the worm on the display from freezing. if (0 == VersionChecker.CompareTo(HWRevisionFiltered, HW_VERSION_2_5) || 0 == VersionChecker.CompareTo(HWRevisionFiltered, HW_VERSION_2_6)) { //We need to reset CPC MemoryStream ParamStream = new MemoryStream(ProcParam); BinaryWriter BinWriter = new BinaryWriter(ParamStream); BinWriter.Write((uint)CloseConfigOptions.CPC); } ProcResult = ExecuteProcedure(Procedures.CLOSE_CONFIG_FILE, ProcParam, out ProcResponse); if (ProcedureResultCodes.COMPLETED != ProcResult) { ConfigResult = ItronDeviceResult.ERROR; } else { ConfigResult = ItronDeviceResult.SUCCESS; } } else { if (Result == PSEMResponse.Isc) { ConfigResult = ItronDeviceResult.SECURITY_ERROR; } else { ConfigResult = ItronDeviceResult.ERROR; } } return(ConfigResult); }
/// <summary> /// This method executes the enter/exit test mode. /// </summary> /// <param name="modeType">TestMode Type</param> /// <param name="timeInTestMode">time for the meter to remain in test minutes</param> /// <param name="pulseWeight">actual test mode kh</param> /// /// <param name="pulseQuantity">Quantity to be measured in test mode</param> /// <returns>The result of the test mode operation.</returns> // MM/DD/YY who Version Issue# Description // -------- --- ------- -------- --------------------------------------- // 06/23/17 CFB 4.72.02 WR767058 Created // public virtual ItronDeviceResult EnterExitTestMode(TestMode modeType, byte timeInTestMode, float pulseWeight, uint pulseQuantity) { ItronDeviceResult Result = ItronDeviceResult.ERROR; ProcedureResultCodes ProcResult = ProcedureResultCodes.INVALID_PARAM; byte[] ProcParam = new byte[8]; OpenWayMFGTable2170 Table2170 = new OpenWayMFGTable2170(m_PSEM, Table00); byte[] ProcResponse; PSEMBinaryWriter PSEMWriter = new PSEMBinaryWriter(new MemoryStream(ProcParam)); bool blnWaitResponse = true; int iSeconds = 0; //Pulse Weight Test value should be in increments of 0.025 so multiply by 40 float fPulseWeightParam = pulseWeight * 40; PSEMWriter.Write((byte)modeType); PSEMWriter.Write(timeInTestMode); PSEMWriter.Write(pulseQuantity); PSEMWriter.Write((ushort)fPulseWeightParam); ProcResult = ExecuteProcedure(Procedures.ENTER_EXIT_TEST_MODE, ProcParam, out ProcResponse); if (ProcedureResultCodes.COMPLETED == ProcResult) { if (TestMode.ENTER_TEST_MODE == modeType) { //If we are entering test mode then we will wait //while IsInTestMode property is false. blnWaitResponse = false; } while (blnWaitResponse == IsInTestMode && 5 > iSeconds) { //Check mode every 1 sec. for 5 sec. System.Threading.Thread.Sleep(1000); iSeconds += 1; } } switch (ProcResult) { case ProcedureResultCodes.COMPLETED: { //Success Result = ItronDeviceResult.SUCCESS; break; } case ProcedureResultCodes.NO_AUTHORIZATION: { //Isc error Result = ItronDeviceResult.SECURITY_ERROR; break; } default: { //General Error Result = ItronDeviceResult.ERROR; break; } } return(Result); }
/// <summary> /// Implements the IConfiguration interface. Initializes the meter /// based on the given program name. /// </summary> /// <param name="strProgramName">The name of the program to use to /// initialize the meter</param> /// <returns>ConfigurationResult</returns> // Revision History // MM/DD/YY who Version Issue# Description // -------- --- ------- ------ ------------------------------------------- // 01/17/07 jrf 8.00 N/A Created // 01/25/07 jrf 8.00 N/A Modifed to reflect changes to IntializeDevice(), // now pass in optical probe and not device ID // 02/21/07 jrf 8.00.13 Updating the name of the namespace and class // for calling initialize device. // 03/28/07 jrf 8.00.23 2748 Determine from replica setting the reset billing // registers on initialization option and pass in // call to DeviceWrapper. // 04/11/06 jrf 8.00.29 2891 We need to set the baud rate when logging // back on after initialization otherwise // logging on at 4800 baud will fail. // public ConfigurationResult Configure(string strProgramName) { ConfigurationResult InitResult = ConfigurationResult.ERROR; ItronDeviceResult Result = ItronDeviceResult.ERROR; //Save off current communication information string strPortName = m_SCSProtocol.m_CommPort.PortName; uint uiPortNumber = 0; uint uiBaudRate = m_SCSProtocol.m_CommPort.BaudRate; OpticalProbeTypes OpticalProbe = m_SCSProtocol.m_CommPort.OpticalProbe; // Let the replica settings determine what we should do concerning // resetting billing registers CXMLFieldProSettings xmlFieldProSettings = new CXMLFieldProSettings("");; CXMLFieldProSettingsAllDevices.RESET_BILLING_REG_OPTIONS ResetBillingOption = xmlFieldProSettings.AllDevices.ResetBillingOnInit; //Before we logoff we need to get the security code, since it will //get cleared string strSecurityCode = m_strCurrentSecurityCode; //Convert the port name to port number string temp = strPortName.Remove(0, 3); temp = temp.TrimEnd(':'); uiPortNumber = Convert.ToUInt32(temp, CultureInfo.InvariantCulture); m_Logger.WriteLine(Logger.LoggingLevel.Functional, "Initializing Device"); //Logoff the current device Logoff(); //Close the port m_SCSProtocol.m_CommPort.ClosePort(); try { //Initialize device InitResult = (ConfigurationResult) Itron.Metering.DeviceWrapper.DeviceWrapper.InitializeDevice(strProgramName, MeterType, strSecurityCode, uiPortNumber, uiBaudRate, OpticalProbe, ResetBillingOption); } catch { InitResult = ConfigurationResult.ERROR; } switch (InitResult) { // For these errors, lets log back on so the user may continue case ConfigurationResult.MEMORY_ERROR: case ConfigurationResult.IO_ERROR: case ConfigurationResult.SECURITY_ERROR: case ConfigurationResult.UNSUPPORTED_FUNCTION: case ConfigurationResult.MISMATCH_ID: case ConfigurationResult.USER_ABORT: case ConfigurationResult.DB_ACCESS_ERROR: case ConfigurationResult.INVALID_CONFIG: case ConfigurationResult.MEMORY_MAP_ERROR: { //Need to do this so Logon will reissue Wakeup and Identify requests, otherwise //Security will fail. m_SCSProtocol.Identified = false; //Re-open the port m_SCSProtocol.m_CommPort.OpenPort(strPortName); //Set to the appropriate baud rate m_SCSProtocol.m_CommPort.BaudRate = uiBaudRate; if (MeterType == m_rmStrings.GetString("FULC_METER_NAME")) { //Fulcrum needs a few seconds to itself before allowing a logon //after a logoff Thread.Sleep(4000); } //Re-Logon to the meter Result = Logon(); if (ItronDeviceResult.SUCCESS == Result) { //Issue Security System.Collections.Generic.List <string> passwords = new System.Collections.Generic.List <string>(); //It should be cleared but just be be safe, clear out the current //security code so we will issue the command. m_strCurrentSecurityCode = null; passwords.Add(strSecurityCode); Result = Security(passwords); } if (ItronDeviceResult.SUCCESS != Result) { //We were not successful in logging back on so throw a timeout throw new TimeOutException(); } break; } default: { // Do nothing. Remain Logged off break; } } return(InitResult); }
/// <summary> /// Implements the ISiteScan interface. Resets the diagnostic counters /// </summary> /// <exception cref="SCSException"> /// Thrown when the diagnostic counters cannot be reset in the meter. /// </exception> /// MM/DD/YY who Version Issue# Description /// -------- --- ------- ------ --------------------------------------- /// 04/27/06 mrj 7.30.00 N/A Created /// 05/26/06 jrf 7.30.00 N/A Modified /// ItronDeviceResult ISiteScan.ResetDiagCounters() { ItronDeviceResult Result = ItronDeviceResult.SUCCESS; byte[] byDiagnostic1To4Counters = new byte[VEC_DIAGNOSTIC_1_TO_4_COUNTS_LENGTH]; byte[] byDiagnostic5Counters = new byte[VEC_DIAGNOSTIC_5_COUNTS_LENGTH]; SCSProtocolResponse ProtocolResponse = SCSProtocolResponse.NoResponse; int iExceptionAddress = (int)VECAddresses.DIAGNOSTICS_COUNTS; m_Logger.WriteLine( Logger.LoggingLevel.Functional, "Starting Reset Diagnositc Counters"); // Prepare arrays to reset all diagnostic counters byDiagnostic1To4Counters.Initialize(); byDiagnostic5Counters.Initialize(); m_Logger.WriteLine(Logger.LoggingLevel.Detailed, "Reset Diagnostic Counters 1-4"); // Reset diagnostic 1 to 4 counters ProtocolResponse = m_SCSProtocol.Download( (int)VECAddresses.DIAGNOSTICS_COUNTS, VEC_DIAGNOSTIC_1_TO_4_COUNTS_LENGTH, ref byDiagnostic1To4Counters); if (SCSProtocolResponse.SCS_ACK == ProtocolResponse) { m_Logger.WriteLine(Logger.LoggingLevel.Detailed, "Reset Diagnostic 5 Counters"); // Reset diagnostic 5 counters ProtocolResponse = m_SCSProtocol.Download( (int)VECAddresses.DIAGNOSTIC_5_COUNTS, VEC_DIAGNOSTIC_5_COUNTS_LENGTH, ref byDiagnostic5Counters); iExceptionAddress = (int)VECAddresses.DIAGNOSTIC_5_COUNTS; } if (SCSProtocolResponse.SCS_ACK == ProtocolResponse) { Result = ItronDeviceResult.SUCCESS; } else if (SCSProtocolResponse.SCS_CAN == ProtocolResponse) { Result = ItronDeviceResult.ERROR; } else if (SCSProtocolResponse.NoResponse == ProtocolResponse) { Result = ItronDeviceResult.ERROR; } else { SCSException objSCSException = new SCSException( SCSCommands.SCS_U, ProtocolResponse, iExceptionAddress, m_rmStrings.GetString("RESET_DIAG")); throw objSCSException; } return(Result); } //End ISiteScan.ResetDiagCounters()