1#[derive(Debug, Clone, PartialEq, Eq)]
5#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
6pub enum IdTagInfoStatus {
7 Accepted,
8 Blocked,
9 Expired,
10 Invalid,
11 ConcurrentTx,
12}
13#[derive(Debug, Clone, PartialEq, Eq)]
14#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
15pub struct IdTagInfo {
16 #[cfg_attr(feature = "serde", serde(rename = "expiryDate"))]
17 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
18 pub expiry_date: Option<crate::OcppTimestamp>,
19 #[cfg_attr(feature = "serde", serde(rename = "parentIdTag"))]
20 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
21 pub parent_id_tag: Option<heapless::String<20usize>>,
22 pub status: IdTagInfoStatus,
23}
24#[derive(Debug, Clone, PartialEq, Eq)]
25#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
26pub enum BootNotificationResponseStatus {
27 Accepted,
28 Pending,
29 Rejected,
30}
31#[derive(Debug, Clone, PartialEq, Eq)]
32#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
33pub enum CancelReservationResponseStatus {
34 Accepted,
35 Rejected,
36}
37#[derive(Debug, Clone, PartialEq, Eq)]
38#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
39pub enum CertificateSignedResponseStatus {
40 Accepted,
41 Rejected,
42}
43#[derive(Debug, Clone, PartialEq, Eq)]
44#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
45pub enum ChangeAvailabilityRequestType {
46 Inoperative,
47 Operative,
48}
49#[derive(Debug, Clone, PartialEq, Eq)]
50#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
51pub enum ChangeAvailabilityResponseStatus {
52 Accepted,
53 Rejected,
54 Scheduled,
55}
56#[derive(Debug, Clone, PartialEq, Eq)]
57#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
58pub enum ChangeConfigurationResponseStatus {
59 Accepted,
60 Rejected,
61 RebootRequired,
62 NotSupported,
63}
64#[derive(Debug, Clone, PartialEq, Eq)]
65#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
66pub enum ClearCacheResponseStatus {
67 Accepted,
68 Rejected,
69}
70#[derive(Debug, Clone, PartialEq, Eq)]
71#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
72pub enum ChargingProfilePurpose {
73 ChargePointMaxProfile,
74 TxDefaultProfile,
75 TxProfile,
76}
77#[derive(Debug, Clone, PartialEq, Eq)]
78#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
79pub enum ClearChargingProfileResponseStatus {
80 Accepted,
81 Unknown,
82}
83#[derive(Debug, Clone, PartialEq, Eq)]
84#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
85pub enum DataTransferResponseStatus {
86 Accepted,
87 Rejected,
88 UnknownMessageId,
89 UnknownVendorId,
90}
91#[derive(Debug, Clone, PartialEq, Eq)]
92#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
93pub enum HashAlgorithm {
94 SHA256,
95 SHA384,
96 SHA512,
97}
98#[derive(Debug, Clone, PartialEq, Eq)]
99#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
100pub struct CertificateHashData {
101 #[cfg_attr(feature = "serde", serde(rename = "hashAlgorithm"))]
102 pub hash_algorithm: HashAlgorithm,
103 #[cfg_attr(feature = "serde", serde(rename = "issuerKeyHash"))]
104 pub issuer_key_hash: heapless::String<128usize>,
105 #[cfg_attr(feature = "serde", serde(rename = "issuerNameHash"))]
106 pub issuer_name_hash: heapless::String<128usize>,
107 #[cfg_attr(feature = "serde", serde(rename = "serialNumber"))]
108 pub serial_number: heapless::String<40usize>,
109}
110#[derive(Debug, Clone, PartialEq, Eq)]
111#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
112pub enum DeleteCertificateResponseStatus {
113 Accepted,
114 Failed,
115 NotFound,
116}
117#[derive(Debug, Clone, PartialEq, Eq)]
118#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
119pub enum DiagnosticsStatusNotificationRequestStatus {
120 Idle,
121 Uploaded,
122 UploadFailed,
123 Uploading,
124}
125#[derive(Debug, Clone, PartialEq, Eq)]
126#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
127pub enum ExtendedTriggerMessageRequestRequestedMessage {
128 BootNotification,
129 LogStatusNotification,
130 FirmwareStatusNotification,
131 Heartbeat,
132 MeterValues,
133 SignChargePointCertificate,
134 StatusNotification,
135}
136#[derive(Debug, Clone, PartialEq, Eq)]
137#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
138pub enum ExtendedTriggerMessageResponseStatus {
139 Accepted,
140 Rejected,
141 NotImplemented,
142}
143#[derive(Debug, Clone, PartialEq, Eq)]
144#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
145pub enum FirmwareStatusNotificationRequestStatus {
146 Downloaded,
147 DownloadFailed,
148 Downloading,
149 Idle,
150 InstallationFailed,
151 Installing,
152 Installed,
153}
154#[derive(Debug, Clone, PartialEq, Eq)]
155#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
156pub enum ChargingRateUnit {
157 A,
158 W,
159}
160#[derive(Debug, Clone, PartialEq)]
161#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
162pub struct ChargingSchedulePeriodItem {
163 pub limit: f64,
164 #[cfg_attr(feature = "serde", serde(rename = "numberPhases"))]
165 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
166 pub number_phases: Option<i64>,
167 #[cfg_attr(feature = "serde", serde(rename = "startPeriod"))]
168 pub start_period: i64,
169}
170#[cfg(feature = "alloc")]
171#[derive(Debug, Clone, PartialEq)]
172#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
173pub struct ChargingSchedule {
174 #[cfg_attr(feature = "serde", serde(rename = "chargingRateUnit"))]
175 pub charging_rate_unit: ChargingRateUnit,
176 #[cfg_attr(feature = "serde", serde(rename = "chargingSchedulePeriod"))]
177 pub charging_schedule_period: alloc::vec::Vec<ChargingSchedulePeriodItem>,
178 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
179 pub duration: Option<i64>,
180 #[cfg_attr(feature = "serde", serde(rename = "minChargingRate"))]
181 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
182 pub min_charging_rate: Option<f64>,
183 #[cfg_attr(feature = "serde", serde(rename = "startSchedule"))]
184 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
185 pub start_schedule: Option<crate::OcppTimestamp>,
186}
187#[cfg(not(feature = "alloc"))]
188#[derive(Debug, Clone, PartialEq)]
189#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
190pub struct ChargingSchedule<
191 const CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP: usize = 8usize,
192> {
193 #[cfg_attr(feature = "serde", serde(rename = "chargingRateUnit"))]
194 pub charging_rate_unit: ChargingRateUnit,
195 #[cfg_attr(feature = "serde", serde(rename = "chargingSchedulePeriod"))]
196 pub charging_schedule_period: heapless::Vec<
197 ChargingSchedulePeriodItem,
198 CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP,
199 >,
200 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
201 pub duration: Option<i64>,
202 #[cfg_attr(feature = "serde", serde(rename = "minChargingRate"))]
203 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
204 pub min_charging_rate: Option<f64>,
205 #[cfg_attr(feature = "serde", serde(rename = "startSchedule"))]
206 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
207 pub start_schedule: Option<crate::OcppTimestamp>,
208}
209#[derive(Debug, Clone, PartialEq, Eq)]
210#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
211pub enum GetCompositeScheduleResponseStatus {
212 Accepted,
213 Rejected,
214}
215#[derive(Debug, Clone, PartialEq, Eq)]
216#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
217pub struct ConfigurationKeyItem {
218 pub key: heapless::String<50usize>,
219 pub readonly: bool,
220 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
221 pub value: Option<heapless::String<500usize>>,
222}
223#[derive(Debug, Clone, PartialEq, Eq)]
224#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
225pub enum CertificateType {
226 CentralSystemRootCertificate,
227 ManufacturerRootCertificate,
228}
229#[derive(Debug, Clone, PartialEq, Eq)]
230#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
231pub enum GetInstalledCertificateIdsResponseStatus {
232 Accepted,
233 NotFound,
234}
235#[derive(Debug, Clone, PartialEq, Eq)]
236#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
237pub struct Log {
238 #[cfg_attr(feature = "serde", serde(rename = "latestTimestamp"))]
239 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
240 pub latest_timestamp: Option<crate::OcppTimestamp>,
241 #[cfg_attr(feature = "serde", serde(rename = "oldestTimestamp"))]
242 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
243 pub oldest_timestamp: Option<crate::OcppTimestamp>,
244 #[cfg_attr(feature = "serde", serde(rename = "remoteLocation"))]
245 pub remote_location: heapless::String<512usize>,
246}
247#[derive(Debug, Clone, PartialEq, Eq)]
248#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
249pub enum LogType {
250 DiagnosticsLog,
251 SecurityLog,
252}
253#[derive(Debug, Clone, PartialEq, Eq)]
254#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
255pub enum GetLogResponseStatus {
256 Accepted,
257 Rejected,
258 AcceptedCanceled,
259}
260#[derive(Debug, Clone, PartialEq, Eq)]
261#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
262pub enum InstallCertificateResponseStatus {
263 Accepted,
264 Failed,
265 Rejected,
266}
267#[derive(Debug, Clone, PartialEq, Eq)]
268#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
269pub enum LogStatusNotificationRequestStatus {
270 BadMessage,
271 Idle,
272 NotSupportedOperation,
273 PermissionDenied,
274 Uploaded,
275 UploadFailure,
276 Uploading,
277}
278#[derive(Debug, Clone, PartialEq, Eq)]
279#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
280pub enum Context {
281 #[cfg_attr(feature = "serde", serde(rename = "Interruption.Begin"))]
282 InterruptionBegin,
283 #[cfg_attr(feature = "serde", serde(rename = "Interruption.End"))]
284 InterruptionEnd,
285 #[cfg_attr(feature = "serde", serde(rename = "Sample.Clock"))]
286 SampleClock,
287 #[cfg_attr(feature = "serde", serde(rename = "Sample.Periodic"))]
288 SamplePeriodic,
289 #[cfg_attr(feature = "serde", serde(rename = "Transaction.Begin"))]
290 TransactionBegin,
291 #[cfg_attr(feature = "serde", serde(rename = "Transaction.End"))]
292 TransactionEnd,
293 Trigger,
294 Other,
295}
296#[derive(Debug, Clone, PartialEq, Eq)]
297#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
298pub enum Format {
299 Raw,
300 SignedData,
301}
302#[derive(Debug, Clone, PartialEq, Eq)]
303#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
304pub enum Location {
305 Cable,
306 EV,
307 Inlet,
308 Outlet,
309 Body,
310}
311#[derive(Debug, Clone, PartialEq, Eq)]
312#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
313pub enum Measurand {
314 #[cfg_attr(feature = "serde", serde(rename = "Energy.Active.Export.Register"))]
315 EnergyActiveExportRegister,
316 #[cfg_attr(feature = "serde", serde(rename = "Energy.Active.Import.Register"))]
317 EnergyActiveImportRegister,
318 #[cfg_attr(feature = "serde", serde(rename = "Energy.Reactive.Export.Register"))]
319 EnergyReactiveExportRegister,
320 #[cfg_attr(feature = "serde", serde(rename = "Energy.Reactive.Import.Register"))]
321 EnergyReactiveImportRegister,
322 #[cfg_attr(feature = "serde", serde(rename = "Energy.Active.Export.Interval"))]
323 EnergyActiveExportInterval,
324 #[cfg_attr(feature = "serde", serde(rename = "Energy.Active.Import.Interval"))]
325 EnergyActiveImportInterval,
326 #[cfg_attr(feature = "serde", serde(rename = "Energy.Reactive.Export.Interval"))]
327 EnergyReactiveExportInterval,
328 #[cfg_attr(feature = "serde", serde(rename = "Energy.Reactive.Import.Interval"))]
329 EnergyReactiveImportInterval,
330 #[cfg_attr(feature = "serde", serde(rename = "Power.Active.Export"))]
331 PowerActiveExport,
332 #[cfg_attr(feature = "serde", serde(rename = "Power.Active.Import"))]
333 PowerActiveImport,
334 #[cfg_attr(feature = "serde", serde(rename = "Power.Offered"))]
335 PowerOffered,
336 #[cfg_attr(feature = "serde", serde(rename = "Power.Reactive.Export"))]
337 PowerReactiveExport,
338 #[cfg_attr(feature = "serde", serde(rename = "Power.Reactive.Import"))]
339 PowerReactiveImport,
340 #[cfg_attr(feature = "serde", serde(rename = "Power.Factor"))]
341 PowerFactor,
342 #[cfg_attr(feature = "serde", serde(rename = "Current.Import"))]
343 CurrentImport,
344 #[cfg_attr(feature = "serde", serde(rename = "Current.Export"))]
345 CurrentExport,
346 #[cfg_attr(feature = "serde", serde(rename = "Current.Offered"))]
347 CurrentOffered,
348 Voltage,
349 Frequency,
350 Temperature,
351 SoC,
352 RPM,
353}
354#[derive(Debug, Clone, PartialEq, Eq)]
355#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
356pub enum Phase {
357 L1,
358 L2,
359 L3,
360 N,
361 #[cfg_attr(feature = "serde", serde(rename = "L1-N"))]
362 L1N,
363 #[cfg_attr(feature = "serde", serde(rename = "L2-N"))]
364 L2N,
365 #[cfg_attr(feature = "serde", serde(rename = "L3-N"))]
366 L3N,
367 #[cfg_attr(feature = "serde", serde(rename = "L1-L2"))]
368 L1L2,
369 #[cfg_attr(feature = "serde", serde(rename = "L2-L3"))]
370 L2L3,
371 #[cfg_attr(feature = "serde", serde(rename = "L3-L1"))]
372 L3L1,
373}
374#[derive(Debug, Clone, PartialEq, Eq)]
375#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
376pub enum SampledValueItemUnit {
377 Wh,
378 #[cfg_attr(feature = "serde", serde(rename = "kWh"))]
379 KWh,
380 #[cfg_attr(feature = "serde", serde(rename = "varh"))]
381 Varh,
382 #[cfg_attr(feature = "serde", serde(rename = "kvarh"))]
383 Kvarh,
384 W,
385 #[cfg_attr(feature = "serde", serde(rename = "kW"))]
386 KW,
387 VA,
388 #[cfg_attr(feature = "serde", serde(rename = "kVA"))]
389 KVA,
390 #[cfg_attr(feature = "serde", serde(rename = "var"))]
391 Var,
392 #[cfg_attr(feature = "serde", serde(rename = "kvar"))]
393 Kvar,
394 A,
395 V,
396 K,
397 Celcius,
398 Celsius,
399 Fahrenheit,
400 Percent,
401}
402#[cfg(feature = "alloc")]
403#[derive(Debug, Clone, PartialEq, Eq)]
404#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
405pub struct SampledValueItem {
406 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
407 pub context: Option<Context>,
408 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
409 pub format: Option<Format>,
410 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
411 pub location: Option<Location>,
412 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
413 pub measurand: Option<Measurand>,
414 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
415 pub phase: Option<Phase>,
416 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
417 pub unit: Option<SampledValueItemUnit>,
418 pub value: alloc::string::String,
419}
420#[cfg(not(feature = "alloc"))]
421#[derive(Debug, Clone, PartialEq, Eq)]
422#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
423pub struct SampledValueItem<const SAMPLED_VALUE_ITEM_VALUE_CAP: usize = 1024usize> {
424 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
425 pub context: Option<Context>,
426 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
427 pub format: Option<Format>,
428 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
429 pub location: Option<Location>,
430 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
431 pub measurand: Option<Measurand>,
432 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
433 pub phase: Option<Phase>,
434 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
435 pub unit: Option<SampledValueItemUnit>,
436 pub value: heapless::String<SAMPLED_VALUE_ITEM_VALUE_CAP>,
437}
438#[cfg(feature = "alloc")]
439#[derive(Debug, Clone, PartialEq, Eq)]
440#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
441pub struct MeterValueItem {
442 #[cfg_attr(feature = "serde", serde(rename = "sampledValue"))]
443 pub sampled_value: alloc::vec::Vec<SampledValueItem>,
444 pub timestamp: crate::OcppTimestamp,
445}
446#[cfg(not(feature = "alloc"))]
447#[derive(Debug, Clone, PartialEq, Eq)]
448#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
449pub struct MeterValueItem<
450 const METER_VALUE_ITEM_SAMPLED_VALUE_CAP: usize = 8usize,
451 const SAMPLED_VALUE_ITEM_VALUE_CAP: usize = 1024usize,
452> {
453 #[cfg_attr(feature = "serde", serde(rename = "sampledValue"))]
454 pub sampled_value: heapless::Vec<
455 SampledValueItem<SAMPLED_VALUE_ITEM_VALUE_CAP>,
456 METER_VALUE_ITEM_SAMPLED_VALUE_CAP,
457 >,
458 pub timestamp: crate::OcppTimestamp,
459}
460#[derive(Debug, Clone, PartialEq, Eq)]
461#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
462pub enum ChargingProfileKind {
463 Absolute,
464 Recurring,
465 Relative,
466}
467#[derive(Debug, Clone, PartialEq, Eq)]
468#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
469pub enum RecurrencyKind {
470 Daily,
471 Weekly,
472}
473#[cfg(feature = "alloc")]
474#[derive(Debug, Clone, PartialEq)]
475#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
476pub struct ChargingProfile {
477 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileId"))]
478 pub charging_profile_id: i64,
479 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileKind"))]
480 pub charging_profile_kind: ChargingProfileKind,
481 #[cfg_attr(feature = "serde", serde(rename = "chargingProfilePurpose"))]
482 pub charging_profile_purpose: ChargingProfilePurpose,
483 #[cfg_attr(feature = "serde", serde(rename = "chargingSchedule"))]
484 pub charging_schedule: ChargingSchedule,
485 #[cfg_attr(feature = "serde", serde(rename = "recurrencyKind"))]
486 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
487 pub recurrency_kind: Option<RecurrencyKind>,
488 #[cfg_attr(feature = "serde", serde(rename = "stackLevel"))]
489 pub stack_level: i64,
490 #[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
491 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
492 pub transaction_id: Option<i64>,
493 #[cfg_attr(feature = "serde", serde(rename = "validFrom"))]
494 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
495 pub valid_from: Option<crate::OcppTimestamp>,
496 #[cfg_attr(feature = "serde", serde(rename = "validTo"))]
497 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
498 pub valid_to: Option<crate::OcppTimestamp>,
499}
500#[cfg(not(feature = "alloc"))]
501#[derive(Debug, Clone, PartialEq)]
502#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
503pub struct ChargingProfile<
504 const CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP: usize = 8usize,
505> {
506 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileId"))]
507 pub charging_profile_id: i64,
508 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileKind"))]
509 pub charging_profile_kind: ChargingProfileKind,
510 #[cfg_attr(feature = "serde", serde(rename = "chargingProfilePurpose"))]
511 pub charging_profile_purpose: ChargingProfilePurpose,
512 #[cfg_attr(feature = "serde", serde(rename = "chargingSchedule"))]
513 pub charging_schedule: ChargingSchedule<
514 CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP,
515 >,
516 #[cfg_attr(feature = "serde", serde(rename = "recurrencyKind"))]
517 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
518 pub recurrency_kind: Option<RecurrencyKind>,
519 #[cfg_attr(feature = "serde", serde(rename = "stackLevel"))]
520 pub stack_level: i64,
521 #[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
522 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
523 pub transaction_id: Option<i64>,
524 #[cfg_attr(feature = "serde", serde(rename = "validFrom"))]
525 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
526 pub valid_from: Option<crate::OcppTimestamp>,
527 #[cfg_attr(feature = "serde", serde(rename = "validTo"))]
528 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
529 pub valid_to: Option<crate::OcppTimestamp>,
530}
531#[derive(Debug, Clone, PartialEq, Eq)]
532#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
533pub enum RemoteStartTransactionResponseStatus {
534 Accepted,
535 Rejected,
536}
537#[derive(Debug, Clone, PartialEq, Eq)]
538#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
539pub enum RemoteStopTransactionResponseStatus {
540 Accepted,
541 Rejected,
542}
543#[derive(Debug, Clone, PartialEq, Eq)]
544#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
545pub enum ReserveNowResponseStatus {
546 Accepted,
547 Faulted,
548 Occupied,
549 Rejected,
550 Unavailable,
551}
552#[derive(Debug, Clone, PartialEq, Eq)]
553#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
554pub enum ResetRequestType {
555 Hard,
556 Soft,
557}
558#[derive(Debug, Clone, PartialEq, Eq)]
559#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
560pub enum ResetResponseStatus {
561 Accepted,
562 Rejected,
563}
564#[derive(Debug, Clone, PartialEq, Eq)]
565#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
566pub struct LocalAuthorizationListItem {
567 #[cfg_attr(feature = "serde", serde(rename = "idTag"))]
568 pub id_tag: super::IdTag,
569 #[cfg_attr(feature = "serde", serde(rename = "idTagInfo"))]
570 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
571 pub id_tag_info: Option<IdTagInfo>,
572}
573#[derive(Debug, Clone, PartialEq, Eq)]
574#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
575pub enum UpdateType {
576 Differential,
577 Full,
578}
579#[derive(Debug, Clone, PartialEq, Eq)]
580#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
581pub enum SendLocalListResponseStatus {
582 Accepted,
583 Failed,
584 NotSupported,
585 VersionMismatch,
586}
587#[cfg(feature = "alloc")]
588#[derive(Debug, Clone, PartialEq)]
589#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
590pub struct CsChargingProfiles {
591 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileId"))]
592 pub charging_profile_id: i64,
593 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileKind"))]
594 pub charging_profile_kind: ChargingProfileKind,
595 #[cfg_attr(feature = "serde", serde(rename = "chargingProfilePurpose"))]
596 pub charging_profile_purpose: ChargingProfilePurpose,
597 #[cfg_attr(feature = "serde", serde(rename = "chargingSchedule"))]
598 pub charging_schedule: ChargingSchedule,
599 #[cfg_attr(feature = "serde", serde(rename = "recurrencyKind"))]
600 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
601 pub recurrency_kind: Option<RecurrencyKind>,
602 #[cfg_attr(feature = "serde", serde(rename = "stackLevel"))]
603 pub stack_level: i64,
604 #[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
605 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
606 pub transaction_id: Option<i64>,
607 #[cfg_attr(feature = "serde", serde(rename = "validFrom"))]
608 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
609 pub valid_from: Option<crate::OcppTimestamp>,
610 #[cfg_attr(feature = "serde", serde(rename = "validTo"))]
611 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
612 pub valid_to: Option<crate::OcppTimestamp>,
613}
614#[cfg(not(feature = "alloc"))]
615#[derive(Debug, Clone, PartialEq)]
616#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
617pub struct CsChargingProfiles<
618 const CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP: usize = 8usize,
619> {
620 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileId"))]
621 pub charging_profile_id: i64,
622 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileKind"))]
623 pub charging_profile_kind: ChargingProfileKind,
624 #[cfg_attr(feature = "serde", serde(rename = "chargingProfilePurpose"))]
625 pub charging_profile_purpose: ChargingProfilePurpose,
626 #[cfg_attr(feature = "serde", serde(rename = "chargingSchedule"))]
627 pub charging_schedule: ChargingSchedule<
628 CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP,
629 >,
630 #[cfg_attr(feature = "serde", serde(rename = "recurrencyKind"))]
631 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
632 pub recurrency_kind: Option<RecurrencyKind>,
633 #[cfg_attr(feature = "serde", serde(rename = "stackLevel"))]
634 pub stack_level: i64,
635 #[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
636 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
637 pub transaction_id: Option<i64>,
638 #[cfg_attr(feature = "serde", serde(rename = "validFrom"))]
639 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
640 pub valid_from: Option<crate::OcppTimestamp>,
641 #[cfg_attr(feature = "serde", serde(rename = "validTo"))]
642 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
643 pub valid_to: Option<crate::OcppTimestamp>,
644}
645#[derive(Debug, Clone, PartialEq, Eq)]
646#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
647pub enum SetChargingProfileResponseStatus {
648 Accepted,
649 Rejected,
650 NotSupported,
651}
652#[derive(Debug, Clone, PartialEq, Eq)]
653#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
654pub enum SignCertificateResponseStatus {
655 Accepted,
656 Rejected,
657}
658#[derive(Debug, Clone, PartialEq, Eq)]
659#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
660pub enum SignedFirmwareStatusNotificationRequestStatus {
661 Downloaded,
662 DownloadFailed,
663 Downloading,
664 DownloadScheduled,
665 DownloadPaused,
666 Idle,
667 InstallationFailed,
668 Installing,
669 Installed,
670 InstallRebooting,
671 InstallScheduled,
672 InstallVerificationFailed,
673 InvalidSignature,
674 SignatureVerified,
675}
676#[cfg(feature = "alloc")]
677#[derive(Debug, Clone, PartialEq, Eq)]
678#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
679pub struct Firmware {
680 #[cfg_attr(feature = "serde", serde(rename = "installDateTime"))]
681 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
682 pub install_date_time: Option<crate::OcppTimestamp>,
683 pub location: heapless::String<512usize>,
684 #[cfg_attr(feature = "serde", serde(rename = "retrieveDateTime"))]
685 pub retrieve_date_time: crate::OcppTimestamp,
686 pub signature: alloc::string::String,
687 #[cfg_attr(feature = "serde", serde(rename = "signingCertificate"))]
688 pub signing_certificate: alloc::string::String,
689}
690#[cfg(not(feature = "alloc"))]
691#[derive(Debug, Clone, PartialEq, Eq)]
692#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
693pub struct Firmware<
694 const FIRMWARE_SIGNATURE_CAP: usize = 800usize,
695 const FIRMWARE_SIGNING_CERTIFICATE_CAP: usize = 1024usize,
696> {
697 #[cfg_attr(feature = "serde", serde(rename = "installDateTime"))]
698 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
699 pub install_date_time: Option<crate::OcppTimestamp>,
700 pub location: heapless::String<512usize>,
701 #[cfg_attr(feature = "serde", serde(rename = "retrieveDateTime"))]
702 pub retrieve_date_time: crate::OcppTimestamp,
703 pub signature: heapless::String<FIRMWARE_SIGNATURE_CAP>,
704 #[cfg_attr(feature = "serde", serde(rename = "signingCertificate"))]
705 pub signing_certificate: heapless::String<FIRMWARE_SIGNING_CERTIFICATE_CAP>,
706}
707#[derive(Debug, Clone, PartialEq, Eq)]
708#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
709pub enum SignedUpdateFirmwareResponseStatus {
710 Accepted,
711 Rejected,
712 AcceptedCanceled,
713 InvalidCertificate,
714 RevokedCertificate,
715}
716#[derive(Debug, Clone, PartialEq, Eq)]
717#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
718pub enum ErrorCode {
719 ConnectorLockFailure,
720 EVCommunicationError,
721 GroundFailure,
722 HighTemperature,
723 InternalError,
724 LocalListConflict,
725 NoError,
726 OtherError,
727 OverCurrentFailure,
728 PowerMeterFailure,
729 PowerSwitchFailure,
730 ReaderFailure,
731 ResetFailure,
732 UnderVoltage,
733 OverVoltage,
734 WeakSignal,
735}
736#[derive(Debug, Clone, PartialEq, Eq)]
737#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
738pub enum StatusNotificationRequestStatus {
739 Available,
740 Preparing,
741 Charging,
742 SuspendedEVSE,
743 SuspendedEV,
744 Finishing,
745 Reserved,
746 Unavailable,
747 Faulted,
748}
749#[derive(Debug, Clone, PartialEq, Eq)]
750#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
751pub enum Reason {
752 EmergencyStop,
753 EVDisconnected,
754 HardReset,
755 Local,
756 Other,
757 PowerLoss,
758 Reboot,
759 Remote,
760 SoftReset,
761 UnlockCommand,
762 DeAuthorized,
763}
764#[cfg(feature = "alloc")]
765#[derive(Debug, Clone, PartialEq, Eq)]
766#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
767pub struct TransactionDataItem {
768 #[cfg_attr(feature = "serde", serde(rename = "sampledValue"))]
769 pub sampled_value: alloc::vec::Vec<SampledValueItem>,
770 pub timestamp: crate::OcppTimestamp,
771}
772#[cfg(not(feature = "alloc"))]
773#[derive(Debug, Clone, PartialEq, Eq)]
774#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
775pub struct TransactionDataItem<
776 const TRANSACTION_DATA_ITEM_SAMPLED_VALUE_CAP: usize = 8usize,
777 const SAMPLED_VALUE_ITEM_VALUE_CAP: usize = 1024usize,
778> {
779 #[cfg_attr(feature = "serde", serde(rename = "sampledValue"))]
780 pub sampled_value: heapless::Vec<
781 SampledValueItem<SAMPLED_VALUE_ITEM_VALUE_CAP>,
782 TRANSACTION_DATA_ITEM_SAMPLED_VALUE_CAP,
783 >,
784 pub timestamp: crate::OcppTimestamp,
785}
786#[derive(Debug, Clone, PartialEq, Eq)]
787#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
788pub enum TriggerMessageRequestRequestedMessage {
789 BootNotification,
790 DiagnosticsStatusNotification,
791 FirmwareStatusNotification,
792 Heartbeat,
793 MeterValues,
794 StatusNotification,
795}
796#[derive(Debug, Clone, PartialEq, Eq)]
797#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
798pub enum TriggerMessageResponseStatus {
799 Accepted,
800 Rejected,
801 NotImplemented,
802}
803#[derive(Debug, Clone, PartialEq, Eq)]
804#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
805pub enum UnlockConnectorResponseStatus {
806 Unlocked,
807 UnlockFailed,
808 NotSupported,
809}