// @generated by ocpp-codegen from schemas/. Do not edit by hand -- run
// `scripts/generate.sh` to regenerate; manual changes will be overwritten.
/// This class does not get 'AdditionalProperties = false' in the schema generation, so it can be extended with arbitrary JSON properties to allow adding custom data.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CustomData {
#[cfg_attr(feature = "serde", serde(rename = "vendorId"))]
pub vendor_id: heapless::String<255usize>,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for CustomData {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Contains a case insensitive identifier to use for the authorization and the type of authorization to support multiple forms of identifiers.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AdditionalInfo<CustomDataType = crate::NoCustomData> {
/// This field specifies the additional IdToken.
#[cfg_attr(feature = "serde", serde(rename = "additionalIdToken"))]
pub additional_id_token: heapless::String<36usize>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// This defines the type of the additionalIdToken. This is a custom type, so the implementation needs to be agreed upon by all involved parties.
pub r#type: heapless::String<50usize>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for AdditionalInfo<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Enumeration of possible idToken types.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum IdTokenEnum {
Central,
#[cfg_attr(feature = "serde", serde(rename = "eMAID"))]
EMAID,
ISO14443,
ISO15693,
KeyCode,
Local,
MacAddress,
NoAuthorization,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for IdTokenEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[cfg(feature = "alloc")]
/// Contains a case insensitive identifier to use for the authorization and the type of authorization to support multiple forms of identifiers.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct IdToken<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "additionalInfo"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub additional_info: Option<alloc::vec::Vec<AdditionalInfo<CustomDataType>>>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// IdToken is case insensitive. Might hold the hidden id of an RFID tag, but can for example also contain a UUID.
#[cfg_attr(feature = "serde", serde(rename = "idToken"))]
pub id_token: heapless::String<36usize>,
pub r#type: IdTokenEnum,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl<CustomDataType> crate::validate::Validate for IdToken<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.additional_info {
crate::validate::check_min_items(value.len(), 1usize)
.map_err(|error| error.in_field("additionalInfo"))?;
for (index, item) in value.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| error.in_index(index).in_field("additionalInfo"))?;
}
}
crate::validate::Validate::validate(&self.r#type)
.map_err(|error| error.in_field("type"))?;
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
/// Contains a case insensitive identifier to use for the authorization and the type of authorization to support multiple forms of identifiers.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct IdToken<
CustomDataType = crate::NoCustomData,
const ID_TOKEN_ADDITIONAL_INFO_CAP: usize = 8usize,
> {
#[cfg_attr(feature = "serde", serde(rename = "additionalInfo"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub additional_info: Option<
heapless::Vec<AdditionalInfo<CustomDataType>, ID_TOKEN_ADDITIONAL_INFO_CAP>,
>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// IdToken is case insensitive. Might hold the hidden id of an RFID tag, but can for example also contain a UUID.
#[cfg_attr(feature = "serde", serde(rename = "idToken"))]
pub id_token: heapless::String<36usize>,
pub r#type: IdTokenEnum,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<CustomDataType, const ID_TOKEN_ADDITIONAL_INFO_CAP: usize> crate::validate::Validate
for IdToken<CustomDataType, ID_TOKEN_ADDITIONAL_INFO_CAP> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.additional_info {
crate::validate::check_min_items(value.len(), 1usize)
.map_err(|error| error.in_field("additionalInfo"))?;
for (index, item) in value.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| error.in_index(index).in_field("additionalInfo"))?;
}
}
crate::validate::Validate::validate(&self.r#type)
.map_err(|error| error.in_field("type"))?;
Ok(())
}
}
/// Used algorithms for the hashes provided.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum HashAlgorithmEnum {
SHA256,
SHA384,
SHA512,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for HashAlgorithmEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct OCSPRequestData<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "hashAlgorithm"))]
pub hash_algorithm: HashAlgorithmEnum,
/// Hashed value of the issuers public key
#[cfg_attr(feature = "serde", serde(rename = "issuerKeyHash"))]
pub issuer_key_hash: heapless::String<128usize>,
/// Hashed value of the Issuer DN (Distinguished Name).
#[cfg_attr(feature = "serde", serde(rename = "issuerNameHash"))]
pub issuer_name_hash: heapless::String<128usize>,
/// This contains the responder URL (Case insensitive).
#[cfg_attr(feature = "serde", serde(rename = "responderURL"))]
pub responder_u_r_l: heapless::String<512usize>,
/// The serial number of the certificate.
#[cfg_attr(feature = "serde", serde(rename = "serialNumber"))]
pub serial_number: heapless::String<40usize>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for OCSPRequestData<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.hash_algorithm)
.map_err(|error| error.in_field("hashAlgorithm"))?;
Ok(())
}
}
/// Certificate status information.
/// - if all certificates are valid: return 'Accepted'.
/// - if one of the certificates was revoked, return 'CertificateRevoked'.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum AuthorizeCertificateStatusEnum {
Accepted,
SignatureError,
CertificateExpired,
CertificateRevoked,
NoCertificateAvailable,
CertChainError,
ContractCancelled,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for AuthorizeCertificateStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Message_ Content. Format. Message_ Format_ Code
/// urn:x-enexis:ecdm:uid:1:570848
/// Format of the message.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum MessageFormatEnum {
ASCII,
HTML,
URI,
UTF8,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for MessageFormatEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Message_ Content
/// urn:x-enexis:ecdm:uid:2:234490
/// Contains message details, for a message to be displayed on a Charging Station.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct MessageContent<CustomDataType = crate::NoCustomData> {
/// Message_ Content. Content. Message
/// urn:x-enexis:ecdm:uid:1:570852
/// Message contents.
pub content: heapless::String<512usize>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
pub format: MessageFormatEnum,
/// Message_ Content. Language. Language_ Code
/// urn:x-enexis:ecdm:uid:1:570849
/// Message language identifier. Contains a language code as defined in <<ref-RFC5646,\[RFC5646\]>>.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub language: Option<heapless::String<8usize>>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for MessageContent<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.format)
.map_err(|error| error.in_field("format"))?;
Ok(())
}
}
/// ID_ Token. Status. Authorization_ Status
/// urn:x-oca:ocpp:uid:1:569372
/// Current status of the ID Token.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum AuthorizationStatusEnum {
Accepted,
Blocked,
ConcurrentTx,
Expired,
Invalid,
NoCredit,
NotAllowedTypeEVSE,
NotAtThisLocation,
NotAtThisTime,
Unknown,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for AuthorizationStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[cfg(feature = "alloc")]
/// ID_ Token
/// urn:x-oca:ocpp:uid:2:233247
/// Contains status information about an identifier.
/// It is advised to not stop charging for a token that expires during charging, as ExpiryDate is only used for caching purposes. If ExpiryDate is not given, the status has no end date.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct IdTokenInfo<CustomDataType = crate::NoCustomData> {
/// ID_ Token. Expiry. Date_ Time
/// urn:x-oca:ocpp:uid:1:569373
/// Date and Time after which the token must be considered invalid.
#[cfg_attr(feature = "serde", serde(rename = "cacheExpiryDateTime"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub cache_expiry_date_time: Option<crate::OcppTimestamp>,
/// Priority from a business point of view. Default priority is 0, The range is from -9 to 9. Higher values indicate a higher priority. The chargingPriority in <<transactioneventresponse,TransactionEventResponse>> overrules this one.
#[cfg_attr(feature = "serde", serde(rename = "chargingPriority"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub charging_priority: Option<i64>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Only used when the IdToken is only valid for one or more specific EVSEs, not for the entire Charging Station.
#[cfg_attr(feature = "serde", serde(rename = "evseId"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub evse_id: Option<alloc::vec::Vec<i64>>,
#[cfg_attr(feature = "serde", serde(rename = "groupIdToken"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub group_id_token: Option<IdToken<CustomDataType>>,
/// ID_ Token. Language1. Language_ Code
/// urn:x-oca:ocpp:uid:1:569374
/// Preferred user interface language of identifier user. Contains a language code as defined in <<ref-RFC5646,\[RFC5646\]>>.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub language1: Option<heapless::String<8usize>>,
/// ID_ Token. Language2. Language_ Code
/// urn:x-oca:ocpp:uid:1:569375
/// Second preferred user interface language of identifier user. Don’t use when language1 is omitted, has to be different from language1. Contains a language code as defined in <<ref-RFC5646,\[RFC5646\]>>.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub language2: Option<heapless::String<8usize>>,
#[cfg_attr(feature = "serde", serde(rename = "personalMessage"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub personal_message: Option<MessageContent<CustomDataType>>,
pub status: AuthorizationStatusEnum,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl<CustomDataType> crate::validate::Validate for IdTokenInfo<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.evse_id {
crate::validate::check_min_items(value.len(), 1usize)
.map_err(|error| error.in_field("evseId"))?;
}
if let Some(value) = &self.group_id_token {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("groupIdToken"))?;
}
if let Some(value) = &self.personal_message {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("personalMessage"))?;
}
crate::validate::Validate::validate(&self.status)
.map_err(|error| error.in_field("status"))?;
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
/// ID_ Token
/// urn:x-oca:ocpp:uid:2:233247
/// Contains status information about an identifier.
/// It is advised to not stop charging for a token that expires during charging, as ExpiryDate is only used for caching purposes. If ExpiryDate is not given, the status has no end date.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct IdTokenInfo<
CustomDataType = crate::NoCustomData,
const ID_TOKEN_INFO_EVSE_ID_CAP: usize = 8usize,
const ID_TOKEN_ADDITIONAL_INFO_CAP: usize = 8usize,
> {
/// ID_ Token. Expiry. Date_ Time
/// urn:x-oca:ocpp:uid:1:569373
/// Date and Time after which the token must be considered invalid.
#[cfg_attr(feature = "serde", serde(rename = "cacheExpiryDateTime"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub cache_expiry_date_time: Option<crate::OcppTimestamp>,
/// Priority from a business point of view. Default priority is 0, The range is from -9 to 9. Higher values indicate a higher priority. The chargingPriority in <<transactioneventresponse,TransactionEventResponse>> overrules this one.
#[cfg_attr(feature = "serde", serde(rename = "chargingPriority"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub charging_priority: Option<i64>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Only used when the IdToken is only valid for one or more specific EVSEs, not for the entire Charging Station.
#[cfg_attr(feature = "serde", serde(rename = "evseId"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub evse_id: Option<heapless::Vec<i64, ID_TOKEN_INFO_EVSE_ID_CAP>>,
#[cfg_attr(feature = "serde", serde(rename = "groupIdToken"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub group_id_token: Option<IdToken<CustomDataType, ID_TOKEN_ADDITIONAL_INFO_CAP>>,
/// ID_ Token. Language1. Language_ Code
/// urn:x-oca:ocpp:uid:1:569374
/// Preferred user interface language of identifier user. Contains a language code as defined in <<ref-RFC5646,\[RFC5646\]>>.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub language1: Option<heapless::String<8usize>>,
/// ID_ Token. Language2. Language_ Code
/// urn:x-oca:ocpp:uid:1:569375
/// Second preferred user interface language of identifier user. Don’t use when language1 is omitted, has to be different from language1. Contains a language code as defined in <<ref-RFC5646,\[RFC5646\]>>.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub language2: Option<heapless::String<8usize>>,
#[cfg_attr(feature = "serde", serde(rename = "personalMessage"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub personal_message: Option<MessageContent<CustomDataType>>,
pub status: AuthorizationStatusEnum,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
CustomDataType,
const ID_TOKEN_INFO_EVSE_ID_CAP: usize,
const ID_TOKEN_ADDITIONAL_INFO_CAP: usize,
> crate::validate::Validate
for IdTokenInfo<
CustomDataType,
ID_TOKEN_INFO_EVSE_ID_CAP,
ID_TOKEN_ADDITIONAL_INFO_CAP,
> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.evse_id {
crate::validate::check_min_items(value.len(), 1usize)
.map_err(|error| error.in_field("evseId"))?;
}
if let Some(value) = &self.group_id_token {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("groupIdToken"))?;
}
if let Some(value) = &self.personal_message {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("personalMessage"))?;
}
crate::validate::Validate::validate(&self.status)
.map_err(|error| error.in_field("status"))?;
Ok(())
}
}
/// Wireless_ Communication_ Module
/// urn:x-oca:ocpp:uid:2:233306
/// Defines parameters required for initiating and maintaining wireless communication with other devices.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Modem<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Wireless_ Communication_ Module. ICCID. CI20_ Text
/// urn:x-oca:ocpp:uid:1:569327
/// This contains the ICCID of the modem’s SIM card.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub iccid: Option<heapless::String<20usize>>,
/// Wireless_ Communication_ Module. IMSI. CI20_ Text
/// urn:x-oca:ocpp:uid:1:569328
/// This contains the IMSI of the modem’s SIM card.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub imsi: Option<heapless::String<20usize>>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for Modem<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Charge_ Point
/// urn:x-oca:ocpp:uid:2:233122
/// The physical system where an Electrical Vehicle (EV) can be charged.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargingStation<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// This contains the firmware version of the Charging Station.
#[cfg_attr(feature = "serde", serde(rename = "firmwareVersion"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub firmware_version: Option<heapless::String<50usize>>,
/// Device. Model. CI20_ Text
/// urn:x-oca:ocpp:uid:1:569325
/// Defines the model of the device.
pub model: heapless::String<20usize>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub modem: Option<Modem<CustomDataType>>,
/// Device. Serial_ Number. Serial_ Number
/// urn:x-oca:ocpp:uid:1:569324
/// Vendor-specific device identifier.
#[cfg_attr(feature = "serde", serde(rename = "serialNumber"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub serial_number: Option<heapless::String<25usize>>,
/// Identifies the vendor (not necessarily in a unique manner).
#[cfg_attr(feature = "serde", serde(rename = "vendorName"))]
pub vendor_name: heapless::String<50usize>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for ChargingStation<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.modem {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("modem"))?;
}
Ok(())
}
}
/// This contains the reason for sending this message to the CSMS.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum BootReasonEnum {
ApplicationReset,
FirmwareUpdate,
LocalReset,
PowerUp,
RemoteReset,
ScheduledReset,
Triggered,
Unknown,
Watchdog,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for BootReasonEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// This contains whether the Charging Station has been registered
/// within the CSMS.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum RegistrationStatusEnum {
Accepted,
Pending,
Rejected,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for RegistrationStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Element providing more information about the status.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct StatusInfo<CustomDataType = crate::NoCustomData> {
/// Additional text to provide detailed information.
#[cfg_attr(feature = "serde", serde(rename = "additionalInfo"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub additional_info: Option<heapless::String<512usize>>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// A predefined code for the reason why the status is returned in this response. The string is case-insensitive.
#[cfg_attr(feature = "serde", serde(rename = "reasonCode"))]
pub reason_code: heapless::String<20usize>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for StatusInfo<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// This indicates the success or failure of the canceling of a reservation by CSMS.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum CancelReservationStatusEnum {
Accepted,
Rejected,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for CancelReservationStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Indicates the type of the signed certificate that is returned. When omitted the certificate is used for both the 15118 connection (if implemented) and the Charging Station to CSMS connection. This field is required when a typeOfCertificate was included in the <<signcertificaterequest,SignCertificateRequest>> that requested this certificate to be signed AND both the 15118 connection and the Charging Station connection are implemented.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum CertificateSigningUseEnum {
ChargingStationCertificate,
V2GCertificate,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for CertificateSigningUseEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Returns whether certificate signing has been accepted, otherwise rejected.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum CertificateSignedStatusEnum {
Accepted,
Rejected,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for CertificateSignedStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// EVSE
/// urn:x-oca:ocpp:uid:2:233123
/// Electric Vehicle Supply Equipment
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EVSE<CustomDataType = crate::NoCustomData> {
/// An id to designate a specific connector (on an EVSE) by connector index number.
#[cfg_attr(feature = "serde", serde(rename = "connectorId"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub connector_id: Option<i64>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Identified_ Object. MRID. Numeric_ Identifier
/// urn:x-enexis:ecdm:uid:1:569198
/// EVSE Identifier. This contains a number (> 0) designating an EVSE of the Charging Station.
pub id: i64,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for EVSE<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// This contains the type of availability change that the Charging Station should perform.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum OperationalStatusEnum {
Inoperative,
Operative,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for OperationalStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// This indicates whether the Charging Station is able to perform the availability change.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ChangeAvailabilityStatusEnum {
Accepted,
Rejected,
Scheduled,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ChangeAvailabilityStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Accepted if the Charging Station has executed the request, otherwise rejected.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ClearCacheStatusEnum {
Accepted,
Rejected,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ClearCacheStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Charging_ Profile. Charging_ Profile_ Purpose. Charging_ Profile_ Purpose_ Code
/// urn:x-oca:ocpp:uid:1:569231
/// Specifies to purpose of the charging profiles that will be cleared, if they meet the other criteria in the request.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ChargingProfilePurposeEnum {
ChargingStationExternalConstraints,
ChargingStationMaxProfile,
TxDefaultProfile,
TxProfile,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ChargingProfilePurposeEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Charging_ Profile
/// urn:x-oca:ocpp:uid:2:233255
/// A ChargingProfile consists of a ChargingSchedule, describing the amount of power or current that can be delivered per time interval.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ClearChargingProfile<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "chargingProfilePurpose"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub charging_profile_purpose: Option<ChargingProfilePurposeEnum>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Identified_ Object. MRID. Numeric_ Identifier
/// urn:x-enexis:ecdm:uid:1:569198
/// Specifies the id of the EVSE for which to clear charging profiles. An evseId of zero (0) specifies the charging profile for the overall Charging Station. Absence of this parameter means the clearing applies to all charging profiles that match the other criteria in the request.
#[cfg_attr(feature = "serde", serde(rename = "evseId"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub evse_id: Option<i64>,
/// Charging_ Profile. Stack_ Level. Counter
/// urn:x-oca:ocpp:uid:1:569230
/// Specifies the stackLevel for which charging profiles will be cleared, if they meet the other criteria in the request.
#[cfg_attr(feature = "serde", serde(rename = "stackLevel"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub stack_level: Option<i64>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for ClearChargingProfile<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.charging_profile_purpose {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("chargingProfilePurpose"))?;
}
Ok(())
}
}
/// Indicates if the Charging Station was able to execute the request.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ClearChargingProfileStatusEnum {
Accepted,
Unknown,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ClearChargingProfileStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Returns whether the Charging Station has been able to remove the message.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ClearMessageStatusEnum {
Accepted,
Unknown,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ClearMessageStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Result of the clear request for this monitor, identified by its Id.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ClearMonitoringStatusEnum {
Accepted,
Rejected,
NotFound,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ClearMonitoringStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ClearMonitoringResult<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Id of the monitor of which a clear was requested.
pub id: i64,
pub status: ClearMonitoringStatusEnum,
#[cfg_attr(feature = "serde", serde(rename = "statusInfo"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub status_info: Option<StatusInfo<CustomDataType>>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate
for ClearMonitoringResult<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.status)
.map_err(|error| error.in_field("status"))?;
if let Some(value) = &self.status_info {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("statusInfo"))?;
}
Ok(())
}
}
/// Source of the charging limit.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ChargingLimitSourceEnum {
EMS,
Other,
SO,
CSO,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ChargingLimitSourceEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CertificateHashData<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "hashAlgorithm"))]
pub hash_algorithm: HashAlgorithmEnum,
/// Hashed value of the issuers public key
#[cfg_attr(feature = "serde", serde(rename = "issuerKeyHash"))]
pub issuer_key_hash: heapless::String<128usize>,
/// Hashed value of the Issuer DN (Distinguished Name).
#[cfg_attr(feature = "serde", serde(rename = "issuerNameHash"))]
pub issuer_name_hash: heapless::String<128usize>,
/// The serial number of the certificate.
#[cfg_attr(feature = "serde", serde(rename = "serialNumber"))]
pub serial_number: heapless::String<40usize>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for CertificateHashData<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.hash_algorithm)
.map_err(|error| error.in_field("hashAlgorithm"))?;
Ok(())
}
}
/// Indicates whether the request was accepted.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum CustomerInformationStatusEnum {
Accepted,
Rejected,
Invalid,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for CustomerInformationStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// This indicates the success or failure of the data transfer.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum DataTransferStatusEnum {
Accepted,
Rejected,
UnknownMessageId,
UnknownVendorId,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for DataTransferStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Charging Station indicates if it can process the request.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum DeleteCertificateStatusEnum {
Accepted,
Failed,
NotFound,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for DeleteCertificateStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// This contains the progress status of the firmware installation.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum FirmwareStatusEnum {
Downloaded,
DownloadFailed,
Downloading,
DownloadScheduled,
DownloadPaused,
Idle,
InstallationFailed,
Installing,
Installed,
InstallRebooting,
InstallScheduled,
InstallVerificationFailed,
InvalidSignature,
SignatureVerified,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for FirmwareStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Defines whether certificate needs to be installed or updated.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum CertificateActionEnum {
Install,
Update,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for CertificateActionEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Indicates whether the message was processed properly.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum Iso15118EVCertificateStatusEnum {
Accepted,
Failed,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for Iso15118EVCertificateStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// This field specifies the report base.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ReportBaseEnum {
ConfigurationInventory,
FullInventory,
SummaryInventory,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ReportBaseEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// This indicates whether the Charging Station is able to accept this request.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum GenericDeviceModelStatusEnum {
Accepted,
Rejected,
NotSupported,
EmptyResultSet,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for GenericDeviceModelStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// This indicates whether the charging station was able to retrieve the OCSP certificate status.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum GetCertificateStatusEnum {
Accepted,
Failed,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for GetCertificateStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[cfg(feature = "alloc")]
/// Charging_ Profile
/// urn:x-oca:ocpp:uid:2:233255
/// A ChargingProfile consists of ChargingSchedule, describing the amount of power or current that can be delivered per time interval.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargingProfileCriterion<CustomDataType = crate::NoCustomData> {
/// For which charging limit sources, charging profiles SHALL be reported. If omitted, the Charging Station SHALL not filter on chargingLimitSource.
#[cfg_attr(feature = "serde", serde(rename = "chargingLimitSource"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub charging_limit_source: Option<heapless::Vec<ChargingLimitSourceEnum, 4usize>>,
/// List of all the chargingProfileIds requested. Any ChargingProfile that matches one of these profiles will be reported. If omitted, the Charging Station SHALL not filter on chargingProfileId. This field SHALL NOT contain more ids than set in <<configkey-charging-profile-entries,ChargingProfileEntries.maxLimit>>
#[cfg_attr(feature = "serde", serde(rename = "chargingProfileId"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub charging_profile_id: Option<alloc::vec::Vec<i64>>,
#[cfg_attr(feature = "serde", serde(rename = "chargingProfilePurpose"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub charging_profile_purpose: Option<ChargingProfilePurposeEnum>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Charging_ Profile. Stack_ Level. Counter
/// urn:x-oca:ocpp:uid:1:569230
/// Value determining level in hierarchy stack of profiles. Higher values have precedence over lower values. Lowest level is 0.
#[cfg_attr(feature = "serde", serde(rename = "stackLevel"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub stack_level: Option<i64>,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl<CustomDataType> crate::validate::Validate
for ChargingProfileCriterion<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.charging_limit_source {
crate::validate::check_min_items(value.len(), 1usize)
.map_err(|error| error.in_field("chargingLimitSource"))?;
for (index, item) in value.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| {
error.in_index(index).in_field("chargingLimitSource")
})?;
}
}
if let Some(value) = &self.charging_profile_id {
crate::validate::check_min_items(value.len(), 1usize)
.map_err(|error| error.in_field("chargingProfileId"))?;
}
if let Some(value) = &self.charging_profile_purpose {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("chargingProfilePurpose"))?;
}
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
/// Charging_ Profile
/// urn:x-oca:ocpp:uid:2:233255
/// A ChargingProfile consists of ChargingSchedule, describing the amount of power or current that can be delivered per time interval.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargingProfileCriterion<
CustomDataType = crate::NoCustomData,
const CHARGING_PROFILE_CRITERION_CHARGING_PROFILE_ID_CAP: usize = 8usize,
> {
/// For which charging limit sources, charging profiles SHALL be reported. If omitted, the Charging Station SHALL not filter on chargingLimitSource.
#[cfg_attr(feature = "serde", serde(rename = "chargingLimitSource"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub charging_limit_source: Option<heapless::Vec<ChargingLimitSourceEnum, 4usize>>,
/// List of all the chargingProfileIds requested. Any ChargingProfile that matches one of these profiles will be reported. If omitted, the Charging Station SHALL not filter on chargingProfileId. This field SHALL NOT contain more ids than set in <<configkey-charging-profile-entries,ChargingProfileEntries.maxLimit>>
#[cfg_attr(feature = "serde", serde(rename = "chargingProfileId"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub charging_profile_id: Option<
heapless::Vec<i64, CHARGING_PROFILE_CRITERION_CHARGING_PROFILE_ID_CAP>,
>,
#[cfg_attr(feature = "serde", serde(rename = "chargingProfilePurpose"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub charging_profile_purpose: Option<ChargingProfilePurposeEnum>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Charging_ Profile. Stack_ Level. Counter
/// urn:x-oca:ocpp:uid:1:569230
/// Value determining level in hierarchy stack of profiles. Higher values have precedence over lower values. Lowest level is 0.
#[cfg_attr(feature = "serde", serde(rename = "stackLevel"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub stack_level: Option<i64>,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
CustomDataType,
const CHARGING_PROFILE_CRITERION_CHARGING_PROFILE_ID_CAP: usize,
> crate::validate::Validate
for ChargingProfileCriterion<
CustomDataType,
CHARGING_PROFILE_CRITERION_CHARGING_PROFILE_ID_CAP,
> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.charging_limit_source {
crate::validate::check_min_items(value.len(), 1usize)
.map_err(|error| error.in_field("chargingLimitSource"))?;
for (index, item) in value.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| {
error.in_index(index).in_field("chargingLimitSource")
})?;
}
}
if let Some(value) = &self.charging_profile_id {
crate::validate::check_min_items(value.len(), 1usize)
.map_err(|error| error.in_field("chargingProfileId"))?;
}
if let Some(value) = &self.charging_profile_purpose {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("chargingProfilePurpose"))?;
}
Ok(())
}
}
/// This indicates whether the Charging Station is able to process this request and will send <<reportchargingprofilesrequest, ReportChargingProfilesRequest>> messages.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum GetChargingProfileStatusEnum {
Accepted,
NoProfiles,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for GetChargingProfileStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Can be used to force a power or current profile.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ChargingRateUnitEnum {
W,
A,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ChargingRateUnitEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Charging_ Schedule_ Period
/// urn:x-oca:ocpp:uid:2:233257
/// Charging schedule period structure defines a time period in a charging schedule.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargingSchedulePeriod<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Charging_ Schedule_ Period. Limit. Measure
/// urn:x-oca:ocpp:uid:1:569241
/// Charging rate limit during the schedule period, in the applicable chargingRateUnit, for example in Amperes (A) or Watts (W). Accepts at most one digit fraction (e.g. 8.1).
pub limit: f64,
/// Charging_ Schedule_ Period. Number_ Phases. Counter
/// urn:x-oca:ocpp:uid:1:569242
/// The number of phases that can be used for charging. If a number of phases is needed, numberPhases=3 will be assumed unless another number is given.
#[cfg_attr(feature = "serde", serde(rename = "numberPhases"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub number_phases: Option<i64>,
/// Values: 1..3, Used if numberPhases=1 and if the EVSE is capable of switching the phase connected to the EV, i.e. ACPhaseSwitchingSupported is defined and true. It’s not allowed unless both conditions above are true. If both conditions are true, and phaseToUse is omitted, the Charging Station / EVSE will make the selection on its own.
#[cfg_attr(feature = "serde", serde(rename = "phaseToUse"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub phase_to_use: Option<i64>,
/// Charging_ Schedule_ Period. Start_ Period. Elapsed_ Time
/// urn:x-oca:ocpp:uid:1:569240
/// Start of the period, in seconds from the start of schedule. The value of StartPeriod also defines the stop time of the previous period.
#[cfg_attr(feature = "serde", serde(rename = "startPeriod"))]
pub start_period: i64,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate
for ChargingSchedulePeriod<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[cfg(feature = "alloc")]
/// Composite_ Schedule
/// urn:x-oca:ocpp:uid:2:233362
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CompositeSchedule<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "chargingRateUnit"))]
pub charging_rate_unit: ChargingRateUnitEnum,
#[cfg_attr(feature = "serde", serde(rename = "chargingSchedulePeriod"))]
pub charging_schedule_period: alloc::vec::Vec<
ChargingSchedulePeriod<CustomDataType>,
>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Duration of the schedule in seconds.
pub duration: i64,
/// The ID of the EVSE for which the
/// schedule is requested. When evseid=0, the
/// Charging Station calculated the expected
/// consumption for the grid connection.
#[cfg_attr(feature = "serde", serde(rename = "evseId"))]
pub evse_id: i64,
/// Composite_ Schedule. Start. Date_ Time
/// urn:x-oca:ocpp:uid:1:569456
/// Date and time at which the schedule becomes active. All time measurements within the schedule are relative to this timestamp.
#[cfg_attr(feature = "serde", serde(rename = "scheduleStart"))]
pub schedule_start: crate::OcppTimestamp,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl<CustomDataType> crate::validate::Validate for CompositeSchedule<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.charging_rate_unit)
.map_err(|error| error.in_field("chargingRateUnit"))?;
crate::validate::check_min_items(self.charging_schedule_period.len(), 1usize)
.map_err(|error| error.in_field("chargingSchedulePeriod"))?;
for (index, item) in self.charging_schedule_period.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| {
error.in_index(index).in_field("chargingSchedulePeriod")
})?;
}
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
/// Composite_ Schedule
/// urn:x-oca:ocpp:uid:2:233362
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CompositeSchedule<
CustomDataType = crate::NoCustomData,
const COMPOSITE_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP: usize = 8usize,
> {
#[cfg_attr(feature = "serde", serde(rename = "chargingRateUnit"))]
pub charging_rate_unit: ChargingRateUnitEnum,
#[cfg_attr(feature = "serde", serde(rename = "chargingSchedulePeriod"))]
pub charging_schedule_period: heapless::Vec<
ChargingSchedulePeriod<CustomDataType>,
COMPOSITE_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP,
>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Duration of the schedule in seconds.
pub duration: i64,
/// The ID of the EVSE for which the
/// schedule is requested. When evseid=0, the
/// Charging Station calculated the expected
/// consumption for the grid connection.
#[cfg_attr(feature = "serde", serde(rename = "evseId"))]
pub evse_id: i64,
/// Composite_ Schedule. Start. Date_ Time
/// urn:x-oca:ocpp:uid:1:569456
/// Date and time at which the schedule becomes active. All time measurements within the schedule are relative to this timestamp.
#[cfg_attr(feature = "serde", serde(rename = "scheduleStart"))]
pub schedule_start: crate::OcppTimestamp,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
CustomDataType,
const COMPOSITE_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP: usize,
> crate::validate::Validate
for CompositeSchedule<CustomDataType, COMPOSITE_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.charging_rate_unit)
.map_err(|error| error.in_field("chargingRateUnit"))?;
crate::validate::check_min_items(self.charging_schedule_period.len(), 1usize)
.map_err(|error| error.in_field("chargingSchedulePeriod"))?;
for (index, item) in self.charging_schedule_period.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| {
error.in_index(index).in_field("chargingSchedulePeriod")
})?;
}
Ok(())
}
}
/// The Charging Station will indicate if it was
/// able to process the request
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum GenericStatusEnum {
Accepted,
Rejected,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for GenericStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// If provided the Charging Station shall return Display Messages with the given priority only.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum MessagePriorityEnum {
AlwaysFront,
InFront,
NormalCycle,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for MessagePriorityEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// If provided the Charging Station shall return Display Messages with the given state only.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum MessageStateEnum {
Charging,
Faulted,
Idle,
Unavailable,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for MessageStateEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Indicates if the Charging Station has Display Messages that match the request criteria in the <<getdisplaymessagesrequest,GetDisplayMessagesRequest>>
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum GetDisplayMessagesStatusEnum {
Accepted,
Unknown,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for GetDisplayMessagesStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum GetCertificateIdUseEnum {
V2GRootCertificate,
MORootCertificate,
CSMSRootCertificate,
V2GCertificateChain,
ManufacturerRootCertificate,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for GetCertificateIdUseEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CertificateHashDataChain<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "certificateHashData"))]
pub certificate_hash_data: CertificateHashData<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "certificateType"))]
pub certificate_type: GetCertificateIdUseEnum,
#[cfg_attr(feature = "serde", serde(rename = "childCertificateHashData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub child_certificate_hash_data: Option<
heapless::Vec<CertificateHashData<CustomDataType>, 4usize>,
>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate
for CertificateHashDataChain<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.certificate_hash_data)
.map_err(|error| error.in_field("certificateHashData"))?;
crate::validate::Validate::validate(&self.certificate_type)
.map_err(|error| error.in_field("certificateType"))?;
if let Some(value) = &self.child_certificate_hash_data {
crate::validate::check_min_items(value.len(), 1usize)
.map_err(|error| error.in_field("childCertificateHashData"))?;
for (index, item) in value.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| {
error.in_index(index).in_field("childCertificateHashData")
})?;
}
}
Ok(())
}
}
/// Charging Station indicates if it can process the request.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum GetInstalledCertificateStatusEnum {
Accepted,
NotFound,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for GetInstalledCertificateStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Log
/// urn:x-enexis:ecdm:uid:2:233373
/// Generic class for the configuration of logging entries.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct LogParameters<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Log. Latest_ Timestamp. Date_ Time
/// urn:x-enexis:ecdm:uid:1:569482
/// This contains the date and time of the latest logging information to include in the diagnostics.
#[cfg_attr(feature = "serde", serde(rename = "latestTimestamp"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub latest_timestamp: Option<crate::OcppTimestamp>,
/// Log. Oldest_ Timestamp. Date_ Time
/// urn:x-enexis:ecdm:uid:1:569477
/// This contains the date and time of the oldest logging information to include in the diagnostics.
#[cfg_attr(feature = "serde", serde(rename = "oldestTimestamp"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub oldest_timestamp: Option<crate::OcppTimestamp>,
/// Log. Remote_ Location. URI
/// urn:x-enexis:ecdm:uid:1:569484
/// The URL of the location at the remote system where the log should be stored.
#[cfg_attr(feature = "serde", serde(rename = "remoteLocation"))]
pub remote_location: heapless::String<512usize>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for LogParameters<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// This contains the type of log file that the Charging Station
/// should send.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum LogEnum {
DiagnosticsLog,
SecurityLog,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for LogEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// This field indicates whether the Charging Station was able to accept the request.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum LogStatusEnum {
Accepted,
Rejected,
AcceptedCanceled,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for LogStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// A physical or logical component
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Component<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub evse: Option<EVSE<CustomDataType>>,
/// Name of instance in case the component exists as multiple instances. Case Insensitive. strongly advised to use Camel Case.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub instance: Option<heapless::String<50usize>>,
/// Name of the component. Name should be taken from the list of standardized component names whenever possible. Case Insensitive. strongly advised to use Camel Case.
pub name: heapless::String<50usize>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for Component<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.evse {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("evse"))?;
}
Ok(())
}
}
/// Reference key to a component-variable.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Variable<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Name of instance in case the variable exists as multiple instances. Case Insensitive. strongly advised to use Camel Case.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub instance: Option<heapless::String<50usize>>,
/// Name of the variable. Name should be taken from the list of standardized variable names whenever possible. Case Insensitive. strongly advised to use Camel Case.
pub name: heapless::String<50usize>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for Variable<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Class to report components, variables and variable attributes and characteristics.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ComponentVariable<CustomDataType = crate::NoCustomData> {
pub component: Component<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub variable: Option<Variable<CustomDataType>>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for ComponentVariable<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.component)
.map_err(|error| error.in_field("component"))?;
if let Some(value) = &self.variable {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("variable"))?;
}
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum MonitoringCriterionEnum {
ThresholdMonitoring,
DeltaMonitoring,
PeriodicMonitoring,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for MonitoringCriterionEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ComponentCriterionEnum {
Active,
Available,
Enabled,
Problem,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ComponentCriterionEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Attribute type for which value is requested. When absent, default Actual is assumed.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum AttributeEnum {
Actual,
Target,
MinSet,
MaxSet,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for AttributeEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Class to hold parameters for GetVariables request.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct GetVariableData<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "attributeType"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub attribute_type: Option<AttributeEnum>,
pub component: Component<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
pub variable: Variable<CustomDataType>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for GetVariableData<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.attribute_type {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("attributeType"))?;
}
crate::validate::Validate::validate(&self.component)
.map_err(|error| error.in_field("component"))?;
crate::validate::Validate::validate(&self.variable)
.map_err(|error| error.in_field("variable"))?;
Ok(())
}
}
/// Result status of getting the variable.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum GetVariableStatusEnum {
Accepted,
Rejected,
UnknownComponent,
UnknownVariable,
NotSupportedAttributeType,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for GetVariableStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[cfg(feature = "alloc")]
/// Class to hold results of GetVariables request.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct GetVariableResult<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "attributeStatus"))]
pub attribute_status: GetVariableStatusEnum,
#[cfg_attr(feature = "serde", serde(rename = "attributeStatusInfo"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub attribute_status_info: Option<StatusInfo<CustomDataType>>,
#[cfg_attr(feature = "serde", serde(rename = "attributeType"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub attribute_type: Option<AttributeEnum>,
/// Value of requested attribute type of component-variable. This field can only be empty when the given status is NOT accepted.
///
/// The Configuration Variable <<configkey-reporting-value-size,ReportingValueSize>> can be used to limit GetVariableResult.attributeValue, VariableAttribute.value and EventData.actualValue. The max size of these values will always remain equal.
#[cfg_attr(feature = "serde", serde(rename = "attributeValue"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub attribute_value: Option<alloc::string::String>,
pub component: Component<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
pub variable: Variable<CustomDataType>,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl<CustomDataType> crate::validate::Validate for GetVariableResult<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.attribute_status)
.map_err(|error| error.in_field("attributeStatus"))?;
if let Some(value) = &self.attribute_status_info {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("attributeStatusInfo"))?;
}
if let Some(value) = &self.attribute_type {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("attributeType"))?;
}
if let Some(value) = &self.attribute_value {
crate::validate::check_max_length(value, 2500usize)
.map_err(|error| error.in_field("attributeValue"))?;
}
crate::validate::Validate::validate(&self.component)
.map_err(|error| error.in_field("component"))?;
crate::validate::Validate::validate(&self.variable)
.map_err(|error| error.in_field("variable"))?;
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
/// Class to hold results of GetVariables request.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct GetVariableResult<
CustomDataType = crate::NoCustomData,
const GET_VARIABLE_RESULT_ATTRIBUTE_VALUE_CAP: usize = 1024usize,
> {
#[cfg_attr(feature = "serde", serde(rename = "attributeStatus"))]
pub attribute_status: GetVariableStatusEnum,
#[cfg_attr(feature = "serde", serde(rename = "attributeStatusInfo"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub attribute_status_info: Option<StatusInfo<CustomDataType>>,
#[cfg_attr(feature = "serde", serde(rename = "attributeType"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub attribute_type: Option<AttributeEnum>,
/// Value of requested attribute type of component-variable. This field can only be empty when the given status is NOT accepted.
///
/// The Configuration Variable <<configkey-reporting-value-size,ReportingValueSize>> can be used to limit GetVariableResult.attributeValue, VariableAttribute.value and EventData.actualValue. The max size of these values will always remain equal.
#[cfg_attr(feature = "serde", serde(rename = "attributeValue"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub attribute_value: Option<
heapless::String<GET_VARIABLE_RESULT_ATTRIBUTE_VALUE_CAP>,
>,
pub component: Component<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
pub variable: Variable<CustomDataType>,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
CustomDataType,
const GET_VARIABLE_RESULT_ATTRIBUTE_VALUE_CAP: usize,
> crate::validate::Validate
for GetVariableResult<CustomDataType, GET_VARIABLE_RESULT_ATTRIBUTE_VALUE_CAP> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.attribute_status)
.map_err(|error| error.in_field("attributeStatus"))?;
if let Some(value) = &self.attribute_status_info {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("attributeStatusInfo"))?;
}
if let Some(value) = &self.attribute_type {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("attributeType"))?;
}
if let Some(value) = &self.attribute_value {
crate::validate::check_max_length(value, 2500usize)
.map_err(|error| error.in_field("attributeValue"))?;
}
crate::validate::Validate::validate(&self.component)
.map_err(|error| error.in_field("component"))?;
crate::validate::Validate::validate(&self.variable)
.map_err(|error| error.in_field("variable"))?;
Ok(())
}
}
/// Indicates the certificate type that is sent.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum InstallCertificateUseEnum {
V2GRootCertificate,
MORootCertificate,
CSMSRootCertificate,
ManufacturerRootCertificate,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for InstallCertificateUseEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Charging Station indicates if installation was successful.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum InstallCertificateStatusEnum {
Accepted,
Rejected,
Failed,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for InstallCertificateStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// This contains the status of the log upload.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum UploadLogStatusEnum {
BadMessage,
Idle,
NotSupportedOperation,
PermissionDenied,
Uploaded,
UploadFailure,
Uploading,
AcceptedCanceled,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for UploadLogStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Sampled_ Value. Context. Reading_ Context_ Code
/// urn:x-oca:ocpp:uid:1:569261
/// Type of detail value: start, end or sample. Default = "Sample.Periodic"
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ReadingContextEnum {
#[cfg_attr(feature = "serde", serde(rename = "Interruption.Begin"))]
InterruptionBegin,
#[cfg_attr(feature = "serde", serde(rename = "Interruption.End"))]
InterruptionEnd,
Other,
#[cfg_attr(feature = "serde", serde(rename = "Sample.Clock"))]
SampleClock,
#[cfg_attr(feature = "serde", serde(rename = "Sample.Periodic"))]
SamplePeriodic,
#[cfg_attr(feature = "serde", serde(rename = "Transaction.Begin"))]
TransactionBegin,
#[cfg_attr(feature = "serde", serde(rename = "Transaction.End"))]
TransactionEnd,
Trigger,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ReadingContextEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Sampled_ Value. Location. Location_ Code
/// urn:x-oca:ocpp:uid:1:569265
/// Indicates where the measured value has been sampled. Default = "Outlet"
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum LocationEnum {
Body,
Cable,
EV,
Inlet,
Outlet,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for LocationEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Sampled_ Value. Measurand. Measurand_ Code
/// urn:x-oca:ocpp:uid:1:569263
/// Type of measurement. Default = "Energy.Active.Import.Register"
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum MeasurandEnum {
#[cfg_attr(feature = "serde", serde(rename = "Current.Export"))]
CurrentExport,
#[cfg_attr(feature = "serde", serde(rename = "Current.Import"))]
CurrentImport,
#[cfg_attr(feature = "serde", serde(rename = "Current.Offered"))]
CurrentOffered,
#[cfg_attr(feature = "serde", serde(rename = "Energy.Active.Export.Register"))]
EnergyActiveExportRegister,
#[cfg_attr(feature = "serde", serde(rename = "Energy.Active.Import.Register"))]
EnergyActiveImportRegister,
#[cfg_attr(feature = "serde", serde(rename = "Energy.Reactive.Export.Register"))]
EnergyReactiveExportRegister,
#[cfg_attr(feature = "serde", serde(rename = "Energy.Reactive.Import.Register"))]
EnergyReactiveImportRegister,
#[cfg_attr(feature = "serde", serde(rename = "Energy.Active.Export.Interval"))]
EnergyActiveExportInterval,
#[cfg_attr(feature = "serde", serde(rename = "Energy.Active.Import.Interval"))]
EnergyActiveImportInterval,
#[cfg_attr(feature = "serde", serde(rename = "Energy.Active.Net"))]
EnergyActiveNet,
#[cfg_attr(feature = "serde", serde(rename = "Energy.Reactive.Export.Interval"))]
EnergyReactiveExportInterval,
#[cfg_attr(feature = "serde", serde(rename = "Energy.Reactive.Import.Interval"))]
EnergyReactiveImportInterval,
#[cfg_attr(feature = "serde", serde(rename = "Energy.Reactive.Net"))]
EnergyReactiveNet,
#[cfg_attr(feature = "serde", serde(rename = "Energy.Apparent.Net"))]
EnergyApparentNet,
#[cfg_attr(feature = "serde", serde(rename = "Energy.Apparent.Import"))]
EnergyApparentImport,
#[cfg_attr(feature = "serde", serde(rename = "Energy.Apparent.Export"))]
EnergyApparentExport,
Frequency,
#[cfg_attr(feature = "serde", serde(rename = "Power.Active.Export"))]
PowerActiveExport,
#[cfg_attr(feature = "serde", serde(rename = "Power.Active.Import"))]
PowerActiveImport,
#[cfg_attr(feature = "serde", serde(rename = "Power.Factor"))]
PowerFactor,
#[cfg_attr(feature = "serde", serde(rename = "Power.Offered"))]
PowerOffered,
#[cfg_attr(feature = "serde", serde(rename = "Power.Reactive.Export"))]
PowerReactiveExport,
#[cfg_attr(feature = "serde", serde(rename = "Power.Reactive.Import"))]
PowerReactiveImport,
SoC,
Voltage,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for MeasurandEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Sampled_ Value. Phase. Phase_ Code
/// urn:x-oca:ocpp:uid:1:569264
/// Indicates how the measured value is to be interpreted. For instance between L1 and neutral (L1-N) Please note that not all values of phase are applicable to all Measurands. When phase is absent, the measured value is interpreted as an overall value.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum PhaseEnum {
L1,
L2,
L3,
N,
#[cfg_attr(feature = "serde", serde(rename = "L1-N"))]
L1N,
#[cfg_attr(feature = "serde", serde(rename = "L2-N"))]
L2N,
#[cfg_attr(feature = "serde", serde(rename = "L3-N"))]
L3N,
#[cfg_attr(feature = "serde", serde(rename = "L1-L2"))]
L1L2,
#[cfg_attr(feature = "serde", serde(rename = "L2-L3"))]
L2L3,
#[cfg_attr(feature = "serde", serde(rename = "L3-L1"))]
L3L1,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for PhaseEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[cfg(feature = "alloc")]
/// Represent a signed version of the meter value.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SignedMeterValue<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Method used to encode the meter values before applying the digital signature algorithm.
#[cfg_attr(feature = "serde", serde(rename = "encodingMethod"))]
pub encoding_method: heapless::String<50usize>,
/// Base64 encoded, sending depends on configuration variable _PublicKeyWithSignedMeterValue_.
#[cfg_attr(feature = "serde", serde(rename = "publicKey"))]
pub public_key: alloc::string::String,
/// Base64 encoded, contains the signed data which might contain more then just the meter value. It can contain information like timestamps, reference to a customer etc.
#[cfg_attr(feature = "serde", serde(rename = "signedMeterData"))]
pub signed_meter_data: alloc::string::String,
/// Method used to create the digital signature.
#[cfg_attr(feature = "serde", serde(rename = "signingMethod"))]
pub signing_method: heapless::String<50usize>,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl<CustomDataType> crate::validate::Validate for SignedMeterValue<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::check_max_length(&self.public_key, 2500usize)
.map_err(|error| error.in_field("publicKey"))?;
crate::validate::check_max_length(&self.signed_meter_data, 2500usize)
.map_err(|error| error.in_field("signedMeterData"))?;
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
/// Represent a signed version of the meter value.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SignedMeterValue<
CustomDataType = crate::NoCustomData,
const SIGNED_METER_VALUE_PUBLIC_KEY_CAP: usize = 1024usize,
const SIGNED_METER_VALUE_SIGNED_METER_DATA_CAP: usize = 1024usize,
> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Method used to encode the meter values before applying the digital signature algorithm.
#[cfg_attr(feature = "serde", serde(rename = "encodingMethod"))]
pub encoding_method: heapless::String<50usize>,
/// Base64 encoded, sending depends on configuration variable _PublicKeyWithSignedMeterValue_.
#[cfg_attr(feature = "serde", serde(rename = "publicKey"))]
pub public_key: heapless::String<SIGNED_METER_VALUE_PUBLIC_KEY_CAP>,
/// Base64 encoded, contains the signed data which might contain more then just the meter value. It can contain information like timestamps, reference to a customer etc.
#[cfg_attr(feature = "serde", serde(rename = "signedMeterData"))]
pub signed_meter_data: heapless::String<SIGNED_METER_VALUE_SIGNED_METER_DATA_CAP>,
/// Method used to create the digital signature.
#[cfg_attr(feature = "serde", serde(rename = "signingMethod"))]
pub signing_method: heapless::String<50usize>,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
CustomDataType,
const SIGNED_METER_VALUE_PUBLIC_KEY_CAP: usize,
const SIGNED_METER_VALUE_SIGNED_METER_DATA_CAP: usize,
> crate::validate::Validate
for SignedMeterValue<
CustomDataType,
SIGNED_METER_VALUE_PUBLIC_KEY_CAP,
SIGNED_METER_VALUE_SIGNED_METER_DATA_CAP,
> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::check_max_length(&self.public_key, 2500usize)
.map_err(|error| error.in_field("publicKey"))?;
crate::validate::check_max_length(&self.signed_meter_data, 2500usize)
.map_err(|error| error.in_field("signedMeterData"))?;
Ok(())
}
}
/// Represents a UnitOfMeasure with a multiplier
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct UnitOfMeasure<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Multiplier, this value represents the exponent to base 10. I.e. multiplier 3 means 10 raised to the 3rd power. Default is 0.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub multiplier: Option<i64>,
/// Unit of the value. Default = "Wh" if the (default) measurand is an "Energy" type.
/// This field SHALL use a value from the list Standardized Units of Measurements in Part 2 Appendices.
/// If an applicable unit is available in that list, otherwise a "custom" unit might be used.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub unit: Option<heapless::String<20usize>>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for UnitOfMeasure<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[cfg(feature = "alloc")]
/// Sampled_ Value
/// urn:x-oca:ocpp:uid:2:233266
/// Single sampled value in MeterValues. Each value can be accompanied by optional fields.
///
/// To save on mobile data usage, default values of all of the optional fields are such that. The value without any additional fields will be interpreted, as a register reading of active import energy in Wh (Watt-hour) units.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SampledValue<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub context: Option<ReadingContextEnum>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub location: Option<LocationEnum>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub measurand: Option<MeasurandEnum>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub phase: Option<PhaseEnum>,
#[cfg_attr(feature = "serde", serde(rename = "signedMeterValue"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub signed_meter_value: Option<SignedMeterValue<CustomDataType>>,
#[cfg_attr(feature = "serde", serde(rename = "unitOfMeasure"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub unit_of_measure: Option<UnitOfMeasure<CustomDataType>>,
/// Sampled_ Value. Value. Measure
/// urn:x-oca:ocpp:uid:1:569260
/// Indicates the measured value.
pub value: f64,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl<CustomDataType> crate::validate::Validate for SampledValue<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.context {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("context"))?;
}
if let Some(value) = &self.location {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("location"))?;
}
if let Some(value) = &self.measurand {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("measurand"))?;
}
if let Some(value) = &self.phase {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("phase"))?;
}
if let Some(value) = &self.signed_meter_value {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("signedMeterValue"))?;
}
if let Some(value) = &self.unit_of_measure {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("unitOfMeasure"))?;
}
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
/// Sampled_ Value
/// urn:x-oca:ocpp:uid:2:233266
/// Single sampled value in MeterValues. Each value can be accompanied by optional fields.
///
/// To save on mobile data usage, default values of all of the optional fields are such that. The value without any additional fields will be interpreted, as a register reading of active import energy in Wh (Watt-hour) units.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SampledValue<
CustomDataType = crate::NoCustomData,
const SIGNED_METER_VALUE_PUBLIC_KEY_CAP: usize = 1024usize,
const SIGNED_METER_VALUE_SIGNED_METER_DATA_CAP: usize = 1024usize,
> {
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub context: Option<ReadingContextEnum>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub location: Option<LocationEnum>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub measurand: Option<MeasurandEnum>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub phase: Option<PhaseEnum>,
#[cfg_attr(feature = "serde", serde(rename = "signedMeterValue"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub signed_meter_value: Option<
SignedMeterValue<
CustomDataType,
SIGNED_METER_VALUE_PUBLIC_KEY_CAP,
SIGNED_METER_VALUE_SIGNED_METER_DATA_CAP,
>,
>,
#[cfg_attr(feature = "serde", serde(rename = "unitOfMeasure"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub unit_of_measure: Option<UnitOfMeasure<CustomDataType>>,
/// Sampled_ Value. Value. Measure
/// urn:x-oca:ocpp:uid:1:569260
/// Indicates the measured value.
pub value: f64,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
CustomDataType,
const SIGNED_METER_VALUE_PUBLIC_KEY_CAP: usize,
const SIGNED_METER_VALUE_SIGNED_METER_DATA_CAP: usize,
> crate::validate::Validate
for SampledValue<
CustomDataType,
SIGNED_METER_VALUE_PUBLIC_KEY_CAP,
SIGNED_METER_VALUE_SIGNED_METER_DATA_CAP,
> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.context {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("context"))?;
}
if let Some(value) = &self.location {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("location"))?;
}
if let Some(value) = &self.measurand {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("measurand"))?;
}
if let Some(value) = &self.phase {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("phase"))?;
}
if let Some(value) = &self.signed_meter_value {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("signedMeterValue"))?;
}
if let Some(value) = &self.unit_of_measure {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("unitOfMeasure"))?;
}
Ok(())
}
}
#[cfg(feature = "alloc")]
/// Meter_ Value
/// urn:x-oca:ocpp:uid:2:233265
/// Collection of one or more sampled values in MeterValuesRequest and TransactionEvent. All sampled values in a MeterValue are sampled at the same point in time.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct MeterValue<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "sampledValue"))]
pub sampled_value: alloc::vec::Vec<SampledValue<CustomDataType>>,
/// Meter_ Value. Timestamp. Date_ Time
/// urn:x-oca:ocpp:uid:1:569259
/// Timestamp for measured value(s).
pub timestamp: crate::OcppTimestamp,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl<CustomDataType> crate::validate::Validate for MeterValue<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::check_min_items(self.sampled_value.len(), 1usize)
.map_err(|error| error.in_field("sampledValue"))?;
for (index, item) in self.sampled_value.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| error.in_index(index).in_field("sampledValue"))?;
}
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
/// Meter_ Value
/// urn:x-oca:ocpp:uid:2:233265
/// Collection of one or more sampled values in MeterValuesRequest and TransactionEvent. All sampled values in a MeterValue are sampled at the same point in time.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct MeterValue<
CustomDataType = crate::NoCustomData,
const METER_VALUE_SAMPLED_VALUE_CAP: usize = 8usize,
const SIGNED_METER_VALUE_PUBLIC_KEY_CAP: usize = 1024usize,
const SIGNED_METER_VALUE_SIGNED_METER_DATA_CAP: usize = 1024usize,
> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "sampledValue"))]
pub sampled_value: heapless::Vec<
SampledValue<
CustomDataType,
SIGNED_METER_VALUE_PUBLIC_KEY_CAP,
SIGNED_METER_VALUE_SIGNED_METER_DATA_CAP,
>,
METER_VALUE_SAMPLED_VALUE_CAP,
>,
/// Meter_ Value. Timestamp. Date_ Time
/// urn:x-oca:ocpp:uid:1:569259
/// Timestamp for measured value(s).
pub timestamp: crate::OcppTimestamp,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
CustomDataType,
const METER_VALUE_SAMPLED_VALUE_CAP: usize,
const SIGNED_METER_VALUE_PUBLIC_KEY_CAP: usize,
const SIGNED_METER_VALUE_SIGNED_METER_DATA_CAP: usize,
> crate::validate::Validate
for MeterValue<
CustomDataType,
METER_VALUE_SAMPLED_VALUE_CAP,
SIGNED_METER_VALUE_PUBLIC_KEY_CAP,
SIGNED_METER_VALUE_SIGNED_METER_DATA_CAP,
> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::check_min_items(self.sampled_value.len(), 1usize)
.map_err(|error| error.in_field("sampledValue"))?;
for (index, item) in self.sampled_value.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| error.in_index(index).in_field("sampledValue"))?;
}
Ok(())
}
}
/// Charging_ Limit
/// urn:x-enexis:ecdm:uid:2:234489
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargingLimit<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "chargingLimitSource"))]
pub charging_limit_source: ChargingLimitSourceEnum,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Charging_ Limit. Is_ Grid_ Critical. Indicator
/// urn:x-enexis:ecdm:uid:1:570847
/// Indicates whether the charging limit is critical for the grid.
#[cfg_attr(feature = "serde", serde(rename = "isGridCritical"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub is_grid_critical: Option<bool>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for ChargingLimit<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.charging_limit_source)
.map_err(|error| error.in_field("chargingLimitSource"))?;
Ok(())
}
}
/// Cost. Cost_ Kind. Cost_ Kind_ Code
/// urn:x-oca:ocpp:uid:1:569243
/// The kind of cost referred to in the message element amount
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum CostKindEnum {
CarbonDioxideEmission,
RelativePricePercentage,
RenewableGenerationPercentage,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for CostKindEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Cost
/// urn:x-oca:ocpp:uid:2:233258
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Cost<CustomDataType = crate::NoCustomData> {
/// Cost. Amount. Amount
/// urn:x-oca:ocpp:uid:1:569244
/// The estimated or actual cost per kWh
pub amount: i64,
/// Cost. Amount_ Multiplier. Integer
/// urn:x-oca:ocpp:uid:1:569245
/// Values: -3..3, The amountMultiplier defines the exponent to base 10 (dec). The final value is determined by: amount * 10 ^ amountMultiplier
#[cfg_attr(feature = "serde", serde(rename = "amountMultiplier"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub amount_multiplier: Option<i64>,
#[cfg_attr(feature = "serde", serde(rename = "costKind"))]
pub cost_kind: CostKindEnum,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for Cost<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.cost_kind)
.map_err(|error| error.in_field("costKind"))?;
Ok(())
}
}
/// Consumption_ Cost
/// urn:x-oca:ocpp:uid:2:233259
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ConsumptionCost<CustomDataType = crate::NoCustomData> {
pub cost: heapless::Vec<Cost<CustomDataType>, 3usize>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Consumption_ Cost. Start_ Value. Numeric
/// urn:x-oca:ocpp:uid:1:569246
/// The lowest level of consumption that defines the starting point of this consumption block. The block interval extends to the start of the next interval.
#[cfg_attr(feature = "serde", serde(rename = "startValue"))]
pub start_value: f64,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for ConsumptionCost<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::check_min_items(self.cost.len(), 1usize)
.map_err(|error| error.in_field("cost"))?;
for (index, item) in self.cost.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| error.in_index(index).in_field("cost"))?;
}
Ok(())
}
}
/// Relative_ Timer_ Interval
/// urn:x-oca:ocpp:uid:2:233270
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RelativeTimeInterval<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Relative_ Timer_ Interval. Duration. Elapsed_ Time
/// urn:x-oca:ocpp:uid:1:569280
/// Duration of the interval, in seconds.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub duration: Option<i64>,
/// Relative_ Timer_ Interval. Start. Elapsed_ Time
/// urn:x-oca:ocpp:uid:1:569279
/// Start of the interval, in seconds from NOW.
pub start: i64,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for RelativeTimeInterval<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Sales_ Tariff_ Entry
/// urn:x-oca:ocpp:uid:2:233271
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SalesTariffEntry<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "consumptionCost"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub consumption_cost: Option<heapless::Vec<ConsumptionCost<CustomDataType>, 3usize>>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Sales_ Tariff_ Entry. E_ Price_ Level. Unsigned_ Integer
/// urn:x-oca:ocpp:uid:1:569281
/// Defines the price level of this SalesTariffEntry (referring to NumEPriceLevels). Small values for the EPriceLevel represent a cheaper TariffEntry. Large values for the EPriceLevel represent a more expensive TariffEntry.
#[cfg_attr(feature = "serde", serde(rename = "ePriceLevel"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub e_price_level: Option<i64>,
#[cfg_attr(feature = "serde", serde(rename = "relativeTimeInterval"))]
pub relative_time_interval: RelativeTimeInterval<CustomDataType>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for SalesTariffEntry<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.consumption_cost {
crate::validate::check_min_items(value.len(), 1usize)
.map_err(|error| error.in_field("consumptionCost"))?;
for (index, item) in value.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| error.in_index(index).in_field("consumptionCost"))?;
}
}
if let Some(value) = self.e_price_level {
crate::validate::check_min_i64(value, 0i64)
.map_err(|error| error.in_field("ePriceLevel"))?;
}
crate::validate::Validate::validate(&self.relative_time_interval)
.map_err(|error| error.in_field("relativeTimeInterval"))?;
Ok(())
}
}
#[cfg(feature = "alloc")]
/// Sales_ Tariff
/// urn:x-oca:ocpp:uid:2:233272
/// NOTE: This dataType is based on dataTypes from <<ref-ISOIEC15118-2,ISO 15118-2>>.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SalesTariff<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Identified_ Object. MRID. Numeric_ Identifier
/// urn:x-enexis:ecdm:uid:1:569198
/// SalesTariff identifier used to identify one sales tariff. An SAID remains a unique identifier for one schedule throughout a charging session.
pub id: i64,
/// Sales_ Tariff. Num_ E_ Price_ Levels. Counter
/// urn:x-oca:ocpp:uid:1:569284
/// Defines the overall number of distinct price levels used across all provided SalesTariff elements.
#[cfg_attr(feature = "serde", serde(rename = "numEPriceLevels"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub num_e_price_levels: Option<i64>,
/// Sales_ Tariff. Sales. Tariff_ Description
/// urn:x-oca:ocpp:uid:1:569283
/// A human readable title/short description of the sales tariff e.g. for HMI display purposes.
#[cfg_attr(feature = "serde", serde(rename = "salesTariffDescription"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub sales_tariff_description: Option<heapless::String<32usize>>,
#[cfg_attr(feature = "serde", serde(rename = "salesTariffEntry"))]
pub sales_tariff_entry: alloc::vec::Vec<SalesTariffEntry<CustomDataType>>,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl<CustomDataType> crate::validate::Validate for SalesTariff<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::check_min_items(self.sales_tariff_entry.len(), 1usize)
.map_err(|error| error.in_field("salesTariffEntry"))?;
crate::validate::check_max_items(self.sales_tariff_entry.len(), 1024usize)
.map_err(|error| error.in_field("salesTariffEntry"))?;
for (index, item) in self.sales_tariff_entry.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| error.in_index(index).in_field("salesTariffEntry"))?;
}
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
/// Sales_ Tariff
/// urn:x-oca:ocpp:uid:2:233272
/// NOTE: This dataType is based on dataTypes from <<ref-ISOIEC15118-2,ISO 15118-2>>.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SalesTariff<
CustomDataType = crate::NoCustomData,
const SALES_TARIFF_SALES_TARIFF_ENTRY_CAP: usize = 8usize,
> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Identified_ Object. MRID. Numeric_ Identifier
/// urn:x-enexis:ecdm:uid:1:569198
/// SalesTariff identifier used to identify one sales tariff. An SAID remains a unique identifier for one schedule throughout a charging session.
pub id: i64,
/// Sales_ Tariff. Num_ E_ Price_ Levels. Counter
/// urn:x-oca:ocpp:uid:1:569284
/// Defines the overall number of distinct price levels used across all provided SalesTariff elements.
#[cfg_attr(feature = "serde", serde(rename = "numEPriceLevels"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub num_e_price_levels: Option<i64>,
/// Sales_ Tariff. Sales. Tariff_ Description
/// urn:x-oca:ocpp:uid:1:569283
/// A human readable title/short description of the sales tariff e.g. for HMI display purposes.
#[cfg_attr(feature = "serde", serde(rename = "salesTariffDescription"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub sales_tariff_description: Option<heapless::String<32usize>>,
#[cfg_attr(feature = "serde", serde(rename = "salesTariffEntry"))]
pub sales_tariff_entry: heapless::Vec<
SalesTariffEntry<CustomDataType>,
SALES_TARIFF_SALES_TARIFF_ENTRY_CAP,
>,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
CustomDataType,
const SALES_TARIFF_SALES_TARIFF_ENTRY_CAP: usize,
> crate::validate::Validate
for SalesTariff<CustomDataType, SALES_TARIFF_SALES_TARIFF_ENTRY_CAP> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::check_min_items(self.sales_tariff_entry.len(), 1usize)
.map_err(|error| error.in_field("salesTariffEntry"))?;
crate::validate::check_max_items(self.sales_tariff_entry.len(), 1024usize)
.map_err(|error| error.in_field("salesTariffEntry"))?;
for (index, item) in self.sales_tariff_entry.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| error.in_index(index).in_field("salesTariffEntry"))?;
}
Ok(())
}
}
#[cfg(feature = "alloc")]
/// Charging_ Schedule
/// urn:x-oca:ocpp:uid:2:233256
/// Charging schedule structure defines a list of charging periods, as used in: GetCompositeSchedule.conf and ChargingProfile.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargingSchedule<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "chargingRateUnit"))]
pub charging_rate_unit: ChargingRateUnitEnum,
#[cfg_attr(feature = "serde", serde(rename = "chargingSchedulePeriod"))]
pub charging_schedule_period: alloc::vec::Vec<
ChargingSchedulePeriod<CustomDataType>,
>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Charging_ Schedule. Duration. Elapsed_ Time
/// urn:x-oca:ocpp:uid:1:569236
/// Duration of the charging schedule in seconds. If the duration is left empty, the last period will continue indefinitely or until end of the transaction if chargingProfilePurpose = TxProfile.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub duration: Option<i64>,
/// Identifies the ChargingSchedule.
pub id: i64,
/// Charging_ Schedule. Min_ Charging_ Rate. Numeric
/// urn:x-oca:ocpp:uid:1:569239
/// Minimum charging rate supported by the EV. The unit of measure is defined by the chargingRateUnit. This parameter is intended to be used by a local smart charging algorithm to optimize the power allocation for in the case a charging process is inefficient at lower charging rates. Accepts at most one digit fraction (e.g. 8.1)
#[cfg_attr(feature = "serde", serde(rename = "minChargingRate"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub min_charging_rate: Option<f64>,
#[cfg_attr(feature = "serde", serde(rename = "salesTariff"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub sales_tariff: Option<SalesTariff<CustomDataType>>,
/// Charging_ Schedule. Start_ Schedule. Date_ Time
/// urn:x-oca:ocpp:uid:1:569237
/// Starting point of an absolute schedule. If absent the schedule will be relative to start of charging.
#[cfg_attr(feature = "serde", serde(rename = "startSchedule"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub start_schedule: Option<crate::OcppTimestamp>,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl<CustomDataType> crate::validate::Validate for ChargingSchedule<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.charging_rate_unit)
.map_err(|error| error.in_field("chargingRateUnit"))?;
crate::validate::check_min_items(self.charging_schedule_period.len(), 1usize)
.map_err(|error| error.in_field("chargingSchedulePeriod"))?;
crate::validate::check_max_items(self.charging_schedule_period.len(), 1024usize)
.map_err(|error| error.in_field("chargingSchedulePeriod"))?;
for (index, item) in self.charging_schedule_period.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| {
error.in_index(index).in_field("chargingSchedulePeriod")
})?;
}
if let Some(value) = &self.sales_tariff {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("salesTariff"))?;
}
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
/// Charging_ Schedule
/// urn:x-oca:ocpp:uid:2:233256
/// Charging schedule structure defines a list of charging periods, as used in: GetCompositeSchedule.conf and ChargingProfile.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargingSchedule<
CustomDataType = crate::NoCustomData,
const CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP: usize = 8usize,
const SALES_TARIFF_SALES_TARIFF_ENTRY_CAP: usize = 8usize,
> {
#[cfg_attr(feature = "serde", serde(rename = "chargingRateUnit"))]
pub charging_rate_unit: ChargingRateUnitEnum,
#[cfg_attr(feature = "serde", serde(rename = "chargingSchedulePeriod"))]
pub charging_schedule_period: heapless::Vec<
ChargingSchedulePeriod<CustomDataType>,
CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP,
>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Charging_ Schedule. Duration. Elapsed_ Time
/// urn:x-oca:ocpp:uid:1:569236
/// Duration of the charging schedule in seconds. If the duration is left empty, the last period will continue indefinitely or until end of the transaction if chargingProfilePurpose = TxProfile.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub duration: Option<i64>,
/// Identifies the ChargingSchedule.
pub id: i64,
/// Charging_ Schedule. Min_ Charging_ Rate. Numeric
/// urn:x-oca:ocpp:uid:1:569239
/// Minimum charging rate supported by the EV. The unit of measure is defined by the chargingRateUnit. This parameter is intended to be used by a local smart charging algorithm to optimize the power allocation for in the case a charging process is inefficient at lower charging rates. Accepts at most one digit fraction (e.g. 8.1)
#[cfg_attr(feature = "serde", serde(rename = "minChargingRate"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub min_charging_rate: Option<f64>,
#[cfg_attr(feature = "serde", serde(rename = "salesTariff"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub sales_tariff: Option<
SalesTariff<CustomDataType, SALES_TARIFF_SALES_TARIFF_ENTRY_CAP>,
>,
/// Charging_ Schedule. Start_ Schedule. Date_ Time
/// urn:x-oca:ocpp:uid:1:569237
/// Starting point of an absolute schedule. If absent the schedule will be relative to start of charging.
#[cfg_attr(feature = "serde", serde(rename = "startSchedule"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub start_schedule: Option<crate::OcppTimestamp>,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
CustomDataType,
const CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP: usize,
const SALES_TARIFF_SALES_TARIFF_ENTRY_CAP: usize,
> crate::validate::Validate
for ChargingSchedule<
CustomDataType,
CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP,
SALES_TARIFF_SALES_TARIFF_ENTRY_CAP,
> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.charging_rate_unit)
.map_err(|error| error.in_field("chargingRateUnit"))?;
crate::validate::check_min_items(self.charging_schedule_period.len(), 1usize)
.map_err(|error| error.in_field("chargingSchedulePeriod"))?;
crate::validate::check_max_items(self.charging_schedule_period.len(), 1024usize)
.map_err(|error| error.in_field("chargingSchedulePeriod"))?;
for (index, item) in self.charging_schedule_period.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| {
error.in_index(index).in_field("chargingSchedulePeriod")
})?;
}
if let Some(value) = &self.sales_tariff {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("salesTariff"))?;
}
Ok(())
}
}
/// Message_ Info
/// urn:x-enexis:ecdm:uid:2:233264
/// Contains message details, for a message to be displayed on a Charging Station.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct MessageInfo<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub display: Option<Component<CustomDataType>>,
/// Message_ Info. End. Date_ Time
/// urn:x-enexis:ecdm:uid:1:569257
/// Until what date-time should this message be shown, after this date/time this message SHALL be removed.
#[cfg_attr(feature = "serde", serde(rename = "endDateTime"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub end_date_time: Option<crate::OcppTimestamp>,
/// Identified_ Object. MRID. Numeric_ Identifier
/// urn:x-enexis:ecdm:uid:1:569198
/// Master resource identifier, unique within an exchange context. It is defined within the OCPP context as a positive Integer value (greater or equal to zero).
pub id: i64,
pub message: MessageContent<CustomDataType>,
pub priority: MessagePriorityEnum,
/// Message_ Info. Start. Date_ Time
/// urn:x-enexis:ecdm:uid:1:569256
/// From what date-time should this message be shown. If omitted: directly.
#[cfg_attr(feature = "serde", serde(rename = "startDateTime"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub start_date_time: Option<crate::OcppTimestamp>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub state: Option<MessageStateEnum>,
/// During which transaction shall this message be shown.
/// Message SHALL be removed by the Charging Station after transaction has
/// ended.
#[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub transaction_id: Option<heapless::String<36usize>>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for MessageInfo<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.display {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("display"))?;
}
crate::validate::Validate::validate(&self.message)
.map_err(|error| error.in_field("message"))?;
crate::validate::Validate::validate(&self.priority)
.map_err(|error| error.in_field("priority"))?;
if let Some(value) = &self.state {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("state"))?;
}
Ok(())
}
}
/// AC_ Charging_ Parameters
/// urn:x-oca:ocpp:uid:2:233250
/// EV AC charging parameters.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ACChargingParameters<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// AC_ Charging_ Parameters. Energy_ Amount. Energy_ Amount
/// urn:x-oca:ocpp:uid:1:569211
/// Amount of energy requested (in Wh). This includes energy required for preconditioning.
#[cfg_attr(feature = "serde", serde(rename = "energyAmount"))]
pub energy_amount: i64,
/// AC_ Charging_ Parameters. EV_ Max. Current
/// urn:x-oca:ocpp:uid:1:569213
/// Maximum current (amps) supported by the electric vehicle (per phase). Includes cable capacity.
#[cfg_attr(feature = "serde", serde(rename = "evMaxCurrent"))]
pub ev_max_current: i64,
/// AC_ Charging_ Parameters. EV_ Max. Voltage
/// urn:x-oca:ocpp:uid:1:569214
/// Maximum voltage supported by the electric vehicle
#[cfg_attr(feature = "serde", serde(rename = "evMaxVoltage"))]
pub ev_max_voltage: i64,
/// AC_ Charging_ Parameters. EV_ Min. Current
/// urn:x-oca:ocpp:uid:1:569212
/// Minimum current (amps) supported by the electric vehicle (per phase).
#[cfg_attr(feature = "serde", serde(rename = "evMinCurrent"))]
pub ev_min_current: i64,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for ACChargingParameters<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// DC_ Charging_ Parameters
/// urn:x-oca:ocpp:uid:2:233251
/// EV DC charging parameters
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DCChargingParameters<CustomDataType = crate::NoCustomData> {
/// DC_ Charging_ Parameters. Bulk_ SOC. Percentage
/// urn:x-oca:ocpp:uid:1:569222
/// Percentage of SoC at which the EV considers a fast charging process to end. (possible values: 0 - 100)
#[cfg_attr(feature = "serde", serde(rename = "bulkSoC"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub bulk_so_c: Option<i64>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// DC_ Charging_ Parameters. Energy_ Amount. Energy_ Amount
/// urn:x-oca:ocpp:uid:1:569217
/// Amount of energy requested (in Wh). This inludes energy required for preconditioning.
#[cfg_attr(feature = "serde", serde(rename = "energyAmount"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub energy_amount: Option<i64>,
/// DC_ Charging_ Parameters. EV_ Energy_ Capacity. Numeric
/// urn:x-oca:ocpp:uid:1:569220
/// Capacity of the electric vehicle battery (in Wh)
#[cfg_attr(feature = "serde", serde(rename = "evEnergyCapacity"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub ev_energy_capacity: Option<i64>,
/// DC_ Charging_ Parameters. EV_ Max. Current
/// urn:x-oca:ocpp:uid:1:569215
/// Maximum current (amps) supported by the electric vehicle. Includes cable capacity.
#[cfg_attr(feature = "serde", serde(rename = "evMaxCurrent"))]
pub ev_max_current: i64,
/// DC_ Charging_ Parameters. EV_ Max. Power
/// urn:x-oca:ocpp:uid:1:569218
/// Maximum power (in W) supported by the electric vehicle. Required for DC charging.
#[cfg_attr(feature = "serde", serde(rename = "evMaxPower"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub ev_max_power: Option<i64>,
/// DC_ Charging_ Parameters. EV_ Max. Voltage
/// urn:x-oca:ocpp:uid:1:569216
/// Maximum voltage supported by the electric vehicle
#[cfg_attr(feature = "serde", serde(rename = "evMaxVoltage"))]
pub ev_max_voltage: i64,
/// DC_ Charging_ Parameters. Full_ SOC. Percentage
/// urn:x-oca:ocpp:uid:1:569221
/// Percentage of SoC at which the EV considers the battery fully charged. (possible values: 0 - 100)
#[cfg_attr(feature = "serde", serde(rename = "fullSoC"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub full_so_c: Option<i64>,
/// DC_ Charging_ Parameters. State_ Of_ Charge. Numeric
/// urn:x-oca:ocpp:uid:1:569219
/// Energy available in the battery (in percent of the battery capacity)
#[cfg_attr(feature = "serde", serde(rename = "stateOfCharge"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub state_of_charge: Option<i64>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for DCChargingParameters<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = self.bulk_so_c {
crate::validate::check_min_i64(value, 0i64)
.map_err(|error| error.in_field("bulkSoC"))?;
crate::validate::check_max_i64(value, 100i64)
.map_err(|error| error.in_field("bulkSoC"))?;
}
if let Some(value) = self.full_so_c {
crate::validate::check_min_i64(value, 0i64)
.map_err(|error| error.in_field("fullSoC"))?;
crate::validate::check_max_i64(value, 100i64)
.map_err(|error| error.in_field("fullSoC"))?;
}
if let Some(value) = self.state_of_charge {
crate::validate::check_min_i64(value, 0i64)
.map_err(|error| error.in_field("stateOfCharge"))?;
crate::validate::check_max_i64(value, 100i64)
.map_err(|error| error.in_field("stateOfCharge"))?;
}
Ok(())
}
}
/// Charging_ Needs. Requested. Energy_ Transfer_ Mode_ Code
/// urn:x-oca:ocpp:uid:1:569209
/// Mode of energy transfer requested by the EV.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum EnergyTransferModeEnum {
DC,
#[cfg_attr(feature = "serde", serde(rename = "AC_single_phase"))]
ACsinglephase,
#[cfg_attr(feature = "serde", serde(rename = "AC_two_phase"))]
ACtwophase,
#[cfg_attr(feature = "serde", serde(rename = "AC_three_phase"))]
ACthreephase,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for EnergyTransferModeEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Charging_ Needs
/// urn:x-oca:ocpp:uid:2:233249
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargingNeeds<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "acChargingParameters"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub ac_charging_parameters: Option<ACChargingParameters<CustomDataType>>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "dcChargingParameters"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub dc_charging_parameters: Option<DCChargingParameters<CustomDataType>>,
/// Charging_ Needs. Departure_ Time. Date_ Time
/// urn:x-oca:ocpp:uid:1:569223
/// Estimated departure time of the EV.
#[cfg_attr(feature = "serde", serde(rename = "departureTime"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub departure_time: Option<crate::OcppTimestamp>,
#[cfg_attr(feature = "serde", serde(rename = "requestedEnergyTransfer"))]
pub requested_energy_transfer: EnergyTransferModeEnum,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for ChargingNeeds<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.ac_charging_parameters {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("acChargingParameters"))?;
}
if let Some(value) = &self.dc_charging_parameters {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("dcChargingParameters"))?;
}
crate::validate::Validate::validate(&self.requested_energy_transfer)
.map_err(|error| error.in_field("requestedEnergyTransfer"))?;
Ok(())
}
}
/// Returns whether the CSMS has been able to process the message successfully. It does not imply that the evChargingNeeds can be met with the current charging profile.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum NotifyEVChargingNeedsStatusEnum {
Accepted,
Rejected,
Processing,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for NotifyEVChargingNeedsStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Specifies the event notification type of the message.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum EventNotificationEnum {
HardWiredNotification,
HardWiredMonitor,
PreconfiguredMonitor,
CustomMonitor,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for EventNotificationEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Type of monitor that triggered this event, e.g. exceeding a threshold value.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum EventTriggerEnum {
Alerting,
Delta,
Periodic,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for EventTriggerEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[cfg(feature = "alloc")]
/// Class to report an event notification for a component-variable.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EventData<CustomDataType = crate::NoCustomData> {
/// Actual value (_attributeType_ Actual) of the variable.
///
/// The Configuration Variable <<configkey-reporting-value-size,ReportingValueSize>> can be used to limit GetVariableResult.attributeValue, VariableAttribute.value and EventData.actualValue. The max size of these values will always remain equal.
#[cfg_attr(feature = "serde", serde(rename = "actualValue"))]
pub actual_value: alloc::string::String,
/// Refers to the Id of an event that is considered to be the cause for this event.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub cause: Option<i64>,
/// _Cleared_ is set to true to report the clearing of a monitored situation, i.e. a 'return to normal'.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub cleared: Option<bool>,
pub component: Component<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Identifies the event. This field can be referred to as a cause by other events.
#[cfg_attr(feature = "serde", serde(rename = "eventId"))]
pub event_id: i64,
#[cfg_attr(feature = "serde", serde(rename = "eventNotificationType"))]
pub event_notification_type: EventNotificationEnum,
/// Technical (error) code as reported by component.
#[cfg_attr(feature = "serde", serde(rename = "techCode"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub tech_code: Option<heapless::String<50usize>>,
/// Technical detail information as reported by component.
#[cfg_attr(feature = "serde", serde(rename = "techInfo"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub tech_info: Option<heapless::String<500usize>>,
/// Timestamp of the moment the report was generated.
pub timestamp: crate::OcppTimestamp,
/// If an event notification is linked to a specific transaction, this field can be used to specify its transactionId.
#[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub transaction_id: Option<heapless::String<36usize>>,
pub trigger: EventTriggerEnum,
pub variable: Variable<CustomDataType>,
/// Identifies the VariableMonitoring which triggered the event.
#[cfg_attr(feature = "serde", serde(rename = "variableMonitoringId"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub variable_monitoring_id: Option<i64>,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl<CustomDataType> crate::validate::Validate for EventData<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::check_max_length(&self.actual_value, 2500usize)
.map_err(|error| error.in_field("actualValue"))?;
crate::validate::Validate::validate(&self.component)
.map_err(|error| error.in_field("component"))?;
crate::validate::Validate::validate(&self.event_notification_type)
.map_err(|error| error.in_field("eventNotificationType"))?;
crate::validate::Validate::validate(&self.trigger)
.map_err(|error| error.in_field("trigger"))?;
crate::validate::Validate::validate(&self.variable)
.map_err(|error| error.in_field("variable"))?;
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
/// Class to report an event notification for a component-variable.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EventData<
CustomDataType = crate::NoCustomData,
const EVENT_DATA_ACTUAL_VALUE_CAP: usize = 1024usize,
> {
/// Actual value (_attributeType_ Actual) of the variable.
///
/// The Configuration Variable <<configkey-reporting-value-size,ReportingValueSize>> can be used to limit GetVariableResult.attributeValue, VariableAttribute.value and EventData.actualValue. The max size of these values will always remain equal.
#[cfg_attr(feature = "serde", serde(rename = "actualValue"))]
pub actual_value: heapless::String<EVENT_DATA_ACTUAL_VALUE_CAP>,
/// Refers to the Id of an event that is considered to be the cause for this event.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub cause: Option<i64>,
/// _Cleared_ is set to true to report the clearing of a monitored situation, i.e. a 'return to normal'.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub cleared: Option<bool>,
pub component: Component<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Identifies the event. This field can be referred to as a cause by other events.
#[cfg_attr(feature = "serde", serde(rename = "eventId"))]
pub event_id: i64,
#[cfg_attr(feature = "serde", serde(rename = "eventNotificationType"))]
pub event_notification_type: EventNotificationEnum,
/// Technical (error) code as reported by component.
#[cfg_attr(feature = "serde", serde(rename = "techCode"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub tech_code: Option<heapless::String<50usize>>,
/// Technical detail information as reported by component.
#[cfg_attr(feature = "serde", serde(rename = "techInfo"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub tech_info: Option<heapless::String<500usize>>,
/// Timestamp of the moment the report was generated.
pub timestamp: crate::OcppTimestamp,
/// If an event notification is linked to a specific transaction, this field can be used to specify its transactionId.
#[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub transaction_id: Option<heapless::String<36usize>>,
pub trigger: EventTriggerEnum,
pub variable: Variable<CustomDataType>,
/// Identifies the VariableMonitoring which triggered the event.
#[cfg_attr(feature = "serde", serde(rename = "variableMonitoringId"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub variable_monitoring_id: Option<i64>,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<CustomDataType, const EVENT_DATA_ACTUAL_VALUE_CAP: usize> crate::validate::Validate
for EventData<CustomDataType, EVENT_DATA_ACTUAL_VALUE_CAP> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::check_max_length(&self.actual_value, 2500usize)
.map_err(|error| error.in_field("actualValue"))?;
crate::validate::Validate::validate(&self.component)
.map_err(|error| error.in_field("component"))?;
crate::validate::Validate::validate(&self.event_notification_type)
.map_err(|error| error.in_field("eventNotificationType"))?;
crate::validate::Validate::validate(&self.trigger)
.map_err(|error| error.in_field("trigger"))?;
crate::validate::Validate::validate(&self.variable)
.map_err(|error| error.in_field("variable"))?;
Ok(())
}
}
/// The type of this monitor, e.g. a threshold, delta or periodic monitor.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum MonitorEnum {
UpperThreshold,
LowerThreshold,
Delta,
Periodic,
PeriodicClockAligned,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for MonitorEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// A monitoring setting for a variable.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VariableMonitoring<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Identifies the monitor.
pub id: i64,
/// The severity that will be assigned to an event that is triggered by this monitor. The severity range is 0-9, with 0 as the highest and 9 as the lowest severity level.
///
/// The severity levels have the following meaning: +
/// *0-Danger* +
/// Indicates lives are potentially in danger. Urgent attention is needed and action should be taken immediately. +
/// *1-Hardware Failure* +
/// Indicates that the Charging Station is unable to continue regular operations due to Hardware issues. Action is required. +
/// *2-System Failure* +
/// Indicates that the Charging Station is unable to continue regular operations due to software or minor hardware issues. Action is required. +
/// *3-Critical* +
/// Indicates a critical error. Action is required. +
/// *4-Error* +
/// Indicates a non-urgent error. Action is required. +
/// *5-Alert* +
/// Indicates an alert event. Default severity for any type of monitoring event. +
/// *6-Warning* +
/// Indicates a warning event. Action may be required. +
/// *7-Notice* +
/// Indicates an unusual event. No immediate action is required. +
/// *8-Informational* +
/// Indicates a regular operational event. May be used for reporting, measuring throughput, etc. No action is required. +
/// *9-Debug* +
/// Indicates information useful to developers for debugging, not useful during operations.
pub severity: i64,
/// Monitor only active when a transaction is ongoing on a component relevant to this transaction.
pub transaction: bool,
pub r#type: MonitorEnum,
/// Value for threshold or delta monitoring.
/// For Periodic or PeriodicClockAligned this is the interval in seconds.
pub value: f64,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for VariableMonitoring<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.r#type)
.map_err(|error| error.in_field("type"))?;
Ok(())
}
}
#[cfg(feature = "alloc")]
/// Class to hold parameters of SetVariableMonitoring request.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct MonitoringData<CustomDataType = crate::NoCustomData> {
pub component: Component<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
pub variable: Variable<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "variableMonitoring"))]
pub variable_monitoring: alloc::vec::Vec<VariableMonitoring<CustomDataType>>,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl<CustomDataType> crate::validate::Validate for MonitoringData<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.component)
.map_err(|error| error.in_field("component"))?;
crate::validate::Validate::validate(&self.variable)
.map_err(|error| error.in_field("variable"))?;
crate::validate::check_min_items(self.variable_monitoring.len(), 1usize)
.map_err(|error| error.in_field("variableMonitoring"))?;
for (index, item) in self.variable_monitoring.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| error.in_index(index).in_field("variableMonitoring"))?;
}
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
/// Class to hold parameters of SetVariableMonitoring request.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct MonitoringData<
CustomDataType = crate::NoCustomData,
const MONITORING_DATA_VARIABLE_MONITORING_CAP: usize = 8usize,
> {
pub component: Component<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
pub variable: Variable<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "variableMonitoring"))]
pub variable_monitoring: heapless::Vec<
VariableMonitoring<CustomDataType>,
MONITORING_DATA_VARIABLE_MONITORING_CAP,
>,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
CustomDataType,
const MONITORING_DATA_VARIABLE_MONITORING_CAP: usize,
> crate::validate::Validate
for MonitoringData<CustomDataType, MONITORING_DATA_VARIABLE_MONITORING_CAP> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.component)
.map_err(|error| error.in_field("component"))?;
crate::validate::Validate::validate(&self.variable)
.map_err(|error| error.in_field("variable"))?;
crate::validate::check_min_items(self.variable_monitoring.len(), 1usize)
.map_err(|error| error.in_field("variableMonitoring"))?;
for (index, item) in self.variable_monitoring.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| error.in_index(index).in_field("variableMonitoring"))?;
}
Ok(())
}
}
/// Defines the mutability of this attribute. Default is ReadWrite when omitted.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum MutabilityEnum {
ReadOnly,
WriteOnly,
ReadWrite,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for MutabilityEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[cfg(feature = "alloc")]
/// Attribute data of a variable.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VariableAttribute<CustomDataType = crate::NoCustomData> {
/// If true, value that will never be changed by the Charging Station at runtime. Default when omitted is false.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub constant: Option<bool>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub mutability: Option<MutabilityEnum>,
/// If true, value will be persistent across system reboots or power down. Default when omitted is false.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub persistent: Option<bool>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub r#type: Option<AttributeEnum>,
/// Value of the attribute. May only be omitted when mutability is set to 'WriteOnly'.
///
/// The Configuration Variable <<configkey-reporting-value-size,ReportingValueSize>> can be used to limit GetVariableResult.attributeValue, VariableAttribute.value and EventData.actualValue. The max size of these values will always remain equal.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub value: Option<alloc::string::String>,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl<CustomDataType> crate::validate::Validate for VariableAttribute<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.mutability {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("mutability"))?;
}
if let Some(value) = &self.r#type {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("type"))?;
}
if let Some(value) = &self.value {
crate::validate::check_max_length(value, 2500usize)
.map_err(|error| error.in_field("value"))?;
}
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
/// Attribute data of a variable.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VariableAttribute<
CustomDataType = crate::NoCustomData,
const VARIABLE_ATTRIBUTE_VALUE_CAP: usize = 1024usize,
> {
/// If true, value that will never be changed by the Charging Station at runtime. Default when omitted is false.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub constant: Option<bool>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub mutability: Option<MutabilityEnum>,
/// If true, value will be persistent across system reboots or power down. Default when omitted is false.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub persistent: Option<bool>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub r#type: Option<AttributeEnum>,
/// Value of the attribute. May only be omitted when mutability is set to 'WriteOnly'.
///
/// The Configuration Variable <<configkey-reporting-value-size,ReportingValueSize>> can be used to limit GetVariableResult.attributeValue, VariableAttribute.value and EventData.actualValue. The max size of these values will always remain equal.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub value: Option<heapless::String<VARIABLE_ATTRIBUTE_VALUE_CAP>>,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<CustomDataType, const VARIABLE_ATTRIBUTE_VALUE_CAP: usize> crate::validate::Validate
for VariableAttribute<CustomDataType, VARIABLE_ATTRIBUTE_VALUE_CAP> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.mutability {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("mutability"))?;
}
if let Some(value) = &self.r#type {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("type"))?;
}
if let Some(value) = &self.value {
crate::validate::check_max_length(value, 2500usize)
.map_err(|error| error.in_field("value"))?;
}
Ok(())
}
}
/// Data type of this variable.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum DataEnum {
#[cfg_attr(feature = "serde", serde(rename = "string"))]
String,
#[cfg_attr(feature = "serde", serde(rename = "decimal"))]
Decimal,
#[cfg_attr(feature = "serde", serde(rename = "integer"))]
Integer,
#[cfg_attr(feature = "serde", serde(rename = "dateTime"))]
DateTime,
#[cfg_attr(feature = "serde", serde(rename = "boolean"))]
Boolean,
OptionList,
SequenceList,
MemberList,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for DataEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[cfg(feature = "alloc")]
/// Fixed read-only parameters of a variable.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VariableCharacteristics<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "dataType"))]
pub data_type: DataEnum,
/// Maximum possible value of this variable. When the datatype of this Variable is String, OptionList, SequenceList or MemberList, this field defines the maximum length of the (CSV) string.
#[cfg_attr(feature = "serde", serde(rename = "maxLimit"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub max_limit: Option<f64>,
/// Minimum possible value of this variable.
#[cfg_attr(feature = "serde", serde(rename = "minLimit"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub min_limit: Option<f64>,
/// Flag indicating if this variable supports monitoring.
#[cfg_attr(feature = "serde", serde(rename = "supportsMonitoring"))]
pub supports_monitoring: bool,
/// Unit of the variable. When the transmitted value has a unit, this field SHALL be included.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub unit: Option<heapless::String<16usize>>,
/// Allowed values when variable is Option/Member/SequenceList.
///
/// * OptionList: The (Actual) Variable value must be a single value from the reported (CSV) enumeration list.
///
/// * MemberList: The (Actual) Variable value may be an (unordered) (sub-)set of the reported (CSV) valid values list.
///
/// * SequenceList: The (Actual) Variable value may be an ordered (priority, etc) (sub-)set of the reported (CSV) valid values.
///
/// This is a comma separated list.
///
/// The Configuration Variable <<configkey-configuration-value-size,ConfigurationValueSize>> can be used to limit SetVariableData.attributeValue and VariableCharacteristics.valueList. The max size of these values will always remain equal.
#[cfg_attr(feature = "serde", serde(rename = "valuesList"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub values_list: Option<alloc::string::String>,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl<CustomDataType> crate::validate::Validate
for VariableCharacteristics<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.data_type)
.map_err(|error| error.in_field("dataType"))?;
if let Some(value) = &self.values_list {
crate::validate::check_max_length(value, 1000usize)
.map_err(|error| error.in_field("valuesList"))?;
}
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
/// Fixed read-only parameters of a variable.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VariableCharacteristics<
CustomDataType = crate::NoCustomData,
const VARIABLE_CHARACTERISTICS_VALUES_LIST_CAP: usize = 1000usize,
> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "dataType"))]
pub data_type: DataEnum,
/// Maximum possible value of this variable. When the datatype of this Variable is String, OptionList, SequenceList or MemberList, this field defines the maximum length of the (CSV) string.
#[cfg_attr(feature = "serde", serde(rename = "maxLimit"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub max_limit: Option<f64>,
/// Minimum possible value of this variable.
#[cfg_attr(feature = "serde", serde(rename = "minLimit"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub min_limit: Option<f64>,
/// Flag indicating if this variable supports monitoring.
#[cfg_attr(feature = "serde", serde(rename = "supportsMonitoring"))]
pub supports_monitoring: bool,
/// Unit of the variable. When the transmitted value has a unit, this field SHALL be included.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub unit: Option<heapless::String<16usize>>,
/// Allowed values when variable is Option/Member/SequenceList.
///
/// * OptionList: The (Actual) Variable value must be a single value from the reported (CSV) enumeration list.
///
/// * MemberList: The (Actual) Variable value may be an (unordered) (sub-)set of the reported (CSV) valid values list.
///
/// * SequenceList: The (Actual) Variable value may be an ordered (priority, etc) (sub-)set of the reported (CSV) valid values.
///
/// This is a comma separated list.
///
/// The Configuration Variable <<configkey-configuration-value-size,ConfigurationValueSize>> can be used to limit SetVariableData.attributeValue and VariableCharacteristics.valueList. The max size of these values will always remain equal.
#[cfg_attr(feature = "serde", serde(rename = "valuesList"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub values_list: Option<heapless::String<VARIABLE_CHARACTERISTICS_VALUES_LIST_CAP>>,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
CustomDataType,
const VARIABLE_CHARACTERISTICS_VALUES_LIST_CAP: usize,
> crate::validate::Validate
for VariableCharacteristics<CustomDataType, VARIABLE_CHARACTERISTICS_VALUES_LIST_CAP> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.data_type)
.map_err(|error| error.in_field("dataType"))?;
if let Some(value) = &self.values_list {
crate::validate::check_max_length(value, 1000usize)
.map_err(|error| error.in_field("valuesList"))?;
}
Ok(())
}
}
#[cfg(feature = "alloc")]
/// Class to report components, variables and variable attributes and characteristics.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ReportData<CustomDataType = crate::NoCustomData> {
pub component: Component<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
pub variable: Variable<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "variableAttribute"))]
pub variable_attribute: heapless::Vec<VariableAttribute<CustomDataType>, 4usize>,
#[cfg_attr(feature = "serde", serde(rename = "variableCharacteristics"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub variable_characteristics: Option<VariableCharacteristics<CustomDataType>>,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl<CustomDataType> crate::validate::Validate for ReportData<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.component)
.map_err(|error| error.in_field("component"))?;
crate::validate::Validate::validate(&self.variable)
.map_err(|error| error.in_field("variable"))?;
crate::validate::check_min_items(self.variable_attribute.len(), 1usize)
.map_err(|error| error.in_field("variableAttribute"))?;
for (index, item) in self.variable_attribute.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| error.in_index(index).in_field("variableAttribute"))?;
}
if let Some(value) = &self.variable_characteristics {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("variableCharacteristics"))?;
}
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
/// Class to report components, variables and variable attributes and characteristics.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ReportData<
CustomDataType = crate::NoCustomData,
const VARIABLE_ATTRIBUTE_VALUE_CAP: usize = 1024usize,
const VARIABLE_CHARACTERISTICS_VALUES_LIST_CAP: usize = 1000usize,
> {
pub component: Component<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
pub variable: Variable<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "variableAttribute"))]
pub variable_attribute: heapless::Vec<
VariableAttribute<CustomDataType, VARIABLE_ATTRIBUTE_VALUE_CAP>,
4usize,
>,
#[cfg_attr(feature = "serde", serde(rename = "variableCharacteristics"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub variable_characteristics: Option<
VariableCharacteristics<CustomDataType, VARIABLE_CHARACTERISTICS_VALUES_LIST_CAP>,
>,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
CustomDataType,
const VARIABLE_ATTRIBUTE_VALUE_CAP: usize,
const VARIABLE_CHARACTERISTICS_VALUES_LIST_CAP: usize,
> crate::validate::Validate
for ReportData<
CustomDataType,
VARIABLE_ATTRIBUTE_VALUE_CAP,
VARIABLE_CHARACTERISTICS_VALUES_LIST_CAP,
> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.component)
.map_err(|error| error.in_field("component"))?;
crate::validate::Validate::validate(&self.variable)
.map_err(|error| error.in_field("variable"))?;
crate::validate::check_min_items(self.variable_attribute.len(), 1usize)
.map_err(|error| error.in_field("variableAttribute"))?;
for (index, item) in self.variable_attribute.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| error.in_index(index).in_field("variableAttribute"))?;
}
if let Some(value) = &self.variable_characteristics {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("variableCharacteristics"))?;
}
Ok(())
}
}
/// This contains the progress status of the publishfirmware
/// installation.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum PublishFirmwareStatusEnum {
Idle,
DownloadScheduled,
Downloading,
Downloaded,
Published,
DownloadFailed,
DownloadPaused,
InvalidChecksum,
ChecksumVerified,
PublishFailed,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for PublishFirmwareStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Charging_ Profile. Charging_ Profile_ Kind. Charging_ Profile_ Kind_ Code
/// urn:x-oca:ocpp:uid:1:569232
/// Indicates the kind of schedule.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ChargingProfileKindEnum {
Absolute,
Recurring,
Relative,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ChargingProfileKindEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Charging_ Profile. Recurrency_ Kind. Recurrency_ Kind_ Code
/// urn:x-oca:ocpp:uid:1:569233
/// Indicates the start point of a recurrence.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum RecurrencyKindEnum {
Daily,
Weekly,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for RecurrencyKindEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[cfg(feature = "alloc")]
/// Charging_ Profile
/// urn:x-oca:ocpp:uid:2:233255
/// A ChargingProfile consists of ChargingSchedule, describing the amount of power or current that can be delivered per time interval.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargingProfile<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "chargingProfileKind"))]
pub charging_profile_kind: ChargingProfileKindEnum,
#[cfg_attr(feature = "serde", serde(rename = "chargingProfilePurpose"))]
pub charging_profile_purpose: ChargingProfilePurposeEnum,
#[cfg_attr(feature = "serde", serde(rename = "chargingSchedule"))]
pub charging_schedule: heapless::Vec<ChargingSchedule<CustomDataType>, 3usize>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Identified_ Object. MRID. Numeric_ Identifier
/// urn:x-enexis:ecdm:uid:1:569198
/// Id of ChargingProfile.
pub id: i64,
#[cfg_attr(feature = "serde", serde(rename = "recurrencyKind"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub recurrency_kind: Option<RecurrencyKindEnum>,
/// Charging_ Profile. Stack_ Level. Counter
/// urn:x-oca:ocpp:uid:1:569230
/// Value determining level in hierarchy stack of profiles. Higher values have precedence over lower values. Lowest level is 0.
#[cfg_attr(feature = "serde", serde(rename = "stackLevel"))]
pub stack_level: i64,
/// SHALL only be included if ChargingProfilePurpose is set to TxProfile. The transactionId is used to match the profile to a specific transaction.
#[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub transaction_id: Option<heapless::String<36usize>>,
/// Charging_ Profile. Valid_ From. Date_ Time
/// urn:x-oca:ocpp:uid:1:569234
/// Point in time at which the profile starts to be valid. If absent, the profile is valid as soon as it is received by the Charging Station.
#[cfg_attr(feature = "serde", serde(rename = "validFrom"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub valid_from: Option<crate::OcppTimestamp>,
/// Charging_ Profile. Valid_ To. Date_ Time
/// urn:x-oca:ocpp:uid:1:569235
/// Point in time at which the profile stops to be valid. If absent, the profile is valid until it is replaced by another profile.
#[cfg_attr(feature = "serde", serde(rename = "validTo"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub valid_to: Option<crate::OcppTimestamp>,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl<CustomDataType> crate::validate::Validate for ChargingProfile<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.charging_profile_kind)
.map_err(|error| error.in_field("chargingProfileKind"))?;
crate::validate::Validate::validate(&self.charging_profile_purpose)
.map_err(|error| error.in_field("chargingProfilePurpose"))?;
crate::validate::check_min_items(self.charging_schedule.len(), 1usize)
.map_err(|error| error.in_field("chargingSchedule"))?;
for (index, item) in self.charging_schedule.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| error.in_index(index).in_field("chargingSchedule"))?;
}
if let Some(value) = &self.recurrency_kind {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("recurrencyKind"))?;
}
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
/// Charging_ Profile
/// urn:x-oca:ocpp:uid:2:233255
/// A ChargingProfile consists of ChargingSchedule, describing the amount of power or current that can be delivered per time interval.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargingProfile<
CustomDataType = crate::NoCustomData,
const CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP: usize = 8usize,
const SALES_TARIFF_SALES_TARIFF_ENTRY_CAP: usize = 8usize,
> {
#[cfg_attr(feature = "serde", serde(rename = "chargingProfileKind"))]
pub charging_profile_kind: ChargingProfileKindEnum,
#[cfg_attr(feature = "serde", serde(rename = "chargingProfilePurpose"))]
pub charging_profile_purpose: ChargingProfilePurposeEnum,
#[cfg_attr(feature = "serde", serde(rename = "chargingSchedule"))]
pub charging_schedule: heapless::Vec<
ChargingSchedule<
CustomDataType,
CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP,
SALES_TARIFF_SALES_TARIFF_ENTRY_CAP,
>,
3usize,
>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Identified_ Object. MRID. Numeric_ Identifier
/// urn:x-enexis:ecdm:uid:1:569198
/// Id of ChargingProfile.
pub id: i64,
#[cfg_attr(feature = "serde", serde(rename = "recurrencyKind"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub recurrency_kind: Option<RecurrencyKindEnum>,
/// Charging_ Profile. Stack_ Level. Counter
/// urn:x-oca:ocpp:uid:1:569230
/// Value determining level in hierarchy stack of profiles. Higher values have precedence over lower values. Lowest level is 0.
#[cfg_attr(feature = "serde", serde(rename = "stackLevel"))]
pub stack_level: i64,
/// SHALL only be included if ChargingProfilePurpose is set to TxProfile. The transactionId is used to match the profile to a specific transaction.
#[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub transaction_id: Option<heapless::String<36usize>>,
/// Charging_ Profile. Valid_ From. Date_ Time
/// urn:x-oca:ocpp:uid:1:569234
/// Point in time at which the profile starts to be valid. If absent, the profile is valid as soon as it is received by the Charging Station.
#[cfg_attr(feature = "serde", serde(rename = "validFrom"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub valid_from: Option<crate::OcppTimestamp>,
/// Charging_ Profile. Valid_ To. Date_ Time
/// urn:x-oca:ocpp:uid:1:569235
/// Point in time at which the profile stops to be valid. If absent, the profile is valid until it is replaced by another profile.
#[cfg_attr(feature = "serde", serde(rename = "validTo"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub valid_to: Option<crate::OcppTimestamp>,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
CustomDataType,
const CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP: usize,
const SALES_TARIFF_SALES_TARIFF_ENTRY_CAP: usize,
> crate::validate::Validate
for ChargingProfile<
CustomDataType,
CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP,
SALES_TARIFF_SALES_TARIFF_ENTRY_CAP,
> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.charging_profile_kind)
.map_err(|error| error.in_field("chargingProfileKind"))?;
crate::validate::Validate::validate(&self.charging_profile_purpose)
.map_err(|error| error.in_field("chargingProfilePurpose"))?;
crate::validate::check_min_items(self.charging_schedule.len(), 1usize)
.map_err(|error| error.in_field("chargingSchedule"))?;
for (index, item) in self.charging_schedule.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| error.in_index(index).in_field("chargingSchedule"))?;
}
if let Some(value) = &self.recurrency_kind {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("recurrencyKind"))?;
}
Ok(())
}
}
/// Status indicating whether the Charging Station accepts the request to start a transaction.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum RequestStartStopStatusEnum {
Accepted,
Rejected,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for RequestStartStopStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// The updated reservation status.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ReservationUpdateStatusEnum {
Expired,
Removed,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ReservationUpdateStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// This field specifies the connector type.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ConnectorEnum {
#[cfg_attr(feature = "serde", serde(rename = "cCCS1"))]
CCCS1,
#[cfg_attr(feature = "serde", serde(rename = "cCCS2"))]
CCCS2,
#[cfg_attr(feature = "serde", serde(rename = "cG105"))]
CG105,
#[cfg_attr(feature = "serde", serde(rename = "cTesla"))]
CTesla,
#[cfg_attr(feature = "serde", serde(rename = "cType1"))]
CType1,
#[cfg_attr(feature = "serde", serde(rename = "cType2"))]
CType2,
#[cfg_attr(feature = "serde", serde(rename = "s309-1P-16A"))]
S3091P16A,
#[cfg_attr(feature = "serde", serde(rename = "s309-1P-32A"))]
S3091P32A,
#[cfg_attr(feature = "serde", serde(rename = "s309-3P-16A"))]
S3093P16A,
#[cfg_attr(feature = "serde", serde(rename = "s309-3P-32A"))]
S3093P32A,
#[cfg_attr(feature = "serde", serde(rename = "sBS1361"))]
SBS1361,
#[cfg_attr(feature = "serde", serde(rename = "sCEE-7-7"))]
SCEE77,
#[cfg_attr(feature = "serde", serde(rename = "sType2"))]
SType2,
#[cfg_attr(feature = "serde", serde(rename = "sType3"))]
SType3,
Other1PhMax16A,
Other1PhOver16A,
Other3Ph,
Pan,
#[cfg_attr(feature = "serde", serde(rename = "wInductive"))]
WInductive,
#[cfg_attr(feature = "serde", serde(rename = "wResonant"))]
WResonant,
Undetermined,
Unknown,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ConnectorEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// This indicates the success or failure of the reservation.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ReserveNowStatusEnum {
Accepted,
Faulted,
Occupied,
Rejected,
Unavailable,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ReserveNowStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// This contains the type of reset that the Charging Station or EVSE should perform.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ResetEnum {
Immediate,
OnIdle,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ResetEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// This indicates whether the Charging Station is able to perform the reset.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ResetStatusEnum {
Accepted,
Rejected,
Scheduled,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ResetStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[cfg(feature = "alloc")]
/// Contains the identifier to use for authorization.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AuthorizationData<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "idToken"))]
pub id_token: IdToken<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "idTokenInfo"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub id_token_info: Option<IdTokenInfo<CustomDataType>>,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl<CustomDataType> crate::validate::Validate for AuthorizationData<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.id_token)
.map_err(|error| error.in_field("idToken"))?;
if let Some(value) = &self.id_token_info {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("idTokenInfo"))?;
}
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
/// Contains the identifier to use for authorization.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AuthorizationData<
CustomDataType = crate::NoCustomData,
const ID_TOKEN_ADDITIONAL_INFO_CAP: usize = 8usize,
const ID_TOKEN_INFO_EVSE_ID_CAP: usize = 8usize,
> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "idToken"))]
pub id_token: IdToken<CustomDataType, ID_TOKEN_ADDITIONAL_INFO_CAP>,
#[cfg_attr(feature = "serde", serde(rename = "idTokenInfo"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub id_token_info: Option<
IdTokenInfo<
CustomDataType,
ID_TOKEN_INFO_EVSE_ID_CAP,
ID_TOKEN_ADDITIONAL_INFO_CAP,
>,
>,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
CustomDataType,
const ID_TOKEN_ADDITIONAL_INFO_CAP: usize,
const ID_TOKEN_INFO_EVSE_ID_CAP: usize,
> crate::validate::Validate
for AuthorizationData<
CustomDataType,
ID_TOKEN_ADDITIONAL_INFO_CAP,
ID_TOKEN_INFO_EVSE_ID_CAP,
> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.id_token)
.map_err(|error| error.in_field("idToken"))?;
if let Some(value) = &self.id_token_info {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("idTokenInfo"))?;
}
Ok(())
}
}
/// This contains the type of update (full or differential) of this request.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum UpdateEnum {
Differential,
Full,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for UpdateEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// This indicates whether the Charging Station has successfully received and applied the update of the Local Authorization List.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SendLocalListStatusEnum {
Accepted,
Failed,
VersionMismatch,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for SendLocalListStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Returns whether the Charging Station has been able to process the message successfully. This does not guarantee the schedule will be followed to the letter. There might be other constraints the Charging Station may need to take into account.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ChargingProfileStatusEnum {
Accepted,
Rejected,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ChargingProfileStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// This indicates whether the Charging Station is able to display the message.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum DisplayMessageStatusEnum {
Accepted,
NotSupportedMessageFormat,
Rejected,
NotSupportedPriority,
NotSupportedState,
UnknownTransaction,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for DisplayMessageStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Specify which monitoring base will be set
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum MonitoringBaseEnum {
All,
FactoryDefault,
HardWiredOnly,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for MonitoringBaseEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// APN. APN_ Authentication. APN_ Authentication_ Code
/// urn:x-oca:ocpp:uid:1:568828
/// Authentication method.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum APNAuthenticationEnum {
CHAP,
NONE,
PAP,
AUTO,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for APNAuthenticationEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// APN
/// urn:x-oca:ocpp:uid:2:233134
/// Collection of configuration data needed to make a data-connection over a cellular network.
///
/// NOTE: When asking a GSM modem to dial in, it is possible to specify which mobile operator should be used. This can be done with the mobile country code (MCC) in combination with a mobile network code (MNC). Example: If your preferred network is Vodafone Netherlands, the MCC=204 and the MNC=04 which means the key PreferredNetwork = 20404 Some modems allows to specify a preferred network, which means, if this network is not available, a different network is used. If you specify UseOnlyPreferredNetwork and this network is not available, the modem will not dial in.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct APN<CustomDataType = crate::NoCustomData> {
/// APN. APN. URI
/// urn:x-oca:ocpp:uid:1:568814
/// The Access Point Name as an URL.
pub apn: heapless::String<512usize>,
#[cfg_attr(feature = "serde", serde(rename = "apnAuthentication"))]
pub apn_authentication: APNAuthenticationEnum,
/// APN. APN. Password
/// urn:x-oca:ocpp:uid:1:568819
/// APN Password.
#[cfg_attr(feature = "serde", serde(rename = "apnPassword"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub apn_password: Option<heapless::String<20usize>>,
/// APN. APN. User_ Name
/// urn:x-oca:ocpp:uid:1:568818
/// APN username.
#[cfg_attr(feature = "serde", serde(rename = "apnUserName"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub apn_user_name: Option<heapless::String<20usize>>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// APN. Preferred_ Network. Mobile_ Network_ ID
/// urn:x-oca:ocpp:uid:1:568822
/// Preferred network, written as MCC and MNC concatenated. See note.
#[cfg_attr(feature = "serde", serde(rename = "preferredNetwork"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub preferred_network: Option<heapless::String<6usize>>,
/// APN. SIMPIN. PIN_ Code
/// urn:x-oca:ocpp:uid:1:568821
/// SIM card pin code.
#[cfg_attr(feature = "serde", serde(rename = "simPin"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub sim_pin: Option<i64>,
/// APN. Use_ Only_ Preferred_ Network. Indicator
/// urn:x-oca:ocpp:uid:1:568824
/// Default: false. Use only the preferred Network, do
/// not dial in when not available. See Note.
#[cfg_attr(feature = "serde", serde(rename = "useOnlyPreferredNetwork"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub use_only_preferred_network: Option<bool>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for APN<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.apn_authentication)
.map_err(|error| error.in_field("apnAuthentication"))?;
Ok(())
}
}
/// Applicable Network Interface.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum OCPPInterfaceEnum {
Wired0,
Wired1,
Wired2,
Wired3,
Wireless0,
Wireless1,
Wireless2,
Wireless3,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for OCPPInterfaceEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Communication_ Function. OCPP_ Transport. OCPP_ Transport_ Code
/// urn:x-oca:ocpp:uid:1:569356
/// Defines the transport protocol (e.g. SOAP or JSON). Note: SOAP is not supported in OCPP 2.0, but is supported by other versions of OCPP.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum OCPPTransportEnum {
JSON,
SOAP,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for OCPPTransportEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Communication_ Function. OCPP_ Version. OCPP_ Version_ Code
/// urn:x-oca:ocpp:uid:1:569355
/// Defines the OCPP version used for this communication function.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum OCPPVersionEnum {
OCPP12,
OCPP15,
OCPP16,
OCPP20,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for OCPPVersionEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// VPN. Type. VPN_ Code
/// urn:x-oca:ocpp:uid:1:569277
/// Type of VPN
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum VPNEnum {
IKEv2,
IPSec,
L2TP,
PPTP,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for VPNEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// VPN
/// urn:x-oca:ocpp:uid:2:233268
/// VPN Configuration settings
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VPN<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// VPN. Group. Group_ Name
/// urn:x-oca:ocpp:uid:1:569274
/// VPN group.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub group: Option<heapless::String<20usize>>,
/// VPN. Key. VPN_ Key
/// urn:x-oca:ocpp:uid:1:569276
/// VPN shared secret.
pub key: heapless::String<255usize>,
/// VPN. Password. Password
/// urn:x-oca:ocpp:uid:1:569275
/// VPN Password.
pub password: heapless::String<20usize>,
/// VPN. Server. URI
/// urn:x-oca:ocpp:uid:1:569272
/// VPN Server Address
pub server: heapless::String<512usize>,
pub r#type: VPNEnum,
/// VPN. User. User_ Name
/// urn:x-oca:ocpp:uid:1:569273
/// VPN User
pub user: heapless::String<20usize>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for VPN<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.r#type)
.map_err(|error| error.in_field("type"))?;
Ok(())
}
}
/// Communication_ Function
/// urn:x-oca:ocpp:uid:2:233304
/// The NetworkConnectionProfile defines the functional and technical parameters of a communication link.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct NetworkConnectionProfile<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub apn: Option<APN<CustomDataType>>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Duration in seconds before a message send by the Charging Station via this network connection times-out.
/// The best setting depends on the underlying network and response times of the CSMS.
/// If you are looking for a some guideline: use 30 seconds as a starting point.
#[cfg_attr(feature = "serde", serde(rename = "messageTimeout"))]
pub message_timeout: i64,
/// Communication_ Function. OCPP_ Central_ System_ URL. URI
/// urn:x-oca:ocpp:uid:1:569357
/// URL of the CSMS(s) that this Charging Station communicates with.
#[cfg_attr(feature = "serde", serde(rename = "ocppCsmsUrl"))]
pub ocpp_csms_url: heapless::String<512usize>,
#[cfg_attr(feature = "serde", serde(rename = "ocppInterface"))]
pub ocpp_interface: OCPPInterfaceEnum,
#[cfg_attr(feature = "serde", serde(rename = "ocppTransport"))]
pub ocpp_transport: OCPPTransportEnum,
#[cfg_attr(feature = "serde", serde(rename = "ocppVersion"))]
pub ocpp_version: OCPPVersionEnum,
/// This field specifies the security profile used when connecting to the CSMS with this NetworkConnectionProfile.
#[cfg_attr(feature = "serde", serde(rename = "securityProfile"))]
pub security_profile: i64,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub vpn: Option<VPN<CustomDataType>>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate
for NetworkConnectionProfile<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.apn {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("apn"))?;
}
crate::validate::Validate::validate(&self.ocpp_interface)
.map_err(|error| error.in_field("ocppInterface"))?;
crate::validate::Validate::validate(&self.ocpp_transport)
.map_err(|error| error.in_field("ocppTransport"))?;
crate::validate::Validate::validate(&self.ocpp_version)
.map_err(|error| error.in_field("ocppVersion"))?;
if let Some(value) = &self.vpn {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("vpn"))?;
}
Ok(())
}
}
/// Result of operation.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SetNetworkProfileStatusEnum {
Accepted,
Rejected,
Failed,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for SetNetworkProfileStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Class to hold parameters of SetVariableMonitoring request.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SetMonitoringData<CustomDataType = crate::NoCustomData> {
pub component: Component<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// An id SHALL only be given to replace an existing monitor. The Charging Station handles the generation of id's for new monitors.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub id: Option<i64>,
/// The severity that will be assigned to an event that is triggered by this monitor. The severity range is 0-9, with 0 as the highest and 9 as the lowest severity level.
///
/// The severity levels have the following meaning: +
/// *0-Danger* +
/// Indicates lives are potentially in danger. Urgent attention is needed and action should be taken immediately. +
/// *1-Hardware Failure* +
/// Indicates that the Charging Station is unable to continue regular operations due to Hardware issues. Action is required. +
/// *2-System Failure* +
/// Indicates that the Charging Station is unable to continue regular operations due to software or minor hardware issues. Action is required. +
/// *3-Critical* +
/// Indicates a critical error. Action is required. +
/// *4-Error* +
/// Indicates a non-urgent error. Action is required. +
/// *5-Alert* +
/// Indicates an alert event. Default severity for any type of monitoring event. +
/// *6-Warning* +
/// Indicates a warning event. Action may be required. +
/// *7-Notice* +
/// Indicates an unusual event. No immediate action is required. +
/// *8-Informational* +
/// Indicates a regular operational event. May be used for reporting, measuring throughput, etc. No action is required. +
/// *9-Debug* +
/// Indicates information useful to developers for debugging, not useful during operations.
pub severity: i64,
/// Monitor only active when a transaction is ongoing on a component relevant to this transaction. Default = false.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub transaction: Option<bool>,
pub r#type: MonitorEnum,
/// Value for threshold or delta monitoring.
/// For Periodic or PeriodicClockAligned this is the interval in seconds.
pub value: f64,
pub variable: Variable<CustomDataType>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for SetMonitoringData<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.component)
.map_err(|error| error.in_field("component"))?;
crate::validate::Validate::validate(&self.r#type)
.map_err(|error| error.in_field("type"))?;
crate::validate::Validate::validate(&self.variable)
.map_err(|error| error.in_field("variable"))?;
Ok(())
}
}
/// Status is OK if a value could be returned. Otherwise this will indicate the reason why a value could not be returned.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SetMonitoringStatusEnum {
Accepted,
UnknownComponent,
UnknownVariable,
UnsupportedMonitorType,
Rejected,
Duplicate,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for SetMonitoringStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Class to hold result of SetVariableMonitoring request.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SetMonitoringResult<CustomDataType = crate::NoCustomData> {
pub component: Component<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Id given to the VariableMonitor by the Charging Station. The Id is only returned when status is accepted. Installed VariableMonitors should have unique id's but the id's of removed Installed monitors should have unique id's but the id's of removed monitors MAY be reused.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub id: Option<i64>,
/// The severity that will be assigned to an event that is triggered by this monitor. The severity range is 0-9, with 0 as the highest and 9 as the lowest severity level.
///
/// The severity levels have the following meaning: +
/// *0-Danger* +
/// Indicates lives are potentially in danger. Urgent attention is needed and action should be taken immediately. +
/// *1-Hardware Failure* +
/// Indicates that the Charging Station is unable to continue regular operations due to Hardware issues. Action is required. +
/// *2-System Failure* +
/// Indicates that the Charging Station is unable to continue regular operations due to software or minor hardware issues. Action is required. +
/// *3-Critical* +
/// Indicates a critical error. Action is required. +
/// *4-Error* +
/// Indicates a non-urgent error. Action is required. +
/// *5-Alert* +
/// Indicates an alert event. Default severity for any type of monitoring event. +
/// *6-Warning* +
/// Indicates a warning event. Action may be required. +
/// *7-Notice* +
/// Indicates an unusual event. No immediate action is required. +
/// *8-Informational* +
/// Indicates a regular operational event. May be used for reporting, measuring throughput, etc. No action is required. +
/// *9-Debug* +
/// Indicates information useful to developers for debugging, not useful during operations.
pub severity: i64,
pub status: SetMonitoringStatusEnum,
#[cfg_attr(feature = "serde", serde(rename = "statusInfo"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub status_info: Option<StatusInfo<CustomDataType>>,
pub r#type: MonitorEnum,
pub variable: Variable<CustomDataType>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for SetMonitoringResult<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.component)
.map_err(|error| error.in_field("component"))?;
crate::validate::Validate::validate(&self.status)
.map_err(|error| error.in_field("status"))?;
if let Some(value) = &self.status_info {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("statusInfo"))?;
}
crate::validate::Validate::validate(&self.r#type)
.map_err(|error| error.in_field("type"))?;
crate::validate::Validate::validate(&self.variable)
.map_err(|error| error.in_field("variable"))?;
Ok(())
}
}
#[cfg(feature = "alloc")]
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SetVariableData<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "attributeType"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub attribute_type: Option<AttributeEnum>,
/// Value to be assigned to attribute of variable.
///
/// The Configuration Variable <<configkey-configuration-value-size,ConfigurationValueSize>> can be used to limit SetVariableData.attributeValue and VariableCharacteristics.valueList. The max size of these values will always remain equal.
#[cfg_attr(feature = "serde", serde(rename = "attributeValue"))]
pub attribute_value: alloc::string::String,
pub component: Component<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
pub variable: Variable<CustomDataType>,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl<CustomDataType> crate::validate::Validate for SetVariableData<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.attribute_type {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("attributeType"))?;
}
crate::validate::check_max_length(&self.attribute_value, 1000usize)
.map_err(|error| error.in_field("attributeValue"))?;
crate::validate::Validate::validate(&self.component)
.map_err(|error| error.in_field("component"))?;
crate::validate::Validate::validate(&self.variable)
.map_err(|error| error.in_field("variable"))?;
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SetVariableData<
CustomDataType = crate::NoCustomData,
const SET_VARIABLE_DATA_ATTRIBUTE_VALUE_CAP: usize = 1000usize,
> {
#[cfg_attr(feature = "serde", serde(rename = "attributeType"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub attribute_type: Option<AttributeEnum>,
/// Value to be assigned to attribute of variable.
///
/// The Configuration Variable <<configkey-configuration-value-size,ConfigurationValueSize>> can be used to limit SetVariableData.attributeValue and VariableCharacteristics.valueList. The max size of these values will always remain equal.
#[cfg_attr(feature = "serde", serde(rename = "attributeValue"))]
pub attribute_value: heapless::String<SET_VARIABLE_DATA_ATTRIBUTE_VALUE_CAP>,
pub component: Component<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
pub variable: Variable<CustomDataType>,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
CustomDataType,
const SET_VARIABLE_DATA_ATTRIBUTE_VALUE_CAP: usize,
> crate::validate::Validate
for SetVariableData<CustomDataType, SET_VARIABLE_DATA_ATTRIBUTE_VALUE_CAP> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.attribute_type {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("attributeType"))?;
}
crate::validate::check_max_length(&self.attribute_value, 1000usize)
.map_err(|error| error.in_field("attributeValue"))?;
crate::validate::Validate::validate(&self.component)
.map_err(|error| error.in_field("component"))?;
crate::validate::Validate::validate(&self.variable)
.map_err(|error| error.in_field("variable"))?;
Ok(())
}
}
/// Result status of setting the variable.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SetVariableStatusEnum {
Accepted,
Rejected,
UnknownComponent,
UnknownVariable,
NotSupportedAttributeType,
RebootRequired,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for SetVariableStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SetVariableResult<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "attributeStatus"))]
pub attribute_status: SetVariableStatusEnum,
#[cfg_attr(feature = "serde", serde(rename = "attributeStatusInfo"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub attribute_status_info: Option<StatusInfo<CustomDataType>>,
#[cfg_attr(feature = "serde", serde(rename = "attributeType"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub attribute_type: Option<AttributeEnum>,
pub component: Component<CustomDataType>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
pub variable: Variable<CustomDataType>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for SetVariableResult<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.attribute_status)
.map_err(|error| error.in_field("attributeStatus"))?;
if let Some(value) = &self.attribute_status_info {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("attributeStatusInfo"))?;
}
if let Some(value) = &self.attribute_type {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("attributeType"))?;
}
crate::validate::Validate::validate(&self.component)
.map_err(|error| error.in_field("component"))?;
crate::validate::Validate::validate(&self.variable)
.map_err(|error| error.in_field("variable"))?;
Ok(())
}
}
/// This contains the current status of the Connector.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ConnectorStatusEnum {
Available,
Occupied,
Reserved,
Unavailable,
Faulted,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ConnectorStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// This contains the type of this event.
/// The first TransactionEvent of a transaction SHALL contain: "Started" The last TransactionEvent of a transaction SHALL contain: "Ended" All others SHALL contain: "Updated"
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum TransactionEventEnum {
Ended,
Started,
Updated,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for TransactionEventEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Transaction. State. Transaction_ State_ Code
/// urn:x-oca:ocpp:uid:1:569419
/// Current charging state, is required when state
/// has changed.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ChargingStateEnum {
Charging,
EVConnected,
SuspendedEV,
SuspendedEVSE,
Idle,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ChargingStateEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Transaction. Stopped_ Reason. EOT_ Reason_ Code
/// urn:x-oca:ocpp:uid:1:569413
/// This contains the reason why the transaction was stopped. MAY only be omitted when Reason is "Local".
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ReasonEnum {
DeAuthorized,
EmergencyStop,
EnergyLimitReached,
EVDisconnected,
GroundFault,
ImmediateReset,
Local,
LocalOutOfCredit,
MasterPass,
Other,
OvercurrentFault,
PowerLoss,
PowerQuality,
Reboot,
Remote,
SOCLimitReached,
StoppedByEV,
TimeLimitReached,
Timeout,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ReasonEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Transaction
/// urn:x-oca:ocpp:uid:2:233318
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Transaction<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "chargingState"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub charging_state: Option<ChargingStateEnum>,
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// The ID given to remote start request (<<requeststarttransactionrequest, RequestStartTransactionRequest>>. This enables to CSMS to match the started transaction to the given start request.
#[cfg_attr(feature = "serde", serde(rename = "remoteStartId"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub remote_start_id: Option<i64>,
#[cfg_attr(feature = "serde", serde(rename = "stoppedReason"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub stopped_reason: Option<ReasonEnum>,
/// Transaction. Time_ Spent_ Charging. Elapsed_ Time
/// urn:x-oca:ocpp:uid:1:569415
/// Contains the total time that energy flowed from EVSE to EV during the transaction (in seconds). Note that timeSpentCharging is smaller or equal to the duration of the transaction.
#[cfg_attr(feature = "serde", serde(rename = "timeSpentCharging"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub time_spent_charging: Option<i64>,
/// This contains the Id of the transaction.
#[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
pub transaction_id: heapless::String<36usize>,
}
#[cfg(feature = "validate")]
impl<CustomDataType> crate::validate::Validate for Transaction<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.charging_state {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("chargingState"))?;
}
if let Some(value) = &self.stopped_reason {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("stoppedReason"))?;
}
Ok(())
}
}
/// Reason the Charging Station sends this message to the CSMS
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum TriggerReasonEnum {
Authorized,
CablePluggedIn,
ChargingRateChanged,
ChargingStateChanged,
Deauthorized,
EnergyLimitReached,
EVCommunicationLost,
EVConnectTimeout,
MeterValueClock,
MeterValuePeriodic,
TimeLimitReached,
Trigger,
UnlockCommand,
StopAuthorized,
EVDeparted,
EVDetected,
RemoteStop,
RemoteStart,
AbnormalCondition,
SignedDataReceived,
ResetCommand,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for TriggerReasonEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Type of message to be triggered.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum MessageTriggerEnum {
BootNotification,
LogStatusNotification,
FirmwareStatusNotification,
Heartbeat,
MeterValues,
SignChargingStationCertificate,
SignV2GCertificate,
StatusNotification,
TransactionEvent,
SignCombinedCertificate,
PublishFirmwareStatusNotification,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for MessageTriggerEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Indicates whether the Charging Station will send the requested notification or not.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum TriggerMessageStatusEnum {
Accepted,
Rejected,
NotImplemented,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for TriggerMessageStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// This indicates whether the Charging Station has unlocked the connector.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum UnlockStatusEnum {
Unlocked,
UnlockFailed,
OngoingAuthorizedTransaction,
UnknownConnector,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for UnlockStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
/// Indicates whether the Local Controller succeeded in unpublishing the firmware.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum UnpublishFirmwareStatusEnum {
DownloadOngoing,
NoFirmware,
Unpublished,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for UnpublishFirmwareStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[cfg(feature = "alloc")]
/// Firmware
/// urn:x-enexis:ecdm:uid:2:233291
/// Represents a copy of the firmware that can be loaded/updated on the Charging Station.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Firmware<CustomDataType = crate::NoCustomData> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Firmware. Install. Date_ Time
/// urn:x-enexis:ecdm:uid:1:569462
/// Date and time at which the firmware shall be installed.
#[cfg_attr(feature = "serde", serde(rename = "installDateTime"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub install_date_time: Option<crate::OcppTimestamp>,
/// Firmware. Location. URI
/// urn:x-enexis:ecdm:uid:1:569460
/// URI defining the origin of the firmware.
pub location: heapless::String<512usize>,
/// Firmware. Retrieve. Date_ Time
/// urn:x-enexis:ecdm:uid:1:569461
/// Date and time at which the firmware shall be retrieved.
#[cfg_attr(feature = "serde", serde(rename = "retrieveDateTime"))]
pub retrieve_date_time: crate::OcppTimestamp,
/// Firmware. Signature. Signature
/// urn:x-enexis:ecdm:uid:1:569464
/// Base64 encoded firmware signature.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub signature: Option<alloc::string::String>,
/// Certificate with which the firmware was signed.
/// PEM encoded X.509 certificate.
#[cfg_attr(feature = "serde", serde(rename = "signingCertificate"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub signing_certificate: Option<alloc::string::String>,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl<CustomDataType> crate::validate::Validate for Firmware<CustomDataType> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.signature {
crate::validate::check_max_length(value, 800usize)
.map_err(|error| error.in_field("signature"))?;
}
if let Some(value) = &self.signing_certificate {
crate::validate::check_max_length(value, 5500usize)
.map_err(|error| error.in_field("signingCertificate"))?;
}
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
/// Firmware
/// urn:x-enexis:ecdm:uid:2:233291
/// Represents a copy of the firmware that can be loaded/updated on the Charging Station.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Firmware<
CustomDataType = crate::NoCustomData,
const FIRMWARE_SIGNATURE_CAP: usize = 800usize,
const FIRMWARE_SIGNING_CERTIFICATE_CAP: usize = 1024usize,
> {
#[cfg_attr(feature = "serde", serde(rename = "customData"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub custom_data: Option<CustomDataType>,
/// Firmware. Install. Date_ Time
/// urn:x-enexis:ecdm:uid:1:569462
/// Date and time at which the firmware shall be installed.
#[cfg_attr(feature = "serde", serde(rename = "installDateTime"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub install_date_time: Option<crate::OcppTimestamp>,
/// Firmware. Location. URI
/// urn:x-enexis:ecdm:uid:1:569460
/// URI defining the origin of the firmware.
pub location: heapless::String<512usize>,
/// Firmware. Retrieve. Date_ Time
/// urn:x-enexis:ecdm:uid:1:569461
/// Date and time at which the firmware shall be retrieved.
#[cfg_attr(feature = "serde", serde(rename = "retrieveDateTime"))]
pub retrieve_date_time: crate::OcppTimestamp,
/// Firmware. Signature. Signature
/// urn:x-enexis:ecdm:uid:1:569464
/// Base64 encoded firmware signature.
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub signature: Option<heapless::String<FIRMWARE_SIGNATURE_CAP>>,
/// Certificate with which the firmware was signed.
/// PEM encoded X.509 certificate.
#[cfg_attr(feature = "serde", serde(rename = "signingCertificate"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub signing_certificate: Option<heapless::String<FIRMWARE_SIGNING_CERTIFICATE_CAP>>,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
CustomDataType,
const FIRMWARE_SIGNATURE_CAP: usize,
const FIRMWARE_SIGNING_CERTIFICATE_CAP: usize,
> crate::validate::Validate
for Firmware<CustomDataType, FIRMWARE_SIGNATURE_CAP, FIRMWARE_SIGNING_CERTIFICATE_CAP> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.signature {
crate::validate::check_max_length(value, 800usize)
.map_err(|error| error.in_field("signature"))?;
}
if let Some(value) = &self.signing_certificate {
crate::validate::check_max_length(value, 5500usize)
.map_err(|error| error.in_field("signingCertificate"))?;
}
Ok(())
}
}
/// This field indicates whether the Charging Station was able to accept the request.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum UpdateFirmwareStatusEnum {
Accepted,
Rejected,
AcceptedCanceled,
InvalidCertificate,
RevokedCertificate,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for UpdateFirmwareStatusEnum {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}