Endorphin.Instrument.Twickenham.MagnetController

Documentation

The Endorphin.Instrument.Twickenham.MagnetController library can be installed from NuGet:

PM> Install-Package Endorphin.Instrument.Twickenham.MagnetController -Pre

Example

This shows how to connect to the magnet controller via F# with the library.

1: 
2: 
3:

let magnetController =
    MagnetController.openInstrument "GPIB0::4" 3000<ms> settings 
    |> Async.RunSynchronously

Samples & documentation

See how to:

The API Reference contains automatically generated documentation for all types, modules and functions in the library.

The project is hosted on GitHub where you can report issues, fork the project and submit pull requests. If you're adding a new public API, please also consider adding samples that can be turned into a documentation. You might also want to read the library design notes to understand how it works.

The library is available under Apache 2.0 license. For more information see the License file in the GitHub repository.

namespace System

namespace Microsoft

namespace Microsoft.FSharp

namespace Microsoft.FSharp.Data

namespace Microsoft.FSharp.Data.UnitSystems

namespace Microsoft.FSharp.Data.UnitSystems.SI

namespace Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols

namespace Endorphin

namespace Endorphin.Instrument

namespace Endorphin.Instrument.Twickenham

namespace Endorphin.Instrument.Twickenham.MagnetController

val settings : MagnetController.Settings

Full name: Index.settings

Multiple items
module MagnetController

from Endorphin.Instrument.Twickenham.MagnetController.Instrument

--------------------
module MagnetController

from Endorphin.Instrument.Twickenham.MagnetController

--------------------
type MagnetController = private | MagnetController of magnetController: Instrument * settings: Settings

Full name: Endorphin.Instrument.Twickenham.MagnetController.Model.MagnetController

type HardwareParameters =
{MaximumCurrent: decimal<A>;
CalibratedRampRates: decimal<A/s> list;}

Full name: Endorphin.Instrument.Twickenham.MagnetController.MagnetControllerModule.HardwareParameters

[<Measure>]
type A = Data.UnitSystems.SI.UnitNames.ampere

Full name: Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols.A

Multiple items
module List

from Microsoft.FSharp.Collections

--------------------
type List<'T> =
  | ( [] )
  | ( :: ) of Head: 'T * Tail: 'T list
  interface IEnumerable
  interface IEnumerable<'T>
  member GetSlice : startIndex:int option * endIndex:int option -> 'T list
  member Head : 'T
  member IsEmpty : bool
  member Item : index:int -> 'T with get
  member Length : int
  member Tail : 'T list
  static member Cons : head:'T * tail:'T list -> 'T list
  static member Empty : 'T list

Full name: Microsoft.FSharp.Collections.List<_>

val map : mapping:('T -> 'U) -> list:'T list -> 'U list

Full name: Microsoft.FSharp.Collections.List.map

val x : float

Multiple items
val decimal : value:'T -> decimal (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.decimal

--------------------
type decimal = Decimal

Full name: Microsoft.FSharp.Core.decimal

--------------------
type decimal<'Measure> = decimal

Full name: Microsoft.FSharp.Core.decimal<_>

[<Measure>]
type s = Data.UnitSystems.SI.UnitNames.second

Full name: Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols.s

type Limits =
  {RampRateLimit: decimal<A/s>;
   TripVoltageLimit: decimal<V>;
   CurrentLimit: decimal<A>;}

Full name: Endorphin.Instrument.Twickenham.MagnetController.MagnetControllerModule.Limits

[<Measure>]
type V = Data.UnitSystems.SI.UnitNames.volt

Full name: Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols.V

type FieldCalibration =
{StaticField: decimal<T>;
LinearCoefficient: decimal<T/A>;}

Full name: Endorphin.Instrument.Twickenham.MagnetController.MagnetControllerModule.FieldCalibration

[<Measure>]
type T = Data.UnitSystems.SI.UnitNames.tesla

Full name: Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols.T

type ShuntCalibration =
  {VoltageOffset: decimal<V>;
   LinearCoefficient: decimal<V/A>;
   RmsVoltageNoise: decimal<V>;}

Full name: Endorphin.Instrument.Twickenham.MagnetController.MagnetControllerModule.ShuntCalibration

