Struct UpdateChannel 

pub struct UpdateChannel { /* private fields */ }

Set channel configuration

The UpdateChannel instruction is used to configure all the channels of ArC2 based on their functionality; see ChannelState for more details.

Instruction layout

       +--------+-------------+-------+-------+---------------+
       | OpCode |  SourceConf | Empty | Empty |  ChannelConf  |
       +--------+-------------+-------+-------+---------------+
Words:     1            1         1       1           4

Example

use libarc2::registers::{ChannelConf, SourceConf, ChannelState};
use libarc2::instructions::{UpdateChannel, Instruction};

// new channel configuration
let mut chanconf = ChannelConf::new();
// set all output channels to arbitrary voltage
chanconf.set_all(ChannelState::VoltArb);

// source configuration; use default, 11 kΩ digipot
let sourceconf = SourceConf::new();

// make the instruction
let mut instr = UpdateChannel::from_regs(&sourceconf, &chanconf);

assert_eq!(instr.compile().view(), &[0x40, 0x73400000,
    0x00000000, 0x00000000, 0xaaaaaaaa, 0xaaaaaaaa,
    0xaaaaaaaa, 0xaaaaaaaa, 0x80008000]);

Implementations

impl UpdateChannel

pub fn new() -> Self

Create a new instruction with invalid state.

pub fn from_regs(sourceconf: &SourceConf, chanconf: &ChannelConf) -> Self

Create a new instruction from existing configuration.

pub fn from_regs_default_source(chanconf: &ChannelConf) -> Self

Create a new instruction with standard source configuration

pub fn from_regs_global_state(state: ChannelState) -> Self

Create a new instruction with default source and specified state

use libarc2::registers::{ChannelState};
use libarc2::instructions::{UpdateChannel, Instruction};

// Arbitrary voltage output
let state = ChannelState::VoltArb;

let mut instr = UpdateChannel::from_regs_global_state(state);

assert_eq!(instr.compile().view(), &[0x40, 0x73400000,
    0x00000000, 0x00000000, 0xaaaaaaaa, 0xaaaaaaaa,
    0xaaaaaaaa, 0xaaaaaaaa, 0x80008000]);

pub fn mask(&self, val: ChannelState) -> ChanMask

Generate a mask that contains all channels at the specified channel state.

use libarc2::instructions::*;
use libarc2::registers::*;

let mut conf = ChannelConf::new();
conf.set(3, ChannelState::VoltArb);
conf.set(19, ChannelState::VoltArb);
let upch = UpdateChannel::from_regs_default_source(&conf);

let mask = upch.mask(ChannelState::VoltArb);

assert_eq!(mask.as_slice(), &[0x00000000, 0x00080008]);

Trait Implementations

impl Instruction for UpdateChannel

fn create() -> UpdateChannel

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 and 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.