simp_protocol/
sbt_client.rs1#![allow(dead_code)]
2use std::time::Duration;
3
4use crate::uart::{receive_data_in_sequence, send_data_in_sequence, Uart};
5
6#[derive(Debug, PartialEq)]
7pub struct SbtResponse {
8 pub response_code: u8,
9 pub args: Vec<Vec<u8>>,
10}
11
12impl SbtResponse {
13 pub fn new(response_code: u8, args: Vec<Vec<u8>>) -> Self {
14 SbtResponse {
15 response_code,
16 args,
17 }
18 }
19}
20
21pub struct SbtClient {
22 uart: Box<dyn Uart>,
23 timeout: Duration,
24}
25
26impl SbtClient {
27 pub fn new(uart: Box<dyn Uart>, timeout: Duration) -> Self {
28 SbtClient { uart, timeout }
29 }
30
31 pub fn send_request(
32 &mut self,
33 command: u8,
34 args: Vec<Vec<u8>>,
35 ) -> Result<SbtResponse, &'static str> {
36 let mut request = vec![command];
37 for arg in args {
38 request.push(arg.len() as u8);
39 request.extend(arg);
40 }
41 match send_data_in_sequence(&mut *self.uart, &request, self.timeout, true) {
42 Ok(_) => self.receive_response(),
43 Err(err) => Err(err),
44 }
45 }
46
47 fn receive_response(&mut self) -> Result<SbtResponse, &'static str> {
48 match receive_data_in_sequence(&mut *self.uart, self.timeout, true) {
49 Ok(response) => {
50 let response_code = response[0];
51 let arg_count = response[1];
52
53 let mut args: Vec<Vec<u8>> = Vec::new();
54
55 let mut response_index = 2;
56 for _ in 0..arg_count {
57 let arg_len = response[response_index] as usize;
58 response_index += 1;
59 let arg = response[response_index..response_index + arg_len].to_vec();
60 response_index += arg_len;
61 args.push(arg);
62 }
63 Ok(SbtResponse::new(response_code, args))
64 }
65 Err(err) => Err(err),
66 }
67 }
68}