use crate::{
byte_converter::*,
converting_callback_receiver::ConvertingCallbackReceiver,
converting_receiver::{BrickletError, ConvertingReceiver},
device::*,
ip_connection::GetRequestSender,
};
pub enum MasterBrickFunction {
GetStackVoltage,
GetStackCurrent,
SetExtensionType,
GetExtensionType,
IsChibiPresent,
SetChibiAddress,
GetChibiAddress,
SetChibiMasterAddress,
GetChibiMasterAddress,
SetChibiSlaveAddress,
GetChibiSlaveAddress,
GetChibiSignalStrength,
GetChibiErrorLog,
SetChibiFrequency,
GetChibiFrequency,
SetChibiChannel,
GetChibiChannel,
IsRs485Present,
SetRs485Address,
GetRs485Address,
SetRs485SlaveAddress,
GetRs485SlaveAddress,
GetRs485ErrorLog,
SetRs485Configuration,
GetRs485Configuration,
IsWifiPresent,
SetWifiConfiguration,
GetWifiConfiguration,
SetWifiEncryption,
GetWifiEncryption,
GetWifiStatus,
RefreshWifiStatus,
SetWifiCertificate,
GetWifiCertificate,
SetWifiPowerMode,
GetWifiPowerMode,
GetWifiBufferInfo,
SetWifiRegulatoryDomain,
GetWifiRegulatoryDomain,
GetUsbVoltage,
SetLongWifiKey,
GetLongWifiKey,
SetWifiHostname,
GetWifiHostname,
SetStackCurrentCallbackPeriod,
GetStackCurrentCallbackPeriod,
SetStackVoltageCallbackPeriod,
GetStackVoltageCallbackPeriod,
SetUsbVoltageCallbackPeriod,
GetUsbVoltageCallbackPeriod,
SetStackCurrentCallbackThreshold,
GetStackCurrentCallbackThreshold,
SetStackVoltageCallbackThreshold,
GetStackVoltageCallbackThreshold,
SetUsbVoltageCallbackThreshold,
GetUsbVoltageCallbackThreshold,
SetDebouncePeriod,
GetDebouncePeriod,
IsEthernetPresent,
SetEthernetConfiguration,
GetEthernetConfiguration,
GetEthernetStatus,
SetEthernetHostname,
SetEthernetMacAddress,
SetEthernetWebsocketConfiguration,
GetEthernetWebsocketConfiguration,
SetEthernetAuthenticationSecret,
GetEthernetAuthenticationSecret,
SetWifiAuthenticationSecret,
GetWifiAuthenticationSecret,
GetConnectionType,
IsWifi2Present,
StartWifi2Bootloader,
WriteWifi2SerialPort,
ReadWifi2SerialPort,
SetWifi2AuthenticationSecret,
GetWifi2AuthenticationSecret,
SetWifi2Configuration,
GetWifi2Configuration,
GetWifi2Status,
SetWifi2ClientConfiguration,
GetWifi2ClientConfiguration,
SetWifi2ClientHostname,
GetWifi2ClientHostname,
SetWifi2ClientPassword,
GetWifi2ClientPassword,
SetWifi2ApConfiguration,
GetWifi2ApConfiguration,
SetWifi2ApPassword,
GetWifi2ApPassword,
SaveWifi2Configuration,
GetWifi2FirmwareVersion,
EnableWifi2StatusLed,
DisableWifi2StatusLed,
IsWifi2StatusLedEnabled,
SetWifi2MeshConfiguration,
GetWifi2MeshConfiguration,
SetWifi2MeshRouterSsid,
GetWifi2MeshRouterSsid,
SetWifi2MeshRouterPassword,
GetWifi2MeshRouterPassword,
GetWifi2MeshCommonStatus,
GetWifi2MeshClientStatus,
GetWifi2MeshApStatus,
SetSpitfpBaudrateConfig,
GetSpitfpBaudrateConfig,
GetSendTimeoutCount,
SetSpitfpBaudrate,
GetSpitfpBaudrate,
GetSpitfpErrorCount,
EnableStatusLed,
DisableStatusLed,
IsStatusLedEnabled,
GetProtocol1BrickletName,
GetChipTemperature,
Reset,
GetIdentity,
CallbackStackCurrent,
CallbackStackVoltage,
CallbackUsbVoltage,
CallbackStackCurrentReached,
CallbackStackVoltageReached,
CallbackUsbVoltageReached,
}
impl From<MasterBrickFunction> for u8 {
fn from(fun: MasterBrickFunction) -> Self {
match fun {
MasterBrickFunction::GetStackVoltage => 1,
MasterBrickFunction::GetStackCurrent => 2,
MasterBrickFunction::SetExtensionType => 3,
MasterBrickFunction::GetExtensionType => 4,
MasterBrickFunction::IsChibiPresent => 5,
MasterBrickFunction::SetChibiAddress => 6,
MasterBrickFunction::GetChibiAddress => 7,
MasterBrickFunction::SetChibiMasterAddress => 8,
MasterBrickFunction::GetChibiMasterAddress => 9,
MasterBrickFunction::SetChibiSlaveAddress => 10,
MasterBrickFunction::GetChibiSlaveAddress => 11,
MasterBrickFunction::GetChibiSignalStrength => 12,
MasterBrickFunction::GetChibiErrorLog => 13,
MasterBrickFunction::SetChibiFrequency => 14,
MasterBrickFunction::GetChibiFrequency => 15,
MasterBrickFunction::SetChibiChannel => 16,
MasterBrickFunction::GetChibiChannel => 17,
MasterBrickFunction::IsRs485Present => 18,
MasterBrickFunction::SetRs485Address => 19,
MasterBrickFunction::GetRs485Address => 20,
MasterBrickFunction::SetRs485SlaveAddress => 21,
MasterBrickFunction::GetRs485SlaveAddress => 22,
MasterBrickFunction::GetRs485ErrorLog => 23,
MasterBrickFunction::SetRs485Configuration => 24,
MasterBrickFunction::GetRs485Configuration => 25,
MasterBrickFunction::IsWifiPresent => 26,
MasterBrickFunction::SetWifiConfiguration => 27,
MasterBrickFunction::GetWifiConfiguration => 28,
MasterBrickFunction::SetWifiEncryption => 29,
MasterBrickFunction::GetWifiEncryption => 30,
MasterBrickFunction::GetWifiStatus => 31,
MasterBrickFunction::RefreshWifiStatus => 32,
MasterBrickFunction::SetWifiCertificate => 33,
MasterBrickFunction::GetWifiCertificate => 34,
MasterBrickFunction::SetWifiPowerMode => 35,
MasterBrickFunction::GetWifiPowerMode => 36,
MasterBrickFunction::GetWifiBufferInfo => 37,
MasterBrickFunction::SetWifiRegulatoryDomain => 38,
MasterBrickFunction::GetWifiRegulatoryDomain => 39,
MasterBrickFunction::GetUsbVoltage => 40,
MasterBrickFunction::SetLongWifiKey => 41,
MasterBrickFunction::GetLongWifiKey => 42,
MasterBrickFunction::SetWifiHostname => 43,
MasterBrickFunction::GetWifiHostname => 44,
MasterBrickFunction::SetStackCurrentCallbackPeriod => 45,
MasterBrickFunction::GetStackCurrentCallbackPeriod => 46,
MasterBrickFunction::SetStackVoltageCallbackPeriod => 47,
MasterBrickFunction::GetStackVoltageCallbackPeriod => 48,
MasterBrickFunction::SetUsbVoltageCallbackPeriod => 49,
MasterBrickFunction::GetUsbVoltageCallbackPeriod => 50,
MasterBrickFunction::SetStackCurrentCallbackThreshold => 51,
MasterBrickFunction::GetStackCurrentCallbackThreshold => 52,
MasterBrickFunction::SetStackVoltageCallbackThreshold => 53,
MasterBrickFunction::GetStackVoltageCallbackThreshold => 54,
MasterBrickFunction::SetUsbVoltageCallbackThreshold => 55,
MasterBrickFunction::GetUsbVoltageCallbackThreshold => 56,
MasterBrickFunction::SetDebouncePeriod => 57,
MasterBrickFunction::GetDebouncePeriod => 58,
MasterBrickFunction::IsEthernetPresent => 65,
MasterBrickFunction::SetEthernetConfiguration => 66,
MasterBrickFunction::GetEthernetConfiguration => 67,
MasterBrickFunction::GetEthernetStatus => 68,
MasterBrickFunction::SetEthernetHostname => 69,
MasterBrickFunction::SetEthernetMacAddress => 70,
MasterBrickFunction::SetEthernetWebsocketConfiguration => 71,
MasterBrickFunction::GetEthernetWebsocketConfiguration => 72,
MasterBrickFunction::SetEthernetAuthenticationSecret => 73,
MasterBrickFunction::GetEthernetAuthenticationSecret => 74,
MasterBrickFunction::SetWifiAuthenticationSecret => 75,
MasterBrickFunction::GetWifiAuthenticationSecret => 76,
MasterBrickFunction::GetConnectionType => 77,
MasterBrickFunction::IsWifi2Present => 78,
MasterBrickFunction::StartWifi2Bootloader => 79,
MasterBrickFunction::WriteWifi2SerialPort => 80,
MasterBrickFunction::ReadWifi2SerialPort => 81,
MasterBrickFunction::SetWifi2AuthenticationSecret => 82,
MasterBrickFunction::GetWifi2AuthenticationSecret => 83,
MasterBrickFunction::SetWifi2Configuration => 84,
MasterBrickFunction::GetWifi2Configuration => 85,
MasterBrickFunction::GetWifi2Status => 86,
MasterBrickFunction::SetWifi2ClientConfiguration => 87,
MasterBrickFunction::GetWifi2ClientConfiguration => 88,
MasterBrickFunction::SetWifi2ClientHostname => 89,
MasterBrickFunction::GetWifi2ClientHostname => 90,
MasterBrickFunction::SetWifi2ClientPassword => 91,
MasterBrickFunction::GetWifi2ClientPassword => 92,
MasterBrickFunction::SetWifi2ApConfiguration => 93,
MasterBrickFunction::GetWifi2ApConfiguration => 94,
MasterBrickFunction::SetWifi2ApPassword => 95,
MasterBrickFunction::GetWifi2ApPassword => 96,
MasterBrickFunction::SaveWifi2Configuration => 97,
MasterBrickFunction::GetWifi2FirmwareVersion => 98,
MasterBrickFunction::EnableWifi2StatusLed => 99,
MasterBrickFunction::DisableWifi2StatusLed => 100,
MasterBrickFunction::IsWifi2StatusLedEnabled => 101,
MasterBrickFunction::SetWifi2MeshConfiguration => 102,
MasterBrickFunction::GetWifi2MeshConfiguration => 103,
MasterBrickFunction::SetWifi2MeshRouterSsid => 104,
MasterBrickFunction::GetWifi2MeshRouterSsid => 105,
MasterBrickFunction::SetWifi2MeshRouterPassword => 106,
MasterBrickFunction::GetWifi2MeshRouterPassword => 107,
MasterBrickFunction::GetWifi2MeshCommonStatus => 108,
MasterBrickFunction::GetWifi2MeshClientStatus => 109,
MasterBrickFunction::GetWifi2MeshApStatus => 110,
MasterBrickFunction::SetSpitfpBaudrateConfig => 231,
MasterBrickFunction::GetSpitfpBaudrateConfig => 232,
MasterBrickFunction::GetSendTimeoutCount => 233,
MasterBrickFunction::SetSpitfpBaudrate => 234,
MasterBrickFunction::GetSpitfpBaudrate => 235,
MasterBrickFunction::GetSpitfpErrorCount => 237,
MasterBrickFunction::EnableStatusLed => 238,
MasterBrickFunction::DisableStatusLed => 239,
MasterBrickFunction::IsStatusLedEnabled => 240,
MasterBrickFunction::GetProtocol1BrickletName => 241,
MasterBrickFunction::GetChipTemperature => 242,
MasterBrickFunction::Reset => 243,
MasterBrickFunction::GetIdentity => 255,
MasterBrickFunction::CallbackStackCurrent => 59,
MasterBrickFunction::CallbackStackVoltage => 60,
MasterBrickFunction::CallbackUsbVoltage => 61,
MasterBrickFunction::CallbackStackCurrentReached => 62,
MasterBrickFunction::CallbackStackVoltageReached => 63,
MasterBrickFunction::CallbackUsbVoltageReached => 64,
}
}
}
pub const MASTER_BRICK_EXTENSION_TYPE_CHIBI: u32 = 1;
pub const MASTER_BRICK_EXTENSION_TYPE_RS485: u32 = 2;
pub const MASTER_BRICK_EXTENSION_TYPE_WIFI: u32 = 3;
pub const MASTER_BRICK_EXTENSION_TYPE_ETHERNET: u32 = 4;
pub const MASTER_BRICK_EXTENSION_TYPE_WIFI2: u32 = 5;
pub const MASTER_BRICK_CHIBI_FREQUENCY_OQPSK_868_MHZ: u8 = 0;
pub const MASTER_BRICK_CHIBI_FREQUENCY_OQPSK_915_MHZ: u8 = 1;
pub const MASTER_BRICK_CHIBI_FREQUENCY_OQPSK_780_MHZ: u8 = 2;
pub const MASTER_BRICK_CHIBI_FREQUENCY_BPSK40_915_MHZ: u8 = 3;
pub const MASTER_BRICK_RS485_PARITY_NONE: char = 'n';
pub const MASTER_BRICK_RS485_PARITY_EVEN: char = 'e';
pub const MASTER_BRICK_RS485_PARITY_ODD: char = 'o';
pub const MASTER_BRICK_WIFI_CONNECTION_DHCP: u8 = 0;
pub const MASTER_BRICK_WIFI_CONNECTION_STATIC_IP: u8 = 1;
pub const MASTER_BRICK_WIFI_CONNECTION_ACCESS_POINT_DHCP: u8 = 2;
pub const MASTER_BRICK_WIFI_CONNECTION_ACCESS_POINT_STATIC_IP: u8 = 3;
pub const MASTER_BRICK_WIFI_CONNECTION_AD_HOC_DHCP: u8 = 4;
pub const MASTER_BRICK_WIFI_CONNECTION_AD_HOC_STATIC_IP: u8 = 5;
pub const MASTER_BRICK_WIFI_ENCRYPTION_WPA_WPA2: u8 = 0;
pub const MASTER_BRICK_WIFI_ENCRYPTION_WPA_ENTERPRISE: u8 = 1;
pub const MASTER_BRICK_WIFI_ENCRYPTION_WEP: u8 = 2;
pub const MASTER_BRICK_WIFI_ENCRYPTION_NO_ENCRYPTION: u8 = 3;
pub const MASTER_BRICK_WIFI_EAP_OPTION_OUTER_AUTH_EAP_FAST: u8 = 0;
pub const MASTER_BRICK_WIFI_EAP_OPTION_OUTER_AUTH_EAP_TLS: u8 = 1;
pub const MASTER_BRICK_WIFI_EAP_OPTION_OUTER_AUTH_EAP_TTLS: u8 = 2;
pub const MASTER_BRICK_WIFI_EAP_OPTION_OUTER_AUTH_EAP_PEAP: u8 = 3;
pub const MASTER_BRICK_WIFI_EAP_OPTION_INNER_AUTH_EAP_MSCHAP: u8 = 0;
pub const MASTER_BRICK_WIFI_EAP_OPTION_INNER_AUTH_EAP_GTC: u8 = 4;
pub const MASTER_BRICK_WIFI_EAP_OPTION_CERT_TYPE_CA_CERT: u8 = 0;
pub const MASTER_BRICK_WIFI_EAP_OPTION_CERT_TYPE_CLIENT_CERT: u8 = 8;
pub const MASTER_BRICK_WIFI_EAP_OPTION_CERT_TYPE_PRIVATE_KEY: u8 = 16;
pub const MASTER_BRICK_WIFI_STATE_DISASSOCIATED: u8 = 0;
pub const MASTER_BRICK_WIFI_STATE_ASSOCIATED: u8 = 1;
pub const MASTER_BRICK_WIFI_STATE_ASSOCIATING: u8 = 2;
pub const MASTER_BRICK_WIFI_STATE_ERROR: u8 = 3;
pub const MASTER_BRICK_WIFI_STATE_NOT_INITIALIZED_YET: u8 = 255;
pub const MASTER_BRICK_WIFI_POWER_MODE_FULL_SPEED: u8 = 0;
pub const MASTER_BRICK_WIFI_POWER_MODE_LOW_POWER: u8 = 1;
pub const MASTER_BRICK_WIFI_DOMAIN_CHANNEL_1TO11: u8 = 0;
pub const MASTER_BRICK_WIFI_DOMAIN_CHANNEL_1TO13: u8 = 1;
pub const MASTER_BRICK_WIFI_DOMAIN_CHANNEL_1TO14: u8 = 2;
pub const MASTER_BRICK_THRESHOLD_OPTION_OFF: char = 'x';
pub const MASTER_BRICK_THRESHOLD_OPTION_OUTSIDE: char = 'o';
pub const MASTER_BRICK_THRESHOLD_OPTION_INSIDE: char = 'i';
pub const MASTER_BRICK_THRESHOLD_OPTION_SMALLER: char = '<';
pub const MASTER_BRICK_THRESHOLD_OPTION_GREATER: char = '>';
pub const MASTER_BRICK_ETHERNET_CONNECTION_DHCP: u8 = 0;
pub const MASTER_BRICK_ETHERNET_CONNECTION_STATIC_IP: u8 = 1;
pub const MASTER_BRICK_CONNECTION_TYPE_NONE: u8 = 0;
pub const MASTER_BRICK_CONNECTION_TYPE_USB: u8 = 1;
pub const MASTER_BRICK_CONNECTION_TYPE_SPI_STACK: u8 = 2;
pub const MASTER_BRICK_CONNECTION_TYPE_CHIBI: u8 = 3;
pub const MASTER_BRICK_CONNECTION_TYPE_RS485: u8 = 4;
pub const MASTER_BRICK_CONNECTION_TYPE_WIFI: u8 = 5;
pub const MASTER_BRICK_CONNECTION_TYPE_ETHERNET: u8 = 6;
pub const MASTER_BRICK_CONNECTION_TYPE_WIFI2: u8 = 7;
pub const MASTER_BRICK_WIFI2_PHY_MODE_B: u8 = 0;
pub const MASTER_BRICK_WIFI2_PHY_MODE_G: u8 = 1;
pub const MASTER_BRICK_WIFI2_PHY_MODE_N: u8 = 2;
pub const MASTER_BRICK_WIFI2_CLIENT_STATUS_IDLE: u8 = 0;
pub const MASTER_BRICK_WIFI2_CLIENT_STATUS_CONNECTING: u8 = 1;
pub const MASTER_BRICK_WIFI2_CLIENT_STATUS_WRONG_PASSWORD: u8 = 2;
pub const MASTER_BRICK_WIFI2_CLIENT_STATUS_NO_AP_FOUND: u8 = 3;
pub const MASTER_BRICK_WIFI2_CLIENT_STATUS_CONNECT_FAILED: u8 = 4;
pub const MASTER_BRICK_WIFI2_CLIENT_STATUS_GOT_IP: u8 = 5;
pub const MASTER_BRICK_WIFI2_CLIENT_STATUS_UNKNOWN: u8 = 255;
pub const MASTER_BRICK_WIFI2_AP_ENCRYPTION_OPEN: u8 = 0;
pub const MASTER_BRICK_WIFI2_AP_ENCRYPTION_WEP: u8 = 1;
pub const MASTER_BRICK_WIFI2_AP_ENCRYPTION_WPA_PSK: u8 = 2;
pub const MASTER_BRICK_WIFI2_AP_ENCRYPTION_WPA2_PSK: u8 = 3;
pub const MASTER_BRICK_WIFI2_AP_ENCRYPTION_WPA_WPA2_PSK: u8 = 4;
pub const MASTER_BRICK_WIFI2_MESH_STATUS_DISABLED: u8 = 0;
pub const MASTER_BRICK_WIFI2_MESH_STATUS_WIFI_CONNECTING: u8 = 1;
pub const MASTER_BRICK_WIFI2_MESH_STATUS_GOT_IP: u8 = 2;
pub const MASTER_BRICK_WIFI2_MESH_STATUS_MESH_LOCAL: u8 = 3;
pub const MASTER_BRICK_WIFI2_MESH_STATUS_MESH_ONLINE: u8 = 4;
pub const MASTER_BRICK_WIFI2_MESH_STATUS_AP_AVAILABLE: u8 = 5;
pub const MASTER_BRICK_WIFI2_MESH_STATUS_AP_SETUP: u8 = 6;
pub const MASTER_BRICK_WIFI2_MESH_STATUS_LEAF_AVAILABLE: u8 = 7;
pub const MASTER_BRICK_COMMUNICATION_METHOD_NONE: u8 = 0;
pub const MASTER_BRICK_COMMUNICATION_METHOD_USB: u8 = 1;
pub const MASTER_BRICK_COMMUNICATION_METHOD_SPI_STACK: u8 = 2;
pub const MASTER_BRICK_COMMUNICATION_METHOD_CHIBI: u8 = 3;
pub const MASTER_BRICK_COMMUNICATION_METHOD_RS485: u8 = 4;
pub const MASTER_BRICK_COMMUNICATION_METHOD_WIFI: u8 = 5;
pub const MASTER_BRICK_COMMUNICATION_METHOD_ETHERNET: u8 = 6;
pub const MASTER_BRICK_COMMUNICATION_METHOD_WIFI_V2: u8 = 7;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct ChibiErrorLog {
pub underrun: u16,
pub crc_error: u16,
pub no_ack: u16,
pub overflow: u16,
}
impl FromByteSlice for ChibiErrorLog {
fn bytes_expected() -> usize { 8 }
fn from_le_byte_slice(bytes: &[u8]) -> ChibiErrorLog {
ChibiErrorLog {
underrun: <u16>::from_le_byte_slice(&bytes[0..2]),
crc_error: <u16>::from_le_byte_slice(&bytes[2..4]),
no_ack: <u16>::from_le_byte_slice(&bytes[4..6]),
overflow: <u16>::from_le_byte_slice(&bytes[6..8]),
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct Rs485Configuration {
pub speed: u32,
pub parity: char,
pub stopbits: u8,
}
impl FromByteSlice for Rs485Configuration {
fn bytes_expected() -> usize { 6 }
fn from_le_byte_slice(bytes: &[u8]) -> Rs485Configuration {
Rs485Configuration {
speed: <u32>::from_le_byte_slice(&bytes[0..4]),
parity: <char>::from_le_byte_slice(&bytes[4..5]),
stopbits: <u8>::from_le_byte_slice(&bytes[5..6]),
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct WifiConfiguration {
pub ssid: String,
pub connection: u8,
pub ip: [u8; 4],
pub subnet_mask: [u8; 4],
pub gateway: [u8; 4],
pub port: u16,
}
impl FromByteSlice for WifiConfiguration {
fn bytes_expected() -> usize { 47 }
fn from_le_byte_slice(bytes: &[u8]) -> WifiConfiguration {
WifiConfiguration {
ssid: <String>::from_le_byte_slice(&bytes[0..32]),
connection: <u8>::from_le_byte_slice(&bytes[32..33]),
ip: <[u8; 4]>::from_le_byte_slice(&bytes[33..37]),
subnet_mask: <[u8; 4]>::from_le_byte_slice(&bytes[37..41]),
gateway: <[u8; 4]>::from_le_byte_slice(&bytes[41..45]),
port: <u16>::from_le_byte_slice(&bytes[45..47]),
}
}
}
#[derive(Clone)]
pub struct WifiEncryption {
pub encryption: u8,
pub key: String,
pub key_index: u8,
pub eap_options: u8,
pub ca_certificate_length: u16,
pub client_certificate_length: u16,
pub private_key_length: u16,
}
impl FromByteSlice for WifiEncryption {
fn bytes_expected() -> usize { 59 }
fn from_le_byte_slice(bytes: &[u8]) -> WifiEncryption {
WifiEncryption {
encryption: <u8>::from_le_byte_slice(&bytes[0..1]),
key: <String>::from_le_byte_slice(&bytes[1..51]),
key_index: <u8>::from_le_byte_slice(&bytes[51..52]),
eap_options: <u8>::from_le_byte_slice(&bytes[52..53]),
ca_certificate_length: <u16>::from_le_byte_slice(&bytes[53..55]),
client_certificate_length: <u16>::from_le_byte_slice(&bytes[55..57]),
private_key_length: <u16>::from_le_byte_slice(&bytes[57..59]),
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct WifiStatus {
pub mac_address: [u8; 6],
pub bssid: [u8; 6],
pub channel: u8,
pub rssi: i16,
pub ip: [u8; 4],
pub subnet_mask: [u8; 4],
pub gateway: [u8; 4],
pub rx_count: u32,
pub tx_count: u32,
pub state: u8,
}
impl FromByteSlice for WifiStatus {
fn bytes_expected() -> usize { 36 }
fn from_le_byte_slice(bytes: &[u8]) -> WifiStatus {
WifiStatus {
mac_address: <[u8; 6]>::from_le_byte_slice(&bytes[0..6]),
bssid: <[u8; 6]>::from_le_byte_slice(&bytes[6..12]),
channel: <u8>::from_le_byte_slice(&bytes[12..13]),
rssi: <i16>::from_le_byte_slice(&bytes[13..15]),
ip: <[u8; 4]>::from_le_byte_slice(&bytes[15..19]),
subnet_mask: <[u8; 4]>::from_le_byte_slice(&bytes[19..23]),
gateway: <[u8; 4]>::from_le_byte_slice(&bytes[23..27]),
rx_count: <u32>::from_le_byte_slice(&bytes[27..31]),
tx_count: <u32>::from_le_byte_slice(&bytes[31..35]),
state: <u8>::from_le_byte_slice(&bytes[35..36]),
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct WifiCertificate {
pub data: [u8; 32],
pub data_length: u8,
}
impl FromByteSlice for WifiCertificate {
fn bytes_expected() -> usize { 33 }
fn from_le_byte_slice(bytes: &[u8]) -> WifiCertificate {
WifiCertificate { data: <[u8; 32]>::from_le_byte_slice(&bytes[0..32]), data_length: <u8>::from_le_byte_slice(&bytes[32..33]) }
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct WifiBufferInfo {
pub overflow: u32,
pub low_watermark: u16,
pub used: u16,
}
impl FromByteSlice for WifiBufferInfo {
fn bytes_expected() -> usize { 8 }
fn from_le_byte_slice(bytes: &[u8]) -> WifiBufferInfo {
WifiBufferInfo {
overflow: <u32>::from_le_byte_slice(&bytes[0..4]),
low_watermark: <u16>::from_le_byte_slice(&bytes[4..6]),
used: <u16>::from_le_byte_slice(&bytes[6..8]),
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct StackCurrentCallbackThreshold {
pub option: char,
pub min: u16,
pub max: u16,
}
impl FromByteSlice for StackCurrentCallbackThreshold {
fn bytes_expected() -> usize { 5 }
fn from_le_byte_slice(bytes: &[u8]) -> StackCurrentCallbackThreshold {
StackCurrentCallbackThreshold {
option: <char>::from_le_byte_slice(&bytes[0..1]),
min: <u16>::from_le_byte_slice(&bytes[1..3]),
max: <u16>::from_le_byte_slice(&bytes[3..5]),
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct StackVoltageCallbackThreshold {
pub option: char,
pub min: u16,
pub max: u16,
}
impl FromByteSlice for StackVoltageCallbackThreshold {
fn bytes_expected() -> usize { 5 }
fn from_le_byte_slice(bytes: &[u8]) -> StackVoltageCallbackThreshold {
StackVoltageCallbackThreshold {
option: <char>::from_le_byte_slice(&bytes[0..1]),
min: <u16>::from_le_byte_slice(&bytes[1..3]),
max: <u16>::from_le_byte_slice(&bytes[3..5]),
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct UsbVoltageCallbackThreshold {
pub option: char,
pub min: u16,
pub max: u16,
}
impl FromByteSlice for UsbVoltageCallbackThreshold {
fn bytes_expected() -> usize { 5 }
fn from_le_byte_slice(bytes: &[u8]) -> UsbVoltageCallbackThreshold {
UsbVoltageCallbackThreshold {
option: <char>::from_le_byte_slice(&bytes[0..1]),
min: <u16>::from_le_byte_slice(&bytes[1..3]),
max: <u16>::from_le_byte_slice(&bytes[3..5]),
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct EthernetConfiguration {
pub connection: u8,
pub ip: [u8; 4],
pub subnet_mask: [u8; 4],
pub gateway: [u8; 4],
pub port: u16,
}
impl FromByteSlice for EthernetConfiguration {
fn bytes_expected() -> usize { 15 }
fn from_le_byte_slice(bytes: &[u8]) -> EthernetConfiguration {
EthernetConfiguration {
connection: <u8>::from_le_byte_slice(&bytes[0..1]),
ip: <[u8; 4]>::from_le_byte_slice(&bytes[1..5]),
subnet_mask: <[u8; 4]>::from_le_byte_slice(&bytes[5..9]),
gateway: <[u8; 4]>::from_le_byte_slice(&bytes[9..13]),
port: <u16>::from_le_byte_slice(&bytes[13..15]),
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct EthernetStatus {
pub mac_address: [u8; 6],
pub ip: [u8; 4],
pub subnet_mask: [u8; 4],
pub gateway: [u8; 4],
pub rx_count: u32,
pub tx_count: u32,
pub hostname: String,
}
impl FromByteSlice for EthernetStatus {
fn bytes_expected() -> usize { 58 }
fn from_le_byte_slice(bytes: &[u8]) -> EthernetStatus {
EthernetStatus {
mac_address: <[u8; 6]>::from_le_byte_slice(&bytes[0..6]),
ip: <[u8; 4]>::from_le_byte_slice(&bytes[6..10]),
subnet_mask: <[u8; 4]>::from_le_byte_slice(&bytes[10..14]),
gateway: <[u8; 4]>::from_le_byte_slice(&bytes[14..18]),
rx_count: <u32>::from_le_byte_slice(&bytes[18..22]),
tx_count: <u32>::from_le_byte_slice(&bytes[22..26]),
hostname: <String>::from_le_byte_slice(&bytes[26..58]),
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct EthernetWebsocketConfiguration {
pub sockets: u8,
pub port: u16,
}
impl FromByteSlice for EthernetWebsocketConfiguration {
fn bytes_expected() -> usize { 3 }
fn from_le_byte_slice(bytes: &[u8]) -> EthernetWebsocketConfiguration {
EthernetWebsocketConfiguration { sockets: <u8>::from_le_byte_slice(&bytes[0..1]), port: <u16>::from_le_byte_slice(&bytes[1..3]) }
}
}
#[derive(Clone, Copy)]
pub struct ReadWifi2SerialPort {
pub data: [u8; 60],
pub result: u8,
}
impl FromByteSlice for ReadWifi2SerialPort {
fn bytes_expected() -> usize { 61 }
fn from_le_byte_slice(bytes: &[u8]) -> ReadWifi2SerialPort {
ReadWifi2SerialPort { data: <[u8; 60]>::from_le_byte_slice(&bytes[0..60]), result: <u8>::from_le_byte_slice(&bytes[60..61]) }
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct Wifi2Configuration {
pub port: u16,
pub websocket_port: u16,
pub website_port: u16,
pub phy_mode: u8,
pub sleep_mode: u8,
pub website: u8,
}
impl FromByteSlice for Wifi2Configuration {
fn bytes_expected() -> usize { 9 }
fn from_le_byte_slice(bytes: &[u8]) -> Wifi2Configuration {
Wifi2Configuration {
port: <u16>::from_le_byte_slice(&bytes[0..2]),
websocket_port: <u16>::from_le_byte_slice(&bytes[2..4]),
website_port: <u16>::from_le_byte_slice(&bytes[4..6]),
phy_mode: <u8>::from_le_byte_slice(&bytes[6..7]),
sleep_mode: <u8>::from_le_byte_slice(&bytes[7..8]),
website: <u8>::from_le_byte_slice(&bytes[8..9]),
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct Wifi2Status {
pub client_enabled: bool,
pub client_status: u8,
pub client_ip: [u8; 4],
pub client_subnet_mask: [u8; 4],
pub client_gateway: [u8; 4],
pub client_mac_address: [u8; 6],
pub client_rx_count: u32,
pub client_tx_count: u32,
pub client_rssi: i8,
pub ap_enabled: bool,
pub ap_ip: [u8; 4],
pub ap_subnet_mask: [u8; 4],
pub ap_gateway: [u8; 4],
pub ap_mac_address: [u8; 6],
pub ap_rx_count: u32,
pub ap_tx_count: u32,
pub ap_connected_count: u8,
}
impl FromByteSlice for Wifi2Status {
fn bytes_expected() -> usize { 57 }
fn from_le_byte_slice(bytes: &[u8]) -> Wifi2Status {
Wifi2Status {
client_enabled: <bool>::from_le_byte_slice(&bytes[0..1]),
client_status: <u8>::from_le_byte_slice(&bytes[1..2]),
client_ip: <[u8; 4]>::from_le_byte_slice(&bytes[2..6]),
client_subnet_mask: <[u8; 4]>::from_le_byte_slice(&bytes[6..10]),
client_gateway: <[u8; 4]>::from_le_byte_slice(&bytes[10..14]),
client_mac_address: <[u8; 6]>::from_le_byte_slice(&bytes[14..20]),
client_rx_count: <u32>::from_le_byte_slice(&bytes[20..24]),
client_tx_count: <u32>::from_le_byte_slice(&bytes[24..28]),
client_rssi: <i8>::from_le_byte_slice(&bytes[28..29]),
ap_enabled: <bool>::from_le_byte_slice(&bytes[29..30]),
ap_ip: <[u8; 4]>::from_le_byte_slice(&bytes[30..34]),
ap_subnet_mask: <[u8; 4]>::from_le_byte_slice(&bytes[34..38]),
ap_gateway: <[u8; 4]>::from_le_byte_slice(&bytes[38..42]),
ap_mac_address: <[u8; 6]>::from_le_byte_slice(&bytes[42..48]),
ap_rx_count: <u32>::from_le_byte_slice(&bytes[48..52]),
ap_tx_count: <u32>::from_le_byte_slice(&bytes[52..56]),
ap_connected_count: <u8>::from_le_byte_slice(&bytes[56..57]),
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct Wifi2ClientConfiguration {
pub enable: bool,
pub ssid: String,
pub ip: [u8; 4],
pub subnet_mask: [u8; 4],
pub gateway: [u8; 4],
pub mac_address: [u8; 6],
pub bssid: [u8; 6],
}
impl FromByteSlice for Wifi2ClientConfiguration {
fn bytes_expected() -> usize { 57 }
fn from_le_byte_slice(bytes: &[u8]) -> Wifi2ClientConfiguration {
Wifi2ClientConfiguration {
enable: <bool>::from_le_byte_slice(&bytes[0..1]),
ssid: <String>::from_le_byte_slice(&bytes[1..33]),
ip: <[u8; 4]>::from_le_byte_slice(&bytes[33..37]),
subnet_mask: <[u8; 4]>::from_le_byte_slice(&bytes[37..41]),
gateway: <[u8; 4]>::from_le_byte_slice(&bytes[41..45]),
mac_address: <[u8; 6]>::from_le_byte_slice(&bytes[45..51]),
bssid: <[u8; 6]>::from_le_byte_slice(&bytes[51..57]),
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct Wifi2ApConfiguration {
pub enable: bool,
pub ssid: String,
pub ip: [u8; 4],
pub subnet_mask: [u8; 4],
pub gateway: [u8; 4],
pub encryption: u8,
pub hidden: bool,
pub channel: u8,
pub mac_address: [u8; 6],
}
impl FromByteSlice for Wifi2ApConfiguration {
fn bytes_expected() -> usize { 54 }
fn from_le_byte_slice(bytes: &[u8]) -> Wifi2ApConfiguration {
Wifi2ApConfiguration {
enable: <bool>::from_le_byte_slice(&bytes[0..1]),
ssid: <String>::from_le_byte_slice(&bytes[1..33]),
ip: <[u8; 4]>::from_le_byte_slice(&bytes[33..37]),
subnet_mask: <[u8; 4]>::from_le_byte_slice(&bytes[37..41]),
gateway: <[u8; 4]>::from_le_byte_slice(&bytes[41..45]),
encryption: <u8>::from_le_byte_slice(&bytes[45..46]),
hidden: <bool>::from_le_byte_slice(&bytes[46..47]),
channel: <u8>::from_le_byte_slice(&bytes[47..48]),
mac_address: <[u8; 6]>::from_le_byte_slice(&bytes[48..54]),
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct Wifi2MeshConfiguration {
pub enable: bool,
pub root_ip: [u8; 4],
pub root_subnet_mask: [u8; 4],
pub root_gateway: [u8; 4],
pub router_bssid: [u8; 6],
pub group_id: [u8; 6],
pub group_ssid_prefix: String,
pub gateway_ip: [u8; 4],
pub gateway_port: u16,
}
impl FromByteSlice for Wifi2MeshConfiguration {
fn bytes_expected() -> usize { 47 }
fn from_le_byte_slice(bytes: &[u8]) -> Wifi2MeshConfiguration {
Wifi2MeshConfiguration {
enable: <bool>::from_le_byte_slice(&bytes[0..1]),
root_ip: <[u8; 4]>::from_le_byte_slice(&bytes[1..5]),
root_subnet_mask: <[u8; 4]>::from_le_byte_slice(&bytes[5..9]),
root_gateway: <[u8; 4]>::from_le_byte_slice(&bytes[9..13]),
router_bssid: <[u8; 6]>::from_le_byte_slice(&bytes[13..19]),
group_id: <[u8; 6]>::from_le_byte_slice(&bytes[19..25]),
group_ssid_prefix: <String>::from_le_byte_slice(&bytes[25..41]),
gateway_ip: <[u8; 4]>::from_le_byte_slice(&bytes[41..45]),
gateway_port: <u16>::from_le_byte_slice(&bytes[45..47]),
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct Wifi2MeshCommonStatus {
pub status: u8,
pub root_node: bool,
pub root_candidate: bool,
pub connected_nodes: u16,
pub rx_count: u32,
pub tx_count: u32,
}
impl FromByteSlice for Wifi2MeshCommonStatus {
fn bytes_expected() -> usize { 13 }
fn from_le_byte_slice(bytes: &[u8]) -> Wifi2MeshCommonStatus {
Wifi2MeshCommonStatus {
status: <u8>::from_le_byte_slice(&bytes[0..1]),
root_node: <bool>::from_le_byte_slice(&bytes[1..2]),
root_candidate: <bool>::from_le_byte_slice(&bytes[2..3]),
connected_nodes: <u16>::from_le_byte_slice(&bytes[3..5]),
rx_count: <u32>::from_le_byte_slice(&bytes[5..9]),
tx_count: <u32>::from_le_byte_slice(&bytes[9..13]),
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct Wifi2MeshClientStatus {
pub hostname: String,
pub ip: [u8; 4],
pub subnet_mask: [u8; 4],
pub gateway: [u8; 4],
pub mac_address: [u8; 6],
}
impl FromByteSlice for Wifi2MeshClientStatus {
fn bytes_expected() -> usize { 50 }
fn from_le_byte_slice(bytes: &[u8]) -> Wifi2MeshClientStatus {
Wifi2MeshClientStatus {
hostname: <String>::from_le_byte_slice(&bytes[0..32]),
ip: <[u8; 4]>::from_le_byte_slice(&bytes[32..36]),
subnet_mask: <[u8; 4]>::from_le_byte_slice(&bytes[36..40]),
gateway: <[u8; 4]>::from_le_byte_slice(&bytes[40..44]),
mac_address: <[u8; 6]>::from_le_byte_slice(&bytes[44..50]),
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct Wifi2MeshApStatus {
pub ssid: String,
pub ip: [u8; 4],
pub subnet_mask: [u8; 4],
pub gateway: [u8; 4],
pub mac_address: [u8; 6],
}
impl FromByteSlice for Wifi2MeshApStatus {
fn bytes_expected() -> usize { 50 }
fn from_le_byte_slice(bytes: &[u8]) -> Wifi2MeshApStatus {
Wifi2MeshApStatus {
ssid: <String>::from_le_byte_slice(&bytes[0..32]),
ip: <[u8; 4]>::from_le_byte_slice(&bytes[32..36]),
subnet_mask: <[u8; 4]>::from_le_byte_slice(&bytes[36..40]),
gateway: <[u8; 4]>::from_le_byte_slice(&bytes[40..44]),
mac_address: <[u8; 6]>::from_le_byte_slice(&bytes[44..50]),
}
}
}
#[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 MasterBrick {
device: Device,
}
impl MasterBrick {
pub const DEVICE_IDENTIFIER: u16 = 13;
pub const DEVICE_DISPLAY_NAME: &'static str = "Master Brick";
pub fn new<T: GetRequestSender>(uid: &str, req_sender: T) -> MasterBrick {
let mut result = MasterBrick { device: Device::new([2, 0, 9], uid, req_sender, 0) };
result.device.response_expected[u8::from(MasterBrickFunction::GetStackVoltage) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::GetStackCurrent) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetExtensionType) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetExtensionType) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::IsChibiPresent) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetChibiAddress) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetChibiAddress) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetChibiMasterAddress) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetChibiMasterAddress) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetChibiSlaveAddress) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetChibiSlaveAddress) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::GetChibiSignalStrength) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::GetChibiErrorLog) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetChibiFrequency) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetChibiFrequency) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetChibiChannel) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetChibiChannel) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::IsRs485Present) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetRs485Address) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetRs485Address) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetRs485SlaveAddress) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetRs485SlaveAddress) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::GetRs485ErrorLog) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetRs485Configuration) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetRs485Configuration) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::IsWifiPresent) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetWifiConfiguration) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifiConfiguration) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetWifiEncryption) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifiEncryption) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifiStatus) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::RefreshWifiStatus) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::SetWifiCertificate) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifiCertificate) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetWifiPowerMode) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifiPowerMode) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifiBufferInfo) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetWifiRegulatoryDomain) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifiRegulatoryDomain) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::GetUsbVoltage) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetLongWifiKey) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetLongWifiKey) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetWifiHostname) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifiHostname) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetStackCurrentCallbackPeriod) as usize] = ResponseExpectedFlag::True;
result.device.response_expected[u8::from(MasterBrickFunction::GetStackCurrentCallbackPeriod) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetStackVoltageCallbackPeriod) as usize] = ResponseExpectedFlag::True;
result.device.response_expected[u8::from(MasterBrickFunction::GetStackVoltageCallbackPeriod) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetUsbVoltageCallbackPeriod) as usize] = ResponseExpectedFlag::True;
result.device.response_expected[u8::from(MasterBrickFunction::GetUsbVoltageCallbackPeriod) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetStackCurrentCallbackThreshold) as usize] =
ResponseExpectedFlag::True;
result.device.response_expected[u8::from(MasterBrickFunction::GetStackCurrentCallbackThreshold) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetStackVoltageCallbackThreshold) as usize] =
ResponseExpectedFlag::True;
result.device.response_expected[u8::from(MasterBrickFunction::GetStackVoltageCallbackThreshold) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetUsbVoltageCallbackThreshold) as usize] =
ResponseExpectedFlag::True;
result.device.response_expected[u8::from(MasterBrickFunction::GetUsbVoltageCallbackThreshold) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetDebouncePeriod) as usize] = ResponseExpectedFlag::True;
result.device.response_expected[u8::from(MasterBrickFunction::GetDebouncePeriod) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::IsEthernetPresent) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetEthernetConfiguration) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetEthernetConfiguration) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::GetEthernetStatus) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetEthernetHostname) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::SetEthernetMacAddress) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::SetEthernetWebsocketConfiguration) as usize] =
ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetEthernetWebsocketConfiguration) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetEthernetAuthenticationSecret) as usize] =
ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetEthernetAuthenticationSecret) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetWifiAuthenticationSecret) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifiAuthenticationSecret) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::GetConnectionType) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::IsWifi2Present) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::StartWifi2Bootloader) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::WriteWifi2SerialPort) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::ReadWifi2SerialPort) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetWifi2AuthenticationSecret) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifi2AuthenticationSecret) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetWifi2Configuration) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifi2Configuration) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifi2Status) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetWifi2ClientConfiguration) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifi2ClientConfiguration) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetWifi2ClientHostname) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifi2ClientHostname) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetWifi2ClientPassword) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifi2ClientPassword) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetWifi2ApConfiguration) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifi2ApConfiguration) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetWifi2ApPassword) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifi2ApPassword) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SaveWifi2Configuration) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifi2FirmwareVersion) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::EnableWifi2StatusLed) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::DisableWifi2StatusLed) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::IsWifi2StatusLedEnabled) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetWifi2MeshConfiguration) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifi2MeshConfiguration) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetWifi2MeshRouterSsid) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifi2MeshRouterSsid) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetWifi2MeshRouterPassword) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifi2MeshRouterPassword) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifi2MeshCommonStatus) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifi2MeshClientStatus) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::GetWifi2MeshApStatus) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetSpitfpBaudrateConfig) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetSpitfpBaudrateConfig) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::GetSendTimeoutCount) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::SetSpitfpBaudrate) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetSpitfpBaudrate) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::GetSpitfpErrorCount) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::EnableStatusLed) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::DisableStatusLed) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::IsStatusLedEnabled) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::GetProtocol1BrickletName) as usize] =
ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::GetChipTemperature) as usize] = ResponseExpectedFlag::AlwaysTrue;
result.device.response_expected[u8::from(MasterBrickFunction::Reset) as usize] = ResponseExpectedFlag::False;
result.device.response_expected[u8::from(MasterBrickFunction::GetIdentity) as usize] = ResponseExpectedFlag::AlwaysTrue;
result
}
pub fn get_response_expected(&mut self, fun: MasterBrickFunction) -> Result<bool, GetResponseExpectedError> {
self.device.get_response_expected(u8::from(fun))
}
pub fn set_response_expected(&mut self, fun: MasterBrickFunction, 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_stack_current_callback_receiver(&self) -> ConvertingCallbackReceiver<u16> {
self.device.get_callback_receiver(u8::from(MasterBrickFunction::CallbackStackCurrent))
}
pub fn get_stack_voltage_callback_receiver(&self) -> ConvertingCallbackReceiver<u16> {
self.device.get_callback_receiver(u8::from(MasterBrickFunction::CallbackStackVoltage))
}
pub fn get_usb_voltage_callback_receiver(&self) -> ConvertingCallbackReceiver<u16> {
self.device.get_callback_receiver(u8::from(MasterBrickFunction::CallbackUsbVoltage))
}
pub fn get_stack_current_reached_callback_receiver(&self) -> ConvertingCallbackReceiver<u16> {
self.device.get_callback_receiver(u8::from(MasterBrickFunction::CallbackStackCurrentReached))
}
pub fn get_stack_voltage_reached_callback_receiver(&self) -> ConvertingCallbackReceiver<u16> {
self.device.get_callback_receiver(u8::from(MasterBrickFunction::CallbackStackVoltageReached))
}
pub fn get_usb_voltage_reached_callback_receiver(&self) -> ConvertingCallbackReceiver<u16> {
self.device.get_callback_receiver(u8::from(MasterBrickFunction::CallbackUsbVoltageReached))
}
pub fn get_stack_voltage(&self) -> ConvertingReceiver<u16> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetStackVoltage), payload)
}
pub fn get_stack_current(&self) -> ConvertingReceiver<u16> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetStackCurrent), payload)
}
pub fn set_extension_type(&self, extension: u8, exttype: u32) -> ConvertingReceiver<()> {
let mut payload = vec![0; 5];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(extension));
payload[1..5].copy_from_slice(&<u32>::to_le_byte_vec(exttype));
self.device.set(u8::from(MasterBrickFunction::SetExtensionType), payload)
}
pub fn get_extension_type(&self, extension: u8) -> ConvertingReceiver<u32> {
let mut payload = vec![0; 1];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(extension));
self.device.get(u8::from(MasterBrickFunction::GetExtensionType), payload)
}
pub fn is_chibi_present(&self) -> ConvertingReceiver<bool> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::IsChibiPresent), payload)
}
pub fn set_chibi_address(&self, address: u8) -> ConvertingReceiver<()> {
let mut payload = vec![0; 1];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(address));
self.device.set(u8::from(MasterBrickFunction::SetChibiAddress), payload)
}
pub fn get_chibi_address(&self) -> ConvertingReceiver<u8> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetChibiAddress), payload)
}
pub fn set_chibi_master_address(&self, address: u8) -> ConvertingReceiver<()> {
let mut payload = vec![0; 1];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(address));
self.device.set(u8::from(MasterBrickFunction::SetChibiMasterAddress), payload)
}
pub fn get_chibi_master_address(&self) -> ConvertingReceiver<u8> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetChibiMasterAddress), payload)
}
pub fn set_chibi_slave_address(&self, num: u8, address: u8) -> ConvertingReceiver<()> {
let mut payload = vec![0; 2];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(num));
payload[1..2].copy_from_slice(&<u8>::to_le_byte_vec(address));
self.device.set(u8::from(MasterBrickFunction::SetChibiSlaveAddress), payload)
}
pub fn get_chibi_slave_address(&self, num: u8) -> ConvertingReceiver<u8> {
let mut payload = vec![0; 1];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(num));
self.device.get(u8::from(MasterBrickFunction::GetChibiSlaveAddress), payload)
}
pub fn get_chibi_signal_strength(&self) -> ConvertingReceiver<u8> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetChibiSignalStrength), payload)
}
pub fn get_chibi_error_log(&self) -> ConvertingReceiver<ChibiErrorLog> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetChibiErrorLog), payload)
}
pub fn set_chibi_frequency(&self, frequency: u8) -> ConvertingReceiver<()> {
let mut payload = vec![0; 1];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(frequency));
self.device.set(u8::from(MasterBrickFunction::SetChibiFrequency), payload)
}
pub fn get_chibi_frequency(&self) -> ConvertingReceiver<u8> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetChibiFrequency), payload)
}
pub fn set_chibi_channel(&self, channel: u8) -> ConvertingReceiver<()> {
let mut payload = vec![0; 1];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(channel));
self.device.set(u8::from(MasterBrickFunction::SetChibiChannel), payload)
}
pub fn get_chibi_channel(&self) -> ConvertingReceiver<u8> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetChibiChannel), payload)
}
pub fn is_rs485_present(&self) -> ConvertingReceiver<bool> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::IsRs485Present), payload)
}
pub fn set_rs485_address(&self, address: u8) -> ConvertingReceiver<()> {
let mut payload = vec![0; 1];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(address));
self.device.set(u8::from(MasterBrickFunction::SetRs485Address), payload)
}
pub fn get_rs485_address(&self) -> ConvertingReceiver<u8> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetRs485Address), payload)
}
pub fn set_rs485_slave_address(&self, num: u8, address: u8) -> ConvertingReceiver<()> {
let mut payload = vec![0; 2];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(num));
payload[1..2].copy_from_slice(&<u8>::to_le_byte_vec(address));
self.device.set(u8::from(MasterBrickFunction::SetRs485SlaveAddress), payload)
}
pub fn get_rs485_slave_address(&self, num: u8) -> ConvertingReceiver<u8> {
let mut payload = vec![0; 1];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(num));
self.device.get(u8::from(MasterBrickFunction::GetRs485SlaveAddress), payload)
}
pub fn get_rs485_error_log(&self) -> ConvertingReceiver<u16> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetRs485ErrorLog), payload)
}
pub fn set_rs485_configuration(&self, speed: u32, parity: char, stopbits: u8) -> ConvertingReceiver<()> {
let mut payload = vec![0; 6];
payload[0..4].copy_from_slice(&<u32>::to_le_byte_vec(speed));
payload[4..5].copy_from_slice(&<char>::to_le_byte_vec(parity));
payload[5..6].copy_from_slice(&<u8>::to_le_byte_vec(stopbits));
self.device.set(u8::from(MasterBrickFunction::SetRs485Configuration), payload)
}
pub fn get_rs485_configuration(&self) -> ConvertingReceiver<Rs485Configuration> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetRs485Configuration), payload)
}
pub fn is_wifi_present(&self) -> ConvertingReceiver<bool> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::IsWifiPresent), payload)
}
pub fn set_wifi_configuration(
&self,
ssid: String,
connection: u8,
ip: [u8; 4],
subnet_mask: [u8; 4],
gateway: [u8; 4],
port: u16,
) -> ConvertingReceiver<()> {
let mut payload = vec![0; 47];
match <String>::try_to_le_byte_vec(ssid, 32) {
Err(e) => {
let (tx, rx) = std::sync::mpsc::channel::<Result<Vec<u8>, BrickletError>>();
let _ = tx.send(Err(e));
return ConvertingReceiver::new(rx, std::time::Duration::new(1, 0));
}
Ok(bytes) => payload[0..32].copy_from_slice(&bytes),
}
payload[32..33].copy_from_slice(&<u8>::to_le_byte_vec(connection));
payload[33..37].copy_from_slice(&<[u8; 4]>::to_le_byte_vec(ip));
payload[37..41].copy_from_slice(&<[u8; 4]>::to_le_byte_vec(subnet_mask));
payload[41..45].copy_from_slice(&<[u8; 4]>::to_le_byte_vec(gateway));
payload[45..47].copy_from_slice(&<u16>::to_le_byte_vec(port));
self.device.set(u8::from(MasterBrickFunction::SetWifiConfiguration), payload)
}
pub fn get_wifi_configuration(&self) -> ConvertingReceiver<WifiConfiguration> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifiConfiguration), payload)
}
pub fn set_wifi_encryption(
&self,
encryption: u8,
key: String,
key_index: u8,
eap_options: u8,
ca_certificate_length: u16,
client_certificate_length: u16,
private_key_length: u16,
) -> ConvertingReceiver<()> {
let mut payload = vec![0; 59];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(encryption));
match <String>::try_to_le_byte_vec(key, 50) {
Err(e) => {
let (tx, rx) = std::sync::mpsc::channel::<Result<Vec<u8>, BrickletError>>();
let _ = tx.send(Err(e));
return ConvertingReceiver::new(rx, std::time::Duration::new(1, 0));
}
Ok(bytes) => payload[1..51].copy_from_slice(&bytes),
}
payload[51..52].copy_from_slice(&<u8>::to_le_byte_vec(key_index));
payload[52..53].copy_from_slice(&<u8>::to_le_byte_vec(eap_options));
payload[53..55].copy_from_slice(&<u16>::to_le_byte_vec(ca_certificate_length));
payload[55..57].copy_from_slice(&<u16>::to_le_byte_vec(client_certificate_length));
payload[57..59].copy_from_slice(&<u16>::to_le_byte_vec(private_key_length));
self.device.set(u8::from(MasterBrickFunction::SetWifiEncryption), payload)
}
pub fn get_wifi_encryption(&self) -> ConvertingReceiver<WifiEncryption> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifiEncryption), payload)
}
pub fn get_wifi_status(&self) -> ConvertingReceiver<WifiStatus> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifiStatus), payload)
}
pub fn refresh_wifi_status(&self) -> ConvertingReceiver<()> {
let payload = vec![0; 0];
self.device.set(u8::from(MasterBrickFunction::RefreshWifiStatus), payload)
}
pub fn set_wifi_certificate(&self, index: u16, data: [u8; 32], data_length: u8) -> ConvertingReceiver<()> {
let mut payload = vec![0; 35];
payload[0..2].copy_from_slice(&<u16>::to_le_byte_vec(index));
payload[2..34].copy_from_slice(&<[u8; 32]>::to_le_byte_vec(data));
payload[34..35].copy_from_slice(&<u8>::to_le_byte_vec(data_length));
self.device.set(u8::from(MasterBrickFunction::SetWifiCertificate), payload)
}
pub fn get_wifi_certificate(&self, index: u16) -> ConvertingReceiver<WifiCertificate> {
let mut payload = vec![0; 2];
payload[0..2].copy_from_slice(&<u16>::to_le_byte_vec(index));
self.device.get(u8::from(MasterBrickFunction::GetWifiCertificate), payload)
}
pub fn set_wifi_power_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(MasterBrickFunction::SetWifiPowerMode), payload)
}
pub fn get_wifi_power_mode(&self) -> ConvertingReceiver<u8> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifiPowerMode), payload)
}
pub fn get_wifi_buffer_info(&self) -> ConvertingReceiver<WifiBufferInfo> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifiBufferInfo), payload)
}
pub fn set_wifi_regulatory_domain(&self, domain: u8) -> ConvertingReceiver<()> {
let mut payload = vec![0; 1];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(domain));
self.device.set(u8::from(MasterBrickFunction::SetWifiRegulatoryDomain), payload)
}
pub fn get_wifi_regulatory_domain(&self) -> ConvertingReceiver<u8> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifiRegulatoryDomain), payload)
}
pub fn get_usb_voltage(&self) -> ConvertingReceiver<u16> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetUsbVoltage), payload)
}
pub fn set_long_wifi_key(&self, key: String) -> ConvertingReceiver<()> {
let mut payload = vec![0; 64];
match <String>::try_to_le_byte_vec(key, 64) {
Err(e) => {
let (tx, rx) = std::sync::mpsc::channel::<Result<Vec<u8>, BrickletError>>();
let _ = tx.send(Err(e));
return ConvertingReceiver::new(rx, std::time::Duration::new(1, 0));
}
Ok(bytes) => payload[0..64].copy_from_slice(&bytes),
}
self.device.set(u8::from(MasterBrickFunction::SetLongWifiKey), payload)
}
pub fn get_long_wifi_key(&self) -> ConvertingReceiver<String> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetLongWifiKey), payload)
}
pub fn set_wifi_hostname(&self, hostname: String) -> ConvertingReceiver<()> {
let mut payload = vec![0; 16];
match <String>::try_to_le_byte_vec(hostname, 16) {
Err(e) => {
let (tx, rx) = std::sync::mpsc::channel::<Result<Vec<u8>, BrickletError>>();
let _ = tx.send(Err(e));
return ConvertingReceiver::new(rx, std::time::Duration::new(1, 0));
}
Ok(bytes) => payload[0..16].copy_from_slice(&bytes),
}
self.device.set(u8::from(MasterBrickFunction::SetWifiHostname), payload)
}
pub fn get_wifi_hostname(&self) -> ConvertingReceiver<String> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifiHostname), payload)
}
pub fn set_stack_current_callback_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(MasterBrickFunction::SetStackCurrentCallbackPeriod), payload)
}
pub fn get_stack_current_callback_period(&self) -> ConvertingReceiver<u32> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetStackCurrentCallbackPeriod), payload)
}
pub fn set_stack_voltage_callback_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(MasterBrickFunction::SetStackVoltageCallbackPeriod), payload)
}
pub fn get_stack_voltage_callback_period(&self) -> ConvertingReceiver<u32> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetStackVoltageCallbackPeriod), payload)
}
pub fn set_usb_voltage_callback_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(MasterBrickFunction::SetUsbVoltageCallbackPeriod), payload)
}
pub fn get_usb_voltage_callback_period(&self) -> ConvertingReceiver<u32> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetUsbVoltageCallbackPeriod), payload)
}
pub fn set_stack_current_callback_threshold(&self, option: char, min: u16, max: u16) -> ConvertingReceiver<()> {
let mut payload = vec![0; 5];
payload[0..1].copy_from_slice(&<char>::to_le_byte_vec(option));
payload[1..3].copy_from_slice(&<u16>::to_le_byte_vec(min));
payload[3..5].copy_from_slice(&<u16>::to_le_byte_vec(max));
self.device.set(u8::from(MasterBrickFunction::SetStackCurrentCallbackThreshold), payload)
}
pub fn get_stack_current_callback_threshold(&self) -> ConvertingReceiver<StackCurrentCallbackThreshold> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetStackCurrentCallbackThreshold), payload)
}
pub fn set_stack_voltage_callback_threshold(&self, option: char, min: u16, max: u16) -> ConvertingReceiver<()> {
let mut payload = vec![0; 5];
payload[0..1].copy_from_slice(&<char>::to_le_byte_vec(option));
payload[1..3].copy_from_slice(&<u16>::to_le_byte_vec(min));
payload[3..5].copy_from_slice(&<u16>::to_le_byte_vec(max));
self.device.set(u8::from(MasterBrickFunction::SetStackVoltageCallbackThreshold), payload)
}
pub fn get_stack_voltage_callback_threshold(&self) -> ConvertingReceiver<StackVoltageCallbackThreshold> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetStackVoltageCallbackThreshold), payload)
}
pub fn set_usb_voltage_callback_threshold(&self, option: char, min: u16, max: u16) -> ConvertingReceiver<()> {
let mut payload = vec![0; 5];
payload[0..1].copy_from_slice(&<char>::to_le_byte_vec(option));
payload[1..3].copy_from_slice(&<u16>::to_le_byte_vec(min));
payload[3..5].copy_from_slice(&<u16>::to_le_byte_vec(max));
self.device.set(u8::from(MasterBrickFunction::SetUsbVoltageCallbackThreshold), payload)
}
pub fn get_usb_voltage_callback_threshold(&self) -> ConvertingReceiver<UsbVoltageCallbackThreshold> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetUsbVoltageCallbackThreshold), 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(MasterBrickFunction::SetDebouncePeriod), payload)
}
pub fn get_debounce_period(&self) -> ConvertingReceiver<u32> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetDebouncePeriod), payload)
}
pub fn is_ethernet_present(&self) -> ConvertingReceiver<bool> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::IsEthernetPresent), payload)
}
pub fn set_ethernet_configuration(
&self,
connection: u8,
ip: [u8; 4],
subnet_mask: [u8; 4],
gateway: [u8; 4],
port: u16,
) -> ConvertingReceiver<()> {
let mut payload = vec![0; 15];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(connection));
payload[1..5].copy_from_slice(&<[u8; 4]>::to_le_byte_vec(ip));
payload[5..9].copy_from_slice(&<[u8; 4]>::to_le_byte_vec(subnet_mask));
payload[9..13].copy_from_slice(&<[u8; 4]>::to_le_byte_vec(gateway));
payload[13..15].copy_from_slice(&<u16>::to_le_byte_vec(port));
self.device.set(u8::from(MasterBrickFunction::SetEthernetConfiguration), payload)
}
pub fn get_ethernet_configuration(&self) -> ConvertingReceiver<EthernetConfiguration> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetEthernetConfiguration), payload)
}
pub fn get_ethernet_status(&self) -> ConvertingReceiver<EthernetStatus> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetEthernetStatus), payload)
}
pub fn set_ethernet_hostname(&self, hostname: String) -> ConvertingReceiver<()> {
let mut payload = vec![0; 32];
match <String>::try_to_le_byte_vec(hostname, 32) {
Err(e) => {
let (tx, rx) = std::sync::mpsc::channel::<Result<Vec<u8>, BrickletError>>();
let _ = tx.send(Err(e));
return ConvertingReceiver::new(rx, std::time::Duration::new(1, 0));
}
Ok(bytes) => payload[0..32].copy_from_slice(&bytes),
}
self.device.set(u8::from(MasterBrickFunction::SetEthernetHostname), payload)
}
pub fn set_ethernet_mac_address(&self, mac_address: [u8; 6]) -> ConvertingReceiver<()> {
let mut payload = vec![0; 6];
payload[0..6].copy_from_slice(&<[u8; 6]>::to_le_byte_vec(mac_address));
self.device.set(u8::from(MasterBrickFunction::SetEthernetMacAddress), payload)
}
pub fn set_ethernet_websocket_configuration(&self, sockets: u8, port: u16) -> ConvertingReceiver<()> {
let mut payload = vec![0; 3];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(sockets));
payload[1..3].copy_from_slice(&<u16>::to_le_byte_vec(port));
self.device.set(u8::from(MasterBrickFunction::SetEthernetWebsocketConfiguration), payload)
}
pub fn get_ethernet_websocket_configuration(&self) -> ConvertingReceiver<EthernetWebsocketConfiguration> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetEthernetWebsocketConfiguration), payload)
}
pub fn set_ethernet_authentication_secret(&self, secret: String) -> ConvertingReceiver<()> {
let mut payload = vec![0; 64];
match <String>::try_to_le_byte_vec(secret, 64) {
Err(e) => {
let (tx, rx) = std::sync::mpsc::channel::<Result<Vec<u8>, BrickletError>>();
let _ = tx.send(Err(e));
return ConvertingReceiver::new(rx, std::time::Duration::new(1, 0));
}
Ok(bytes) => payload[0..64].copy_from_slice(&bytes),
}
self.device.set(u8::from(MasterBrickFunction::SetEthernetAuthenticationSecret), payload)
}
pub fn get_ethernet_authentication_secret(&self) -> ConvertingReceiver<String> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetEthernetAuthenticationSecret), payload)
}
pub fn set_wifi_authentication_secret(&self, secret: String) -> ConvertingReceiver<()> {
let mut payload = vec![0; 64];
match <String>::try_to_le_byte_vec(secret, 64) {
Err(e) => {
let (tx, rx) = std::sync::mpsc::channel::<Result<Vec<u8>, BrickletError>>();
let _ = tx.send(Err(e));
return ConvertingReceiver::new(rx, std::time::Duration::new(1, 0));
}
Ok(bytes) => payload[0..64].copy_from_slice(&bytes),
}
self.device.set(u8::from(MasterBrickFunction::SetWifiAuthenticationSecret), payload)
}
pub fn get_wifi_authentication_secret(&self) -> ConvertingReceiver<String> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifiAuthenticationSecret), payload)
}
pub fn get_connection_type(&self) -> ConvertingReceiver<u8> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetConnectionType), payload)
}
pub fn is_wifi2_present(&self) -> ConvertingReceiver<bool> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::IsWifi2Present), payload)
}
pub fn start_wifi2_bootloader(&self) -> ConvertingReceiver<i8> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::StartWifi2Bootloader), payload)
}
pub fn write_wifi2_serial_port(&self, data: [u8; 60], length: u8) -> ConvertingReceiver<i8> {
let mut payload = vec![0; 61];
payload[0..60].copy_from_slice(&<[u8; 60]>::to_le_byte_vec(data));
payload[60..61].copy_from_slice(&<u8>::to_le_byte_vec(length));
self.device.get(u8::from(MasterBrickFunction::WriteWifi2SerialPort), payload)
}
pub fn read_wifi2_serial_port(&self, length: u8) -> ConvertingReceiver<ReadWifi2SerialPort> {
let mut payload = vec![0; 1];
payload[0..1].copy_from_slice(&<u8>::to_le_byte_vec(length));
self.device.get(u8::from(MasterBrickFunction::ReadWifi2SerialPort), payload)
}
pub fn set_wifi2_authentication_secret(&self, secret: String) -> ConvertingReceiver<()> {
let mut payload = vec![0; 64];
match <String>::try_to_le_byte_vec(secret, 64) {
Err(e) => {
let (tx, rx) = std::sync::mpsc::channel::<Result<Vec<u8>, BrickletError>>();
let _ = tx.send(Err(e));
return ConvertingReceiver::new(rx, std::time::Duration::new(1, 0));
}
Ok(bytes) => payload[0..64].copy_from_slice(&bytes),
}
self.device.set(u8::from(MasterBrickFunction::SetWifi2AuthenticationSecret), payload)
}
pub fn get_wifi2_authentication_secret(&self) -> ConvertingReceiver<String> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifi2AuthenticationSecret), payload)
}
pub fn set_wifi2_configuration(
&self,
port: u16,
websocket_port: u16,
website_port: u16,
phy_mode: u8,
sleep_mode: u8,
website: u8,
) -> ConvertingReceiver<()> {
let mut payload = vec![0; 9];
payload[0..2].copy_from_slice(&<u16>::to_le_byte_vec(port));
payload[2..4].copy_from_slice(&<u16>::to_le_byte_vec(websocket_port));
payload[4..6].copy_from_slice(&<u16>::to_le_byte_vec(website_port));
payload[6..7].copy_from_slice(&<u8>::to_le_byte_vec(phy_mode));
payload[7..8].copy_from_slice(&<u8>::to_le_byte_vec(sleep_mode));
payload[8..9].copy_from_slice(&<u8>::to_le_byte_vec(website));
self.device.set(u8::from(MasterBrickFunction::SetWifi2Configuration), payload)
}
pub fn get_wifi2_configuration(&self) -> ConvertingReceiver<Wifi2Configuration> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifi2Configuration), payload)
}
pub fn get_wifi2_status(&self) -> ConvertingReceiver<Wifi2Status> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifi2Status), payload)
}
pub fn set_wifi2_client_configuration(
&self,
enable: bool,
ssid: String,
ip: [u8; 4],
subnet_mask: [u8; 4],
gateway: [u8; 4],
mac_address: [u8; 6],
bssid: [u8; 6],
) -> ConvertingReceiver<()> {
let mut payload = vec![0; 57];
payload[0..1].copy_from_slice(&<bool>::to_le_byte_vec(enable));
match <String>::try_to_le_byte_vec(ssid, 32) {
Err(e) => {
let (tx, rx) = std::sync::mpsc::channel::<Result<Vec<u8>, BrickletError>>();
let _ = tx.send(Err(e));
return ConvertingReceiver::new(rx, std::time::Duration::new(1, 0));
}
Ok(bytes) => payload[1..33].copy_from_slice(&bytes),
}
payload[33..37].copy_from_slice(&<[u8; 4]>::to_le_byte_vec(ip));
payload[37..41].copy_from_slice(&<[u8; 4]>::to_le_byte_vec(subnet_mask));
payload[41..45].copy_from_slice(&<[u8; 4]>::to_le_byte_vec(gateway));
payload[45..51].copy_from_slice(&<[u8; 6]>::to_le_byte_vec(mac_address));
payload[51..57].copy_from_slice(&<[u8; 6]>::to_le_byte_vec(bssid));
self.device.set(u8::from(MasterBrickFunction::SetWifi2ClientConfiguration), payload)
}
pub fn get_wifi2_client_configuration(&self) -> ConvertingReceiver<Wifi2ClientConfiguration> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifi2ClientConfiguration), payload)
}
pub fn set_wifi2_client_hostname(&self, hostname: String) -> ConvertingReceiver<()> {
let mut payload = vec![0; 32];
match <String>::try_to_le_byte_vec(hostname, 32) {
Err(e) => {
let (tx, rx) = std::sync::mpsc::channel::<Result<Vec<u8>, BrickletError>>();
let _ = tx.send(Err(e));
return ConvertingReceiver::new(rx, std::time::Duration::new(1, 0));
}
Ok(bytes) => payload[0..32].copy_from_slice(&bytes),
}
self.device.set(u8::from(MasterBrickFunction::SetWifi2ClientHostname), payload)
}
pub fn get_wifi2_client_hostname(&self) -> ConvertingReceiver<String> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifi2ClientHostname), payload)
}
pub fn set_wifi2_client_password(&self, password: String) -> ConvertingReceiver<()> {
let mut payload = vec![0; 64];
match <String>::try_to_le_byte_vec(password, 64) {
Err(e) => {
let (tx, rx) = std::sync::mpsc::channel::<Result<Vec<u8>, BrickletError>>();
let _ = tx.send(Err(e));
return ConvertingReceiver::new(rx, std::time::Duration::new(1, 0));
}
Ok(bytes) => payload[0..64].copy_from_slice(&bytes),
}
self.device.set(u8::from(MasterBrickFunction::SetWifi2ClientPassword), payload)
}
pub fn get_wifi2_client_password(&self) -> ConvertingReceiver<String> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifi2ClientPassword), payload)
}
pub fn set_wifi2_ap_configuration(
&self,
enable: bool,
ssid: String,
ip: [u8; 4],
subnet_mask: [u8; 4],
gateway: [u8; 4],
encryption: u8,
hidden: bool,
channel: u8,
mac_address: [u8; 6],
) -> ConvertingReceiver<()> {
let mut payload = vec![0; 54];
payload[0..1].copy_from_slice(&<bool>::to_le_byte_vec(enable));
match <String>::try_to_le_byte_vec(ssid, 32) {
Err(e) => {
let (tx, rx) = std::sync::mpsc::channel::<Result<Vec<u8>, BrickletError>>();
let _ = tx.send(Err(e));
return ConvertingReceiver::new(rx, std::time::Duration::new(1, 0));
}
Ok(bytes) => payload[1..33].copy_from_slice(&bytes),
}
payload[33..37].copy_from_slice(&<[u8; 4]>::to_le_byte_vec(ip));
payload[37..41].copy_from_slice(&<[u8; 4]>::to_le_byte_vec(subnet_mask));
payload[41..45].copy_from_slice(&<[u8; 4]>::to_le_byte_vec(gateway));
payload[45..46].copy_from_slice(&<u8>::to_le_byte_vec(encryption));
payload[46..47].copy_from_slice(&<bool>::to_le_byte_vec(hidden));
payload[47..48].copy_from_slice(&<u8>::to_le_byte_vec(channel));
payload[48..54].copy_from_slice(&<[u8; 6]>::to_le_byte_vec(mac_address));
self.device.set(u8::from(MasterBrickFunction::SetWifi2ApConfiguration), payload)
}
pub fn get_wifi2_ap_configuration(&self) -> ConvertingReceiver<Wifi2ApConfiguration> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifi2ApConfiguration), payload)
}
pub fn set_wifi2_ap_password(&self, password: String) -> ConvertingReceiver<()> {
let mut payload = vec![0; 64];
match <String>::try_to_le_byte_vec(password, 64) {
Err(e) => {
let (tx, rx) = std::sync::mpsc::channel::<Result<Vec<u8>, BrickletError>>();
let _ = tx.send(Err(e));
return ConvertingReceiver::new(rx, std::time::Duration::new(1, 0));
}
Ok(bytes) => payload[0..64].copy_from_slice(&bytes),
}
self.device.set(u8::from(MasterBrickFunction::SetWifi2ApPassword), payload)
}
pub fn get_wifi2_ap_password(&self) -> ConvertingReceiver<String> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifi2ApPassword), payload)
}
pub fn save_wifi2_configuration(&self) -> ConvertingReceiver<u8> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::SaveWifi2Configuration), payload)
}
pub fn get_wifi2_firmware_version(&self) -> ConvertingReceiver<[u8; 3]> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifi2FirmwareVersion), payload)
}
pub fn enable_wifi2_status_led(&self) -> ConvertingReceiver<()> {
let payload = vec![0; 0];
self.device.set(u8::from(MasterBrickFunction::EnableWifi2StatusLed), payload)
}
pub fn disable_wifi2_status_led(&self) -> ConvertingReceiver<()> {
let payload = vec![0; 0];
self.device.set(u8::from(MasterBrickFunction::DisableWifi2StatusLed), payload)
}
pub fn is_wifi2_status_led_enabled(&self) -> ConvertingReceiver<bool> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::IsWifi2StatusLedEnabled), payload)
}
pub fn set_wifi2_mesh_configuration(
&self,
enable: bool,
root_ip: [u8; 4],
root_subnet_mask: [u8; 4],
root_gateway: [u8; 4],
router_bssid: [u8; 6],
group_id: [u8; 6],
group_ssid_prefix: String,
gateway_ip: [u8; 4],
gateway_port: u16,
) -> ConvertingReceiver<()> {
let mut payload = vec![0; 47];
payload[0..1].copy_from_slice(&<bool>::to_le_byte_vec(enable));
payload[1..5].copy_from_slice(&<[u8; 4]>::to_le_byte_vec(root_ip));
payload[5..9].copy_from_slice(&<[u8; 4]>::to_le_byte_vec(root_subnet_mask));
payload[9..13].copy_from_slice(&<[u8; 4]>::to_le_byte_vec(root_gateway));
payload[13..19].copy_from_slice(&<[u8; 6]>::to_le_byte_vec(router_bssid));
payload[19..25].copy_from_slice(&<[u8; 6]>::to_le_byte_vec(group_id));
match <String>::try_to_le_byte_vec(group_ssid_prefix, 16) {
Err(e) => {
let (tx, rx) = std::sync::mpsc::channel::<Result<Vec<u8>, BrickletError>>();
let _ = tx.send(Err(e));
return ConvertingReceiver::new(rx, std::time::Duration::new(1, 0));
}
Ok(bytes) => payload[25..41].copy_from_slice(&bytes),
}
payload[41..45].copy_from_slice(&<[u8; 4]>::to_le_byte_vec(gateway_ip));
payload[45..47].copy_from_slice(&<u16>::to_le_byte_vec(gateway_port));
self.device.set(u8::from(MasterBrickFunction::SetWifi2MeshConfiguration), payload)
}
pub fn get_wifi2_mesh_configuration(&self) -> ConvertingReceiver<Wifi2MeshConfiguration> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifi2MeshConfiguration), payload)
}
pub fn set_wifi2_mesh_router_ssid(&self, ssid: String) -> ConvertingReceiver<()> {
let mut payload = vec![0; 32];
match <String>::try_to_le_byte_vec(ssid, 32) {
Err(e) => {
let (tx, rx) = std::sync::mpsc::channel::<Result<Vec<u8>, BrickletError>>();
let _ = tx.send(Err(e));
return ConvertingReceiver::new(rx, std::time::Duration::new(1, 0));
}
Ok(bytes) => payload[0..32].copy_from_slice(&bytes),
}
self.device.set(u8::from(MasterBrickFunction::SetWifi2MeshRouterSsid), payload)
}
pub fn get_wifi2_mesh_router_ssid(&self) -> ConvertingReceiver<String> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifi2MeshRouterSsid), payload)
}
pub fn set_wifi2_mesh_router_password(&self, password: String) -> ConvertingReceiver<()> {
let mut payload = vec![0; 64];
match <String>::try_to_le_byte_vec(password, 64) {
Err(e) => {
let (tx, rx) = std::sync::mpsc::channel::<Result<Vec<u8>, BrickletError>>();
let _ = tx.send(Err(e));
return ConvertingReceiver::new(rx, std::time::Duration::new(1, 0));
}
Ok(bytes) => payload[0..64].copy_from_slice(&bytes),
}
self.device.set(u8::from(MasterBrickFunction::SetWifi2MeshRouterPassword), payload)
}
pub fn get_wifi2_mesh_router_password(&self) -> ConvertingReceiver<String> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifi2MeshRouterPassword), payload)
}
pub fn get_wifi2_mesh_common_status(&self) -> ConvertingReceiver<Wifi2MeshCommonStatus> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifi2MeshCommonStatus), payload)
}
pub fn get_wifi2_mesh_client_status(&self) -> ConvertingReceiver<Wifi2MeshClientStatus> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifi2MeshClientStatus), payload)
}
pub fn get_wifi2_mesh_ap_status(&self) -> ConvertingReceiver<Wifi2MeshApStatus> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetWifi2MeshApStatus), 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(MasterBrickFunction::SetSpitfpBaudrateConfig), payload)
}
pub fn get_spitfp_baudrate_config(&self) -> ConvertingReceiver<SpitfpBaudrateConfig> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::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(MasterBrickFunction::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(MasterBrickFunction::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(MasterBrickFunction::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(MasterBrickFunction::GetSpitfpErrorCount), payload)
}
pub fn enable_status_led(&self) -> ConvertingReceiver<()> {
let payload = vec![0; 0];
self.device.set(u8::from(MasterBrickFunction::EnableStatusLed), payload)
}
pub fn disable_status_led(&self) -> ConvertingReceiver<()> {
let payload = vec![0; 0];
self.device.set(u8::from(MasterBrickFunction::DisableStatusLed), payload)
}
pub fn is_status_led_enabled(&self) -> ConvertingReceiver<bool> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::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(MasterBrickFunction::GetProtocol1BrickletName), payload)
}
pub fn get_chip_temperature(&self) -> ConvertingReceiver<i16> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetChipTemperature), payload)
}
pub fn reset(&self) -> ConvertingReceiver<()> {
let payload = vec![0; 0];
self.device.set(u8::from(MasterBrickFunction::Reset), payload)
}
pub fn get_identity(&self) -> ConvertingReceiver<Identity> {
let payload = vec![0; 0];
self.device.get(u8::from(MasterBrickFunction::GetIdentity), payload)
}
}