using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Runtime.InteropServices;
|
using System.Text;
|
|
namespace OpenTap
|
{
|
|
/// <summary> Implements Visa SCPI IO. </summary>
|
class ScpiIO : IScpiIO3
|
{
|
private bool sendEnd = true;
|
private int lockTimeout = 5000;
|
private int ioTimeout = 2000;
|
private byte termChar = 10;
|
private bool useTermChar = false;
|
|
private int rm = Visa.VI_NULL;
|
private int instrument = Visa.VI_NULL;
|
|
private bool IsConnected { get { return instrument != Visa.VI_NULL; } }
|
public int ID => instrument;
|
public event ScpiIOSrqDelegate SRQ
|
{
|
add
|
{
|
lock (srqLock)
|
{
|
try
|
{
|
srqListeners.Add(value);
|
if ((srqListeners.Count == 1) && IsConnected)
|
EnableSRQ();
|
}
|
catch
|
{
|
srqListeners.Remove(value);
|
if (srqListeners.Count == 0)
|
DisableSRQ();
|
throw;
|
}
|
}
|
}
|
|
remove
|
{
|
lock (srqLock)
|
{
|
srqListeners.Remove(value);
|
if ((srqListeners.Count == 0) && IsConnected)
|
DisableSRQ();
|
}
|
}
|
}
|
private void RaiseError(int error)
|
{
|
if (error < 0)
|
throw new VISAException(ID, error);
|
}
|
private void invokeSrqListeners()
|
{
|
var listeners = srqListeners.ToList();
|
foreach (var l in listeners)
|
{
|
try
|
{
|
l.Invoke(this);
|
}
|
catch (Exception ex)
|
{
|
log.Error($"Unhandled exception in SRQ listener '{l.GetType().FullName}': {ex.Message}");
|
log.Debug(ex);
|
}
|
}
|
}
|
|
private GCHandle srqDelegateHandle;
|
private static readonly TraceSource log = Log.CreateSource("SCPI");
|
void EnableSRQ()
|
{
|
// We pass this delegate into unmanaged code, so we need to ensure it will not be garbage collected.
|
// This use of GCAlloc is in line with Microsoft recommendations when passing references to unmanaged libraries.
|
// See the description of `GCHandleType.Normal' here:
|
// https://learn.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.gchandletype?view=net-9.0
|
// ... This enumeration member is useful when an unmanaged client holds the only reference,
|
// which is undetectable from the garbage collector, to a managed object.
|
|
if (!srqDelegateHandle.IsAllocated)
|
{
|
srqDelegateHandle = GCHandle.Alloc(new VisaFunctions.ViEventHandler((_, _, _, _) =>
|
{
|
try
|
{
|
invokeSrqListeners();
|
}
|
catch (Exception ex)
|
{
|
log.Error($"Unhandled exception during SRQ event: {ex.Message}");
|
log.Debug(ex);
|
}
|
return Visa.VI_SUCCESS;
|
}), GCHandleType.Normal);
|
}
|
RaiseError(Visa.viInstallHandler(instrument, Visa.VI_EVENT_SERVICE_REQ, (VisaFunctions.ViEventHandler)srqDelegateHandle.Target, 0));
|
RaiseError(Visa.viEnableEvent(instrument, Visa.VI_EVENT_SERVICE_REQ, Visa.VI_HNDLR, Visa.VI_NULL));
|
}
|
|
void DisableSRQ()
|
{
|
if (srqDelegateHandle.IsAllocated)
|
{
|
RaiseError(Visa.viDisableEvent(instrument, Visa.VI_EVENT_SERVICE_REQ, Visa.VI_ALL_MECH));
|
RaiseError(Visa.viUninstallHandler(instrument, Visa.VI_EVENT_SERVICE_REQ, null, 0));
|
|
srqDelegateHandle.Free();
|
srqDelegateHandle = default;
|
}
|
}
|
|
public void OpenSRQ()
|
{
|
lock (srqLock)
|
if (srqListeners.Count > 0)
|
EnableSRQ();
|
}
|
|
public void CloseSRQ()
|
{
|
lock (srqLock)
|
DisableSRQ();
|
}
|
|
private List<ScpiIOSrqDelegate> srqListeners = new List<ScpiIOSrqDelegate>();
|
private object srqLock = new object();
|
|
private ScpiIOResult MakeError(int result)
|
{
|
switch (result)
|
{
|
case Visa.VI_SUCCESS: return ScpiIOResult.Success;
|
case Visa.VI_SUCCESS_MAX_CNT: return ScpiIOResult.Success_MaxCount;
|
case Visa.VI_SUCCESS_TERM_CHAR: return ScpiIOResult.Success_TermChar;
|
|
case Visa.VI_ERROR_TMO: return ScpiIOResult.Error_Timeout;
|
case Visa.VI_ERROR_RSRC_LOCKED: return ScpiIOResult.Error_ResourceLocked;
|
case Visa.VI_ERROR_CONN_LOST: return ScpiIOResult.Error_ConnectionLost;
|
case Visa.VI_ERROR_RSRC_NFOUND: return ScpiIOResult.Error_ResourceNotFound;
|
}
|
|
if (result >= 0)
|
return ScpiIOResult.Success;
|
else
|
return ScpiIOResult.Error_General;
|
}
|
|
private void SyncSettings()
|
{
|
Visa.viSetAttribute(instrument, Visa.VI_ATTR_SEND_END_EN, (byte)(sendEnd ? 1 : 0));
|
Visa.viSetAttribute(instrument, Visa.VI_ATTR_TMO_VALUE, ioTimeout);
|
Visa.viSetAttribute(instrument, Visa.VI_ATTR_TERMCHAR, termChar);
|
Visa.viSetAttribute(instrument, Visa.VI_ATTR_TERMCHAR_EN, (byte)(useTermChar ? 1 : 0));
|
}
|
|
public ScpiIOResult Open(string visaAddress, bool exclusiveLock)
|
{
|
if (instrument != Visa.VI_NULL)
|
throw new Exception("IO is already open");
|
var res2 = Visa.viOpenDefaultRM(out rm);
|
if (res2 < 0) return MakeError(res2);
|
|
var res = Visa.viOpen(ScpiInstrument.GetResourceManager(), visaAddress, exclusiveLock ? Visa.VI_EXCLUSIVE_LOCK : Visa.VI_NO_LOCK, IOTimeoutMS, out instrument);
|
|
// Use sensible defaults
|
sendEnd = true;
|
useTermChar = false;
|
|
if (res >= 0)
|
SyncSettings();
|
else
|
instrument = Visa.VI_NULL;
|
|
return MakeError(res);
|
}
|
|
public ScpiIOResult Close()
|
{
|
try
|
{
|
return MakeError(Visa.viClose(instrument));
|
}
|
finally
|
{
|
Visa.viClose(rm);
|
instrument = Visa.VI_NULL;
|
}
|
}
|
|
public bool SendEnd
|
{
|
get => sendEnd;
|
set
|
{
|
if (sendEnd != value)
|
{
|
sendEnd = value;
|
if (IsConnected) Visa.viSetAttribute(instrument, Visa.VI_ATTR_SEND_END_EN, (byte)(value ? 1 : 0));
|
}
|
}
|
}
|
public int IOTimeoutMS
|
{
|
get => ioTimeout;
|
set
|
{
|
if (ioTimeout != value)
|
{
|
ioTimeout = value;
|
if (IsConnected) Visa.viSetAttribute(instrument, Visa.VI_ATTR_TMO_VALUE, ioTimeout);
|
}
|
}
|
}
|
public int LockTimeoutMS
|
{
|
get { return lockTimeout; }
|
set { lockTimeout = value; }
|
}
|
public byte TerminationCharacter
|
{
|
get => termChar;
|
set
|
{
|
if (termChar != value)
|
{
|
termChar = value;
|
if (IsConnected) Visa.viSetAttribute(instrument, Visa.VI_ATTR_TERMCHAR, value);
|
}
|
}
|
}
|
public bool UseTerminationCharacter
|
{
|
get => useTermChar;
|
set
|
{
|
if (useTermChar != value)
|
{
|
useTermChar = value;
|
if (IsConnected) Visa.viSetAttribute(instrument, Visa.VI_ATTR_TERMCHAR_EN, (byte)(value ? 1 : 0));
|
}
|
}
|
}
|
|
public string ResourceClass
|
{
|
get
|
{
|
var sb = new StringBuilder();
|
Visa.viGetAttribute(instrument, Visa.VI_ATTR_RSRC_CLASS, sb);
|
return sb.ToString();
|
}
|
}
|
|
public ScpiIOResult DeviceClear()
|
{
|
return MakeError(Visa.viClear(instrument));
|
}
|
|
public ScpiIOResult Lock(ScpiLockType lockType, string sharedKey = null)
|
{
|
var sb = new StringBuilder();
|
return MakeError(Visa.viLock(instrument, lockType == ScpiLockType.Exclusive ? Visa.VI_EXCLUSIVE_LOCK : Visa.VI_SHARED_LOCK, LockTimeoutMS, sharedKey, sb));
|
}
|
|
public ScpiIOResult Read(ArraySegment<byte> buffer, int count, ref bool eoi, ref int read)
|
{
|
var res = Visa.viRead(instrument, buffer, count, out read);
|
eoi = (res == Visa.VI_SUCCESS);
|
return MakeError(res);
|
}
|
|
public ScpiIOResult ReadSTB(ref byte stb)
|
{
|
short statusByte = 0;
|
var res = Visa.viReadSTB(instrument, ref statusByte);
|
stb = (byte)statusByte;
|
return MakeError(res);
|
}
|
|
public ScpiIOResult Unlock()
|
{
|
return MakeError(Visa.viUnlock(instrument));
|
}
|
|
public ScpiIOResult Write(ArraySegment<byte> buffer, int count, ref int written)
|
{
|
return MakeError(Visa.viWrite(instrument, buffer, count, out written));
|
}
|
|
public ScpiIOResult EnableEvent(ScpiEvent eventType, ScpiEventMechanism mechanism)
|
{
|
return MakeError(Visa.viEnableEvent(instrument, (int)eventType, (short)mechanism, Visa.VI_NULL));
|
}
|
|
public ScpiIOResult DisableEvent(ScpiEvent eventType, ScpiEventMechanism mechanism)
|
{
|
return MakeError(Visa.viDisableEvent(instrument, (int)eventType, (short)mechanism));
|
}
|
|
public ScpiIOResult WaitOnEvent(ScpiEvent eventType, int timeout, out ScpiEvent outEventType)
|
{
|
var result = Visa.viWaitOnEvent(instrument, (int)eventType, timeout, out int outEvent, IntPtr.Zero);
|
outEventType = (ScpiEvent)outEvent;
|
return MakeError(result);
|
}
|
}
|
}
|
