embrasul_models/models/
mod.rs

1use std::io::Write;
2use crate::types::*;
3
4pub mod model1;
5pub mod model2;
6pub mod model3;
7pub mod model4;
8pub mod model5;
9pub mod model6;
10pub mod model7;
11pub mod model8;
12pub mod model9;
13
14
15#[derive(Debug, Clone)]
16pub struct EModel {
17    pub start_addr: u16,
18    pub end_addr: u16,
19    pub model_number: u16,
20    pub qtd: u16,
21    pub update: bool,
22    pub data: Vec<EDataTypes>,
23}
24
25#[derive(Debug, Clone)]
26pub struct EModels {
27    pub models: Vec<EModel>,
28}
29
30// Declare the struct
31pub trait EmbrasulModels {
32    // This new function acts as a constructor
33    fn new (model_number: u16) -> Self;
34    fn update_data(&mut self, point: &str, value: &EDataTypes);
35    fn update_data_by_index(&mut self, index: usize, value: &EDataTypes);
36    fn get_data(&self, point: &str) -> EDataTypes;
37    fn get_data_index(&self, point: &str) -> usize;
38    fn get_string(&self, point: &str) -> Option<String>;
39    fn get_string_by_index(&self, idx: usize) -> Option<String>;
40    fn get_f32(&self, point: &str) -> Option<f32>;
41    fn get_f32_by_index(&self, idx: usize) -> Option<f32>;
42    fn get_u16(&self, point: &str) -> Option<u16>;
43    fn get_u16_by_index(&self, idx: usize) -> Option<u16>;
44    fn get_u32(&self, point: &str) -> Option<u32>;
45    fn get_u32_by_index(&self, idx: usize) -> Option<u32>;
46    fn get_u64(&self, point: &str) -> Option<u64>;
47    fn get_u64_by_index(&self, idx: usize) -> Option<u64>;
48    fn get_u128(&self, point: &str) -> Option<u128>;
49    fn get_u128_by_index(&self, idx: usize) -> Option<u128>;
50    fn get_i16(&self, point: &str) -> Option<i16>;
51    fn get_i16_by_index(&self, idx: usize) -> Option<i16>;
52    fn get_i32(&self, point: &str) -> Option<i32>;
53    fn get_i32_by_index(&self, idx: usize) -> Option<i32>;
54    fn get_i64(&self, point: &str) -> Option<i64>;
55    fn get_i64_by_index(&self, idx: usize) -> Option<i64>;
56    fn print(&self);
57}
58
59impl Default for EModels {
60    fn default() -> Self {
61        Self::new()
62    }
63}
64
65impl EModels {
66    pub fn new () -> EModels {
67        EModels { models: Vec::new() }
68    }
69
70    pub fn get_model_index(&self, model_number: u16) -> Option<usize> {
71        for (idx, model) in self.models.iter().enumerate() {
72            if model_number == model.model_number {
73                return Some(idx);
74            }
75        }
76        None
77    }
78
79    pub fn compute_addr (&mut self) {
80        let mut end_addr = 0;
81        for (idx, model) in self.models.iter_mut().enumerate() {
82            if idx == 0 {
83                model.start_addr = 2;
84            }else{
85                model.start_addr = end_addr;
86            }
87            model.end_addr = model.start_addr + model.qtd + 2;
88            end_addr = model.end_addr;
89        }
90    }
91}
92
93fn model_end() -> EModel {
94    EModel {
95        start_addr: 0,
96        model_number: 0xFFFF,
97        qtd: 0,
98        end_addr: 0,
99        update: false,
100        data: Vec::new(),
101    }
102}
103
104impl EmbrasulModels for EModel {
105    fn new (model_number: u16) -> EModel {
106        match model_number {
107            1 => model1::model1(),
108            2 => model2::model2(),
109            3 => model3::model3(),
110            4 => model4::model4(),
111            5 => model5::model5(),
112            6 => model6::model6(),
113            7 => model7::model7(),
114            8 => model8::model8(),
115            9 => model9::model9(),
116            _ => model_end(),
117        }
118    }
119
120    fn update_data(&mut self, point: &str, value: &EDataTypes) {
121        for data_tmp in self.data.iter_mut() {
122            match data_tmp {
123                EDataTypes::EmbrasulString(data) => {
124                    if data.name.contains(point) && (data.name.len() == point.len()){
125                        if let EDataTypes::EmbrasulString(update_value) = value {
126                            data.value.clone_from(&update_value.value);
127                        }
128                    }
129                },
130                EDataTypes::EmbrasulF32(data) => {
131                    if data.name.contains(point) && (data.name.len() == point.len()){
132                        if let EDataTypes::EmbrasulF32(update_value) = value {
133                            data.value = update_value.value;
134                        }
135                    }
136                },
137                EDataTypes::EmbrasulU16(data) => {
138                    if data.name.contains(point) && (data.name.len() == point.len()){
139                        if let EDataTypes::EmbrasulU16(update_value) = value {
140                            data.value = update_value.value;
141                        }
142                    }
143                },
144                EDataTypes::EmbrasulU32(data) => {
145                    if data.name.contains(point) && (data.name.len() == point.len()){
146                        if let EDataTypes::EmbrasulU32(update_value) = value {
147                            data.value = update_value.value;
148                        }
149                    }
150                },
151                EDataTypes::EmbrasulU64(data) => {
152                    if data.name.contains(point) && (data.name.len() == point.len()){
153                        if let EDataTypes::EmbrasulU64(update_value) = value {
154                            data.value = update_value.value;
155                        }
156                    }
157                },
158                EDataTypes::EmbrasulU128(data) => {
159                    if data.name.contains(point) && (data.name.len() == point.len()){
160                        if let EDataTypes::EmbrasulU128(update_value) = value {
161                            data.value = update_value.value;
162                        }
163                    }
164                },
165                EDataTypes::EmbrasulI16(data) => {
166                    if data.name.contains(point) && (data.name.len() == point.len()){
167                        if let EDataTypes::EmbrasulI16(update_value) = value {
168                            data.value = update_value.value;
169                        }
170                    }
171                },
172                EDataTypes::EmbrasulI32(data) => {
173                    if data.name.contains(point) && (data.name.len() == point.len()){
174                        if let EDataTypes::EmbrasulI32(update_value) = value {
175                            data.value = update_value.value;
176                        }
177                    }
178                },
179                EDataTypes::EmbrasulI64(data) => {
180                    if data.name.contains(point) && (data.name.len() == point.len()){
181                        if let EDataTypes::EmbrasulI64(update_value) = value {
182                            data.value = update_value.value;
183                        }
184                    }
185                },
186            }
187        }
188    }
189
190    fn update_data_by_index(&mut self, index: usize, value: &EDataTypes) {
191        match &mut self.data[index] {
192            EDataTypes::EmbrasulString(data) => {
193                if let EDataTypes::EmbrasulString(update_value) = value {
194                    data.value.clone_from(&update_value.value);
195                }
196            },
197            EDataTypes::EmbrasulF32(data) => {
198                if let EDataTypes::EmbrasulF32(update_value) = value {
199                    data.value = update_value.value;
200                }
201            },
202            EDataTypes::EmbrasulU16(data) => {
203                if let EDataTypes::EmbrasulU16(update_value) = value {
204                    data.value = update_value.value;
205                }
206            },
207            EDataTypes::EmbrasulU32(data) => {
208                if let EDataTypes::EmbrasulU32(update_value) = value {
209                    data.value = update_value.value;
210                }
211            },
212            EDataTypes::EmbrasulU64(data) => {
213                if let EDataTypes::EmbrasulU64(update_value) = value {
214                    data.value = update_value.value;
215                }
216            },
217            EDataTypes::EmbrasulU128(data) => {
218                if let EDataTypes::EmbrasulU128(update_value) = value {
219                    data.value = update_value.value;
220                }
221            },
222            EDataTypes::EmbrasulI16(data) => {
223                if let EDataTypes::EmbrasulI16(update_value) = value {
224                    data.value = update_value.value;
225                }
226            },
227            EDataTypes::EmbrasulI32(data) => {
228                if let EDataTypes::EmbrasulI32(update_value) = value {
229                    data.value = update_value.value;
230                }
231            },
232            EDataTypes::EmbrasulI64(data) => {
233                if let EDataTypes::EmbrasulI64(update_value) = value {
234                    data.value = update_value.value;
235                }
236            },
237        }
238    }
239
240    fn get_data(&self, point: &str) -> EDataTypes {
241        for data_tmp in self.data.iter() {
242            match data_tmp {
243                EDataTypes::EmbrasulString(data) => {
244                    if data.name.contains(point) && (data.name.len() == point.len()) {
245                        return data_tmp.clone();
246                    }
247                },
248                EDataTypes::EmbrasulU16(data) => {
249                    if data.name.contains(point) && (data.name.len() == point.len()) {
250                        return data_tmp.clone();
251                    }
252                },
253                EDataTypes::EmbrasulU32(data) => {
254                    if data.name.contains(point) && (data.name.len() == point.len()) {
255                        return data_tmp.clone();
256                    }
257                },
258                EDataTypes::EmbrasulU64(data) => {
259                    if data.name.contains(point) && (data.name.len() == point.len()) {
260                        return data_tmp.clone();
261                    }
262                },
263                EDataTypes::EmbrasulU128(data) => {
264                    if data.name.contains(point) && (data.name.len() == point.len()) {
265                        return data_tmp.clone();
266                    }
267                },
268                EDataTypes::EmbrasulI16(data) => {
269                    if data.name.contains(point) && (data.name.len() == point.len()) {
270                        return data_tmp.clone();
271                    }
272                },
273                EDataTypes::EmbrasulI32(data) => {
274                    if data.name.contains(point) && (data.name.len() == point.len()) {
275                        return data_tmp.clone();
276                    }
277                },
278                EDataTypes::EmbrasulI64(data) => {
279                    if data.name.contains(point) && (data.name.len() == point.len()) {
280                        return data_tmp.clone();
281                    }
282                },
283                EDataTypes::EmbrasulF32(data) => {
284                    if data.name.contains(point) && (data.name.len() == point.len()) {
285                        return data_tmp.clone();
286                    }
287                }
288            };
289        }
290        EDataTypes::EmbrasulU16(Point { name: "", offset: 0, length: 1, write_access: false, value: 0 })
291    }
292
293    fn get_data_index(&self, point: &str) -> usize {
294        let mut idx = 0;
295        for data_tmp in self.data.iter() {
296            match data_tmp {
297                EDataTypes::EmbrasulString(data) => {
298                    if data.name.contains(point) && (data.name.len() == point.len()) {
299                        return idx;
300                    }
301                },
302                EDataTypes::EmbrasulU16(data) => {
303                    if data.name.contains(point) && (data.name.len() == point.len()) {
304                        return idx;
305                    }
306                },
307                EDataTypes::EmbrasulU32(data) => {
308                    if data.name.contains(point) && (data.name.len() == point.len()) {
309                        return idx;
310                    }
311                },
312                EDataTypes::EmbrasulU64(data) => {
313                    if data.name.contains(point) && (data.name.len() == point.len()) {
314                        return idx;
315                    }
316                },
317                EDataTypes::EmbrasulU128(data) => {
318                    if data.name.contains(point) && (data.name.len() == point.len()) {
319                        return idx;
320                    }
321                },
322                EDataTypes::EmbrasulI16(data) => {
323                    if data.name.contains(point) && (data.name.len() == point.len()) {
324                        return idx;
325                    }
326                },
327                EDataTypes::EmbrasulI32(data) => {
328                    if data.name.contains(point) && (data.name.len() == point.len()) {
329                        return idx;
330                    }
331                },
332                EDataTypes::EmbrasulI64(data) => {
333                    if data.name.contains(point) && (data.name.len() == point.len()) {
334                        return idx;
335                    }
336                },
337                EDataTypes::EmbrasulF32(data) => {
338                    if data.name.contains(point) && (data.name.len() == point.len()) {
339                        return idx;
340                    }
341                }
342            };
343            idx += 1;
344        }
345        idx
346    }
347
348    fn get_f32(&self, point: &str) -> Option<f32> {
349        for data_tmp in self.data.iter() {
350            if let EDataTypes::EmbrasulF32(data) = data_tmp {
351                if data.name.contains(point) && (data.name.len() == point.len()) {
352                    return Some(data.value);
353                }
354            }
355        }
356        None
357    }
358
359    fn get_f32_by_index(&self, idx: usize) -> Option<f32> {
360        match self.data[idx] {
361            EDataTypes::EmbrasulF32(data) => {
362                Some(data.value)
363            },
364            _ => None,
365        }
366    }
367
368    fn get_string(&self, point: &str) -> Option<String> {
369        for data_tmp in self.data.iter() {
370            if let EDataTypes::EmbrasulString(data) = data_tmp {
371                if data.name.contains(point) && (data.name.len() == point.len()) {
372                    return Some(data.value.clone());
373                }
374            }
375        }
376        None
377    }
378
379    fn get_string_by_index(&self, idx: usize) -> Option<String> {
380        match &self.data[idx] {
381            EDataTypes::EmbrasulString(data) => {
382                Some(data.value.clone())
383            },
384            _ => None,
385        }
386    }
387
388    fn get_u16(&self, point: &str) -> Option<u16> {
389        for data_tmp in self.data.iter() {
390            if let EDataTypes::EmbrasulU16(data) = data_tmp {
391                if data.name.contains(point) && (data.name.len() == point.len()) {
392                    return Some(data.value);
393                }
394            }
395        }
396        None
397    }
398
399    fn get_u16_by_index(&self, idx: usize) -> Option<u16> {
400        match self.data[idx] {
401            EDataTypes::EmbrasulU16(data) => {
402                Some(data.value)
403            },
404            _ => None,
405        }
406    }
407
408    fn get_u32(&self, point: &str) -> Option<u32> {
409        for data_tmp in self.data.iter() {
410            if let EDataTypes::EmbrasulU32(data) = data_tmp {
411                if data.name.contains(point) && (data.name.len() == point.len()) {
412                    return Some(data.value);
413                }
414            }
415        }
416        None
417    }
418
419    fn get_u32_by_index(&self, idx: usize) -> Option<u32> {
420        match self.data[idx] {
421            EDataTypes::EmbrasulU32(data) => {
422                Some(data.value)
423            },
424            _ => None,
425        }
426    }
427
428    fn get_u64(&self, point: &str) -> Option<u64> {
429        for data_tmp in self.data.iter() {
430            if let EDataTypes::EmbrasulU64(data) = data_tmp {
431                if data.name.contains(point) && (data.name.len() == point.len()) {
432                    return Some(data.value);
433                }
434            }
435        }
436        None
437    }
438
439    fn get_u64_by_index(&self, idx: usize) -> Option<u64> {
440        match self.data[idx] {
441            EDataTypes::EmbrasulU64(data) => {
442                Some(data.value)
443            },
444            _ => None,
445        }
446    }
447
448    fn get_u128(&self, point: &str) -> Option<u128> {
449        for data_tmp in self.data.iter() {
450            if let EDataTypes::EmbrasulU128(data) = data_tmp {
451                if data.name.contains(point) && (data.name.len() == point.len()) {
452                    return Some(data.value);
453                }
454            }
455        }
456        None
457    }
458
459    fn get_u128_by_index(&self, idx: usize) -> Option<u128> {
460        match self.data[idx] {
461            EDataTypes::EmbrasulU128(data) => {
462                Some(data.value)
463            },
464            _ => None,
465        }
466    }
467
468    fn get_i16(&self, point: &str) -> Option<i16> {
469        for data_tmp in self.data.iter() {
470            if let EDataTypes::EmbrasulI16(data) = data_tmp {
471                if data.name.contains(point) && (data.name.len() == point.len()) {
472                    return Some(data.value);
473                }
474            }
475        }
476        None
477    }
478
479    fn get_i16_by_index(&self, idx: usize) -> Option<i16> {
480        match self.data[idx] {
481            EDataTypes::EmbrasulI16(data) => {
482                Some(data.value)
483            },
484            _ => None,
485        }
486    }
487
488    fn get_i32(&self, point: &str) -> Option<i32> {
489        for data_tmp in self.data.iter() {
490            if let EDataTypes::EmbrasulI32(data) = data_tmp {
491                if data.name.contains(point) && (data.name.len() == point.len()) {
492                    return Some(data.value);
493                }
494            }
495        }
496        None
497    }
498
499    fn get_i32_by_index(&self, idx: usize) -> Option<i32> {
500        match self.data[idx] {
501            EDataTypes::EmbrasulI32(data) => {
502                Some(data.value)
503            },
504            _ => None,
505        }
506    }
507
508    fn get_i64(&self, point: &str) -> Option<i64> {
509        for data_tmp in self.data.iter() {
510            if let EDataTypes::EmbrasulI64(data) = data_tmp {
511                if data.name.contains(point) && (data.name.len() == point.len()) {
512                    return Some(data.value);
513                }
514            }
515        }
516        None
517    }
518
519    fn get_i64_by_index(&self, idx: usize) -> Option<i64> {
520        match self.data[idx] {
521            EDataTypes::EmbrasulI64(data) => {
522                Some(data.value)
523            },
524            _ => None,
525        }
526    }
527
528    fn print(&self) {
529        println!("Model {}:", self.model_number);
530        for data in self.data.iter() {
531            match data {
532                EDataTypes::EmbrasulF32(data) => println!("{}: {}", data.name, data.value),
533                EDataTypes::EmbrasulU16(data) => println!("{}: {}", data.name, data.value),
534                EDataTypes::EmbrasulU32(data) => println!("{}: {}", data.name, data.value),
535                EDataTypes::EmbrasulU64(data) => println!("{}: {}", data.name, data.value),
536                EDataTypes::EmbrasulU128(data) => println!("{}: {}", data.name, data.value),
537                EDataTypes::EmbrasulI16(data) => println!("{}: {}", data.name, data.value),
538                EDataTypes::EmbrasulI32(data) => println!("{}: {}", data.name, data.value),
539                EDataTypes::EmbrasulI64(data) => println!("{}: {}", data.name, data.value),
540                EDataTypes::EmbrasulString(data) => println!("{}: {}", data.name, data.value.clone()),
541            }
542        }
543        println!(" ");
544    }
545}
546
547
548pub fn srt_to_vec_u8(src: &str, mut dst: &mut [u8]){
549    dst.write_all(src.as_bytes()).unwrap();
550}
551
552
553impl From<EModel> for Vec<u16> {
554    fn from(from: EModel) -> Self {
555        let mut registers: Vec<u16> = vec![0; 2];
556        registers[0] = from.model_number;
557        registers[1] = from.qtd;
558
559        for data in from.data.iter() {
560            match data {
561                EDataTypes::EmbrasulF32(data) => registers.extend(f32::encode(data.value)),
562                EDataTypes::EmbrasulU16(data) => registers.extend(u16::encode(data.value)),
563                EDataTypes::EmbrasulU32(data) => registers.extend(u32::encode(data.value)),
564                EDataTypes::EmbrasulU64(data) => registers.extend(u64::encode(data.value)),
565                EDataTypes::EmbrasulU128(data) => registers.extend(u128::encode(data.value)),
566                EDataTypes::EmbrasulI16(data) => registers.extend(i16::encode(data.value)),
567                EDataTypes::EmbrasulI32(data) => registers.extend(i32::encode(data.value)),
568                EDataTypes::EmbrasulI64(data) => registers.extend(i64::encode(data.value)),
569                EDataTypes::EmbrasulString(data) => registers.extend(Point::<String>::encode(data.clone())),
570            }
571        }
572        registers
573    }
574}
575
576impl From<(Vec<u16>, u16, u16, &EModel)> for EModel {
577    fn from(from: (Vec<u16>, u16, u16, &EModel)) -> Self {
578        let mut model1 = from.3.clone();
579        let mut offset = from.1;
580        let mut qtd = from.2;
581
582        while qtd > 0 {
583            for data in model1.data.iter_mut() {
584                match data {
585                    EDataTypes::EmbrasulString(data) => {
586                        if offset == data.offset {
587                            let slice = from.0[data.offset as usize..(data.offset + data.length) as usize].to_vec();
588                            data.value = String::decode(slice);
589                            offset += data.length;
590                            qtd -= data.length;
591                        }
592                    },
593                    EDataTypes::EmbrasulU16(data) => {
594                        if offset == data.offset {
595                            let slice = from.0[data.offset as usize..(data.offset + data.length) as usize].to_vec();
596                            data.value = u16::decode(slice);
597                            offset += data.length;
598                            qtd -= data.length;
599                        }
600                    },
601                    EDataTypes::EmbrasulU32(data) => {
602                        if offset == data.offset {
603                            let slice = from.0[data.offset as usize..(data.offset + data.length) as usize].to_vec();
604                            data.value = u32::decode(slice);
605                            offset += data.length;
606                            qtd -= data.length;
607                        }
608                    },
609                    EDataTypes::EmbrasulU64(data) => {
610                        if offset == data.offset {
611                            let slice = from.0[data.offset as usize..(data.offset + data.length) as usize].to_vec();
612                            data.value = u64::decode(slice);
613                            offset += data.length;
614                            qtd -= data.length;
615                        }
616                    },
617                    EDataTypes::EmbrasulU128(data) => {
618                        if offset == data.offset {
619                            let slice = from.0[data.offset as usize..(data.offset + data.length) as usize].to_vec();
620                            data.value = u128::decode(slice);
621                            offset += data.length;
622                            qtd -= data.length;
623                        }
624                    },
625                    EDataTypes::EmbrasulI16(data) => {
626                        if offset == data.offset {
627                            let slice = from.0[data.offset as usize..(data.offset + data.length) as usize].to_vec();
628                            data.value = i16::decode(slice);
629                            offset += data.length;
630                            qtd -= data.length;
631                        }
632                    },
633                    EDataTypes::EmbrasulI32(data) => {
634                        if offset == data.offset {
635                            let slice = from.0[data.offset as usize..(data.offset + data.length) as usize].to_vec();
636                            data.value = i32::decode(slice);
637                            offset += data.length;
638                            qtd -= data.length;
639                        }
640                    },
641                    EDataTypes::EmbrasulI64(data) => {
642                        if offset == data.offset {
643                            let slice = from.0[data.offset as usize..(data.offset + data.length) as usize].to_vec();
644                            data.value = i64::decode(slice);
645                            offset += data.length;
646                            qtd -= data.length;
647                        }
648                    },
649                    EDataTypes::EmbrasulF32(data) => {
650                        if offset == data.offset {
651                            let slice = from.0[data.offset as usize..(data.offset + data.length) as usize].to_vec();
652                            data.value = f32::decode(slice);
653                            offset += data.length;
654                            qtd -= data.length;
655                        }
656                    },
657                }
658            }
659        }
660        model1
661    }
662}
embrasul_models/models/mod.rs

embrasul_models/models/
mod.rs
