1use parser::ParseError;
2use serde::{Deserialize, Serialize};
3
4pub mod parser;
5
6#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7pub enum Range {
8 Range0,
9 Range1,
10 Range2,
11 Range3,
12 Range4,
13 Range5,
14 Range6,
15}
16
17impl Range {
18 pub fn parse(c: u8) -> Result<Range, ParseError> {
19 match c {
20 0x30 => Ok(Self::Range0),
21 0x31 => Ok(Self::Range1),
22 0x32 => Ok(Self::Range2),
23 0x33 => Ok(Self::Range3),
24 0x34 => Ok(Self::Range4),
25 0x35 => Ok(Self::Range5),
26 0x36 => Ok(Self::Range6),
27 _ => Err(ParseError::InvalidRange(c)),
28 }
29 }
30}
31
32#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
33pub enum Function {
34 Voltage,
35 MicroAmpere,
36 MilliAmpere,
37 AutoAmpere,
38 ManualAmpere,
39 Ohm,
40 Continuity,
41 Diode,
42 Frequency,
43 Capacitor,
44 Temperature,
45 Adp0,
46 Adp1,
47 Adp2,
48 Adp3,
49}
50
51impl Function {
52 pub fn parse(c: u8) -> Result<Function, ParseError> {
53 match c {
54 0x3b => Ok(Self::Voltage),
55 0x3d => Ok(Self::MicroAmpere),
56 0x3f => Ok(Self::MilliAmpere),
57 0x30 => Ok(Self::AutoAmpere),
58 0x39 => Ok(Self::ManualAmpere),
59 0x33 => Ok(Self::Ohm),
60 0x35 => Ok(Self::Continuity),
61 0x31 => Ok(Self::Diode),
62 0x32 => Ok(Self::Frequency),
63 0x36 => Ok(Self::Capacitor),
64 0x34 => Ok(Self::Temperature),
65 0x3e => Ok(Self::Adp0),
66 0x3c => Ok(Self::Adp1),
67 0x38 => Ok(Self::Adp2),
68 0x3a => Ok(Self::Adp3),
69 _ => Err(ParseError::InvalidFunction(c)),
70 }
71 }
72}
73
74#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
75pub enum TemperatureUnit {
76 Celsius,
77 Fahrenheit,
78}
79
80#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
81pub struct Sign(bool);
82
83pub const SIGN_PLUS: Sign = Sign(false);
84pub const SIGN_MINUS: Sign = Sign(true);
85
86impl Sign {
87 pub fn is_minus(self) -> bool {
88 self.0
89 }
90
91 pub fn is_not_minus(self) -> bool {
92 !self.is_minus()
93 }
94}
95
96impl Into<i8> for Sign {
97 fn into(self) -> i8 {
98 if self.is_minus() { -1 } else { 1 }
99 }
100}
101
102impl Into<i16> for Sign {
103 fn into(self) -> i16 {
104 if self.is_minus() { -1 } else { 1 }
105 }
106}
107
108impl Into<i32> for Sign {
109 fn into(self) -> i32 {
110 if self.is_minus() { -1 } else { 1 }
111 }
112}
113
114impl Into<i64> for Sign {
115 fn into(self) -> i64 {
116 if self.is_minus() { -1 } else { 1 }
117 }
118}
119
120impl Into<i128> for Sign {
121 fn into(self) -> i128 {
122 if self.is_minus() { -1 } else { 1 }
123 }
124}
125
126#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
127pub struct Status {
128 pub temperature_unit: TemperatureUnit,
129 pub sign: Sign,
130 pub is_battery_depleted: bool,
131 pub is_overflow: bool,
132}
133
134impl Status {
135 pub fn parse(c: u8) -> Status {
136 Status {
137 temperature_unit: if (c & 0x08) != 0 { TemperatureUnit::Celsius } else { TemperatureUnit::Fahrenheit },
138 sign: Sign((c & 0x04) != 0),
139 is_battery_depleted: (c & 0x02) != 0,
140 is_overflow: (c & 0x01) != 0,
141 }
142 }
143}
144
145#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
146pub struct Option2 {
147 pub is_dc: bool,
148 pub is_ac: bool,
149 pub is_auto: bool,
150}
151
152impl Option2 {
153 pub fn parse(c: u8) -> Option2 {
154 Option2 {
155 is_dc: (c & 0x08) != 0,
156 is_ac: (c & 0x04) != 0,
157 is_auto: (c & 0x02) != 0,
158 }
159 }
160}
161
162#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
163pub enum PrefixUnit {
164 Mega,
165 Kilo,
166 None,
167 Millis,
168 Micro,
169 Nano,
170}
171
172#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
173pub enum BaseUnit {
174 Ampere,
175 Volt,
176 Ohm,
177 Hearts,
178 Farad,
179}
180
181#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
182pub struct ValueUnit {
183 pub prefix_unit: PrefixUnit,
184 pub base_unit: BaseUnit,
185}
186
187impl ValueUnit {
188 pub fn new(prefix_unit: PrefixUnit, base_unit: BaseUnit) -> Self {
189 Self {
190 prefix_unit, base_unit
191 }
192 }
193}
194
195#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
196pub struct Digits {
197 digits: [u8; 4],
198}
199
200#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
201pub enum DigitRadix {
202 Zero,
203 Minus1,
204 Minus2,
205 Minus3,
206}
207
208impl Digits {
209 fn parse_digit(c: u8) -> Result<u8, ParseError> {
210 if 0x30 <= c && c <= 0x39 {
211 Ok(c - 0x30)
212 } else {
213 Err(ParseError::InvalidDigit(c))
214 }
215 }
216
217 pub fn parse(input: &[u8], loc: usize) -> Result<Digits, ParseError> {
218 let digits: [u8; 4] = [
219 Self::parse_digit(input[loc])?,
220 Self::parse_digit(input[loc + 1])?,
221 Self::parse_digit(input[loc + 2])?,
222 Self::parse_digit(input[loc + 3])?,
223 ];
224 Ok(Digits { digits })
225 }
226
227 pub fn to_value(&self, radix: DigitRadix) -> String {
228 match radix {
229 DigitRadix::Zero => format!(
230 "{}",
231 self.digits[0] as usize * 1000 + self.digits[1] as usize * 100 + self.digits[2] as usize * 10 + self.digits[3] as usize
232 ),
233 DigitRadix::Minus1 => format!(
234 "{}.{}",
235 self.digits[0] as usize * 100 + self.digits[1] as usize * 10 + self.digits[2] as usize, self.digits[3]
236 ),
237 DigitRadix::Minus2 => format!(
238 "{}.{}{}",
239 self.digits[0] as usize * 10 + self.digits[1] as usize, self.digits[2], self.digits[3]
240 ),
241 DigitRadix::Minus3 => format!("{}.{}{}{}", self.digits[0], self.digits[1], self.digits[2], self.digits[3]),
242 }
243 }
244}
245
246const OUTPUT_LENGTH: usize = 9;
247
248#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
249pub struct Output {
250 pub range: Range,
251 pub digits: Digits,
252 pub function: Function,
253 pub status: Status,
254 pub option2: Option2,
255}
256
257#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
258pub struct OutputValue {
259 pub digits: String,
260 pub value_unit: ValueUnit,
261}
262
263impl Output {
264 pub fn parse(input: &[u8]) -> Result<Output, ParseError> {
265 if input.len() == OUTPUT_LENGTH {
266 let range: Range = Range::parse(input[0])?;
267 let function: Function = Function::parse(input[5])?;
268 let status: Status = Status::parse(input[6]);
269 let option2: Option2 = Option2::parse(input[8]);
271
272 Ok(
273 Output { range, digits: Digits::parse(input, 1)?, function, status, option2 }
274 )
275 } else {
276 Err(ParseError::LengthError { len: input.len() })
277 }
278 }
279
280 pub fn get_value(&self) -> Option<OutputValue> {
281 match self.range {
282 Range::Range0 => match self.function {
283 Function::Voltage => {
284 let digits = self.digits.to_value(DigitRadix::Minus3);
285 let value_unit = ValueUnit::new(PrefixUnit::None, BaseUnit::Volt);
286 Some(OutputValue { digits, value_unit })
287 }
288 Function::MicroAmpere => {
289 let digits = self.digits.to_value(DigitRadix::Minus1);
290 let value_unit = ValueUnit::new(PrefixUnit::Micro, BaseUnit::Ampere);
291 Some(OutputValue { digits, value_unit })
292 }
293 Function::MilliAmpere => {
294 let digits = self.digits.to_value(DigitRadix::Minus2);
295 let value_unit = ValueUnit::new(PrefixUnit::Millis, BaseUnit::Ampere);
296 Some(OutputValue { digits, value_unit })
297 }
298 Function::AutoAmpere => {
299 let digits = self.digits.to_value(DigitRadix::Minus3);
300 let value_unit = ValueUnit::new(PrefixUnit::None, BaseUnit::Ampere);
301 Some(OutputValue { digits, value_unit })
302 }
303 Function::ManualAmpere => {
304 let digits = self.digits.to_value(DigitRadix::Minus3);
305 let value_unit = ValueUnit::new(PrefixUnit::None, BaseUnit::Ampere);
306 Some(OutputValue { digits, value_unit })
307 }
308 Function::Ohm => {
309 let digits = self.digits.to_value(DigitRadix::Minus1);
310 let value_unit = ValueUnit::new(PrefixUnit::None, BaseUnit::Ohm);
311 Some(OutputValue { digits, value_unit })
312 }
313 Function::Frequency => {
314 let digits = self.digits.to_value(DigitRadix::Minus3);
315 let value_unit = ValueUnit::new(PrefixUnit::Kilo, BaseUnit::Hearts);
316 Some(OutputValue { digits, value_unit })
317 }
318 Function::Capacitor => {
319 let digits = self.digits.to_value(DigitRadix::Minus3);
320 let value_unit = ValueUnit::new(PrefixUnit::Nano, BaseUnit::Farad);
321 Some(OutputValue { digits, value_unit })
322 }
323 _ => None,
324 }
325 Range::Range1 => match self.function {
326 Function::Voltage => {
327 let digits = self.digits.to_value(DigitRadix::Minus2);
328 let value_unit = ValueUnit::new(PrefixUnit::None, BaseUnit::Volt);
329 Some(OutputValue { digits, value_unit })
330 }
331 Function::MicroAmpere => {
332 let digits = self.digits.to_value(DigitRadix::Zero);
333 let value_unit = ValueUnit::new(PrefixUnit::Micro, BaseUnit::Ampere);
334 Some(OutputValue { digits, value_unit })
335 }
336 Function::MilliAmpere => {
337 let digits = self.digits.to_value(DigitRadix::Minus1);
338 let value_unit = ValueUnit::new(PrefixUnit::Millis, BaseUnit::Ampere);
339 Some(OutputValue { digits, value_unit })
340 }
341 Function::AutoAmpere => {
342 let digits = self.digits.to_value(DigitRadix::Minus2);
343 let value_unit = ValueUnit::new(PrefixUnit::None, BaseUnit::Ampere);
344 Some(OutputValue { digits, value_unit })
345 }
346 Function::Ohm => {
347 let digits = self.digits.to_value(DigitRadix::Minus3);
348 let value_unit = ValueUnit::new(PrefixUnit::Kilo, BaseUnit::Ohm);
349 Some(OutputValue { digits, value_unit })
350 }
351 Function::Frequency => {
352 let digits = self.digits.to_value(DigitRadix::Minus2);
353 let value_unit = ValueUnit::new(PrefixUnit::Kilo, BaseUnit::Hearts);
354 Some(OutputValue { digits, value_unit })
355 }
356 Function::Capacitor => {
357 let digits = self.digits.to_value(DigitRadix::Minus2);
358 let value_unit = ValueUnit::new(PrefixUnit::Nano, BaseUnit::Farad);
359 Some(OutputValue { digits, value_unit })
360 }
361 _ => None,
362 }
363 Range::Range2 => match self.function {
364 Function::Voltage => {
365 let digits = self.digits.to_value(DigitRadix::Minus1);
366 let value_unit = ValueUnit::new(PrefixUnit::None, BaseUnit::Volt);
367 Some(OutputValue { digits, value_unit })
368 }
369 Function::Ohm => {
370 let digits = self.digits.to_value(DigitRadix::Minus2);
371 let value_unit = ValueUnit::new(PrefixUnit::Kilo, BaseUnit::Ohm);
372 Some(OutputValue { digits, value_unit })
373 }
374 Function::Frequency => {
375 let digits = self.digits.to_value(DigitRadix::Minus1);
376 let value_unit = ValueUnit::new(PrefixUnit::Kilo, BaseUnit::Hearts);
377 Some(OutputValue { digits, value_unit })
378 }
379 Function::Capacitor => {
380 let digits = self.digits.to_value(DigitRadix::Minus1);
381 let value_unit = ValueUnit::new(PrefixUnit::Nano, BaseUnit::Farad);
382 Some(OutputValue { digits, value_unit })
383 }
384 _ => None,
385 }
386 Range::Range3 => match self.function {
387 Function::Voltage => {
388 let digits = self.digits.to_value(DigitRadix::Zero);
389 let value_unit = ValueUnit::new(PrefixUnit::None, BaseUnit::Volt);
390 Some(OutputValue { digits, value_unit })
391 }
392 Function::Ohm => {
393 let digits = self.digits.to_value(DigitRadix::Minus1);
394 let value_unit = ValueUnit::new(PrefixUnit::Kilo, BaseUnit::Ohm);
395 Some(OutputValue { digits, value_unit })
396 }
397 Function::Frequency => {
398 let digits = self.digits.to_value(DigitRadix::Minus3);
399 let value_unit = ValueUnit::new(PrefixUnit::Mega, BaseUnit::Hearts);
400 Some(OutputValue { digits, value_unit })
401 }
402 Function::Capacitor => {
403 let digits = self.digits.to_value(DigitRadix::Minus3);
404 let value_unit = ValueUnit::new(PrefixUnit::Micro, BaseUnit::Farad);
405 Some(OutputValue { digits, value_unit })
406 }
407 _ => None,
408 }
409 Range::Range4 => match self.function {
410 Function::Voltage => {
411 let digits = self.digits.to_value(DigitRadix::Minus1);
412 let value_unit = ValueUnit::new(PrefixUnit::Millis, BaseUnit::Volt);
413 Some(OutputValue { digits, value_unit })
414 }
415 Function::Ohm => {
416 let digits = self.digits.to_value(DigitRadix::Minus3);
417 let value_unit = ValueUnit::new(PrefixUnit::Mega, BaseUnit::Ohm);
418 Some(OutputValue { digits, value_unit })
419 }
420 Function::Frequency => {
421 let digits = self.digits.to_value(DigitRadix::Minus2);
422 let value_unit = ValueUnit::new(PrefixUnit::Mega, BaseUnit::Hearts);
423 Some(OutputValue { digits, value_unit })
424 }
425 Function::Capacitor => {
426 let digits = self.digits.to_value(DigitRadix::Minus2);
427 let value_unit = ValueUnit::new(PrefixUnit::Micro, BaseUnit::Farad);
428 Some(OutputValue { digits, value_unit })
429 }
430 _ => None,
431 }
432 Range::Range5 => match self.function {
433 Function::Ohm => {
434 let digits = self.digits.to_value(DigitRadix::Minus2);
435 let value_unit = ValueUnit::new(PrefixUnit::Mega, BaseUnit::Ohm);
436 Some(OutputValue { digits, value_unit })
437 }
438 Function::Capacitor => {
439 let digits = self.digits.to_value(DigitRadix::Minus2);
440 let value_unit = ValueUnit::new(PrefixUnit::Micro, BaseUnit::Farad);
441 Some(OutputValue { digits, value_unit })
442 }
443 _ => None,
444 }
445 Range::Range6 => match self.function {
446 Function::Capacitor => {
447 let digits = self.digits.to_value(DigitRadix::Minus3);
448 let value_unit = ValueUnit::new(PrefixUnit::Millis, BaseUnit::Farad);
449 Some(OutputValue { digits, value_unit })
450 }
451 _ => None,
452 }
453 }
454 }
455}
456
457#[cfg(test)]
458mod tests {
459 use parser::Parser;
460
461 use super::*;
462
463 fn to_u8(s: &str) -> Vec<u8> {
464 s.chars().map(|c| c as u8).collect()
465 }
466
467 #[test]
468 fn voltage() {
469 let inp: Vec<u8> = to_u8("00000;<0:\r\n");
470 let results: Vec<Result<Output, ParseError>> = Parser::new().parse(&inp);
471 assert_eq!(results.len(), 1);
472 let out: &Output = results[0].as_ref().unwrap();
473 assert_eq!(out.status, Status { temperature_unit: TemperatureUnit::Celsius, sign: SIGN_MINUS, is_battery_depleted: false, is_overflow: false });
474 assert_eq!(out.function, Function::Voltage);
475 assert_eq!(out.range, Range::Range0);
476 assert_eq!(out.option2, Option2 { is_dc: true, is_ac: false, is_auto: true });
477 assert_eq!(out.get_value(), Some(OutputValue { digits: "0.000".to_owned(), value_unit: ValueUnit { prefix_unit: PrefixUnit::None, base_unit: BaseUnit::Volt}}));
478
479 let inp: Vec<u8> = to_u8("00002;80:\r\n");
480 let results: Vec<Result<Output, ParseError>> = Parser::new().parse(&inp);
481 assert_eq!(results.len(), 1);
482 let out: &Output = results[0].as_ref().unwrap();
483 assert_eq!(out.status, Status { temperature_unit: TemperatureUnit::Celsius, sign: SIGN_PLUS, is_battery_depleted: false, is_overflow: false });
484 assert_eq!(out.function, Function::Voltage);
485 assert_eq!(out.range, Range::Range0);
486 assert_eq!(out.option2, Option2 { is_dc: true, is_ac: false, is_auto: true });
487 assert_eq!(out.get_value(), Some(OutputValue { digits: "0.002".to_owned(), value_unit: ValueUnit { prefix_unit: PrefixUnit::None, base_unit: BaseUnit::Volt}}));
488
489 let inp: Vec<u8> = to_u8("20989;806\r\n");
490 let results: Vec<Result<Output, ParseError>> = Parser::new().parse(&inp);
491 assert_eq!(results.len(), 1);
492 let out: &Output = results[0].as_ref().unwrap();
493 assert_eq!(out.status, Status { temperature_unit: TemperatureUnit::Celsius, sign: SIGN_PLUS, is_battery_depleted: false, is_overflow: false });
494 assert_eq!(out.function, Function::Voltage);
495 assert_eq!(out.range, Range::Range2);
496 assert_eq!(out.option2, Option2 { is_dc: false, is_ac: true, is_auto: true });
497 assert_eq!(out.get_value(), Some(OutputValue { digits: "98.9".to_owned(), value_unit: ValueUnit { prefix_unit: PrefixUnit::None, base_unit: BaseUnit::Volt}}));
498 }
499
500 #[test]
501 fn ohm() {
502 let inp: Vec<u8> = to_u8("560003902\r\n");
503 let results: Vec<Result<Output, ParseError>> = Parser::new().parse(&inp);
504 assert_eq!(results.len(), 1);
505 let out: &Output = results[0].as_ref().unwrap();
506 assert_eq!(out.status, Status { temperature_unit: TemperatureUnit::Celsius, sign: SIGN_PLUS, is_battery_depleted: false, is_overflow: true });
507 assert_eq!(out.function, Function::Ohm);
508 assert_eq!(out.range, Range::Range5);
509 assert_eq!(out.option2, Option2 { is_dc: false, is_ac: false, is_auto: true });
510 assert_eq!(out.get_value(), Some(OutputValue { digits: "60.00".to_owned(), value_unit: ValueUnit { prefix_unit: PrefixUnit::Mega, base_unit: BaseUnit::Ohm}}));
511
512 let inp: Vec<u8> = to_u8("109853802\r\n");
513 let results: Vec<Result<Output, ParseError>> = Parser::new().parse(&inp);
514 assert_eq!(results.len(), 1);
515 let out: &Output = results[0].as_ref().unwrap();
516 assert_eq!(out.status, Status { temperature_unit: TemperatureUnit::Celsius, sign: SIGN_PLUS, is_battery_depleted: false, is_overflow: false });
517 assert_eq!(out.function, Function::Ohm);
518 assert_eq!(out.range, Range::Range1);
519 assert_eq!(out.option2, Option2 { is_dc: false, is_ac: false, is_auto: true });
520 assert_eq!(out.get_value(), Some(OutputValue { digits: "0.985".to_owned(), value_unit: ValueUnit { prefix_unit: PrefixUnit::Kilo, base_unit: BaseUnit::Ohm}}));
521
522 let inp: Vec<u8> = to_u8("000003802\r\n");
523 let results: Vec<Result<Output, ParseError>> = Parser::new().parse(&inp);
524 assert_eq!(results.len(), 1);
525 let out: &Output = results[0].as_ref().unwrap();
526 assert_eq!(out.status, Status { temperature_unit: TemperatureUnit::Celsius, sign: SIGN_PLUS, is_battery_depleted: false, is_overflow: false });
527 assert_eq!(out.function, Function::Ohm);
528 assert_eq!(out.range, Range::Range0);
529 assert_eq!(out.option2, Option2 { is_dc: false, is_ac: false, is_auto: true });
530 assert_eq!(out.get_value(), Some(OutputValue { digits: "0.0".to_owned(), value_unit: ValueUnit { prefix_unit: PrefixUnit::None, base_unit: BaseUnit::Ohm}}));
531 }
532
533 #[test]
534 fn capacitance() {
535 let inp: Vec<u8> = to_u8("660006902\r\n");
536 let results: Vec<Result<Output, ParseError>> = Parser::new().parse(&inp);
537 assert_eq!(results.len(), 1);
538 let out: &Output = results[0].as_ref().unwrap();
539 assert_eq!(out.status, Status { temperature_unit: TemperatureUnit::Celsius, sign: SIGN_PLUS, is_battery_depleted: false, is_overflow: true });
540 assert_eq!(out.function, Function::Capacitor);
541 assert_eq!(out.range, Range::Range6);
542 assert_eq!(out.option2, Option2 { is_dc: false, is_ac: false, is_auto: true });
543 assert_eq!(out.get_value(), Some(OutputValue { digits: "6.000".to_owned(), value_unit: ValueUnit { prefix_unit: PrefixUnit::Millis, base_unit: BaseUnit::Farad}}));
544
545 let inp: Vec<u8> = to_u8("211656802\r\n");
546 let results: Vec<Result<Output, ParseError>> = Parser::new().parse(&inp);
547 assert_eq!(results.len(), 1);
548 let out: &Output = results[0].as_ref().unwrap();
549 assert_eq!(out.status, Status { temperature_unit: TemperatureUnit::Celsius, sign: SIGN_PLUS, is_battery_depleted: false, is_overflow: false });
550 assert_eq!(out.function, Function::Capacitor);
551 assert_eq!(out.range, Range::Range2);
552 assert_eq!(out.option2, Option2 { is_dc: false, is_ac: false, is_auto: true });
553 assert_eq!(out.get_value(), Some(OutputValue { digits: "116.5".to_owned(), value_unit: ValueUnit { prefix_unit: PrefixUnit::Nano, base_unit: BaseUnit::Farad}}));
554
555 let inp: Vec<u8> = to_u8("000226802\r\n");
556 let results: Vec<Result<Output, ParseError>> = Parser::new().parse(&inp);
557 assert_eq!(results.len(), 1);
558 let out: &Output = results[0].as_ref().unwrap();
559 assert_eq!(out.status, Status { temperature_unit: TemperatureUnit::Celsius, sign: SIGN_PLUS, is_battery_depleted: false, is_overflow: false });
560 assert_eq!(out.function, Function::Capacitor);
561 assert_eq!(out.range, Range::Range0);
562 assert_eq!(out.option2, Option2 { is_dc: false, is_ac: false, is_auto: true });
563 assert_eq!(out.get_value(), Some(OutputValue { digits: "0.022".to_owned(), value_unit: ValueUnit { prefix_unit: PrefixUnit::Nano, base_unit: BaseUnit::Farad}}));
564 }
565
566 #[test]
567 fn frequency() {
568 let inp: Vec<u8> = to_u8("000002802\r\n");
569 let results: Vec<Result<Output, ParseError>> = Parser::new().parse(&inp);
570 assert_eq!(results.len(), 1);
571 let out: &Output = results[0].as_ref().unwrap();
572 assert_eq!(out.status, Status { temperature_unit: TemperatureUnit::Celsius, sign: SIGN_PLUS, is_battery_depleted: false, is_overflow: false });
573 assert_eq!(out.function, Function::Frequency);
574 assert_eq!(out.range, Range::Range0);
575 assert_eq!(out.option2, Option2 { is_dc: false, is_ac: false, is_auto: true });
576 assert_eq!(out.get_value(), Some(OutputValue { digits: "0.000".to_owned(), value_unit: ValueUnit { prefix_unit: PrefixUnit::Kilo, base_unit: BaseUnit::Hearts}}));
577
578 let inp: Vec<u8> = to_u8("210012802\r\n");
579 let results: Vec<Result<Output, ParseError>> = Parser::new().parse(&inp);
580 assert_eq!(results.len(), 1);
581 let out: &Output = results[0].as_ref().unwrap();
582 assert_eq!(out.status, Status { temperature_unit: TemperatureUnit::Celsius, sign: SIGN_PLUS, is_battery_depleted: false, is_overflow: false });
583 assert_eq!(out.function, Function::Frequency);
584 assert_eq!(out.range, Range::Range2);
585 assert_eq!(out.option2, Option2 { is_dc: false, is_ac: false, is_auto: true });
586 assert_eq!(out.get_value(), Some(OutputValue { digits: "100.1".to_owned(), value_unit: ValueUnit { prefix_unit: PrefixUnit::Kilo, base_unit: BaseUnit::Hearts}}));
587 }
588
589 #[test]
590 fn lux() {
591 let inp: Vec<u8> = to_u8("00136>800\r\n");
592 let results: Vec<Result<Output, ParseError>> = Parser::new().parse(&inp);
593 assert_eq!(results.len(), 1);
594 let out: &Output = results[0].as_ref().unwrap();
595 assert_eq!(out.status, Status { temperature_unit: TemperatureUnit::Celsius, sign: SIGN_PLUS, is_battery_depleted: false, is_overflow: false });
596 assert_eq!(out.function, Function::Adp0);
597 assert_eq!(out.range, Range::Range0);
598 assert_eq!(out.option2, Option2 { is_dc: false, is_ac: false, is_auto: false });
599 assert_eq!(&out.digits.to_value(DigitRadix::Zero), "136");
600 assert_eq!(out.get_value(), None);
601 }
602
603 #[test]
604 fn sound_level() {
605 let inp: Vec<u8> = to_u8("00676<800\r\n");
606 let results: Vec<Result<Output, ParseError>> = Parser::new().parse(&inp);
607 assert_eq!(results.len(), 1);
608 let out: &Output = results[0].as_ref().unwrap();
609 assert_eq!(out.status, Status { temperature_unit: TemperatureUnit::Celsius, sign: SIGN_PLUS, is_battery_depleted: false, is_overflow: false });
610 assert_eq!(out.function, Function::Adp1);
611 assert_eq!(out.range, Range::Range0);
612 assert_eq!(out.option2, Option2 { is_dc: false, is_ac: false, is_auto: false });
613 assert_eq!(&out.digits.to_value(DigitRadix::Zero), "676");
614 assert_eq!(out.get_value(), None);
615 }
616
617 #[test]
618 fn temperature() {
619 let inp: Vec<u8> = to_u8("060004900\r\n");
620 let results: Vec<Result<Output, ParseError>> = Parser::new().parse(&inp);
621 assert_eq!(results.len(), 1);
622 let out: &Output = results[0].as_ref().unwrap();
623 assert_eq!(out.status, Status { temperature_unit: TemperatureUnit::Celsius, sign: SIGN_PLUS, is_battery_depleted: false, is_overflow: true });
624 assert_eq!(out.function, Function::Temperature);
625 assert_eq!(out.range, Range::Range0);
626 assert_eq!(out.option2, Option2 { is_dc: false, is_ac: false, is_auto: false });
627 assert_eq!(&out.digits.to_value(DigitRadix::Zero), "6000");
628 assert_eq!(out.get_value(), None);
629
630 let inp: Vec<u8> = to_u8("000304800\r\n");
631 let results: Vec<Result<Output, ParseError>> = Parser::new().parse(&inp);
632 assert_eq!(results.len(), 1);
633 let out: &Output = results[0].as_ref().unwrap();
634 assert_eq!(out.status, Status { temperature_unit: TemperatureUnit::Celsius, sign: SIGN_PLUS, is_battery_depleted: false, is_overflow: false });
635 assert_eq!(out.function, Function::Temperature);
636 assert_eq!(out.range, Range::Range0);
637 assert_eq!(out.option2, Option2 { is_dc: false, is_ac: false, is_auto: false });
638 assert_eq!(&out.digits.to_value(DigitRadix::Zero), "30");
639 assert_eq!(out.get_value(), None);
640 }
641
642 #[test]
643 fn m_ampere() {
644 let inp: Vec<u8> = to_u8("00002?<0:\r\n");
645 let results: Vec<Result<Output, ParseError>> = Parser::new().parse(&inp);
646 assert_eq!(results.len(), 1);
647 let out: &Output = results[0].as_ref().unwrap();
648 assert_eq!(out.status, Status { temperature_unit: TemperatureUnit::Celsius, sign: SIGN_MINUS, is_battery_depleted: false, is_overflow: false });
649 assert_eq!(out.function, Function::MilliAmpere);
650 assert_eq!(out.range, Range::Range0);
651 assert_eq!(out.option2, Option2 { is_dc: true, is_ac: false, is_auto: true });
652 assert_eq!(&out.digits.to_value(DigitRadix::Zero), "2");
653 assert_eq!(out.get_value(), Some(OutputValue { digits: "0.02".to_owned(), value_unit: ValueUnit { prefix_unit: PrefixUnit::Millis, base_unit: BaseUnit::Ampere}}));
654 }
655
656 #[test]
657 fn ampere() {
658 let inp: Vec<u8> = to_u8("000019808\r\n");
659 let results: Vec<Result<Output, ParseError>> = Parser::new().parse(&inp);
660 assert_eq!(results.len(), 1);
661 let out: &Output = results[0].as_ref().unwrap();
662 assert_eq!(out.status, Status { temperature_unit: TemperatureUnit::Celsius, sign: SIGN_PLUS, is_battery_depleted: false, is_overflow: false });
663 assert_eq!(out.function, Function::ManualAmpere);
664 assert_eq!(out.range, Range::Range0);
665 assert_eq!(out.option2, Option2 { is_dc: true, is_ac: false, is_auto: false });
666 assert_eq!(&out.digits.to_value(DigitRadix::Zero), "1");
667 assert_eq!(out.get_value(), Some(OutputValue { digits: "0.001".to_owned(), value_unit: ValueUnit { prefix_unit: PrefixUnit::None, base_unit: BaseUnit::Ampere}}));
668 }
669
670 #[test]
671 fn only_cr() {
672 let inp: Vec<u8> = to_u8("000019808\r000019808\r");
673 let results: Vec<Result<Output, ParseError>> = Parser::new().parse(&inp);
674 assert_eq!(results.len(), 2);
675 let out: &Output = results[0].as_ref().unwrap();
676 assert_eq!(out.status, Status { temperature_unit: TemperatureUnit::Celsius, sign: SIGN_PLUS, is_battery_depleted: false, is_overflow: false });
677 assert_eq!(out.function, Function::ManualAmpere);
678 assert_eq!(out.range, Range::Range0);
679 assert_eq!(out.option2, Option2 { is_dc: true, is_ac: false, is_auto: false });
680 assert_eq!(&out.digits.to_value(DigitRadix::Zero), "1");
681 assert_eq!(out.get_value(), Some(OutputValue { digits: "0.001".to_owned(), value_unit: ValueUnit { prefix_unit: PrefixUnit::None, base_unit: BaseUnit::Ampere}}));
682 assert_eq!(results[0].as_ref(), results[1].as_ref());
683 }
684
685 #[test]
686 fn crlf() {
687 let inp: Vec<u8> = to_u8("000019808\r\n000019808\r\n");
688 let results: Vec<Result<Output, ParseError>> = Parser::new().parse(&inp);
689 assert_eq!(results.len(), 2);
690 let out: &Output = results[0].as_ref().unwrap();
691 assert_eq!(out.status, Status { temperature_unit: TemperatureUnit::Celsius, sign: SIGN_PLUS, is_battery_depleted: false, is_overflow: false });
692 assert_eq!(out.function, Function::ManualAmpere);
693 assert_eq!(out.range, Range::Range0);
694 assert_eq!(out.option2, Option2 { is_dc: true, is_ac: false, is_auto: false });
695 assert_eq!(&out.digits.to_value(DigitRadix::Zero), "1");
696 assert_eq!(out.get_value(), Some(OutputValue { digits: "0.001".to_owned(), value_unit: ValueUnit { prefix_unit: PrefixUnit::None, base_unit: BaseUnit::Ampere}}));
697 assert_eq!(results[0].as_ref(), results[1].as_ref());
698 }
699
700 #[test]
701 fn only_lf() {
702 let inp: Vec<u8> = to_u8("000019808\n000019808\n");
703 let results: Vec<Result<Output, ParseError>> = Parser::new().parse(&inp);
704 assert_eq!(results.len(), 2);
705 let out: &Output = results[0].as_ref().unwrap();
706 assert_eq!(out.status, Status { temperature_unit: TemperatureUnit::Celsius, sign: SIGN_PLUS, is_battery_depleted: false, is_overflow: false });
707 assert_eq!(out.function, Function::ManualAmpere);
708 assert_eq!(out.range, Range::Range0);
709 assert_eq!(out.option2, Option2 { is_dc: true, is_ac: false, is_auto: false });
710 assert_eq!(&out.digits.to_value(DigitRadix::Zero), "1");
711 assert_eq!(out.get_value(), Some(OutputValue { digits: "0.001".to_owned(), value_unit: ValueUnit { prefix_unit: PrefixUnit::None, base_unit: BaseUnit::Ampere}}));
712 assert_eq!(results[0].as_ref(), results[1].as_ref());
713 }
714}