use crate::{
byte_converter::*, converting_callback_receiver::ConvertingCallbackReceiver, converting_receiver::ConvertingReceiver, device::*,
ip_connection::GetRequestSender,
};
pub enum StepperBrickFunction {
SetMaxVelocity,
GetMaxVelocity,
GetCurrentVelocity,
SetSpeedRamping,
GetSpeedRamping,
FullBrake,
SetCurrentPosition,
GetCurrentPosition,
SetTargetPosition,
GetTargetPosition,
SetSteps,
GetSteps,
GetRemainingSteps,
SetStepMode,
GetStepMode,
DriveForward,
DriveBackward,
Stop,
GetStackInputVoltage,
GetExternalInputVoltage,
GetCurrentConsumption,
SetMotorCurrent,
GetMotorCurrent,
Enable,
Disable,
IsEnabled,
SetDecay,
GetDecay,
SetMinimumVoltage,
GetMinimumVoltage,
SetSyncRect,
IsSyncRect,
SetTimeBase,
GetTimeBase,
GetAllData,
SetAllDataPeriod,
GetAllDataPeriod,
SetSpitfpBaudrateConfig,
GetSpitfpBaudrateConfig,
GetSendTimeoutCount,
SetSpitfpBaudrate,
GetSpitfpBaudrate,
GetSpitfpErrorCount,
EnableStatusLed,
DisableStatusLed,
IsStatusLedEnabled,
GetProtocol1BrickletName,
GetChipTemperature,
Reset,
GetIdentity,
CallbackUnderVoltage,
CallbackPositionReached,
CallbackAllData,
CallbackNewState,
}
impl From<StepperBrickFunction> for u8 {
fn from(fun: StepperBrickFunction) -> Self {
match fun {
StepperBrickFunction::SetMaxVelocity => 1,
StepperBrickFunction::GetMaxVelocity => 2,
StepperBrickFunction::GetCurrentVelocity => 3,
StepperBrickFunction::SetSpeedRamping => 4,
StepperBrickFunction::GetSpeedRamping => 5,
StepperBrickFunction::FullBrake => 6,
StepperBrickFunction::SetCurrentPosition => 7,
StepperBrickFunction::GetCurrentPosition => 8,
StepperBrickFunction::SetTargetPosition => 9,
StepperBrickFunction::GetTargetPosition => 10,
StepperBrickFunction::SetSteps => 11,
StepperBrickFunction::GetSteps => 12,
StepperBrickFunction::GetRemainingSteps => 13,
StepperBrickFunction::SetStepMode => 14,
StepperBrickFunction::GetStepMode => 15,
StepperBrickFunction::DriveForward => 16,
StepperBrickFunction::DriveBackward => 17,
StepperBrickFunction::Stop => 18,
StepperBrickFunction::GetStackInputVoltage => 19,
StepperBrickFunction::GetExternalInputVoltage => 20,
StepperBrickFunction::GetCurrentConsumption => 21,
StepperBrickFunction::SetMotorCurrent => 22,
StepperBrickFunction::GetMotorCurrent => 23,
StepperBrickFunction::Enable => 24,
StepperBrickFunction::Disable => 25,
StepperBrickFunction::IsEnabled => 26,
StepperBrickFunction::SetDecay => 27,
StepperBrickFunction::GetDecay => 28,
StepperBrickFunction::SetMinimumVoltage => 29,
StepperBrickFunction::GetMinimumVoltage => 30,
StepperBrickFunction::SetSyncRect => 33,
StepperBrickFunction::IsSyncRect => 34,
StepperBrickFunction::SetTimeBase => 35,
StepperBrickFunction::GetTimeBase => 36,
StepperBrickFunction::GetAllData => 37,
StepperBrickFunction::SetAllDataPeriod => 38,
StepperBrickFunction::GetAllDataPeriod => 39,
StepperBrickFunction::SetSpitfpBaudrateConfig => 231,
StepperBrickFunction::GetSpitfpBaudrateConfig => 232,
StepperBrickFunction::GetSendTimeoutCount => 233,
StepperBrickFunction::SetSpitfpBaudrate => 234,
StepperBrickFunction::GetSpitfpBaudrate => 235,
StepperBrickFunction::GetSpitfpErrorCount => 237,
StepperBrickFunction::EnableStatusLed => 238,
StepperBrickFunction::DisableStatusLed => 239,
StepperBrickFunction::IsStatusLedEnabled => 240,
StepperBrickFunction::GetProtocol1BrickletName => 241,
StepperBrickFunction::GetChipTemperature => 242,
StepperBrickFunction::Reset => 243,
StepperBrickFunction::GetIdentity => 255,
StepperBrickFunction::CallbackUnderVoltage => 31,
StepperBrickFunction::CallbackPositionReached => 32,
StepperBrickFunction::CallbackAllData => 40,
StepperBrickFunction::CallbackNewState => 41,
}
}
}
pub const STEPPER_BRICK_STEP_MODE_FULL_STEP: u8 = 1;
pub const STEPPER_BRICK_STEP_MODE_HALF_STEP: u8 = 2;
pub const STEPPER_BRICK_STEP_MODE_QUARTER_STEP: u8 = 4;
pub const STEPPER_BRICK_STEP_MODE_EIGHTH_STEP: u8 = 8;
pub const STEPPER_BRICK_STATE_STOP: u8 = 1;
pub const STEPPER_BRICK_STATE_ACCELERATION: u8 = 2;
pub const STEPPER_BRICK_STATE_RUN: u8 = 3;
pub const STEPPER_BRICK_STATE_DEACCELERATION: u8 = 4;
pub const STEPPER_BRICK_STATE_DIRECTION_CHANGE_TO_FORWARD: u8 = 5;
pub const STEPPER_BRICK_STATE_DIRECTION_CHANGE_TO_BACKWARD: u8 = 6;
pub const STEPPER_BRICK_COMMUNICATION_METHOD_NONE: u8 = 0;
pub const STEPPER_BRICK_COMMUNICATION_METHOD_USB: u8 = 1;
pub const STEPPER_BRICK_COMMUNICATION_METHOD_SPI_STACK: u8 = 2;
pub const STEPPER_BRICK_COMMUNICATION_METHOD_CHIBI: u8 = 3;
pub const STEPPER_BRICK_COMMUNICATION_METHOD_RS485: u8 = 4;
pub const STEPPER_BRICK_COMMUNICATION_METHOD_WIFI: u8 = 5;
pub const STEPPER_BRICK_COMMUNICATION_METHOD_ETHERNET: u8 = 6;
pub const STEPPER_BRICK_COMMUNICATION_METHOD_WIFI_V2: u8 = 7;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct SpeedRamping {
pub acceleration: u16,
pub deacceleration: u16,
}
impl FromByteSlice for SpeedRamping {
fn bytes_expected() -> usize { 4 }
fn from_le_byte_slice(bytes: &[u8]) -> SpeedRamping {
SpeedRamping { acceleration: <u16>::from_le_byte_slice(&bytes[0..2]), deacceleration: <u16>::from_le_byte_slice(&bytes[2..4]) }
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct AllData {
pub current_velocity: u16,
pub current_position: i32,
pub remaining_steps: i32,
pub stack_voltage: u16,
pub external_voltage: u16,
pub current_consumption: u16,
}
impl FromByteSlice for AllData {
fn bytes_expected() -> usize { 16 }
fn from_le_byte_slice(bytes: &[u8]) -> AllData {
AllData {
current_velocity: <u16>::from_le_byte_slice(&bytes[0..2]),
current_position: <i32>::from_le_byte_slice(&bytes[2..6]),
remaining_steps: <i32>::from_le_byte_slice(&bytes[6..10]),
stack_voltage: <u16>::from_le_byte_slice(&bytes[10..12]),
external_voltage: <u16>::from_le_byte_slice(&bytes[12..14]),
current_consumption: <u16>::from_le_byte_slice(&bytes[14..16]),
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct AllDataEvent {
pub current_velocity: u16,
pub current_position: i32,
pub remaining_steps: i32,
pub stack_voltage: u16,
pub external_voltage: u16,
pub current_consumption: u16,
}
impl FromByteSlice for AllDataEvent {
fn bytes_expected() -> usize { 16 }
fn from_le_byte_slice(bytes: &[u8]) -> AllDataEvent {
AllDataEvent {
current_velocity: <u16>::from_le_byte_slice(&bytes[0..2]),
current_position: <i32>::from_le_byte_slice(&bytes[2..6]),
remaining_steps: <i32>::from_le_byte_slice(&bytes[6..10]),
stack_voltage: <u16>::from_le_byte_slice(&bytes[10..12]),
external_voltage: <u16>::from_le_byte_slice(&bytes[12..14]),
current_consumption: <u16>::from_le_byte_slice(&bytes[14..16]),
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct NewStateEvent {
pub state_new: u8,
pub state_previous: u8,
}
impl FromByteSlice for NewStateEvent {
fn bytes_expected() -> usize { 2 }
fn from_le_byte_slice(bytes: &[u8]) -> NewStateEvent {
NewStateEvent { state_new: <u8>::from_le_byte_slice(&bytes[0..1]), state_previous: <u8>::from_le_byte_slice(&bytes[1..2]) }
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct SpitfpBaudrateConfig {
pub enable_dynamic_baudrate: bool,
pub minimum_dynamic_baudrate: u32,
}
impl FromByteSlice for SpitfpBaudrateConfig {
fn bytes_expected() -> usize { 5 }
fn from_le_byte_slice(bytes: &[u8]) -> SpitfpBaudrateConfig {
SpitfpBaudrateConfig {
enable_dynamic_baudrate: <bool>::from_le_byte_slice(&bytes[0..1]),
minimum_dynamic_baudrate: <u32>::from_le_byte_slice(&bytes[1..5]),
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct SpitfpErrorCount {
pub error_count_ack_checksum: u32,
pub error_count_message_checksum: u32,
pub error_count_frame: u32,
pub error_count_overflow: u32,
}
impl FromByteSlice for SpitfpErrorCount {
fn bytes_expected() -> usize { 16 }
fn from_le_byte_slice(bytes: &[u8]) -> SpitfpErrorCount {
SpitfpErrorCount {
error_count_ack_checksum: <u32>::from_le_byte_slice(&bytes[0..4]),
error_count_message_checksum: <u32>::from_le_byte_slice(&bytes[4..8]),
error_count_frame: <u32>::from_le_byte_slice(&bytes[8..12]),
error_count_overflow: <u32>::from_le_byte_slice(&bytes[12..16]),
}
}
}
#[derive(Clone)]
pub struct Protocol1BrickletName {
pub protocol_version: u8,
pub firmware_version: [u8; 3],
pub name: String,
}
impl FromByteSlice for Protocol1BrickletName {
fn bytes_expected() -> usize { 44 }
fn from_le_byte_slice(bytes: &[u8]) -> Protocol1BrickletName {
Protocol1BrickletName {
protocol_version: <u8>::from_le_byte_slice(&bytes[0..1]),
firmware_version: <[u8; 3]>::from_le_byte_slice(&bytes[1..4]),
name: <String>::from_le_byte_slice(&bytes[4..44]),
}
}
}
#[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 StepperBrick {
device: Device,
}
impl StepperBrick {
pub const DEVICE_IDENTIFIER: u16 = 15;
pub const DEVICE_DISPLAY_NAME: &'static str = "Stepper Brick";
pub fn new<T: GetRequestSender>(uid: &str, req_sender: T) -> StepperBrick {
let mut result = StepperBrick { device: Device::new([2, 0, 4], uid, req_sender, 0) };
result.device.response_expected[u8::from(StepperBrickFunction::SetMaxVelocity) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(StepperBrickFunction::GetMaxVelocity) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::GetCurrentVelocity) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::SetSpeedRamping) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(StepperBrickFunction::GetSpeedRamping) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::FullBrake) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(StepperBrickFunction::SetCurrentPosition) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(StepperBrickFunction::GetCurrentPosition) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::SetTargetPosition) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(StepperBrickFunction::GetTargetPosition) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::SetSteps) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(StepperBrickFunction::GetSteps) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::GetRemainingSteps) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::SetStepMode) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(StepperBrickFunction::GetStepMode) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::DriveForward) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(StepperBrickFunction::DriveBackward) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(StepperBrickFunction::Stop) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(StepperBrickFunction::GetStackInputVoltage) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::GetExternalInputVoltage) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::GetCurrentConsumption) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::SetMotorCurrent) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(StepperBrickFunction::GetMotorCurrent) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::Enable) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(StepperBrickFunction::Disable) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(StepperBrickFunction::IsEnabled) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::SetDecay) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(StepperBrickFunction::GetDecay) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::SetMinimumVoltage) as usize] = ResponseExpectedFlag::True;
result.device.response_expected[u8::from(StepperBrickFunction::GetMinimumVoltage) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::SetSyncRect) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(StepperBrickFunction::IsSyncRect) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::SetTimeBase) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(StepperBrickFunction::GetTimeBase) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::GetAllData) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::SetAllDataPeriod) as usize] = ResponseExpectedFlag::True;
result.device.response_expected[u8::from(StepperBrickFunction::GetAllDataPeriod) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::SetSpitfpBaudrateConfig) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(StepperBrickFunction::GetSpitfpBaudrateConfig) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::GetSendTimeoutCount) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::SetSpitfpBaudrate) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(StepperBrickFunction::GetSpitfpBaudrate) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::GetSpitfpErrorCount) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::EnableStatusLed) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(StepperBrickFunction::DisableStatusLed) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(StepperBrickFunction::IsStatusLedEnabled) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::GetProtocol1BrickletName) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::GetChipTemperature) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(StepperBrickFunction::Reset) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(StepperBrickFunction::GetIdentity) as usize] = ResponseExpectedFlag::AlwaysTrue;
result
}
pub fn get_response_expected(&mut self, fun: StepperBrickFunction) -> Result<bool, GetResponseExpectedError> {
self.device.get_response_expected(u8::from(fun))
}
pub fn set_response_expected(&mut self, fun: StepperBrickFunction, 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_under_voltage_callback_receiver(&self) -> ConvertingCallbackReceiver<u16> {
self.device.get_callback_receiver(u8::from(StepperBrickFunction::CallbackUnderVoltage))
}
pub fn get_position_reached_callback_receiver(&self) -> ConvertingCallbackReceiver<i32> {
self.device.get_callback_receiver(u8::from(StepperBrickFunction::CallbackPositionReached))
}
pub fn get_all_data_callback_receiver(&self) -> ConvertingCallbackReceiver<AllDataEvent> {
self.device.get_callback_receiver(u8::from(StepperBrickFunction::CallbackAllData))
}
pub fn get_new_state_callback_receiver(&self) -> ConvertingCallbackReceiver<NewStateEvent> {
self.device.get_callback_receiver(u8::from(StepperBrickFunction::CallbackNewState))
}
pub fn set_max_velocity(&self, velocity: u16) -> ConvertingReceiver<()> {
let mut payload = vec![0; 2];
payload[0..2].copy_from_slice(&<u16>::to_le_byte_vec(velocity));
self.device.set(u8::from(StepperBrickFunction::SetMaxVelocity), payload)
}
pub fn get_max_velocity(&self) -> ConvertingReceiver<u16> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::GetMaxVelocity), payload)
}
pub fn get_current_velocity(&self) -> ConvertingReceiver<u16> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::GetCurrentVelocity), payload)
}
pub fn set_speed_ramping(&self, acceleration: u16, deacceleration: u16) -> ConvertingReceiver<()> {
let mut payload = vec![0; 4];
payload[0..2].copy_from_slice(&<u16>::to_le_byte_vec(acceleration));
payload[2..4].copy_from_slice(&<u16>::to_le_byte_vec(deacceleration));
self.device.set(u8::from(StepperBrickFunction::SetSpeedRamping), payload)
}
pub fn get_speed_ramping(&self) -> ConvertingReceiver<SpeedRamping> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::GetSpeedRamping), payload)
}
pub fn full_brake(&self) -> ConvertingReceiver<()> {
let payload = vec![0; 0];
self.device.set(u8::from(StepperBrickFunction::FullBrake), payload)
}
pub fn set_current_position(&self, position: i32) -> ConvertingReceiver<()> {
let mut payload = vec![0; 4];
payload[0..4].copy_from_slice(&<i32>::to_le_byte_vec(position));
self.device.set(u8::from(StepperBrickFunction::SetCurrentPosition), payload)
}
pub fn get_current_position(&self) -> ConvertingReceiver<i32> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::GetCurrentPosition), payload)
}
pub fn set_target_position(&self, position: i32) -> ConvertingReceiver<()> {
let mut payload = vec![0; 4];
payload[0..4].copy_from_slice(&<i32>::to_le_byte_vec(position));
self.device.set(u8::from(StepperBrickFunction::SetTargetPosition), payload)
}
pub fn get_target_position(&self) -> ConvertingReceiver<i32> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::GetTargetPosition), payload)
}
pub fn set_steps(&self, steps: i32) -> ConvertingReceiver<()> {
let mut payload = vec![0; 4];
payload[0..4].copy_from_slice(&<i32>::to_le_byte_vec(steps));
self.device.set(u8::from(StepperBrickFunction::SetSteps), payload)
}
pub fn get_steps(&self) -> ConvertingReceiver<i32> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::GetSteps), payload)
}
pub fn get_remaining_steps(&self) -> ConvertingReceiver<i32> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::GetRemainingSteps), payload)
}
pub fn set_step_mode(&self, mode: u8) -> ConvertingReceiver<()> {
let mut payload = vec![0; 1];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(mode));
self.device.set(u8::from(StepperBrickFunction::SetStepMode), payload)
}
pub fn get_step_mode(&self) -> ConvertingReceiver<u8> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::GetStepMode), payload)
}
pub fn drive_forward(&self) -> ConvertingReceiver<()> {
let payload = vec![0; 0];
self.device.set(u8::from(StepperBrickFunction::DriveForward), payload)
}
pub fn drive_backward(&self) -> ConvertingReceiver<()> {
let payload = vec![0; 0];
self.device.set(u8::from(StepperBrickFunction::DriveBackward), payload)
}
pub fn stop(&self) -> ConvertingReceiver<()> {
let payload = vec![0; 0];
self.device.set(u8::from(StepperBrickFunction::Stop), payload)
}
pub fn get_stack_input_voltage(&self) -> ConvertingReceiver<u16> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::GetStackInputVoltage), payload)
}
pub fn get_external_input_voltage(&self) -> ConvertingReceiver<u16> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::GetExternalInputVoltage), payload)
}
pub fn get_current_consumption(&self) -> ConvertingReceiver<u16> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::GetCurrentConsumption), payload)
}
pub fn set_motor_current(&self, current: u16) -> ConvertingReceiver<()> {
let mut payload = vec![0; 2];
payload[0..2].copy_from_slice(&<u16>::to_le_byte_vec(current));
self.device.set(u8::from(StepperBrickFunction::SetMotorCurrent), payload)
}
pub fn get_motor_current(&self) -> ConvertingReceiver<u16> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::GetMotorCurrent), payload)
}
pub fn enable(&self) -> ConvertingReceiver<()> {
let payload = vec![0; 0];
self.device.set(u8::from(StepperBrickFunction::Enable), payload)
}
pub fn disable(&self) -> ConvertingReceiver<()> {
let payload = vec![0; 0];
self.device.set(u8::from(StepperBrickFunction::Disable), payload)
}
pub fn is_enabled(&self) -> ConvertingReceiver<bool> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::IsEnabled), payload)
}
pub fn set_decay(&self, decay: u16) -> ConvertingReceiver<()> {
let mut payload = vec![0; 2];
payload[0..2].copy_from_slice(&<u16>::to_le_byte_vec(decay));
self.device.set(u8::from(StepperBrickFunction::SetDecay), payload)
}
pub fn get_decay(&self) -> ConvertingReceiver<u16> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::GetDecay), payload)
}
pub fn set_minimum_voltage(&self, voltage: u16) -> ConvertingReceiver<()> {
let mut payload = vec![0; 2];
payload[0..2].copy_from_slice(&<u16>::to_le_byte_vec(voltage));
self.device.set(u8::from(StepperBrickFunction::SetMinimumVoltage), payload)
}
pub fn get_minimum_voltage(&self) -> ConvertingReceiver<u16> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::GetMinimumVoltage), payload)
}
pub fn set_sync_rect(&self, sync_rect: bool) -> ConvertingReceiver<()> {
let mut payload = vec![0; 1];
payload[0..1].copy_from_slice(&<bool>::to_le_byte_vec(sync_rect));
self.device.set(u8::from(StepperBrickFunction::SetSyncRect), payload)
}
pub fn is_sync_rect(&self) -> ConvertingReceiver<bool> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::IsSyncRect), payload)
}
pub fn set_time_base(&self, time_base: u32) -> ConvertingReceiver<()> {
let mut payload = vec![0; 4];
payload[0..4].copy_from_slice(&<u32>::to_le_byte_vec(time_base));
self.device.set(u8::from(StepperBrickFunction::SetTimeBase), payload)
}
pub fn get_time_base(&self) -> ConvertingReceiver<u32> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::GetTimeBase), payload)
}
pub fn get_all_data(&self) -> ConvertingReceiver<AllData> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::GetAllData), payload)
}
pub fn set_all_data_period(&self, period: u32) -> ConvertingReceiver<()> {
let mut payload = vec![0; 4];
payload[0..4].copy_from_slice(&<u32>::to_le_byte_vec(period));
self.device.set(u8::from(StepperBrickFunction::SetAllDataPeriod), payload)
}
pub fn get_all_data_period(&self) -> ConvertingReceiver<u32> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::GetAllDataPeriod), payload)
}
pub fn set_spitfp_baudrate_config(&self, enable_dynamic_baudrate: bool, minimum_dynamic_baudrate: u32) -> ConvertingReceiver<()> {
let mut payload = vec![0; 5];
payload[0..1].copy_from_slice(&<bool>::to_le_byte_vec(enable_dynamic_baudrate));
payload[1..5].copy_from_slice(&<u32>::to_le_byte_vec(minimum_dynamic_baudrate));
self.device.set(u8::from(StepperBrickFunction::SetSpitfpBaudrateConfig), payload)
}
pub fn get_spitfp_baudrate_config(&self) -> ConvertingReceiver<SpitfpBaudrateConfig> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::GetSpitfpBaudrateConfig), payload)
}
pub fn get_send_timeout_count(&self, communication_method: u8) -> ConvertingReceiver<u32> {
let mut payload = vec![0; 1];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(communication_method));
self.device.get(u8::from(StepperBrickFunction::GetSendTimeoutCount), payload)
}
pub fn set_spitfp_baudrate(&self, bricklet_port: char, baudrate: u32) -> ConvertingReceiver<()> {
let mut payload = vec![0; 5];
payload[0..1].copy_from_slice(&<char>::to_le_byte_vec(bricklet_port));
payload[1..5].copy_from_slice(&<u32>::to_le_byte_vec(baudrate));
self.device.set(u8::from(StepperBrickFunction::SetSpitfpBaudrate), payload)
}
pub fn get_spitfp_baudrate(&self, bricklet_port: char) -> ConvertingReceiver<u32> {
let mut payload = vec![0; 1];
payload[0..1].copy_from_slice(&<char>::to_le_byte_vec(bricklet_port));
self.device.get(u8::from(StepperBrickFunction::GetSpitfpBaudrate), payload)
}
pub fn get_spitfp_error_count(&self, bricklet_port: char) -> ConvertingReceiver<SpitfpErrorCount> {
let mut payload = vec![0; 1];
payload[0..1].copy_from_slice(&<char>::to_le_byte_vec(bricklet_port));
self.device.get(u8::from(StepperBrickFunction::GetSpitfpErrorCount), payload)
}
pub fn enable_status_led(&self) -> ConvertingReceiver<()> {
let payload = vec![0; 0];
self.device.set(u8::from(StepperBrickFunction::EnableStatusLed), payload)
}
pub fn disable_status_led(&self) -> ConvertingReceiver<()> {
let payload = vec![0; 0];
self.device.set(u8::from(StepperBrickFunction::DisableStatusLed), payload)
}
pub fn is_status_led_enabled(&self) -> ConvertingReceiver<bool> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::IsStatusLedEnabled), payload)
}
pub fn get_protocol1_bricklet_name(&self, port: char) -> ConvertingReceiver<Protocol1BrickletName> {
let mut payload = vec![0; 1];
payload[0..1].copy_from_slice(&<char>::to_le_byte_vec(port));
self.device.get(u8::from(StepperBrickFunction::GetProtocol1BrickletName), payload)
}
pub fn get_chip_temperature(&self) -> ConvertingReceiver<i16> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::GetChipTemperature), payload)
}
pub fn reset(&self) -> ConvertingReceiver<()> {
let payload = vec![0; 0];
self.device.set(u8::from(StepperBrickFunction::Reset), payload)
}
pub fn get_identity(&self) -> ConvertingReceiver<Identity> {
let payload = vec![0; 0];
self.device.get(u8::from(StepperBrickFunction::GetIdentity), payload)
}
}