private void radioButtonLocalFolder_CheckedChanged(object sender, EventArgs e)
{
panelCamera.Enabled = false;
panelCamerapanelLocalFile.Enabled = false;
panelLocalFolder.Enabled = true;
mode = AcquisitionMode.FromFolder;
}
private void ShowAcqMode()
{
AcquisitionMode Mode = Newport.GetAcquisitionMode();
switch (Mode)
{
case AcquisitionMode.Continuous:
cmbAcqMode.SelectedIndex = 0;
break;
case AcquisitionMode.Single:
cmbAcqMode.SelectedIndex = 1;
break;
case AcquisitionMode.ContinuousPeakToPeak:
cmbAcqMode.SelectedIndex = 2;
break;
case AcquisitionMode.SinglePeakToPeak:
cmbAcqMode.SelectedIndex = 3;
break;
case AcquisitionMode.RMS:
cmbAcqMode.SelectedIndex = 4;
break;
default:
cmbAcqMode.SelectedIndex = -1;
break;
}
}
protected override void ChangeAcquisitionMode(AcquisitionMode mode)
{
if (Mode == AcquisitionMode.Ohmeter)
{
_ohmeterTimer.Change(Timeout.Infinite, -1);
}
base.ChangeAcquisitionMode(mode);
}
/// <summary>
/// Configures the HDC1000 Click for temperature, humidity acquisition.
/// </summary>
/// <param name="acquisitionMode">The <see cref="AcquisitionMode"/> for measurement.</param>
/// <param name="temperatureResolution">The <see cref="TemperatureResolution"/> for reading temperature data.</param>
/// <param name="humidityResolution">The <see cref="HumidityResolution"/> for reading humidity data.</param>
/// <param name="heatMode">The <see cref="HeaterMode"/> for enabling or disabling the on-board heater.</param>
/// <example>Example usage:
/// <code language = "C#">
/// _tempHumidity.Configure(Hdc1000Click.AcquisitionMode.Sequential, Hdc1000Click.TemperatureResolution.FourteenBit, Hdc1000Click.HumidityResolution.FourteenBit, Hdc1000Click.HeaterMode.Disabled);
/// </code>
/// </example>
public void Configure(AcquisitionMode acquisitionMode, TemperatureResolution temperatureResolution, HumidityResolution humidityResolution, HeaterMode heatMode)
{
_acquisitionMode = acquisitionMode;
Byte value = (Byte)((Byte)acquisitionMode | (Byte)temperatureResolution | (Byte)humidityResolution | (Byte)heatMode);
WriteRegister(ConfigRegister, value);
Thread.Sleep(15);
}
/// <summary>
/// Sets the acquisition mode.
/// </summary>
/// <param name="mode">The new required acquisition mode.</param>
/// <remarks>
/// Derived classes may override this function to customize how/when acquisition mode
/// is changed, features emulation should be done with <see cref="Feature"/> specific syntax methods.
/// When this method is called <see cref="AcquisitionDevice.Mode"/> still contains <em>old</em> mode.
/// </remarks>
protected virtual void ChangeAcquisitionMode(AcquisitionMode mode)
{
switch (mode)
{
case AcquisitionMode.Idle:
// Even if hardware does not support this we will "emulate" Idle disabling outputting, this
// is default behavior: derived classes may override this function if hardware support this.
break;
case AcquisitionMode.Data:
// To (re)enable data acquisition we disable previously enabled "special" acquisition mode.
if (Mode == AcquisitionMode.Ohmeter)
{
Features.Perform(AcquisitionDeviceFeatures.Ohmeter);
}
else if (Mode == AcquisitionMode.Calibration)
{
Features.Perform(AcquisitionDeviceFeatures.Calibration);
}
// We do nothing here: it means that current mode is Idle and it's supported by hardware,
// it's derived classes task to enter/exit from idle mode (see case AcquisitionMode.Idle).
break;
case AcquisitionMode.Ohmeter:
if (!Features.IsAvailable(AcquisitionDeviceFeatures.Ohmeter))
{
throw new NotSupportedFeatureException(HardwareErrorCodes.Unsupported.AcquisitionMode, "Inputs impedance check (ohmeter) is not supported.");
}
Features.Perform(AcquisitionDeviceFeatures.Ohmeter);
break;
case AcquisitionMode.Calibration:
if (!Features.IsAvailable(AcquisitionDeviceFeatures.Calibration))
{
throw new NotSupportedFeatureException(HardwareErrorCodes.Unsupported.AcquisitionMode, "Inputs calibration signal is not supported.");
}
Features.Perform(AcquisitionDeviceFeatures.Calibration);
break;
default:
throw new NotSupportedFeatureException(HardwareErrorCodes.Unsupported.AcquisitionMode, String.Format("Acquisition mode {0} is unknown.", mode));
}
}
private static Box AcquireBoxPointerPotentiallyWaitForever <TVault>([NotNull] TVault owner, AcquisitionMode mode)
where TVault : ReadWriteVault <T>
{
// ReSharper disable once ConstantConditionalAccessQualifier
Debug.Assert(owner?._lockedResource != null && owner._locker != null);
Debug.Assert(mode == AcquisitionMode.UpgradableReadOnly || mode == AcquisitionMode.ReadWrite ||
mode == AcquisitionMode.ReadOnly);
var locker = owner._locker;
switch (mode)
{
default:
case AcquisitionMode.ReadOnly:
locker.EnterReadLock();
break;
case AcquisitionMode.UpgradableReadOnly:
locker.EnterUpgradeableReadLock();
break;
case AcquisitionMode.ReadWrite:
locker.EnterWriteLock();
break;
}
return(owner._lockedResource);
}
private RwVaultInternalLockedResource([NotNull] ReadWriteVault <T> owner, [NotNull] Box b, [CanBeNull] Action <TimeSpan?, CancellationToken> upgradeAction, [CanBeNull] Action upgradeForeverAction, AcquisitionMode mode)
{
_mode = mode.ValueOrThrowIfNDef();
_b = b ?? throw new ArgumentNullException(nameof(b));
_upgradeAction = upgradeAction;
_upgradeForeverAction = upgradeForeverAction;
_owner = owner ?? throw new ArgumentNullException(nameof(owner));
_releaseFlag = default;
_isGood = true;
Debug.Assert((_upgradeAction == null) == (_upgradeForeverAction == null),
"Both ok, neither ok. Exactly one not ok.");
}
/// <summary>
/// Release the resource
/// </summary>
/// <param name="v">the vault to which the resource should be returned</param>
/// <param name="b">the box of the resource to be returned</param>
/// <param name="mode">the mode in which the lock was obtained</param>
/// <typeparam name="TAv">The type of ReadWriteVault</typeparam>
/// <returns>null</returns>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="mode"/> was not a defined value of
/// the <see cref="AcquisitionMode"/> <see langword="enum"/></exception>
protected internal static Box ReleaseResourceMethod <TAv>([NotNull] TAv v, Box b, AcquisitionMode mode) where TAv : ReadWriteVault <T>
{
// ReSharper disable once ConstantConditionalAccessQualifier
Debug.Assert(b != null && v?._locker != null &&
ReferenceEquals(v._lockedResource, b));
var locker = v._locker;
switch (mode)
{
case AcquisitionMode.ReadOnly:
locker.ExitReadLock();
break;
case AcquisitionMode.UpgradableReadOnly:
locker.ExitUpgradeableReadLock();
break;
case AcquisitionMode.ReadWrite:
locker.ExitWriteLock();
break;
default:
throw new ArgumentOutOfRangeException(nameof(mode),
mode, null);
}
return(null);
}
CreateInternalLockedResource <TV>([NotNull] TV owner, TimeSpan?timeout,
CancellationToken token, AcquisitionMode mode, bool vaultDisposing = false) where TV : ReadWriteVault <T>
{
if (owner == null)
{
throw new ArgumentNullException(nameof(owner));
}
if (timeout == null && token == CancellationToken.None)
{
throw new ArgumentException("Cancellation token may not be none if no timeout is specified.");
}
if (vaultDisposing && !owner.DisposeInProgress)
{
throw new InvalidOperationException($"The {nameof(vaultDisposing)} parameter indicates this call is part of a vault disposal routine." +
" The vault, however, is not performing such a routine.");
}
if (!vaultDisposing && owner.IsDisposed)
{
throw new ArgumentException(@"The vault is disposed.", nameof(owner));
}
mode = mode.ValueOrThrowIfNDef();
(Box AcquiredBox, bool Cancelled, bool TimedOut)boxRes = default;
try
{
boxRes = AcquireBoxPointer(owner, timeout, mode, token);
if (boxRes.Cancelled)
{
throw new OperationCanceledException(token);
}
if (boxRes.TimedOut)
{
throw new TimeoutException(
"Unable to acquire resource within " +
$"[{(timeout ?? owner.DefaultTimeout).TotalMilliseconds:F3}] milliseconds.");
}
(Action <TimeSpan?, CancellationToken> upgradeAction, Action upgradeForeverAction) =
GetUpgradeActions(mode);
Debug.Assert((upgradeForeverAction == null) == (upgradeAction == null));
return(new RwVaultInternalLockedResource(owner, boxRes.AcquiredBox, upgradeAction, upgradeForeverAction, mode));
}
catch (LockRecursionException ex)
{
Debug.Assert(boxRes.AcquiredBox == null);
throw new RwLockAlreadyHeldThreadException(Thread.CurrentThread.ManagedThreadId, ex);
}
catch (Exception)
{
if (boxRes.AcquiredBox != null)
{
ReleaseLock(owner._locker, mode);
}
throw;
}
(Action <TimeSpan?, CancellationToken> UpgradeAction, Action UpgradeForeverAction) GetUpgradeActions(AcquisitionMode m)
{
return(m == AcquisitionMode.UpgradableReadOnly
? (
(TimeSpan? ts, CancellationToken tkn) =>
Upgrade(ts, tkn), () => UpgradeForever()) : (NullUpgradeAction, NullUpgradeForeverAction));
}
void Upgrade(TimeSpan?ts, CancellationToken tkn) =>
CreateInternalLockedResource(owner, ts, tkn, AcquisitionMode.ReadWrite);
void UpgradeForever() => CreateInternalLockedResourceBlockForever(owner, AcquisitionMode.ReadWrite);
}
internal static RwVaultInternalLockedResource CreateInternalLockedResourceBlockForever <TV>([NotNull] TV owner, AcquisitionMode mode, bool vaultDisposing = false) where TV : ReadWriteVault <T>
{
if (owner == null)
{
throw new ArgumentNullException(nameof(owner));
}
if (vaultDisposing && !owner.DisposeInProgress)
{
throw new InvalidOperationException($"The {nameof(vaultDisposing)} parameter indicates this call is part of a vault disposal routine." +
" The vault, however, is not performing such a routine.");
}
if (!vaultDisposing && owner.IsDisposed)
{
throw new ArgumentException(@"The vault is disposed.", nameof(owner));
}
Box boxRes = null;
try
{
boxRes = AcquireBoxPointerPotentiallyWaitForever(owner, mode);
Debug.Assert(boxRes != null);
(Action <TimeSpan?, CancellationToken> upgradeAction, Action upgradeForeverAction) =
GetUpgradeActions(mode);
Debug.Assert((upgradeForeverAction == null) == (upgradeAction == null));
return(new RwVaultInternalLockedResource(owner, boxRes, upgradeAction, upgradeForeverAction, mode));
}
catch (LockRecursionException ex)
{
Debug.Assert(boxRes == null);
throw new RwLockAlreadyHeldThreadException(Thread.CurrentThread.ManagedThreadId, ex);
}
catch (Exception)
{
if (boxRes != null)
{
ReleaseLock(owner._locker, mode);
}
throw;
}
(Action <TimeSpan?, CancellationToken> UpgradeAction, Action UpgradeForeverAction) GetUpgradeActions(AcquisitionMode m)
{
return(m == AcquisitionMode.UpgradableReadOnly
? (
(TimeSpan? ts, CancellationToken tkn) =>
Upgrade(ts, tkn), () => UpgradeForever()) : (NullUpgradeAction, NullUpgradeForeverAction));
}
void Upgrade(TimeSpan?ts, CancellationToken tkn) =>
CreateInternalLockedResource(owner, ts, tkn, AcquisitionMode.ReadWrite);
void UpgradeForever() => CreateInternalLockedResourceBlockForever(owner, AcquisitionMode.ReadWrite);
}
/// <summary>
/// Try to get the resource until earliest of following happens
/// 1- get it successfully,
/// 2- cancellation requested via <paramref name="token"/>
/// 3- time specified by <paramref name="timeout"/> exceeded
/// </summary>
/// <param name="timeout">how long should we wait? Null indicates potential infinite wait .</param>
/// <param name="token">token by which another thread can cancel the attempt to obtain resource</param>
/// <param name="mode">acquisition mode</param>
/// <returns>the resource</returns>
/// <exception cref="ArgumentOutOfRangeException">non-null, non-positive <paramref name="timeout"/> argument; OR mode not
/// a defined value of the <see cref="AcquisitionMode"/> <see langword="enum"/></exception>
/// <exception cref="TimeoutException">didn't obtain it within time specified by <paramref name="timeout"/></exception>
/// <exception cref="OperationCanceledException">operation was cancelled</exception>
/// <exception cref="ObjectDisposedException">the object was disposed</exception>
/// <exception cref="LockAlreadyHeldThreadException">the thread attempting to obtain the lock already holds the lock.</exception>
/// <remarks>After method returns value, you are responsible for disposal until passing to ultimate user behind a method whose return
/// value is annotated by the <see cref="UsingMandatoryAttribute"/>. This means you must dispose of it yourself in all failure/exceptional
/// cases after this method returns a value but before ultimately passed to user.</remarks>
protected RwVaultInternalLockedResource ExecuteGetInternalLockedResource(TimeSpan?timeout, CancellationToken token, AcquisitionMode mode)
{
ThrowIfDisposingOrDisposed();
if (timeout.HasValue && timeout.Value <= TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException(nameof(timeout), timeout, @"Must be positive.");
}
return(RwVaultInternalLockedResource.CreateInternalLockedResource(this, timeout, token, mode.ValueOrThrowIfNDef()));
}
/// <summary>
/// Try to get the locked resource. This thread will block (potentially forever)
/// until the resource is obtained or an exception is thrown.
/// </summary>
/// <returns>The locked resource</returns>
/// <exception cref="ObjectDisposedException">object was disposed</exception>
/// <exception cref="LockAlreadyHeldThreadException">the thread attempting to obtain the lock,
/// already holds the lock.</exception>
protected RwVaultInternalLockedResource ExecuteGetInternalLockedResourceBlockForever(AcquisitionMode mode)
{
ThrowIfDisposingOrDisposed();
return(RwVaultInternalLockedResource.CreateInternalLockedResourceBlockForever(this, mode.ValueOrThrowIfNDef()));
}
/// <summary>
/// Set the acquisition mode to use
/// </summary>
/// <param name="mode">Mode to start using</param>
public void SetAcquisitionMode(AcquisitionMode mode)
{
SendCommandWithErrorOnlyResponse("PM:MODE " + ((int)mode).ToString());
}
private static void RunLittleBit(AcquisitionDevice device, AcquisitionMode mode, int seconds = 2)
{
device.Mode = mode;
Thread.Sleep(seconds * 1000);
}
