feat: add several new UDS enums (#85)

* `DataDefinitionType`
* `DtcSettingType`
* `FileTransferMode`
* `InputOutputControlParameter`
* `LinkControlType`
* `PeriodicTransmissionMode`

Author: nyurik

src/doip/protocol_version.rs

@@ -22,9 +22,6 @@ python_test!(doip, ProtocolVersion, V2010, V2012);
 #[cfg_attr(feature = "pyo3", pyo3::pyclass(eq, eq_int, from_py_object))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum ProtocolVersion {
-    // TODO: needed? This seems like a placeholder that shouldn't be used in Rust
-    // /// Reserved Version
-    // ReservedVer = 0x00,
     /// `DoIP` Payload Version: ISO-13400 2010 Version
     V2010 = 0x01,
 
@@ -36,9 +33,6 @@ pub enum ProtocolVersion {
 
     /// `DoIP` Payload Version: ISO-13400 `2019_AMD1` Version
     V2019amd1 = 0x04,
-    // TODO: needed? This seems like a placeholder that shouldn't be used in Rust
-    // /// `DoIP` Payload Version: Default Version
-    // DefaultValue = 0xFF,
 }
 
 #[cfg(all(test, feature = "serde"))]

src/uds/commands.rs

@@ -1,6 +1,9 @@
 use crate::utils::{enum_wrapper, python_test};
 
-enum_wrapper!(uds, UdsCommand, UdsCommandByte, display = @"10111100423397497463");
+// The display constant ensures we do not accidentally change doc strings below.
+// We treat them as display strings too, so a change to the first line of the doc str is a code change.
+// Use `just bless` to update the expected value.
+enum_wrapper!(uds, UdsCommand, UdsCommandByte, display = @"2468007968532925220");
 python_test!(uds, UdsCommand, DiagnosticSessionControl, ECUReset);
 
 /// UDS Command Service IDs
@@ -16,24 +19,31 @@ python_test!(uds, UdsCommand, DiagnosticSessionControl, ECUReset);
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum UdsCommand {
     /// The client requests to control a diagnostic session with a server(s).
+    /// See also [`crate::uds::UdsSessionType`].
     DiagnosticSessionControl = 0x10,
     /// The client forces the server(s) to perform a reset.
+    /// See also [`crate::uds::ResetType`].
     ECUReset = 0x11,
     /// The client requests to unlock a secured server(s).
+    /// See also [`crate::uds::SecurityOperation`].
     SecurityAccess = 0x27,
     /// The client controls the setting of communication parameters in the server (e.g. communication baud-rate).
+    /// See also [`crate::uds::CommunicationLevel`].
     CommunicationControl = 0x28,
     /// The client indicates to the server(s) that it is still present.
     TesterPresent = 0x3E,
     /// The client requests to access the server(s) with a specific access mode.
+    /// See also [`crate::uds::AuthenticationSubFunction`].
     Authentication = 0x29,
     /// The client uses this service to perform data transmission with an extended data link security.
     SecuredDataTransmission = 0x84,
     /// The client controls the setting of DTCs in the server.
+    /// See also [`crate::uds::DtcSettingType`].
     ControlDTCSetting = 0x85,
     /// The client requests to set up and/or control an event mechanism in the server.
     ResponseOnEvent = 0x86,
     /// The client requests control of the communication baud-rate.
+    /// See also [`crate::uds::LinkControlType`].
     LinkControl = 0x87,
     /// The client requests to read the current value of a record identified by a provided dataIdentifier.
     ReadDataByIdentifier = 0x22,
@@ -42,8 +52,10 @@ pub enum UdsCommand {
     /// The client requests to read the scaling information of a record identified by a provided dataIdentifier.
     ReadScalingDataByIdentifier = 0x24,
     /// The client requests to schedule data in the server for periodic transmission.
+    /// See also [`crate::uds::PeriodicTransmissionMode`].
     ReadDataByPeriodicIdentifier = 0x2A,
-    /// The client requests to dynamically define data Identifiers that may subsequently be read by the [`UdsCommand::ReadDataByIdentifier`] service.
+    /// The client requests to dynamically define data identifiers that may subsequently be read by the `ReadDataByIdentifier` service.
+    /// See also [`UdsCommand::ReadDataByIdentifier`] and [`crate::uds::DataDefinitionType`].
     DynamicallyDefineDataIdentifier = 0x2C,
     /// The client requests to write a record specified by a provided dataIdentifier.
     WriteDataByIdentifier = 0x2E,
@@ -52,10 +64,13 @@ pub enum UdsCommand {
     /// Allows the client to clear diagnostic information from the server (including DTCs, captured data, etc.).
     ClearDiagnosticInformation = 0x14,
     /// Allows the client to request diagnostic information from the server (including DTCs, captured data, etc.).
+    /// See also [`crate::uds::DtcSubFunction`].
     ReadDTCInformation = 0x19,
     /// The client requests the control of an input/output specific to the server.
+    /// See also [`crate::uds::InputOutputControlParameter`].
     InputOutputControlByIdentifier = 0x2F,
-    /// The client requests to start, stop a routine in the server(s) or requests the routine results. See also [`crate::uds::RoutineControlType`].
+    /// The client requests to start, stop a routine in the server(s) or requests the routine results.
+    /// See also [`crate::uds::RoutineControlType`].
     RoutineControl = 0x31,
     /// The client requests the negotiation of a data transfer from the client to the server.
     RequestDownload = 0x34,
@@ -66,6 +81,7 @@ pub enum UdsCommand {
     /// The client requests the termination of a data transfer.
     RequestTransferExit = 0x37,
     /// The client requests the negotiation of a file transfer between server and client.
+    /// See also [`crate::uds::FileTransferMode`].
     RequestFileTransfer = 0x38,
 }
 

src/uds/data_definition_type.rs

@@ -0,0 +1,30 @@
+use crate::utils::{enum_wrapper, python_test};
+
+enum_wrapper!(uds, DataDefinitionType, DataDefinitionTypeByte);
+python_test!(
+    uds,
+    DataDefinitionType,
+    DefineByIdentifier,
+    ClearDynamicallyDefinedDataIdentifier
+);
+
+/// [`UdsCommand::DynamicallyDefineDataIdentifier`](crate::uds::UdsCommand::DynamicallyDefineDataIdentifier) sub-function definitions
+#[repr(u8)]
+#[derive(strum::FromRepr, Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+#[cfg_attr(feature = "bin-proto", derive(bin_proto::BitEncode))]
+#[cfg_attr(feature = "bin-proto", derive(bin_proto::BitDecode))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[cfg_attr(feature = "iter", derive(strum::EnumIter))]
+#[cfg_attr(feature = "pyo3", pyo3::pyclass(eq, eq_int, from_py_object))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum DataDefinitionType {
+    /// Defines the dynamic data identifier via a reference to an existing data identifier
+    DefineByIdentifier = 0x01,
+
+    /// Defines the dynamic data identifier via an absolute memory address and length
+    DefineByMemoryAddress = 0x02,
+
+    /// Clears the specified dynamically defined data identifier; the server responds positively
+    /// even if the identifier does not currently exist
+    ClearDynamicallyDefinedDataIdentifier = 0x03,
+}

src/uds/dtc_setting_type.rs

@@ -0,0 +1,21 @@
+use crate::utils::{enum_wrapper, python_test};
+
+enum_wrapper!(uds, DtcSettingType, DtcSettingTypeByte);
+python_test!(uds, DtcSettingType, On, Off);
+
+/// [`UdsCommand::ControlDTCSetting`](crate::uds::UdsCommand::ControlDTCSetting) sub-function definitions
+#[repr(u8)]
+#[derive(strum::FromRepr, Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+#[cfg_attr(feature = "bin-proto", derive(bin_proto::BitEncode))]
+#[cfg_attr(feature = "bin-proto", derive(bin_proto::BitDecode))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[cfg_attr(feature = "iter", derive(strum::EnumIter))]
+#[cfg_attr(feature = "pyo3", pyo3::pyclass(eq, eq_int, from_py_object))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum DtcSettingType {
+    /// Resumes the updating of DTC status bits according to normal operating conditions
+    On = 0x01,
+
+    /// Stops the updating of DTC status bits in the server
+    Off = 0x02,
+}

src/uds/file_transfer_mode.rs

@@ -0,0 +1,36 @@
+use crate::utils::{enum_wrapper, python_test};
+
+enum_wrapper!(uds, FileTransferMode, FileTransferModeByte);
+python_test!(uds, FileTransferMode, AddFile, ReadFile);
+
+/// `modeOfOperation` data-parameter for
+/// [`UdsCommand::RequestFileTransfer`](crate::uds::UdsCommand::RequestFileTransfer)
+#[repr(u8)]
+#[derive(strum::FromRepr, Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+#[cfg_attr(feature = "bin-proto", derive(bin_proto::BitEncode))]
+#[cfg_attr(feature = "bin-proto", derive(bin_proto::BitDecode))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[cfg_attr(feature = "iter", derive(strum::EnumIter))]
+#[cfg_attr(feature = "pyo3", pyo3::pyclass(eq, eq_int, from_py_object))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum FileTransferMode {
+    /// Downloads (adds) a new file to the server at the path specified by `filePathAndName`
+    AddFile = 0x01,
+
+    /// Deletes the file at the path specified by `filePathAndName` from the server
+    DeleteFile = 0x02,
+
+    /// Downloads and replaces the file at the path specified by `filePathAndName`;
+    /// adds the file if it does not already exist on the server
+    ReplaceFile = 0x03,
+
+    /// Uploads (reads) the file at the path specified by `filePathAndName` from the server
+    ReadFile = 0x04,
+
+    /// Reads the directory listing at the path specified by `filePathAndName` from the server;
+    /// `filePathAndName` indicates a directory, not a file name
+    ReadDir = 0x05,
+
+    /// Resumes a previously interrupted file download at the file position returned by the server
+    ResumeFile = 0x06,
+}

src/uds/input_output_control_parameter.rs

@@ -0,0 +1,38 @@
+use crate::utils::{enum_wrapper, python_test};
+
+enum_wrapper!(
+    uds,
+    InputOutputControlParameter,
+    InputOutputControlParameterByte
+);
+python_test!(
+    uds,
+    InputOutputControlParameter,
+    ReturnControlToEcu,
+    ShortTermAdjustment
+);
+
+/// `inputOutputControlParameter` data-parameter for
+/// [`UdsCommand::InputOutputControlByIdentifier`](crate::uds::UdsCommand::InputOutputControlByIdentifier)
+#[repr(u8)]
+#[derive(strum::FromRepr, Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+#[cfg_attr(feature = "bin-proto", derive(bin_proto::BitEncode))]
+#[cfg_attr(feature = "bin-proto", derive(bin_proto::BitDecode))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[cfg_attr(feature = "iter", derive(strum::EnumIter))]
+#[cfg_attr(feature = "pyo3", pyo3::pyclass(eq, eq_int, from_py_object))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum InputOutputControlParameter {
+    /// Returns control of the input/output signals referenced by the dataIdentifier back to the ECU
+    ReturnControlToEcu = 0x00,
+
+    /// Resets the input/output signals referenced by the dataIdentifier to their default state
+    ResetToDefault = 0x01,
+
+    /// Freezes the current state of the input/output signals referenced by the dataIdentifier
+    FreezeCurrentState = 0x02,
+
+    /// Adjusts the input/output signals referenced by the dataIdentifier to the values
+    /// provided in the `controlState` bytes of the `controlOptionRecord`
+    ShortTermAdjustment = 0x03,
+}

