Struct Delay 

pub struct Delay { /* private fields */ }

Delays with 20 ns precision

The Delay instruction is used to configure to insert delays into the ArC2 command buffer. This can be used for settling other instructions or creating arbitrary waveforms. The delay is essentially a 50 MHz timer as described in the documentation of Duration50. The maximum delay we can implement on board is 2^32 × 20 ns although realistically for delays greater than a second one might want to use software delays. Values exceeding this maximum will be capped to fit. We cannot also do delays lower than 320 ns (16 increments) since that’s the time required by the FPGA to process the instruction. So all arguments will be implicitly decremented by 320 ns to account for that (hence the 320 ns minimum).

Instruction layout

       +--------+------------+
       | OpCode | Duration50 |
       +--------+------------+
Words:     1          1

Example

use libarc2::instructions::{Delay, Instruction};
use std::time::Duration;

// Delays are rounded to the lowest increment of 20 ns
let mut instr0 = Delay::from_nanos(1210);
// Actual time is 320 ns (0x10 increments) lower than whatever the
// argument specifies to account for settling times
assert_eq!(instr0.compile().view(),
    &[0x2000, 0x3C-0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80008000]);

// Same but with a `Duration` object
let mut instr1 = Delay::from_duration(&Duration::from_nanos(1210));
assert_eq!(instr1.compile().view(),
    &[0x2000, 0x3C-0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80008000]);

let mut instr2 = Delay::from_nanos(200);
// Can't go below 320 ns (0x10 increments)
assert_eq!(instr2.compile().view(),
    &[0x2000, 0x10-0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80008000]);

Implementations

impl Delay

pub fn from_nanos(ns: u128) -> Delay

Create a new Delay instruction from the specified number of nanoseconds.

pub fn from_duration(duration: &Duration) -> Delay

Trait Implementations

impl Instruction for Delay

fn create() -> Delay

Create a new empty instruction

fn len(&self) -> usize

Number of allocated registers

fn push_u32s(&mut self, reg: &[u32])

Add an array of u32s to the instruction

fn view(&self) -> &[u32]

Get a u32 view of the current instruction

fn name(&self) -> &'static str

Name of the instruction

type S: Instruction

Type of the instruction. For most cases this should be Self.

fn compile(&mut self) -> &mut Self

Pad and terminate instruction for consumption. This will be typically communicated to ArC2 using the [process][crate::Instrument::process()] and [compile_process][crate::Instrument::compile_process] functions.

fn push_register<T: ToU32s>(&mut self, register: &T)

Add a new register to this instruction

fn to_bytevec(&self) -> Vec<u8>

Convert this instruction into a byte array.