/// <summary> /// Writes calibration data to an instrument. /// </summary> /// <param name="appSettings">ApplicationSettings object.</param> /// <param name="gpibAddress">GPIB address of instrument.</param> /// <param name="sramData">256 byte array containing data to write to instrument SRAM.</param> static void WriteCalibration(ApplicationSettings appSettings, int gpibAddress, byte[] sramData) { // Check for valid data buffer if (sramData == null || sramData.Length != 256) { throw new ArgumentException("SRAM data buffer must contain 256 bytes.", "sramData"); } // Connect to GPIB adapter GPIBConnection gpibConn = new GPIBConnection(appSettings.SerialPortName, appSettings.SerialBaudRate, appSettings.SerialDataBits, appSettings.SerialParity, appSettings.SerialStopBits, appSettings.SerialFlowControl) { Timeout = appSettings.GPIBAdapterTimeout, GPIBAdapterVersionString = appSettings.GPIBAdapterVersionString, GPIBAddress = gpibAddress }; gpibConn.Connect(); try { // Test instrument communications string cmdResult = gpibConn.QueryInstrument("S"); if (cmdResult != "0" && cmdResult != "1") { throw new ApplicationException("Could not communicate with instrument."); } // Display "WRITING CAL" on instrument gpibConn.QueryInstrument("D2WRITING CAL", false); gpibConn.QueryInstrumentBinary(new byte[] { 0x1b, 0x0d }, 0); // Terminate D2 command // Setup command buffer to write calibration data. // // The first byte 'X' is the write SRAM command. // // The second and forth bytes are the ESC (ASCII 27) character // used to escape the following byte in order to ensure it gets // sent to the instrument and not consumed by the GPIB adapter. // // The third byte is the SRAM address to be written. // // The fifth byte is the SRAM data to be written. // // Notes: // - SRAM is 256 x 4 (256 4-bit nibbles). // // - X<addr><val> command is used to write SRAM nibbles where // <addr> is an SRAM address from 0-255 and <val> is the data // to be written. // // - The instrument ignores the upper four bits of the data byte. // For example, to write the value 0x5 to the instrument, // sending a data byte of 0x05 or 0x45 ('E') are both equivalent. // // - Only escaping CR, LF, ESC and '+' is required, but all // characters are escaped for simplicity. byte[] writeCmdBytes = new byte[5]; writeCmdBytes[0] = Convert.ToByte('X'); writeCmdBytes[1] = 0x1b; writeCmdBytes[2] = 0x00; writeCmdBytes[3] = 0x1b; writeCmdBytes[4] = 0x00; // Setup command buffer to read SRAM byte[] readCmdBytes = new byte[3]; readCmdBytes[0] = Convert.ToByte('W'); readCmdBytes[1] = 0x1b; readCmdBytes[2] = 0x00; // Write all 256 nibbles of SRAM byte[] sramBytes = new byte[256]; for (int i = 0; i < 256; i++) { // Send command to instrument writeCmdBytes[2] = (byte)i; writeCmdBytes[4] = sramData[i]; gpibConn.QueryInstrumentBinary(writeCmdBytes, 0); // Read value back for verification of successful write readCmdBytes[2] = (byte)i; byte[] recvByte = gpibConn.QueryInstrumentBinary(readCmdBytes, 1); // Verify correct nibble was read back from instrument if (recvByte == null || recvByte.Length != 1 || (recvByte[0] & 0x0f) != (sramData[i] & 0x0f)) { throw new ApplicationException("Failed while verifying calibration data in instrument SRAM."); } } // Return instrument to normal display gpibConn.QueryInstrument("D1", false); } finally { // Disconnect from GPIB adapter gpibConn.Disconnect(); } }
/// <summary> /// Reads calibration data from an instrument. /// </summary> /// <param name="appSettings">ApplicationSettings object.</param> /// <param name="gpibAddress">GPIB address of instrument.</param> /// <returns>256 byte array containing instrument SRAM data.</returns> static byte[] ReadCalibration(ApplicationSettings appSettings, int gpibAddress) { // Connect to GPIB adapter GPIBConnection gpibConn = new GPIBConnection(appSettings.SerialPortName, appSettings.SerialBaudRate, appSettings.SerialDataBits, appSettings.SerialParity, appSettings.SerialStopBits, appSettings.SerialFlowControl) { Timeout = appSettings.GPIBAdapterTimeout, GPIBAdapterVersionString = appSettings.GPIBAdapterVersionString, GPIBAddress = gpibAddress }; gpibConn.Connect(); byte[] sramBytes; try { // Test instrument communications string cmdResult = gpibConn.QueryInstrument("S"); if (cmdResult != "0" && cmdResult != "1") { throw new ApplicationException("Could not communicate with instrument."); } // Display "READING CAL" on instrument gpibConn.QueryInstrument("D2READING CAL", false); gpibConn.QueryInstrumentBinary(new byte[] { 0x1b, 0x0d }, 0); // Terminate D2 command // Setup command buffer to read calibration data. // // The first byte 'W' is the read SRAM command. // // The second byte is the ESC (ASCII 27) character used to escape // the following byte in order to ensure it gets sent to the // instrument and not consumed by the GPIB adapter. // // The third byte is the SRAM address to be read. // // Notes: // - SRAM is 256 x 4 (256 4-bit nibbles). // // - W<addr> command is used to read SRAM nibbles where <addr> // is an SRAM address from 0-255. // // - Nibbles are returned from the instrument with 0x40 added to // them to make them human readable ASCII. // For example, if the nibble value is 0x5, then 0x45 or 'E' // is the byte returned. // // - Only escaping CR, LF, ESC and '+' is required, but all // characters are escaped for simplicity. byte[] cmdBytes = new byte[3]; cmdBytes[0] = Convert.ToByte('W'); cmdBytes[1] = 0x1b; cmdBytes[2] = 0x00; // Read all 256 nibbles of SRAM sramBytes = new byte[256]; for (int i = 0; i < 256; i++) { // Send command to instrument cmdBytes[2] = (byte)i; byte[] recvByte = gpibConn.QueryInstrumentBinary(cmdBytes, 1); if (recvByte == null || recvByte.Length != 1) { throw new ApplicationException("Failed while reading calibration data from instrument SRAM."); } // Copy received byte to buffer sramBytes[i] = recvByte[0]; } // Return instrument to normal display gpibConn.QueryInstrument("D1", false); } finally { // Disconnect from GPIB adapter gpibConn.Disconnect(); } return(sramBytes); }