Ramping to a target field

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
29: 
30: 
31: 
32: 
33: 
34: 
35: 
36: 
37: 
38: 
39: 
40: 
41: 
42: 
43: 
44: 
45: 
46: 
47: 
48: 
49: 
50: 
51: 
52: 
53: 

// specify the magnet controller settings
let settings = 
    { MagnetController.HardwareParameters =
        { MaximumCurrent = 20.0M<A>
          CalibratedRampRates =
            [ 0.020;   0.024;   0.026;   0.030;   0.036;   0.042;   0.048;   0.054; 
              0.064;   0.072;   0.084;   0.098;   0.110;   0.130;   0.150;   0.170;
              0.20;    0.24;    0.26;    0.30;    0.36;    0.42;    0.48;    0.54; 
              0.64;    0.72;    0.84;    0.98;    1.10;    1.30;    1.50;    1.70; 
              2.0 ]
            |> List.map (fun x -> (decimal x) * 1.0M<A/s>) }
              
      MagnetController.Limits = 
        { RampRateLimit    = 0.1M<A/s>
          TripVoltageLimit = 2.5M<V>
          CurrentLimit     = 17.5M<A> }
          
      MagnetController.FieldCalibration =
        { StaticField       = 14.146M<T>
          LinearCoefficient = -0.002845M<T/A> }
          
      MagnetController.ShuntCalibration = 
        { VoltageOffset     = 0.002M<V>
          LinearCoefficient = 0.400M<V/A> 
          RmsVoltageNoise   = 0.100M<V> }
          
      MagnetController.LastUpdated = new DateTime(2015, 2, 1) }

// specify the field target parameters
let targetParameters = 
    FieldTarget.Parameters.create Forward
    <| MagnetController.Settings.Convert.currentToStepIndex settings 1.5M<A>
    <| MagnetController.Settings.RampRate.nearestIndex settings 0.02M<A/s>

async {
    // connect to the magnet controller
    let! magnetController = MagnetController.openInstrument "GPIB0::4" 3000<ms> settings
    
    try
        // create a new field target based on the parameters and print status updates
        let target = FieldTarget.create magnetController targetParameters
        FieldTarget.status target |> Observable.add (printfn "%A")
    
        // initialise ramping to target
        let targetHandle = FieldTarget.go target
        
        // wait to finish and print the result
        let! result = FieldTarget.waitToFinish targetHandle
        printfn "Magnetic field target finished with result: %A" result
    
    // afterwards, close the connection to the hardware
    finally MagnetController.closeInstrument magnetController |> Async.RunSynchronously }
|> Async.RunSynchronously

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: Fieldtarget.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 targetParameters : FieldTarget.FieldTargetParameers

Full name: Fieldtarget.targetParameters

module FieldTarget

from Endorphin.Instrument.Twickenham.MagnetController

module Parameters

from Endorphin.Instrument.Twickenham.MagnetController.FieldTarget

val create : currentDirection:CurrentDirection -> stepIndex:uint16 -> rampRateIndex:int -> FieldTarget.FieldTargetParameers

Full name: Endorphin.Instrument.Twickenham.MagnetController.FieldTarget.Parameters.create

union case CurrentDirection.Forward: CurrentDirection

Multiple items
module Settings

from Endorphin.Instrument.Twickenham.MagnetController.Instrument.MagnetController

--------------------
type Settings =
  {HardwareParameters: HardwareParameters;
   Limits: Limits;
   FieldCalibration: FieldCalibration;
   ShuntCalibration: ShuntCalibration;
   LastUpdated: DateTime;}

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

module Convert

from Endorphin.Instrument.Twickenham.MagnetController.Instrument.MagnetController.Settings

val currentToStepIndex : magnetController:MagnetController.Settings -> current:decimal<A> -> uint16

Full name: Endorphin.Instrument.Twickenham.MagnetController.Instrument.MagnetController.Settings.Convert.currentToStepIndex

module RampRate

from Endorphin.Instrument.Twickenham.MagnetController.Instrument.MagnetController.Settings

val nearestIndex : settings:MagnetController.Settings -> rampRate:decimal<A/s> -> int

Full name: Endorphin.Instrument.Twickenham.MagnetController.Instrument.MagnetController.Settings.RampRate.nearestIndex

val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async

val magnetController : 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

val target : FieldTarget.FieldTarget

val create : magnetController:MagnetController -> parameters:FieldTarget.FieldTargetParameers -> FieldTarget.FieldTarget

Full name: Endorphin.Instrument.Twickenham.MagnetController.FieldTarget.create

val status : target:FieldTarget.FieldTarget -> IObservable<FieldTarget.FieldTargetStatus>

Full name: Endorphin.Instrument.Twickenham.MagnetController.FieldTarget.status

module Observable

from Microsoft.FSharp.Control

val add : callback:('T -> unit) -> source:IObservable<'T> -> unit

Full name: Microsoft.FSharp.Control.Observable.add

val printfn : format:Printf.TextWriterFormat<'T> -> 'T

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.printfn

val targetHandle : FieldTarget.FieldTargetHandle

val go : target:FieldTarget.FieldTarget -> FieldTarget.FieldTargetHandle

Full name: Endorphin.Instrument.Twickenham.MagnetController.FieldTarget.go

val result : FieldTarget.FieldTargetResult

val waitToFinish : targetHandle:FieldTarget.FieldTargetHandle -> Async<FieldTarget.FieldTargetResult>

Full name: Endorphin.Instrument.Twickenham.MagnetController.FieldTarget.waitToFinish

val closeInstrument : MagnetController -> Async<unit>

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

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