use crate::{
byte_converter::*, converting_callback_receiver::ConvertingCallbackReceiver, converting_receiver::ConvertingReceiver, device::*,
ip_connection::GetRequestSender,
};
pub enum IndustrialDualAnalogInBrickletFunction {
GetVoltage,
SetVoltageCallbackPeriod,
GetVoltageCallbackPeriod,
SetVoltageCallbackThreshold,
GetVoltageCallbackThreshold,
SetDebouncePeriod,
GetDebouncePeriod,
SetSampleRate,
GetSampleRate,
SetCalibration,
GetCalibration,
GetAdcValues,
GetIdentity,
CallbackVoltage,
CallbackVoltageReached,
}
impl From<IndustrialDualAnalogInBrickletFunction> for u8 {
fn from(fun: IndustrialDualAnalogInBrickletFunction) -> Self {
match fun {
IndustrialDualAnalogInBrickletFunction::GetVoltage => 1,
IndustrialDualAnalogInBrickletFunction::SetVoltageCallbackPeriod => 2,
IndustrialDualAnalogInBrickletFunction::GetVoltageCallbackPeriod => 3,
IndustrialDualAnalogInBrickletFunction::SetVoltageCallbackThreshold => 4,
IndustrialDualAnalogInBrickletFunction::GetVoltageCallbackThreshold => 5,
IndustrialDualAnalogInBrickletFunction::SetDebouncePeriod => 6,
IndustrialDualAnalogInBrickletFunction::GetDebouncePeriod => 7,
IndustrialDualAnalogInBrickletFunction::SetSampleRate => 8,
IndustrialDualAnalogInBrickletFunction::GetSampleRate => 9,
IndustrialDualAnalogInBrickletFunction::SetCalibration => 10,
IndustrialDualAnalogInBrickletFunction::GetCalibration => 11,
IndustrialDualAnalogInBrickletFunction::GetAdcValues => 12,
IndustrialDualAnalogInBrickletFunction::GetIdentity => 255,
IndustrialDualAnalogInBrickletFunction::CallbackVoltage => 13,
IndustrialDualAnalogInBrickletFunction::CallbackVoltageReached => 14,
}
}
}
pub const INDUSTRIAL_DUAL_ANALOG_IN_BRICKLET_THRESHOLD_OPTION_OFF: char = 'x';
pub const INDUSTRIAL_DUAL_ANALOG_IN_BRICKLET_THRESHOLD_OPTION_OUTSIDE: char = 'o';
pub const INDUSTRIAL_DUAL_ANALOG_IN_BRICKLET_THRESHOLD_OPTION_INSIDE: char = 'i';
pub const INDUSTRIAL_DUAL_ANALOG_IN_BRICKLET_THRESHOLD_OPTION_SMALLER: char = '<';
pub const INDUSTRIAL_DUAL_ANALOG_IN_BRICKLET_THRESHOLD_OPTION_GREATER: char = '>';
pub const INDUSTRIAL_DUAL_ANALOG_IN_BRICKLET_SAMPLE_RATE_976_SPS: u8 = 0;
pub const INDUSTRIAL_DUAL_ANALOG_IN_BRICKLET_SAMPLE_RATE_488_SPS: u8 = 1;
pub const INDUSTRIAL_DUAL_ANALOG_IN_BRICKLET_SAMPLE_RATE_244_SPS: u8 = 2;
pub const INDUSTRIAL_DUAL_ANALOG_IN_BRICKLET_SAMPLE_RATE_122_SPS: u8 = 3;
pub const INDUSTRIAL_DUAL_ANALOG_IN_BRICKLET_SAMPLE_RATE_61_SPS: u8 = 4;
pub const INDUSTRIAL_DUAL_ANALOG_IN_BRICKLET_SAMPLE_RATE_4_SPS: u8 = 5;
pub const INDUSTRIAL_DUAL_ANALOG_IN_BRICKLET_SAMPLE_RATE_2_SPS: u8 = 6;
pub const INDUSTRIAL_DUAL_ANALOG_IN_BRICKLET_SAMPLE_RATE_1_SPS: u8 = 7;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct VoltageCallbackThreshold {
pub option: char,
pub min: i32,
pub max: i32,
}
impl FromByteSlice for VoltageCallbackThreshold {
fn bytes_expected() -> usize { 9 }
fn from_le_byte_slice(bytes: &[u8]) -> VoltageCallbackThreshold {
VoltageCallbackThreshold {
option: <char>::from_le_byte_slice(&bytes[0..1]),
min: <i32>::from_le_byte_slice(&bytes[1..5]),
max: <i32>::from_le_byte_slice(&bytes[5..9]),
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct Calibration {
pub offset: [i32; 2],
pub gain: [i32; 2],
}
impl FromByteSlice for Calibration {
fn bytes_expected() -> usize { 16 }
fn from_le_byte_slice(bytes: &[u8]) -> Calibration {
Calibration { offset: <[i32; 2]>::from_le_byte_slice(&bytes[0..8]), gain: <[i32; 2]>::from_le_byte_slice(&bytes[8..16]) }
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct VoltageEvent {
pub channel: u8,
pub voltage: i32,
}
impl FromByteSlice for VoltageEvent {
fn bytes_expected() -> usize { 5 }
fn from_le_byte_slice(bytes: &[u8]) -> VoltageEvent {
VoltageEvent { channel: <u8>::from_le_byte_slice(&bytes[0..1]), voltage: <i32>::from_le_byte_slice(&bytes[1..5]) }
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct VoltageReachedEvent {
pub channel: u8,
pub voltage: i32,
}
impl FromByteSlice for VoltageReachedEvent {
fn bytes_expected() -> usize { 5 }
fn from_le_byte_slice(bytes: &[u8]) -> VoltageReachedEvent {
VoltageReachedEvent { channel: <u8>::from_le_byte_slice(&bytes[0..1]), voltage: <i32>::from_le_byte_slice(&bytes[1..5]) }
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct Identity {
pub uid: String,
pub connected_uid: String,
pub position: char,
pub hardware_version: [u8; 3],
pub firmware_version: [u8; 3],
pub device_identifier: u16,
}
impl FromByteSlice for Identity {
fn bytes_expected() -> usize { 25 }
fn from_le_byte_slice(bytes: &[u8]) -> Identity {
Identity {
uid: <String>::from_le_byte_slice(&bytes[0..8]),
connected_uid: <String>::from_le_byte_slice(&bytes[8..16]),
position: <char>::from_le_byte_slice(&bytes[16..17]),
hardware_version: <[u8; 3]>::from_le_byte_slice(&bytes[17..20]),
firmware_version: <[u8; 3]>::from_le_byte_slice(&bytes[20..23]),
device_identifier: <u16>::from_le_byte_slice(&bytes[23..25]),
}
}
}
#[derive(Clone)]
pub struct IndustrialDualAnalogInBricklet {
device: Device,
}
impl IndustrialDualAnalogInBricklet {
pub const DEVICE_IDENTIFIER: u16 = 249;
pub const DEVICE_DISPLAY_NAME: &'static str = "Industrial Dual Analog In Bricklet";
pub fn new<T: GetRequestSender>(uid: &str, req_sender: T) -> IndustrialDualAnalogInBricklet {
let mut result = IndustrialDualAnalogInBricklet { device: Device::new([2, 0, 0], uid, req_sender, 0) };
result.device.response_expected[u8::from(IndustrialDualAnalogInBrickletFunction::GetVoltage) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(IndustrialDualAnalogInBrickletFunction::SetVoltageCallbackPeriod) as usize] =
ResponseExpectedFlag::True;
result.device.response_expected[u8::from(IndustrialDualAnalogInBrickletFunction::GetVoltageCallbackPeriod) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(IndustrialDualAnalogInBrickletFunction::SetVoltageCallbackThreshold) as usize] =
ResponseExpectedFlag::True;
result.device.response_expected[u8::from(IndustrialDualAnalogInBrickletFunction::GetVoltageCallbackThreshold) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(IndustrialDualAnalogInBrickletFunction::SetDebouncePeriod) as usize] =
ResponseExpectedFlag::True;
result.device.response_expected[u8::from(IndustrialDualAnalogInBrickletFunction::GetDebouncePeriod) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(IndustrialDualAnalogInBrickletFunction::SetSampleRate) as usize] =
ResponseExpectedFlag::False;
result.device.response_expected[u8::from(IndustrialDualAnalogInBrickletFunction::GetSampleRate) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(IndustrialDualAnalogInBrickletFunction::SetCalibration) as usize] =
ResponseExpectedFlag::False;
result.device.response_expected[u8::from(IndustrialDualAnalogInBrickletFunction::GetCalibration) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(IndustrialDualAnalogInBrickletFunction::GetAdcValues) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(IndustrialDualAnalogInBrickletFunction::GetIdentity) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result
}
pub fn get_response_expected(&mut self, fun: IndustrialDualAnalogInBrickletFunction) -> Result<bool, GetResponseExpectedError> {
self.device.get_response_expected(u8::from(fun))
}
pub fn set_response_expected(
&mut self,
fun: IndustrialDualAnalogInBrickletFunction,
response_expected: bool,
) -> Result<(), SetResponseExpectedError> {
self.device.set_response_expected(u8::from(fun), response_expected)
}
pub fn set_response_expected_all(&mut self, response_expected: bool) { self.device.set_response_expected_all(response_expected) }
pub fn get_api_version(&self) -> [u8; 3] { self.device.api_version }
pub fn get_voltage_callback_receiver(&self) -> ConvertingCallbackReceiver<VoltageEvent> {
self.device.get_callback_receiver(u8::from(IndustrialDualAnalogInBrickletFunction::CallbackVoltage))
}
pub fn get_voltage_reached_callback_receiver(&self) -> ConvertingCallbackReceiver<VoltageReachedEvent> {
self.device.get_callback_receiver(u8::from(IndustrialDualAnalogInBrickletFunction::CallbackVoltageReached))
}
pub fn get_voltage(&self, channel: u8) -> ConvertingReceiver<i32> {
let mut payload = vec![0; 1];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(channel));
self.device.get(u8::from(IndustrialDualAnalogInBrickletFunction::GetVoltage), payload)
}
pub fn set_voltage_callback_period(&self, channel: u8, period: u32) -> ConvertingReceiver<()> {
let mut payload = vec![0; 5];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(channel));
payload[1..5].copy_from_slice(&<u32>::to_le_byte_vec(period));
self.device.set(u8::from(IndustrialDualAnalogInBrickletFunction::SetVoltageCallbackPeriod), payload)
}
pub fn get_voltage_callback_period(&self, channel: u8) -> ConvertingReceiver<u32> {
let mut payload = vec![0; 1];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(channel));
self.device.get(u8::from(IndustrialDualAnalogInBrickletFunction::GetVoltageCallbackPeriod), payload)
}
pub fn set_voltage_callback_threshold(&self, channel: u8, option: char, min: i32, max: i32) -> ConvertingReceiver<()> {
let mut payload = vec![0; 10];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(channel));
payload[1..2].copy_from_slice(&<char>::to_le_byte_vec(option));
payload[2..6].copy_from_slice(&<i32>::to_le_byte_vec(min));
payload[6..10].copy_from_slice(&<i32>::to_le_byte_vec(max));
self.device.set(u8::from(IndustrialDualAnalogInBrickletFunction::SetVoltageCallbackThreshold), payload)
}
pub fn get_voltage_callback_threshold(&self, channel: u8) -> ConvertingReceiver<VoltageCallbackThreshold> {
let mut payload = vec![0; 1];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(channel));
self.device.get(u8::from(IndustrialDualAnalogInBrickletFunction::GetVoltageCallbackThreshold), payload)
}
pub fn set_debounce_period(&self, debounce: u32) -> ConvertingReceiver<()> {
let mut payload = vec![0; 4];
payload[0..4].copy_from_slice(&<u32>::to_le_byte_vec(debounce));
self.device.set(u8::from(IndustrialDualAnalogInBrickletFunction::SetDebouncePeriod), payload)
}
pub fn get_debounce_period(&self) -> ConvertingReceiver<u32> {
let payload = vec![0; 0];
self.device.get(u8::from(IndustrialDualAnalogInBrickletFunction::GetDebouncePeriod), payload)
}
pub fn set_sample_rate(&self, rate: u8) -> ConvertingReceiver<()> {
let mut payload = vec![0; 1];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(rate));
self.device.set(u8::from(IndustrialDualAnalogInBrickletFunction::SetSampleRate), payload)
}
pub fn get_sample_rate(&self) -> ConvertingReceiver<u8> {
let payload = vec![0; 0];
self.device.get(u8::from(IndustrialDualAnalogInBrickletFunction::GetSampleRate), payload)
}
pub fn set_calibration(&self, offset: [i32; 2], gain: [i32; 2]) -> ConvertingReceiver<()> {
let mut payload = vec![0; 16];
payload[0..8].copy_from_slice(&<[i32; 2]>::to_le_byte_vec(offset));
payload[8..16].copy_from_slice(&<[i32; 2]>::to_le_byte_vec(gain));
self.device.set(u8::from(IndustrialDualAnalogInBrickletFunction::SetCalibration), payload)
}
pub fn get_calibration(&self) -> ConvertingReceiver<Calibration> {
let payload = vec![0; 0];
self.device.get(u8::from(IndustrialDualAnalogInBrickletFunction::GetCalibration), payload)
}
pub fn get_adc_values(&self) -> ConvertingReceiver<[i32; 2]> {
let payload = vec![0; 0];
self.device.get(u8::from(IndustrialDualAnalogInBrickletFunction::GetAdcValues), payload)
}
pub fn get_identity(&self) -> ConvertingReceiver<Identity> {
let payload = vec![0; 0];
self.device.get(u8::from(IndustrialDualAnalogInBrickletFunction::GetIdentity), payload)
}
}