1#[derive(Debug, Clone, PartialEq, Eq)]
5#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
6pub enum Status {
7 Accepted,
8 Blocked,
9 Expired,
10 Invalid,
11 ConcurrentTx,
12}
13#[cfg(feature = "alloc")]
14#[derive(Debug, Clone, PartialEq, Eq)]
15#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
16pub struct IdTagInfo {
17 #[cfg_attr(feature = "serde", serde(rename = "expiryDate"))]
18 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
19 pub expiry_date: Option<alloc::string::String>,
20 #[cfg_attr(feature = "serde", serde(rename = "parentIdTag"))]
21 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
22 pub parent_id_tag: Option<heapless::String<20usize>>,
23 pub status: Status,
24}
25#[cfg(not(feature = "alloc"))]
26#[derive(Debug, Clone, PartialEq, Eq)]
27#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28pub struct IdTagInfo<const ID_TAG_INFO_EXPIRY_DATE_CAP: usize = 1024usize> {
29 #[cfg_attr(feature = "serde", serde(rename = "expiryDate"))]
30 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
31 pub expiry_date: Option<heapless::String<ID_TAG_INFO_EXPIRY_DATE_CAP>>,
32 #[cfg_attr(feature = "serde", serde(rename = "parentIdTag"))]
33 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
34 pub parent_id_tag: Option<heapless::String<20usize>>,
35 pub status: Status,
36}
37#[derive(Debug, Clone, PartialEq, Eq)]
38#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
39pub enum Type {
40 Inoperative,
41 Operative,
42}
43#[derive(Debug, Clone, PartialEq, Eq)]
44#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
45pub enum ChargingProfilePurpose {
46 ChargePointMaxProfile,
47 TxDefaultProfile,
48 TxProfile,
49}
50#[derive(Debug, Clone, PartialEq, Eq)]
51#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
52pub enum ChargingRateUnit {
53 A,
54 W,
55}
56#[derive(Debug, Clone, PartialEq)]
57#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
58pub struct ChargingSchedulePeriodItem {
59 pub limit: f64,
60 #[cfg_attr(feature = "serde", serde(rename = "numberPhases"))]
61 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
62 pub number_phases: Option<i64>,
63 #[cfg_attr(feature = "serde", serde(rename = "startPeriod"))]
64 pub start_period: i64,
65}
66#[cfg(feature = "alloc")]
67#[derive(Debug, Clone, PartialEq)]
68#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
69pub struct ChargingSchedule {
70 #[cfg_attr(feature = "serde", serde(rename = "chargingRateUnit"))]
71 pub charging_rate_unit: ChargingRateUnit,
72 #[cfg_attr(feature = "serde", serde(rename = "chargingSchedulePeriod"))]
73 pub charging_schedule_period: alloc::vec::Vec<ChargingSchedulePeriodItem>,
74 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
75 pub duration: Option<i64>,
76 #[cfg_attr(feature = "serde", serde(rename = "minChargingRate"))]
77 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
78 pub min_charging_rate: Option<f64>,
79 #[cfg_attr(feature = "serde", serde(rename = "startSchedule"))]
80 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
81 pub start_schedule: Option<alloc::string::String>,
82}
83#[cfg(not(feature = "alloc"))]
84#[derive(Debug, Clone, PartialEq)]
85#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
86pub struct ChargingSchedule<
87 const CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP: usize = 16usize,
88 const CHARGING_SCHEDULE_START_SCHEDULE_CAP: usize = 1024usize,
89> {
90 #[cfg_attr(feature = "serde", serde(rename = "chargingRateUnit"))]
91 pub charging_rate_unit: ChargingRateUnit,
92 #[cfg_attr(feature = "serde", serde(rename = "chargingSchedulePeriod"))]
93 pub charging_schedule_period: heapless::Vec<
94 ChargingSchedulePeriodItem,
95 CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP,
96 >,
97 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
98 pub duration: Option<i64>,
99 #[cfg_attr(feature = "serde", serde(rename = "minChargingRate"))]
100 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
101 pub min_charging_rate: Option<f64>,
102 #[cfg_attr(feature = "serde", serde(rename = "startSchedule"))]
103 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
104 pub start_schedule: Option<heapless::String<CHARGING_SCHEDULE_START_SCHEDULE_CAP>>,
105}
106#[derive(Debug, Clone, PartialEq, Eq)]
107#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
108pub struct ConfigurationKeyItem {
109 pub key: heapless::String<50usize>,
110 pub readonly: bool,
111 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
112 pub value: Option<heapless::String<500usize>>,
113}
114#[derive(Debug, Clone, PartialEq, Eq)]
115#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
116pub enum Context {
117 #[cfg_attr(feature = "serde", serde(rename = "Interruption.Begin"))]
118 InterruptionBegin,
119 #[cfg_attr(feature = "serde", serde(rename = "Interruption.End"))]
120 InterruptionEnd,
121 #[cfg_attr(feature = "serde", serde(rename = "Sample.Clock"))]
122 SampleClock,
123 #[cfg_attr(feature = "serde", serde(rename = "Sample.Periodic"))]
124 SamplePeriodic,
125 #[cfg_attr(feature = "serde", serde(rename = "Transaction.Begin"))]
126 TransactionBegin,
127 #[cfg_attr(feature = "serde", serde(rename = "Transaction.End"))]
128 TransactionEnd,
129 Trigger,
130 Other,
131}
132#[derive(Debug, Clone, PartialEq, Eq)]
133#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
134pub enum Format {
135 Raw,
136 SignedData,
137}
138#[derive(Debug, Clone, PartialEq, Eq)]
139#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
140pub enum Location {
141 Cable,
142 EV,
143 Inlet,
144 Outlet,
145 Body,
146}
147#[derive(Debug, Clone, PartialEq, Eq)]
148#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
149pub enum Measurand {
150 #[cfg_attr(feature = "serde", serde(rename = "Energy.Active.Export.Register"))]
151 EnergyActiveExportRegister,
152 #[cfg_attr(feature = "serde", serde(rename = "Energy.Active.Import.Register"))]
153 EnergyActiveImportRegister,
154 #[cfg_attr(feature = "serde", serde(rename = "Energy.Reactive.Export.Register"))]
155 EnergyReactiveExportRegister,
156 #[cfg_attr(feature = "serde", serde(rename = "Energy.Reactive.Import.Register"))]
157 EnergyReactiveImportRegister,
158 #[cfg_attr(feature = "serde", serde(rename = "Energy.Active.Export.Interval"))]
159 EnergyActiveExportInterval,
160 #[cfg_attr(feature = "serde", serde(rename = "Energy.Active.Import.Interval"))]
161 EnergyActiveImportInterval,
162 #[cfg_attr(feature = "serde", serde(rename = "Energy.Reactive.Export.Interval"))]
163 EnergyReactiveExportInterval,
164 #[cfg_attr(feature = "serde", serde(rename = "Energy.Reactive.Import.Interval"))]
165 EnergyReactiveImportInterval,
166 #[cfg_attr(feature = "serde", serde(rename = "Power.Active.Export"))]
167 PowerActiveExport,
168 #[cfg_attr(feature = "serde", serde(rename = "Power.Active.Import"))]
169 PowerActiveImport,
170 #[cfg_attr(feature = "serde", serde(rename = "Power.Offered"))]
171 PowerOffered,
172 #[cfg_attr(feature = "serde", serde(rename = "Power.Reactive.Export"))]
173 PowerReactiveExport,
174 #[cfg_attr(feature = "serde", serde(rename = "Power.Reactive.Import"))]
175 PowerReactiveImport,
176 #[cfg_attr(feature = "serde", serde(rename = "Power.Factor"))]
177 PowerFactor,
178 #[cfg_attr(feature = "serde", serde(rename = "Current.Import"))]
179 CurrentImport,
180 #[cfg_attr(feature = "serde", serde(rename = "Current.Export"))]
181 CurrentExport,
182 #[cfg_attr(feature = "serde", serde(rename = "Current.Offered"))]
183 CurrentOffered,
184 Voltage,
185 Frequency,
186 Temperature,
187 SoC,
188 RPM,
189}
190#[derive(Debug, Clone, PartialEq, Eq)]
191#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
192pub enum Phase {
193 L1,
194 L2,
195 L3,
196 N,
197 #[cfg_attr(feature = "serde", serde(rename = "L1-N"))]
198 L1N,
199 #[cfg_attr(feature = "serde", serde(rename = "L2-N"))]
200 L2N,
201 #[cfg_attr(feature = "serde", serde(rename = "L3-N"))]
202 L3N,
203 #[cfg_attr(feature = "serde", serde(rename = "L1-L2"))]
204 L1L2,
205 #[cfg_attr(feature = "serde", serde(rename = "L2-L3"))]
206 L2L3,
207 #[cfg_attr(feature = "serde", serde(rename = "L3-L1"))]
208 L3L1,
209}
210#[derive(Debug, Clone, PartialEq, Eq)]
211#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
212pub enum Unit {
213 Wh,
214 #[cfg_attr(feature = "serde", serde(rename = "kWh"))]
215 KWh,
216 #[cfg_attr(feature = "serde", serde(rename = "varh"))]
217 Varh,
218 #[cfg_attr(feature = "serde", serde(rename = "kvarh"))]
219 Kvarh,
220 W,
221 #[cfg_attr(feature = "serde", serde(rename = "kW"))]
222 KW,
223 VA,
224 #[cfg_attr(feature = "serde", serde(rename = "kVA"))]
225 KVA,
226 #[cfg_attr(feature = "serde", serde(rename = "var"))]
227 Var,
228 #[cfg_attr(feature = "serde", serde(rename = "kvar"))]
229 Kvar,
230 A,
231 V,
232 K,
233 Celcius,
234 Celsius,
235 Fahrenheit,
236 Percent,
237}
238#[cfg(feature = "alloc")]
239#[derive(Debug, Clone, PartialEq, Eq)]
240#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
241pub struct SampledValueItem {
242 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
243 pub context: Option<Context>,
244 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
245 pub format: Option<Format>,
246 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
247 pub location: Option<Location>,
248 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
249 pub measurand: Option<Measurand>,
250 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
251 pub phase: Option<Phase>,
252 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
253 pub unit: Option<Unit>,
254 pub value: alloc::string::String,
255}
256#[cfg(not(feature = "alloc"))]
257#[derive(Debug, Clone, PartialEq, Eq)]
258#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
259pub struct SampledValueItem<const SAMPLED_VALUE_ITEM_VALUE_CAP: usize = 1024usize> {
260 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
261 pub context: Option<Context>,
262 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
263 pub format: Option<Format>,
264 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
265 pub location: Option<Location>,
266 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
267 pub measurand: Option<Measurand>,
268 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
269 pub phase: Option<Phase>,
270 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
271 pub unit: Option<Unit>,
272 pub value: heapless::String<SAMPLED_VALUE_ITEM_VALUE_CAP>,
273}
274#[cfg(feature = "alloc")]
275#[derive(Debug, Clone, PartialEq, Eq)]
276#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
277pub struct MeterValueItem {
278 #[cfg_attr(feature = "serde", serde(rename = "sampledValue"))]
279 pub sampled_value: alloc::vec::Vec<SampledValueItem>,
280 pub timestamp: alloc::string::String,
281}
282#[cfg(not(feature = "alloc"))]
283#[derive(Debug, Clone, PartialEq, Eq)]
284#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
285pub struct MeterValueItem<
286 const METER_VALUE_ITEM_SAMPLED_VALUE_CAP: usize = 16usize,
287 const SAMPLED_VALUE_ITEM_VALUE_CAP: usize = 1024usize,
288 const METER_VALUE_ITEM_TIMESTAMP_CAP: usize = 1024usize,
289> {
290 #[cfg_attr(feature = "serde", serde(rename = "sampledValue"))]
291 pub sampled_value: heapless::Vec<
292 SampledValueItem<SAMPLED_VALUE_ITEM_VALUE_CAP>,
293 METER_VALUE_ITEM_SAMPLED_VALUE_CAP,
294 >,
295 pub timestamp: heapless::String<METER_VALUE_ITEM_TIMESTAMP_CAP>,
296}
297#[derive(Debug, Clone, PartialEq, Eq)]
298#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
299pub enum ChargingProfileKind {
300 Absolute,
301 Recurring,
302 Relative,
303}
304#[derive(Debug, Clone, PartialEq, Eq)]
305#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
306pub enum RecurrencyKind {
307 Daily,
308 Weekly,
309}
310#[cfg(feature = "alloc")]
311#[derive(Debug, Clone, PartialEq)]
312#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
313pub struct ChargingProfile {
314 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileId"))]
315 pub charging_profile_id: i64,
316 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileKind"))]
317 pub charging_profile_kind: ChargingProfileKind,
318 #[cfg_attr(feature = "serde", serde(rename = "chargingProfilePurpose"))]
319 pub charging_profile_purpose: ChargingProfilePurpose,
320 #[cfg_attr(feature = "serde", serde(rename = "chargingSchedule"))]
321 pub charging_schedule: ChargingSchedule,
322 #[cfg_attr(feature = "serde", serde(rename = "recurrencyKind"))]
323 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
324 pub recurrency_kind: Option<RecurrencyKind>,
325 #[cfg_attr(feature = "serde", serde(rename = "stackLevel"))]
326 pub stack_level: i64,
327 #[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
328 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
329 pub transaction_id: Option<i64>,
330 #[cfg_attr(feature = "serde", serde(rename = "validFrom"))]
331 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
332 pub valid_from: Option<alloc::string::String>,
333 #[cfg_attr(feature = "serde", serde(rename = "validTo"))]
334 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
335 pub valid_to: Option<alloc::string::String>,
336}
337#[cfg(not(feature = "alloc"))]
338#[derive(Debug, Clone, PartialEq)]
339#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
340pub struct ChargingProfile<
341 const CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP: usize = 16usize,
342 const CHARGING_SCHEDULE_START_SCHEDULE_CAP: usize = 1024usize,
343 const CHARGING_PROFILE_VALID_FROM_CAP: usize = 1024usize,
344 const CHARGING_PROFILE_VALID_TO_CAP: usize = 1024usize,
345> {
346 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileId"))]
347 pub charging_profile_id: i64,
348 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileKind"))]
349 pub charging_profile_kind: ChargingProfileKind,
350 #[cfg_attr(feature = "serde", serde(rename = "chargingProfilePurpose"))]
351 pub charging_profile_purpose: ChargingProfilePurpose,
352 #[cfg_attr(feature = "serde", serde(rename = "chargingSchedule"))]
353 pub charging_schedule: ChargingSchedule<
354 CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP,
355 CHARGING_SCHEDULE_START_SCHEDULE_CAP,
356 >,
357 #[cfg_attr(feature = "serde", serde(rename = "recurrencyKind"))]
358 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
359 pub recurrency_kind: Option<RecurrencyKind>,
360 #[cfg_attr(feature = "serde", serde(rename = "stackLevel"))]
361 pub stack_level: i64,
362 #[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
363 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
364 pub transaction_id: Option<i64>,
365 #[cfg_attr(feature = "serde", serde(rename = "validFrom"))]
366 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
367 pub valid_from: Option<heapless::String<CHARGING_PROFILE_VALID_FROM_CAP>>,
368 #[cfg_attr(feature = "serde", serde(rename = "validTo"))]
369 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
370 pub valid_to: Option<heapless::String<CHARGING_PROFILE_VALID_TO_CAP>>,
371}
372#[cfg(feature = "alloc")]
373#[derive(Debug, Clone, PartialEq, Eq)]
374#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
375pub struct LocalAuthorizationListItem {
376 #[cfg_attr(feature = "serde", serde(rename = "idTag"))]
377 pub id_tag: super::IdTag,
378 #[cfg_attr(feature = "serde", serde(rename = "idTagInfo"))]
379 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
380 pub id_tag_info: Option<IdTagInfo>,
381}
382#[cfg(not(feature = "alloc"))]
383#[derive(Debug, Clone, PartialEq, Eq)]
384#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
385pub struct LocalAuthorizationListItem<
386 const ID_TAG_INFO_EXPIRY_DATE_CAP: usize = 1024usize,
387> {
388 #[cfg_attr(feature = "serde", serde(rename = "idTag"))]
389 pub id_tag: super::IdTag,
390 #[cfg_attr(feature = "serde", serde(rename = "idTagInfo"))]
391 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
392 pub id_tag_info: Option<IdTagInfo<ID_TAG_INFO_EXPIRY_DATE_CAP>>,
393}
394#[derive(Debug, Clone, PartialEq, Eq)]
395#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
396pub enum UpdateType {
397 Differential,
398 Full,
399}
400#[cfg(feature = "alloc")]
401#[derive(Debug, Clone, PartialEq)]
402#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
403pub struct CsChargingProfiles {
404 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileId"))]
405 pub charging_profile_id: i64,
406 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileKind"))]
407 pub charging_profile_kind: ChargingProfileKind,
408 #[cfg_attr(feature = "serde", serde(rename = "chargingProfilePurpose"))]
409 pub charging_profile_purpose: ChargingProfilePurpose,
410 #[cfg_attr(feature = "serde", serde(rename = "chargingSchedule"))]
411 pub charging_schedule: ChargingSchedule,
412 #[cfg_attr(feature = "serde", serde(rename = "recurrencyKind"))]
413 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
414 pub recurrency_kind: Option<RecurrencyKind>,
415 #[cfg_attr(feature = "serde", serde(rename = "stackLevel"))]
416 pub stack_level: i64,
417 #[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
418 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
419 pub transaction_id: Option<i64>,
420 #[cfg_attr(feature = "serde", serde(rename = "validFrom"))]
421 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
422 pub valid_from: Option<alloc::string::String>,
423 #[cfg_attr(feature = "serde", serde(rename = "validTo"))]
424 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
425 pub valid_to: Option<alloc::string::String>,
426}
427#[cfg(not(feature = "alloc"))]
428#[derive(Debug, Clone, PartialEq)]
429#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
430pub struct CsChargingProfiles<
431 const CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP: usize = 16usize,
432 const CHARGING_SCHEDULE_START_SCHEDULE_CAP: usize = 1024usize,
433 const CS_CHARGING_PROFILES_VALID_FROM_CAP: usize = 1024usize,
434 const CS_CHARGING_PROFILES_VALID_TO_CAP: usize = 1024usize,
435> {
436 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileId"))]
437 pub charging_profile_id: i64,
438 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileKind"))]
439 pub charging_profile_kind: ChargingProfileKind,
440 #[cfg_attr(feature = "serde", serde(rename = "chargingProfilePurpose"))]
441 pub charging_profile_purpose: ChargingProfilePurpose,
442 #[cfg_attr(feature = "serde", serde(rename = "chargingSchedule"))]
443 pub charging_schedule: ChargingSchedule<
444 CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP,
445 CHARGING_SCHEDULE_START_SCHEDULE_CAP,
446 >,
447 #[cfg_attr(feature = "serde", serde(rename = "recurrencyKind"))]
448 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
449 pub recurrency_kind: Option<RecurrencyKind>,
450 #[cfg_attr(feature = "serde", serde(rename = "stackLevel"))]
451 pub stack_level: i64,
452 #[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
453 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
454 pub transaction_id: Option<i64>,
455 #[cfg_attr(feature = "serde", serde(rename = "validFrom"))]
456 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
457 pub valid_from: Option<heapless::String<CS_CHARGING_PROFILES_VALID_FROM_CAP>>,
458 #[cfg_attr(feature = "serde", serde(rename = "validTo"))]
459 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
460 pub valid_to: Option<heapless::String<CS_CHARGING_PROFILES_VALID_TO_CAP>>,
461}
462#[derive(Debug, Clone, PartialEq, Eq)]
463#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
464pub enum ErrorCode {
465 ConnectorLockFailure,
466 EVCommunicationError,
467 GroundFailure,
468 HighTemperature,
469 InternalError,
470 LocalListConflict,
471 NoError,
472 OtherError,
473 OverCurrentFailure,
474 PowerMeterFailure,
475 PowerSwitchFailure,
476 ReaderFailure,
477 ResetFailure,
478 UnderVoltage,
479 OverVoltage,
480 WeakSignal,
481}
482#[derive(Debug, Clone, PartialEq, Eq)]
483#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
484pub enum Reason {
485 EmergencyStop,
486 EVDisconnected,
487 HardReset,
488 Local,
489 Other,
490 PowerLoss,
491 Reboot,
492 Remote,
493 SoftReset,
494 UnlockCommand,
495 DeAuthorized,
496}
497#[cfg(feature = "alloc")]
498#[derive(Debug, Clone, PartialEq, Eq)]
499#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
500pub struct TransactionDataItem {
501 #[cfg_attr(feature = "serde", serde(rename = "sampledValue"))]
502 pub sampled_value: alloc::vec::Vec<SampledValueItem>,
503 pub timestamp: alloc::string::String,
504}
505#[cfg(not(feature = "alloc"))]
506#[derive(Debug, Clone, PartialEq, Eq)]
507#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
508pub struct TransactionDataItem<
509 const TRANSACTION_DATA_ITEM_SAMPLED_VALUE_CAP: usize = 16usize,
510 const SAMPLED_VALUE_ITEM_VALUE_CAP: usize = 1024usize,
511 const TRANSACTION_DATA_ITEM_TIMESTAMP_CAP: usize = 1024usize,
512> {
513 #[cfg_attr(feature = "serde", serde(rename = "sampledValue"))]
514 pub sampled_value: heapless::Vec<
515 SampledValueItem<SAMPLED_VALUE_ITEM_VALUE_CAP>,
516 TRANSACTION_DATA_ITEM_SAMPLED_VALUE_CAP,
517 >,
518 pub timestamp: heapless::String<TRANSACTION_DATA_ITEM_TIMESTAMP_CAP>,
519}
520#[derive(Debug, Clone, PartialEq, Eq)]
521#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
522pub enum RequestedMessage {
523 BootNotification,
524 DiagnosticsStatusNotification,
525 FirmwareStatusNotification,
526 Heartbeat,
527 MeterValues,
528 StatusNotification,
529}