src/uds/link_control_type.rs

@@ -0,0 +1,31 @@
+use crate::utils::{enum_wrapper, python_test};
+
+enum_wrapper!(uds, LinkControlType, LinkControlTypeByte);
+python_test!(
+    uds,
+    LinkControlType,
+    VerifyModeTransitionWithFixedParameter,
+    TransitionMode
+);
+
+/// [`UdsCommand::LinkControl`](crate::uds::UdsCommand::LinkControl) sub-function definitions
+#[repr(u8)]
+#[derive(strum::FromRepr, Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+#[cfg_attr(feature = "bin-proto", derive(bin_proto::BitEncode))]
+#[cfg_attr(feature = "bin-proto", derive(bin_proto::BitDecode))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[cfg_attr(feature = "iter", derive(strum::EnumIter))]
+#[cfg_attr(feature = "pyo3", pyo3::pyclass(eq, eq_int, from_py_object))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum LinkControlType {
+    /// Verifies whether a mode transition with a predefined parameter,
+    /// specified by the `linkControlModeIdentifier` data-parameter, can be performed
+    VerifyModeTransitionWithFixedParameter = 0x01,
+
+    /// Verifies whether a mode transition with a specific parameter,
+    /// specified by the `linkRecord` data-parameter, can be performed
+    VerifyModeTransitionWithSpecificParameter = 0x02,
+
+    /// Requests the server to transition the data link into the mode verified in the preceding request
+    TransitionMode = 0x03,
+}

