Readout a Fluke oscilloscope via GPIB

#pragma TextEncoding = "Windows-1252"
#pragma rtGlobals=3     // Use modern global access method and strict wave access.
 
/// Acquire spectra from an oscilloscope
/// Tested with a Fluke PM3394B using a PCI GPIB card on Windows 7 and Igor Pro 7 beta
/// The oscilloscope understands SCPI, I've included some commands to add proper units
/// to the acquired data.
///
/// Steps:
/// - Connect oscilloscope
/// - Adapt board and device in Initialize()
/// - Call Initialize(), maybe even twice
/// - Call AcquireData()
/// - Voila!
 
Function/WAVE StringToBufferWave(str)
    string str
    
    Make/B/FREE/N=(strlen(str)) buf = char2num(str[p])
    
    return buf
End
 
Function/S BufferWavetoString(buf)
    Wave buf
    
    string str = ""
    str = PadString(str, DimSize(buf, 0), 0x0)
    variable i
 
    for(i = 0; i < DimSize(buf, 0); i+= 1)
        str[i] = num2char(buf[i])
    endfor
    
    return str
End
 
Function Send(str)
    string str
 
    NVAR gBoardID, gDeviceAddress
    Variable DABend = 0x02
 
    NI4882 Send={gBoardID,gDeviceAddress,StringToBufferWave(str),strlen(str),DABend}
    printf "V_iberr=%d\r", V_iberr 
End
 
Function/WAVE Receive()
 
    NVAR gBoardID, gDeviceAddress
    Variable STOPend = 0x100    // Means stop receiving when END is asserted.
 
    Make/B/U/FREE bufferWave
    NI4882 Receive={gBoardID,gDeviceAddress,bufferWave,100000,STOPend}  // Read 1000 bytes or until END is asserted.
    printf "V_iberr=%d\r", V_iberr
 
    return bufferWave   
End
 
Function Initialize()
    Variable/G gBoardID, gDeviceAddress, gDeviceDesc
    
    gBoardID = 0
    gDeviceAddress = 3
 
    NI4882 ibfind={"gpib0"}
    NI4882 ibcac={V_Flag, 1}
    NI4882 ibdev={gBoardID,gDeviceAddress,0,13,1,0}
    gDeviceDesc = V_Flag
End
 
Function AcquireData()
 
    variable ptPeak, voltOffset, sweepTime, tracePoints
    string str
 
    NVAR gBoardID, gDeviceAddress, gDeviceDesc
 
//  Send("*RST")
    Send("FORMat INTeger,16")
    Send("TRACe:POINts CH1,8192")
///  Only the following trace acquisition lengths can be programmed:
/// 512, 2024 (2K), 4096 (4K), 8192 (8K), 16384 (16K), or 32768 (32K)
    Send("TRIGger:SOURce INTernal1")
    Send("TRIGger:LEVel 0.1")
    Send("INITiate")
    Send("*WAI;TRACe? CH1")
    WAVE bufferWave = Receive()
 
    Duplicate/O bufferWave, root:bufferWave
    WAVE bufferWave
 
    ptPeak      = QueryNumericalValue("SENSe:VOLTage:RANGe:PTPeak?")
    voltOffset  = QueryNumericalValue("SENSe:VOLTage:RANGe:OFFSet?")
    sweepTime   = QueryNumericalValue("SENSe:SWEep:TIME?")
    tracePoints = QueryNumericalValue("TRACe:POINts? CH1")
    printf "ptPeak=%g, voltOffset=%g, sweepTime=%g, tracePoints=%g\r", ptPeak, voltOffset, sweepTime, tracePoints
    WAVE bufferWaveConv = ConvertFromOsziFormat(bufferWave, ptPeak, voltOffset, sweepTime, tracePoints)
    Duplicate/O bufferWaveConv, root:result
End
 
Function QueryNumericalValue(cmd)
    string cmd
 
    string str
 
    Send(cmd)
    WAVE bufferWave = Receive()
    str = BufferWavetoString(bufferWave)
    return str2num(str)
End
 
Function ASSERT(var, str)
    variable var
    string str
 
    try
        AbortOnValue !var, 0; AbortOnRTE
    catch
        printf "Assertion failed: %s\r", str
        Debugger
        Abort
    endtry
End
 
Function/WAVE ConvertFromOsziFormat(wv, ptPeak, voltageOffset, sweepTime, tracePoints)
    WAVE wv
    variable ptPeak, voltageOffset, sweepTime, tracePoints
 
    variable numDigitsSize, checksum, numTraceBytes, intWidth, numRows, i, traceByteOffset
    numRows = DimSize(wv, 0)
 
    ASSERT(numRows > 20, "Malformed data: Wave is too small")
    ASSERT(wv[0] == char2num("#"), "Malformed data: Expected # as first char")
    ASSERT(wv[numRows - 1] == char2num("\n"), "Malformed data: Expected \\n as last char")
 
    numDigitsSize = str2num(num2char(wv[1]))
    numTraceBytes = ExtractLength(wv, numDigitsSize)
    traceByteOffset = numDigitsSize + 3
    ASSERT(numRows == traceByteOffset + numTraceBytes, "Malformed data: Unexpected length")
 
    intWidth = wv[numDigitsSize + 2]
 
    ASSERT(tracePoints == (numTraceBytes - 2) / (intWidth / 8), "Malformed data: Length does not match requested length")
    printf "numDigitsSize=%g, numTraceBytes=%g, intWidth=%g\r", numDigitsSize, numTraceBytes, intWidth
 
    Make/D/FREE/N=(tracePoints) data
 
    for(i = traceByteOffset;i < traceByteOffset + numTraceBytes - 2; i += 1)
        checksum = mod(checksum + wv[i], 256)
    endfor
 
    ASSERT(checksum == mod(wv[numRows - 2] + 256, 256), "Malformed data: Checksum mismatch")
 
    switch(intWidth)
        case 8:
            MultiThread data = ConvertTraceByteToVoltage8Bit(wv[traceByteOffset + p], ptPeak, voltageOffset)
            break
        case 16:
            MultiThread data[0, tracePoints - 1] = ConvertTraceByteToVoltage16Bit(wv[traceByteOffset + p * 2],wv[traceByteOffset + p * 2 + 1], ptPeak, voltageOffset)
            break
        default:
            ASSERT(0, "Unexpected intWidth")
            break
    endswitch
 
    SetScale/P x, 0, sweepTime / (tracePoints - 1), "s", data
    SetScale d, 0, 0, "V", data
 
    return data
End
 
threadsafe Function ConvertTraceByteToVoltage8Bit(byte, ptPeak, voltageOffset)
    variable byte, ptPeak, voltageOffset
    
    variable value
 
    value = byte > 127 ? byte - 256 : byte
 
    return (value / 200) * ptPeak - voltageOffset
End
 
threadsafe Function ConvertTraceByteToVoltage16Bit(msbByte, lsbByte, ptPeak, voltageOffset)
    variable msbByte, lsbByte, ptPeak, voltageOffset
 
    variable value
 
    value = msbByte > 127 ? (msbByte - 256) * 256 + lsbByte : msbByte * 256 + lsbByte
 
    return (value / 51200) * ptPeak - voltageOffset
End
 
Function ExtractLength(wv, numDigitsSize)
    WAVE wv
    variable numDigitsSize
 
    variable i, length
 
    for(i = 0; i < numDigitsSize; i += 1)
        length += str2num(num2char(wv[2 + i])) * 10^(numDigitsSize - (1 + i))
    endfor
 
    return length
End