Multiple items
type DateTime =
  struct
    new : ticks:int64 -> DateTime + 10 overloads
    member Add : value:TimeSpan -> DateTime
    member AddDays : value:float -> DateTime
    member AddHours : value:float -> DateTime
    member AddMilliseconds : value:float -> DateTime
    member AddMinutes : value:float -> DateTime
    member AddMonths : months:int -> DateTime
    member AddSeconds : value:float -> DateTime
    member AddTicks : value:int64 -> DateTime
    member AddYears : value:int -> DateTime
    ...
  end

Full name: System.DateTime

--------------------
DateTime()
   (+0 other overloads)
DateTime(ticks: int64) : unit
   (+0 other overloads)
DateTime(ticks: int64, kind: DateTimeKind) : unit
   (+0 other overloads)
DateTime(year: int, month: int, day: int) : unit
   (+0 other overloads)
DateTime(year: int, month: int, day: int, calendar: Globalization.Calendar) : unit
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int) : unit
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, kind: DateTimeKind) : unit
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, calendar: Globalization.Calendar) : unit
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, millisecond: int) : unit
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, millisecond: int, kind: DateTimeKind) : unit
   (+0 other overloads)

val magnetController : MagnetController

Full name: Index.magnetController

val openInstrument : visaAddress:string -> timeout:int<ms> -> settings:MagnetController.Settings -> Async<MagnetController>

Full name: Endorphin.Instrument.Twickenham.MagnetController.Instrument.MagnetController.openInstrument

[<Measure>]
type ms

Full name: Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols.Units.Time.ms

Multiple items
type Async
static member AsBeginEnd : computation:('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit)
static member AwaitEvent : event:IEvent<'Del,'T> * ?cancelAction:(unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate)
static member AwaitIAsyncResult : iar:IAsyncResult * ?millisecondsTimeout:int -> Async<bool>
static member AwaitTask : task:Task -> Async<unit>
static member AwaitTask : task:Task<'T> -> Async<'T>
static member AwaitWaitHandle : waitHandle:WaitHandle * ?millisecondsTimeout:int -> Async<bool>
static member CancelDefaultToken : unit -> unit
static member Catch : computation:Async<'T> -> Async<Choice<'T,exn>>
static member FromBeginEnd : beginAction:(AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg:'Arg1 * beginAction:('Arg1 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * beginAction:('Arg1 * 'Arg2 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * arg3:'Arg3 * beginAction:('Arg1 * 'Arg2 * 'Arg3 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromContinuations : callback:(('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T>
static member Ignore : computation:Async<'T> -> Async<unit>
static member OnCancel : interruption:(unit -> unit) -> Async<IDisposable>
static member Parallel : computations:seq<Async<'T>> -> Async<'T []>
static member RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:CancellationToken -> 'T
static member Sleep : millisecondsDueTime:int -> Async<unit>
static member Start : computation:Async<unit> * ?cancellationToken:CancellationToken -> unit
static member StartAsTask : computation:Async<'T> * ?taskCreationOptions:TaskCreationOptions * ?cancellationToken:CancellationToken -> Task<'T>
static member StartChild : computation:Async<'T> * ?millisecondsTimeout:int -> Async<Async<'T>>
static member StartChildAsTask : computation:Async<'T> * ?taskCreationOptions:TaskCreationOptions -> Async<Task<'T>>
static member StartImmediate : computation:Async<unit> * ?cancellationToken:CancellationToken -> unit
static member StartWithContinuations : computation:Async<'T> * continuation:('T -> unit) * exceptionContinuation:(exn -> unit) * cancellationContinuation:(OperationCanceledException -> unit) * ?cancellationToken:CancellationToken -> unit
static member SwitchToContext : syncContext:SynchronizationContext -> Async<unit>
static member SwitchToNewThread : unit -> Async<unit>
static member SwitchToThreadPool : unit -> Async<unit>
static member TryCancelled : computation:Async<'T> * compensation:(OperationCanceledException -> unit) -> Async<'T>
static member CancellationToken : Async<CancellationToken>
static member DefaultCancellationToken : CancellationToken

Full name: Microsoft.FSharp.Control.Async

--------------------
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>

static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:Threading.CancellationToken -> 'T