src/uds/mod.rs

@@ -4,7 +4,13 @@ mod authentication;
 mod comm_control;
 mod comm_level;
 mod commands;
+mod data_definition_type;
+mod dtc_setting_type;
 mod errors;
+mod file_transfer_mode;
+mod input_output_control_parameter;
+mod link_control_type;
+mod periodic_transmission_mode;
 mod read_dtc_information;
 mod reset_types;
 mod routine;
@@ -17,7 +23,13 @@ pub use authentication::*;
 pub use comm_control::*;
 pub use comm_level::*;
 pub use commands::*;
+pub use data_definition_type::*;
+pub use dtc_setting_type::*;
 pub use errors::*;
+pub use file_transfer_mode::*;
+pub use input_output_control_parameter::*;
+pub use link_control_type::*;
+pub use periodic_transmission_mode::*;
 pub use read_dtc_information::*;
 pub use reset_types::*;
 pub use routine::*;

src/uds/periodic_transmission_mode.rs

@@ -0,0 +1,28 @@
+use crate::utils::{enum_wrapper, python_test};
+
+enum_wrapper!(uds, PeriodicTransmissionMode, PeriodicTransmissionModeByte);
+python_test!(uds, PeriodicTransmissionMode, SendAtSlowRate, StopSending);
+
+/// `transmissionMode` data-parameter for
+/// [`UdsCommand::ReadDataByPeriodicIdentifier`](crate::uds::UdsCommand::ReadDataByPeriodicIdentifier)
+#[repr(u8)]
+#[derive(strum::FromRepr, Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+#[cfg_attr(feature = "bin-proto", derive(bin_proto::BitEncode))]
+#[cfg_attr(feature = "bin-proto", derive(bin_proto::BitDecode))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[cfg_attr(feature = "iter", derive(strum::EnumIter))]
+#[cfg_attr(feature = "pyo3", pyo3::pyclass(eq, eq_int, from_py_object))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum PeriodicTransmissionMode {
+    /// Requests periodic transmission at a slow, vehicle manufacturer-defined rate
+    SendAtSlowRate = 0x01,
+
+    /// Requests periodic transmission at a medium, vehicle manufacturer-defined rate
+    SendAtMediumRate = 0x02,
+
+    /// Requests periodic transmission at a fast, vehicle manufacturer-defined rate
+    SendAtFastRate = 0x03,
+
+    /// Stops the server from periodically transmitting the specified data record(s)
+    StopSending = 0x04,
+}