llcontrol2

Author:

Peter Milne <peter.milne@d-tacq.com>

• Low Latency control operation:
  • Target push data transfer to slave memory on host card.
  • Data is delivered with minimum latency after the sample clock.

• This implementation uses the same firmware and mechanism as the original LLCONTROL, but it's implemented as an API rather than a framework. In other words, USER code calls the API rather than the FRAMEWORK call USER code as before.

• The API is implemented in C++. This allows the same efficient interface to the device driver as before, while at the same time making for a clean dynamic system instantiation.
• The API is callable from C and, appropriately packaged from another math environment eg Python or IDL.
• In particular, the API allows the user to work with a single array of each of AI, AO, DI, DO across multiple cards, and the complexity of memory buffering is completely hidden by the API.
• The user defined the system using a simple config_file (xml). -The system generates an xml representation of itself. This should be used by higher level code to establish position of channels in the data buffers. The channel position does not change unless the configuration changes, so it is reasonables to code this as a constant.
• Alternatively the system can be instantiated in a few lines of C++, with direct access methods for the channel offsets.

• Implementing a control loop in C:
  1. Define the system cards and slots and operating parameters by calling RtSetup();
  2. Arm the system by calling RtArm()
  3. Run the control loop calling RtIO()
  4. Terminate RtStop();

• Implementing a control loop in C++
  1. Define the system cards and slots, by creating an instance of LL_ControlSystem and populating it with ACQ_Cards.
  2. Define operating parameters using LL_ControlSystem::init();
  3. Set up IO buffers
  4. Call LL_ControlSystem::Arm()
  5. Run the control loop calling LL_ControlSystem::IO()
  6. Terminate with LL_ControlSystem::Stop();

• For overview, please refer to
  • http://www.d-tacq.com/resources/D-Tacq_2G_UserGuide.pdf

• Operation still relies on capture setup scripts as before, or the equivalent.
• D-TACQ examples still use the same automated test environment of
  • MB : ACQ196 Master board
  • SB : optional ACQ196Slave board[s]
  • Sx : optional AO32 slave board[s]
  • CB : Clock Board - a further ACQ196 to provide external clock and trigger

• D-TACQ recommends example-dynamic.cpp, this has complete system definition in xml and is therefore the most general example.
• To run example-dynamic from bash prompt. Assume system definition "xml/example1-krypton.xml":
  • lookup_xml exports a few environment variables used in scripting..

    ./xml_lookup xml/example1-krypton.xml system/exports
    CB=2 S1=3 MB=4
    export $(./xml_lookup xml/example1-krypton.xml system/exports)
    

  • Connect AO32 S1 AO0132 connector to ACQ196 MB AI0132 input
  • Connect AO32 S1 DO0132 connector to ACQ196 MB AI3364 input
  • Connect AO32 S1 DO3364 connector to ACQ196 MB AI6596 input
  • Host-side ACQ200 and AO32 drivers must be loaded.

• Validate driver load:

  acqcmd -s MB hostname
  
  set.ao32 $S1 AO_MODE M_AWGI
  get.ao32 $S1 AO_MODE
  # ... returns M_AWGI
  
  

• Build LLC Software-

  cd LOWLATENCY2; make
  

• define the system by editing a local xml system def file: -eg xml/example1-krypton-96AI.xml

  # create a job control file, example:
  
  # top-level-launcher
  cd PROJECTS/LOWLATENCY2/
   export LL2_SYSFILE=xml/example1-krypton.xml 
   export LL_OUTPUTS=data/ai-ramps.dat 
   export $(./xml_lookup $LL2_SYSFILE system/exports)
   cd scripts
   ./setup.ao32 $MB $S1
   ./deploy-script set.llc.wd $MB
   acqcmd -s $MB set.llc.wd
   source ./setup.clocks2 $MB 0 96 $CB
   init_clocks
  

• now configure and run the system

  source ./top-level-launcher
  # options
  ./web-trigger
  # run the shot -n ITERATIONS ECM (sample interval in 1usec ticks)
  ./example-dynamic -v 2 -n 10000 100
  

  • sample output

    [dt100@krypton LOWLATENCY2]$ LL_OUTPUTS=data/ai-ramps.dat ./example-dynamic -v 2 -n 100 1000
    slot:2 class:acq196
    slot:3 class:ao32
    ECM 1000
    mmap 0xb7f4b000 offset 16
    data: 00000004 37400000 ffffffff 00000ec6
    mmapDmaBuffer() 01: open /dev/acq32/acq32.2.host
    mmapDmaBuffer() ask for full bigbuf portion 400000
    mmapDmaBuffer() fd_in:4 physaddr 0x37400000 vaddr 0xb7b42000 len 4194304
    mmapDmaBuffer() written host0.dat, zeroed
    speed=1197 ticks per microsecond
    ACQ196::init(0x9d49e1c) mbox 0x9d48ee8
    M_SYNC_2V sample size 256
    appEnterLLC_SYNC_2V() va:0xb7b42000 pa:0x37400000 MASTER slaves 1
    enterLLC()
    llSetAddr [2] 0x37400000
    leave LLC
    ~LL_ControlSystemI()
    

• Validation
  • Channel 33-64 DO64 loopback to AI, data in AI.dat

    [dt100@krypton LOWLATENCY2]$ ./scripts/dump.ai.decimal ai.dat 33-64 | ./scripts/do-analyse  | head
             1:00000000000000000000000000000000
             2:00000000000000000000000000000000
             3:11111111111111111111111111111111
             4:00000000000000000000000000000000
             5:11111111111111111111111111111111
             6:00000000000000000000000000000000
             7:11111111111111111111111111111111
             8:00000000000000000000000000000000
    

  • Timestamps

    # NB: does not work on ACQ196-96-500, only ACQ196-96-250
    ./scripts/dump.status.decimal | cut -d\  -f 12 | tail
    9999920
    9999940
    9999960
    9999980
    10000000
    

  • AO/AI data.
    • AO32 loopback to AI01-32 Data saved to ai.dat
    • use gnu-octave to view the data

      cat llplot.m 
      
      1;
      nchan=96
      tb=1:100;
      fp=fopen("ai.dat");
      raw=fread(fp,Inf,"short");
      len=length(raw)
      chx=reshape(raw,nchan,len/nchan);
      plot(tb,chx(1:32,tb))
      octave
      octave:1> llplot