Printing attributes

src/bootloader/attribute.rs

@@ -1,12 +1,69 @@
+use super::codes::*;
+use crate::errors::TockloaderError;
+use std::str;
+
 /// TODO: What exactly is an attribute?
+#[derive(Debug)]
 pub struct Attribute {
  pub key: String,
  pub value: String,
 }
 
 impl Attribute {
  /// Intrepret raw bytes, according to the Tock Format (TODO: Source??)
- pub fn parse_raw(bytes: Vec<u8>) -> Attribute {
- todo!()
+ pub fn parse_raw(bytes: Vec<u8>) -> Result<Attribute, TockloaderError> {
+ // First 2 bytes should be:
+ // <ESCAPE CHAR> <RESPONSE_GET_ATTRIBUTE>
+
+ if bytes[0] != ESCAPE_CHAR {
+ return Err(TockloaderError::MalformedResponse(format!(
+ "Expected attribute to start with ESCAPE_CHAR({}), but got {}",
+ ESCAPE_CHAR, bytes[0]
+ )));
+ }
+
+ if bytes[1] != RESPONSE_GET_ATTRIBUTE {
+ return Err(TockloaderError::MalformedResponse(format!(
+ "Expected attribute to have second byte RESPONSE_GET_ATTRIBUTE({}), but got {}",
+ RESPONSE_GET_ATTRIBUTE, bytes[1]
+ )));
+ }
+
+ // The next 8 bytes will be the name of the attribute (key) with
+ // null bytes as padding
+
+ let key_bytes: Vec<u8> = bytes[2..10]
+ .iter()
+ .copied()
+ .filter(|byte| *byte != 0)
+ .collect();
+ let key = str::from_utf8(&key_bytes)
+ .map_err(|_| {
+ TockloaderError::MalformedResponse(format!(
+ "Failed to parse UTF-8 from key: {:?}",
+ key_bytes
+ ))
+ })?
+ .to_string();
+
+ // 9-th byte is the length of the value (without padding).
+ let len = bytes[10];
+ // 10th+ bytes is the value
+ let val_bytes: Vec<u8> = bytes[11..(11 + len as usize)]
+ .iter()
+ .copied()
+ .filter(|byte| *byte != 0)
+ .collect();
+
+ let value = str::from_utf8(&val_bytes)
+ .map_err(|_| {
+ TockloaderError::MalformedResponse(format!(
+ "Failed to parse UTF-8 from value: {:?}",
+ val_bytes
+ ))
+ })?
+ .to_string();
+
+ Ok(Attribute { key, value })
  }
 }

src/errors.rs

@@ -10,6 +10,9 @@ pub enum TockloaderError {
  IOError(std::io::Error),
  JoinError(JoinError),
  StreamClosed,
+ Timeout,
+ BootloaderNotOpen,
+ MalformedResponse(String),
 }
 
 #[derive(Debug)]
@@ -38,6 +41,15 @@ impl fmt::Display for TockloaderError {
  TockloaderError::StreamClosed => {
  f.write_str("The serial stream unexpectedly closed.")
  },
+ TockloaderError::Timeout => {
+ f.write_str("The operation timed out. Check if the board is still connected.")
+ },
+ TockloaderError::BootloaderNotOpen => {
+ f.write_str("The bootloader wouldn't respond. Try again.")
+ },
+ TockloaderError::MalformedResponse(explanation) => {
+ f.write_str(format!("Received corrupted or unexpected response. {}", *explanation).as_str())
+ },
  }
  }
 }

src/interfaces/jlink/bootloader_interface.rs

@@ -19,7 +19,7 @@ impl BootloaderInterface for JLinkInterface {
  todo!()
  }
 
- async fn get_attribute(&mut self) -> Result<Attribute, TockloaderError> {
+ async fn get_attribute(&mut self, _index: u8) -> Result<Attribute, TockloaderError> {
  todo!()
  }
 }

src/interfaces/openocd/bootloader_interface.rs

@@ -19,7 +19,7 @@ impl BootloaderInterface for OpenOCDInterface {
  todo!()
  }
 
- async fn get_attribute(&mut self) -> Result<Attribute, TockloaderError> {
+ async fn get_attribute(&mut self, _index: u8) -> Result<Attribute, TockloaderError> {
  todo!()
  }
 }

src/interfaces/serial/bootloader_interface.rs

@@ -1,15 +1,13 @@
 use super::binary_codec::BinaryCodec;
 use crate::{
- bootloader::{
- attribute::Attribute,
- codes::{ESCAPE_CHAR, RESPONSE_PONG},
- },
+ bootloader::{attribute::Attribute, codes::*},
  errors::TockloaderError,
  interfaces::traits::BootloaderInterface,
  interfaces::SerialInterface,
+ timeout,
 };
 use async_trait::async_trait;
