huawei_models/models/
mod.rs

1//use 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;
13pub mod model10;
14pub mod model11;
15pub mod model12;
16pub mod model13;
17pub mod model14;
18pub mod model15;
19pub mod model16;
20
21#[derive(Debug, Clone)]
22pub struct HModel {
23    pub start_addr: u16,
24    pub end_addr: u16,
25    pub model_number: u16,
26    pub qtd: u16,
27    pub data: Vec<HDataTypes>,
28}
29
30#[derive(Debug, Clone)]
31pub struct HModels {
32    pub models: Vec<HModel>,
33}
34
35// Declare the struct
36pub trait HuaweiModels {
37    // This new function acts as a constructor
38    fn new (model_number: u16) -> Self;
39    fn update_data(&mut self, point: &str, value: &HDataTypes);
40    fn update_data_by_index(&mut self, index: usize, value: &HDataTypes);
41    fn get_data(&self, point: &str) -> HDataTypes;
42    fn get_data_index(&self, point: &str) -> Option<usize>;
43    fn get_string(&self, point: &str) -> Option<String>;
44    fn get_string_by_index(&self, idx: usize) -> Option<String>;
45    fn get_u16(&self, point: &str) -> Option<u16>;
46    fn get_u16_by_index(&self, idx: usize) -> Option<u16>;
47    fn get_u32(&self, point: &str) -> Option<u32>;
48    fn get_u32_by_index(&self, idx: usize) -> Option<u32>;
49    fn get_i16(&self, point: &str) -> Option<i16>;
50    fn get_i16_by_index(&self, idx: usize) -> Option<i16>;
51    fn get_i32(&self, point: &str) -> Option<i32>;
52    fn get_i32_by_index(&self, idx: usize) -> Option<i32>;
53    fn print(&self);
54}
55
56
57impl HModels {
58    pub fn new () -> HModels {
59        HModels { models: Vec::new() }
60    }
61
62    pub fn get_model_index(&self, model_number: u16) -> Option<usize> {
63        for (idx, model) in self.models.iter().enumerate() {
64            if model_number == model.model_number {
65                return Some(idx);
66            }
67        }
68        None
69    }
70}
71
72impl HuaweiModels for HModel {
73    fn new (model_number: u16) -> HModel {
74        match model_number {
75            1 => model1::model1(),
76            2 => model2::model2(),
77            3 => model3::model3(),
78            4 => model4::model4(),
79            5 => model5::model5(),
80            6 => model6::model6(),
81            7 => model7::model7(),
82            8 => model8::model8(),
83            9 => model9::model9(),
84            10 => model10::model10(),
85            11 => model11::model11(),
86            12 => model12::model12(),
87            13 => model13::model13(),
88            14 => model14::model14(),
89            15 => model15::model15(),
90            16 => model16::model16(),
91            _ => model1::model1(),
92        }
93    }
94
95    fn update_data(&mut self, point: &str, value: &HDataTypes) {
96        for data_tmp in self.data.iter_mut() {
97            match data_tmp {
98                HDataTypes::HuaweiString(data) => {
99                    if data.name.contains(point) && (data.name.len() == point.len()){
100                        if let HDataTypes::HuaweiString(update_value) = value {
101                            data.value = update_value.value.clone();
102                        }
103                    }
104                },
105                HDataTypes::HuaweiU16(data) => {
106                    if data.name.contains(point) && (data.name.len() == point.len()){
107                        if let HDataTypes::HuaweiU16(update_value) = value {
108                            data.value = update_value.value;
109                        }
110                    }
111                },
112                HDataTypes::HuaweiU32(data) => {
113                    if data.name.contains(point) && (data.name.len() == point.len()){
114                        if let HDataTypes::HuaweiU32(update_value) = value {
115                            data.value = update_value.value;
116                        }
117                    }
118                },
119                HDataTypes::HuaweiI16(data) => {
120                    if data.name.contains(point) && (data.name.len() == point.len()){
121                        if let HDataTypes::HuaweiI16(update_value) = value {
122                            data.value = update_value.value;
123                        }
124                    }
125                },
126                HDataTypes::HuaweiI32(data) => {
127                    if data.name.contains(point) && (data.name.len() == point.len()){
128                        if let HDataTypes::HuaweiI32(update_value) = value {
129                            data.value = update_value.value;
130                        }
131                    }
132                },
133            }
134        }
135    }
136
137    fn update_data_by_index(&mut self, index: usize, value: &HDataTypes) {
138        match &mut self.data[index] {
139            HDataTypes::HuaweiString(data) => {
140                if let HDataTypes::HuaweiString(update_value) = value {
141                    data.value = update_value.value.clone();
142                }
143            },
144            HDataTypes::HuaweiU16(data) => {
145                if let HDataTypes::HuaweiU16(update_value) = value {
146                    data.value = update_value.value;
147                }
148            },
149            HDataTypes::HuaweiU32(data) => {
150                if let HDataTypes::HuaweiU32(update_value) = value {
151                    data.value = update_value.value;
152                }
153            },
154            HDataTypes::HuaweiI16(data) => {
155                if let HDataTypes::HuaweiI16(update_value) = value {
156                    data.value = update_value.value;
157                }
158            },
159            HDataTypes::HuaweiI32(data) => {
160                if let HDataTypes::HuaweiI32(update_value) = value {
161                    data.value = update_value.value;
162                }
163            },
164        }
165    }
166
167    fn get_data(&self, point: &str) -> HDataTypes {
168        for data_tmp in self.data.iter() {
169            match data_tmp {
170                HDataTypes::HuaweiString(data) => {
171                    if data.name.contains(point) && (data.name.len() == point.len()) {
172                        return data_tmp.clone();
173                    }
174                },
175                HDataTypes::HuaweiU16(data) => {
176                    if data.name.contains(point) && (data.name.len() == point.len()) {
177                        return data_tmp.clone();
178                    }
179                },
180                HDataTypes::HuaweiU32(data) => {
181                    if data.name.contains(point) && (data.name.len() == point.len()) {
182                        return data_tmp.clone();
183                    }
184                },
185                HDataTypes::HuaweiI16(data) => {
186                    if data.name.contains(point) && (data.name.len() == point.len()) {
187                        return data_tmp.clone();
188                    }
189                },
190                HDataTypes::HuaweiI32(data) => {
191                    if data.name.contains(point) && (data.name.len() == point.len()) {
192                        return data_tmp.clone();
193                    }
194                },
195            };
196        }
197        HDataTypes::HuaweiU16(Point { name: "", offset: 0, length: 1, write_access: false, value: 0 } )
198    }
199
200    fn get_data_index(&self, point: &str) -> Option<usize> {
201        for (idx, data_tmp) in self.data.iter().enumerate() {
202            match data_tmp {
203                HDataTypes::HuaweiString(data) => {
204                    if data.name.contains(point) && (data.name.len() == point.len()) {
205                        return Some(idx);
206                    }
207                },
208                HDataTypes::HuaweiU16(data) => {
209                    if data.name.contains(point) && (data.name.len() == point.len()) {
210                        return Some(idx);
211                    }
212                },
213                HDataTypes::HuaweiU32(data) => {
214                    if data.name.contains(point) && (data.name.len() == point.len()) {
215                        return Some(idx);
216                    }
217                },
218                HDataTypes::HuaweiI16(data) => {
219                    if data.name.contains(point) && (data.name.len() == point.len()) {
220                        return Some(idx);
221                    }
222                },
223                HDataTypes::HuaweiI32(data) => {
224                    if data.name.contains(point) && (data.name.len() == point.len()) {
225                        return Some(idx);
226                    }
227                },
228            };
229        }
230        None
231    }
232
233    fn get_string(&self, point: &str) -> Option<String> {
234        for data_tmp in self.data.iter() {
235            if let HDataTypes::HuaweiString(data) = data_tmp {
236                if data.name.contains(point) && (data.name.len() == point.len()) {
237                    return Some(data.value.clone());
238                }
239            }
240        }
241        None
242    }
243
244    fn get_string_by_index(&self, idx: usize) -> Option<String> {
245        match &self.data[idx] {
246            HDataTypes::HuaweiString(data) => {
247                Some(data.value.clone())
248            },
249            _ => None
250        }
251    }
252
253    fn get_u16(&self, point: &str) -> Option<u16> {
254        for data_tmp in self.data.iter() {
255            if let HDataTypes::HuaweiU16(data) = data_tmp {
256                if data.name.contains(point) && (data.name.len() == point.len()) {
257                    return Some(data.value);
258                }
259            }
260        }
261        None
262    }
263
264    fn get_u16_by_index(&self, idx: usize) -> Option<u16> {
265        match self.data[idx] {
266            HDataTypes::HuaweiU16(data) => {
267                Some(data.value)
268            },
269            _ => None
270        }
271    }
272
273    fn get_u32(&self, point: &str) -> Option<u32> {
274        for data_tmp in self.data.iter() {
275            if let HDataTypes::HuaweiU32(data) = data_tmp {
276                if data.name.contains(point) && (data.name.len() == point.len()) {
277                    return Some(data.value);
278                }
279            }
280        }
281        None
282    }
283
284    fn get_u32_by_index(&self, idx: usize) -> Option<u32> {
285        match self.data[idx] {
286            HDataTypes::HuaweiU32(data) => {
287                Some(data.value)
288            },
289            _ => None
290        }
291    }
292
293    fn get_i16(&self, point: &str) -> Option<i16> {
294        for data_tmp in self.data.iter() {
295            if let HDataTypes::HuaweiI16(data) = data_tmp {
296                if data.name.contains(point) && (data.name.len() == point.len()) {
297                    return Some(data.value);
298                }
299            }
300        }
301        None
302    }
303
304    fn get_i16_by_index(&self, idx: usize) -> Option<i16> {
305        match self.data[idx] {
306            HDataTypes::HuaweiI16(data) => {
307                Some(data.value)
308            },
309            _ => None
310        }
311    }
312
313    fn get_i32(&self, point: &str) -> Option<i32> {
314        for data_tmp in self.data.iter() {
315            if let HDataTypes::HuaweiI32(data) = data_tmp {
316                if data.name.contains(point) && (data.name.len() == point.len()) {
317                    return Some(data.value);
318                }
319            }
320        }
321        None
322    }
323
324    fn get_i32_by_index(&self, idx: usize) -> Option<i32> {
325        match self.data[idx] {
326            HDataTypes::HuaweiI32(data) => {
327                Some(data.value)
328            },
329            _ => None
330        }
331    }
332
333    fn print(&self) {
334        println!("Model {}:", self.model_number);
335        for data in self.data.iter() {
336            match data {
337                HDataTypes::HuaweiI16(data) => println!("{}: {}", data.name, data.value),
338                HDataTypes::HuaweiI32(data) => println!("{}: {}", data.name, data.value),
339                HDataTypes::HuaweiU16(data) => println!("{}: {}", data.name, data.value),
340                HDataTypes::HuaweiU32(data) => println!("{}: {}", data.name, data.value),
341                HDataTypes::HuaweiString(data) => println!("{}: {}", data.name, data.value.clone()),
342            }
343        }
344        println!(" ");
345    }
346}
347
348//pub fn srt_to_vec_u8(src: &str, mut dst: &mut [u8]){
349//    dst.write_all(src.as_bytes()).unwrap();
350//}
351
352impl From<HModel> for Vec<u16> {
353    fn from(from: HModel) -> Self {
354        let mut registers: Vec<u16> = Vec::new();
355
356        for data in from.data.iter() {
357            match data {
358                HDataTypes::HuaweiU16(data) => registers.extend(u16::encode(data.value)),
359                HDataTypes::HuaweiU32(data) => registers.extend(u32::encode(data.value)),
360                HDataTypes::HuaweiI16(data) => registers.extend(i16::encode(data.value)),
361                HDataTypes::HuaweiI32(data) => registers.extend(i32::encode(data.value)),
362                HDataTypes::HuaweiString(data) => registers.extend(Point::<String>::encode(data.clone())),
363            }
364        }
365        registers
366    }
367}
368
369impl From<(Vec<u16>, u16, u16, &HModel)> for HModel {
370    fn from(from: (Vec<u16>, u16, u16, &HModel)) -> Self {
371        let mut model1 = from.3.clone();
372        let mut offset = from.1;
373        let mut qtd = from.2;
374
375        while qtd > 0 {
376            for data in model1.data.iter_mut() {
377                match data {
378                    HDataTypes::HuaweiString(data) => {
379                        if offset == data.offset {
380                            let slice = from.0[data.offset as usize..(data.offset + data.length) as usize].to_vec();
381                            data.value = Point::<String>::decode(slice).value;
382                            offset += data.length;
383                            qtd -= data.length;
384                        }
385                    },
386                    HDataTypes::HuaweiU16(data) => {
387                        if offset == data.offset {
388                            let slice = from.0[data.offset as usize..(data.offset + data.length) as usize].to_vec();
389                            data.value = u16::decode(slice);
390                            offset += data.length;
391                            qtd -= data.length;
392                        }
393                    },
394                    HDataTypes::HuaweiU32(data) => {
395                        if offset == data.offset {
396                            let slice = from.0[data.offset as usize..(data.offset + data.length) as usize].to_vec();
397                            data.value = u32::decode(slice);
398                            offset += data.length;
399                            qtd -= data.length;
400                        }
401                    },
402                    HDataTypes::HuaweiI16(data) => {
403                        if offset == data.offset {
404                            let slice = from.0[data.offset as usize..(data.offset + data.length) as usize].to_vec();
405                            data.value = i16::decode(slice);
406                            offset += data.length;
407                            qtd -= data.length;
408                        }
409                    },
410                    HDataTypes::HuaweiI32(data) => {
411                        if offset == data.offset {
412                            let slice = from.0[data.offset as usize..(data.offset + data.length) as usize].to_vec();
413                            data.value = i32::decode(slice);
414                            offset += data.length;
415                            qtd -= data.length;
416                        }
417                    },
418                }
419            }
420        }
421        model1
422    }
423}
huawei_models/models/mod.rs

huawei_models/models/
mod.rs