-use futures::{SinkExt, StreamExt};
+use futures::{SinkExt, StreamExt, TryFutureExt};
 use std::time::Duration;
 use tokio_serial::SerialPort;
 use tokio_util::codec::Decoder;
@@ -99,9 +97,7 @@ impl BootloaderInterface for SerialInterface {
 
  channel.send([ESCAPE_CHAR, 0x1]).await?;
 
- if let Ok(response) =
- tokio::time::timeout(Duration::from_millis(1000), channel.next()).await
- {
+ if let Ok(response) = timeout!(channel.next()).await {
  if let Some(decoder_result) = response {
  let response = decoder_result?;
  if response == [ESCAPE_CHAR, RESPONSE_PONG] {
@@ -117,10 +113,25 @@ impl BootloaderInterface for SerialInterface {
  }
 
  async fn sync(&mut self) -> Result<(), TockloaderError> {
- todo!()
+ let mut channel = BinaryCodec.framed(self.stream.as_mut().unwrap());
+
+ channel.send([0x00, ESCAPE_CHAR, COMMAND_RESET]).await?;
+ Ok(())
  }
 
- async fn get_attribute(&mut self) -> Result<Attribute, TockloaderError> {
- todo!()
+ async fn get_attribute(&mut self, index: u8) -> Result<Attribute, TockloaderError> {
+ self.sync().await?;
+
+ let mut channel = BinaryCodec.framed(self.stream.as_mut().unwrap());
+
+ channel
+ .send([index, ESCAPE_CHAR, COMMAND_GET_ATTRIBUTE])
+ .await?;
+ if let Some(decoder_result) = timeout!(channel.next()).await? {
+ return Attribute::parse_raw(decoder_result?);
+ }
+
+ // TODO: Is this the right error to give?
+ Err(TockloaderError::BootloaderNotOpen)
  }
 }

src/interfaces/traits.rs

@@ -13,6 +13,35 @@ pub trait VirtualTerminal {
  async fn run_terminal(&mut self) -> Result<(), TockloaderError>;
 }
 
+/// This is a short-hand for tokio::time::timeout with a constant, pre-defined, timeout.
+/// The macro also maps the [Elapsed](tokio::time::error::Elapsed) error to [Timeout](TockloaderError::Timeout).
+/// Used mostly to timeout reading data from a board.
+///
+/// ## Expansion
+/// ```
+/// timeout!(channel.read())
+/// ```
+/// expands to
+/// ```
+/// tokio::time::timeout(Duration::from_millis(1000), channel.read()).map_err(|_| TockloaderError::Timeout)
+/// ```
+///
+/// ## Example
+/// ```
+/// async fn read_data() -> Option(Vec<u8>);
+/// // ...
+/// if let Some(data) = timeout!(read_data()).await? {
+/// println!("{}", data);
+/// }
+/// ```
+#[macro_export]
+macro_rules! timeout {
+ ($operation:expr) => {
+ tokio::time::timeout(Duration::from_millis(1000), $operation)
+ .map_err(|_| TockloaderError::Timeout)
+ };
+}
+
 #[async_trait]
 #[enum_dispatch]
 pub trait BootloaderInterface {
@@ -44,5 +73,5 @@ pub trait BootloaderInterface {
  async fn sync(&mut self) -> Result<(), TockloaderError>;
 
  /// TODO! Description here, what exactly is an attribute?
- async fn get_attribute(&mut self) -> Result<Attribute, TockloaderError>;
+ async fn get_attribute(&mut self, index: u8) -> Result<Attribute, TockloaderError>;
 }

src/main.rs

@@ -2,6 +2,8 @@ mod bootloader;
 mod cli;
 mod errors;
 mod interfaces;
+use std::io::{stdin, Read};
+
 use cli::make_cli;
 use errors::TockloaderError;
 use interfaces::{build_interface, traits::*};
@@ -32,7 +34,18 @@ async fn run() -> Result<(), TockloaderError> {
  Some(("info", sub_matches)) => {
  let mut interface = build_interface(sub_matches)?;
  interface.open()?;
- dbg!(interface.enter_bootloader().await?);
+ if !interface.enter_bootloader().await? {
+ println!("Couldn't enter bootloader automatically. Please try entering it manually and press any key...");
+ // Read a single byte and discard
+ let _ = stdin().read(&mut [0u8]).unwrap();
+ if !interface.bootloader_open().await {
+ return Err(TockloaderError::BootloaderNotOpen);
+ }
+ }
+ for i in 0..16 {
+ let attribute = interface.get_attribute(i).await?;
+ println!("{}: {} = {:?}", i, attribute.key, attribute.value);
+ }
  }
  // If only the "--debug" flag is set, then this branch is executed
  // Or, more likely at this stage, a subcommand hasn't been implemented yet.