add initial version of the implementation

Author: rursprung

.github/workflows/CI.yml

@@ -22,9 +22,7 @@ jobs:
       - uses: actions-rs/cargo@v1
         with:
           command: build
-      - uses: actions-rs/cargo@v1
-        with:
-          command: test
+      # no tests at the moment as the crate currently targets the stm32f4xx-hal and thus can't run on x86
       - uses: actions-rs/cargo@v1
         with:
           command: fmt

Cargo.toml

@@ -6,3 +6,14 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+cortex-m = { version = "0.7", features = ["critical-section-single-core"]}
+cortex-m-rtic = "1.1.3"
+
+stm32f4xx-hal = { version = "0.13.2", features = ["stm32f401"] }
+
+fugit = "0.3"
+
+defmt = "0.3.2"
+defmt-rtt = "0.4"
+
+heapless = { version = "0.7", features = ["defmt-impl"] }

README.md

@@ -0,0 +1,2 @@
+# Adafruit Bluefruit LE UART Friend Rust Driver
+Currently written directly against the stm32f4xx-hal but hopefully this can be rewritten against the embedded-hal traits.

src/bluefruit_protocol/accelerometer_event.rs

@@ -0,0 +1,29 @@
+use super::{try_f32_from_le_bytes, ProtocolParseError};
+
+/// Represents an accelerometer event from the protocol.
+#[derive(Debug, defmt::Format)]
+pub struct AccelerometerEvent {
+    x: f32,
+    y: f32,
+    z: f32,
+}
+
+impl TryFrom<&[u8]> for AccelerometerEvent {
+    type Error = ProtocolParseError;
+
+    /// Parse the data section of an accelerometer event.
+    ///
+    /// The full command is not validated here, identifying the command as an accelerometer event and CRC validation is the responsibility of the caller!
+    fn try_from(input: &[u8]) -> Result<Self, Self::Error> {
+        let expected_len = 3 * super::BYTES_PER_FLOAT;
+        if input.len() != expected_len {
+            Err(ProtocolParseError::InvalidLength(expected_len, input.len()))
+        } else {
+            Ok(AccelerometerEvent {
+                x: try_f32_from_le_bytes(&input[0..4])?,
+                y: try_f32_from_le_bytes(&input[4..8])?,
+                z: try_f32_from_le_bytes(&input[8..12])?,
+            })
+        }
+    }
+}

src/bluefruit_protocol/button_event.rs

@@ -0,0 +1,84 @@
+use super::ProtocolParseError;
+
+/// Errors which can be raised while parsing a button event.
+#[derive(Debug, defmt::Format)]
+pub enum ButtonParseError {
+    UnknownButton(u8),
+    UnknownButtonState(u8),
+}
+
+/// Lists all possible buttons which can be sent in the event.
+#[derive(Debug, defmt::Format)]
+pub enum Button {
+    Button1,
+    Button2,
+    Button3,
+    Button4,
+    Up,
+    Down,
+    Left,
+    Right,
+}
+
+impl Button {
+    /// Maps the ID in the protocol to the [`Button`].
+    pub fn from_id(input: &u8) -> Result<Button, ButtonParseError> {
+        match input {
+            b'1' => Ok(Button::Button1),
+            b'2' => Ok(Button::Button2),
+            b'3' => Ok(Button::Button3),
+            b'4' => Ok(Button::Button4),
+            b'5' => Ok(Button::Up),
+            b'6' => Ok(Button::Down),
+            b'7' => Ok(Button::Left),
+            b'8' => Ok(Button::Right),
+            _ => Err(ButtonParseError::UnknownButton(input.clone())),
+        }
+    }
+}
+
+/// The state of the button.
+#[derive(Debug, defmt::Format)]
+pub enum ButtonState {
+    Released,
+    Pressed,
+}
+
+impl ButtonState {
+    /// Maps the ID in the protocol to the [`ButtonState`].
+    pub fn from_id(input: &u8) -> Result<ButtonState, ButtonParseError> {
+        match input {
+            b'0' => Ok(ButtonState::Released),
+            b'1' => Ok(ButtonState::Pressed),
+            _ => Err(ButtonParseError::UnknownButtonState(input.clone())),
+        }
+    }
+}
+
+/// Represents a button event from the protocol.
+#[derive(Debug, defmt::Format)]
+pub struct ButtonEvent {
+    button: Button,
+    state: ButtonState,
+}
+
+impl TryFrom<&[u8]> for ButtonEvent {
+    type Error = ProtocolParseError;
+
+    /// Parse the data section of a button command.
+    ///
+    /// The full command is not validated here, identifying the command as a button command and CRC validation is the responsibility of the caller!
+    fn try_from(input: &[u8]) -> Result<Self, Self::Error> {
+        let expected_len = 2;
+        if input.len() != expected_len {
+            Err(ProtocolParseError::InvalidLength(expected_len, input.len()))
+        } else {
+            Ok(ButtonEvent {
+                button: Button::from_id(&input[0])
+                    .map_err(|e| ProtocolParseError::ButtonParseError(e))?,
+                state: ButtonState::from_id(&input[1])
+                    .map_err(|e| ProtocolParseError::ButtonParseError(e))?,
+            })
+        }
+    }
+}

src/bluefruit_protocol/color_event.rs

@@ -0,0 +1,29 @@
+use super::ProtocolParseError;
+
+/// Represents a color event from the protocol.
+#[derive(Debug, defmt::Format)]
+pub struct ColorEvent {
+    red: u8,
+    green: u8,
+    blue: u8,
+}
+
+impl TryFrom<&[u8]> for ColorEvent {
+    type Error = ProtocolParseError;
+
+    /// Parse the data section of a color event.
+    ///
+    /// The full command is not validated here, identifying the command as a color event and CRC validation is the responsibility of the caller!
+    fn try_from(input: &[u8]) -> Result<Self, Self::Error> {
+        let expected_len = 3;
+        if input.len() != expected_len {
+            Err(ProtocolParseError::InvalidLength(expected_len, input.len()))
+        } else {
+            Ok(ColorEvent {
+                red: input[0],
+                green: input[1],
+                blue: input[2],
+            })
+        }
+    }
+}

src/bluefruit_protocol/gyro_event.rs

@@ -0,0 +1,29 @@
+use super::{try_f32_from_le_bytes, ProtocolParseError};
+
+/// Represents a gyro event from the protocol.
+#[derive(Debug, defmt::Format)]
+pub struct GyroEvent {
+    x: f32,
+    y: f32,
+    z: f32,
+}
+
+impl TryFrom<&[u8]> for GyroEvent {
+    type Error = ProtocolParseError;
+
+    /// Parse the data section of a gyro event.
+    ///
+    /// The full command is not validated here, identifying the command as a gyro event and CRC validation is the responsibility of the caller!
+    fn try_from(input: &[u8]) -> Result<Self, Self::Error> {
+        let expected_len = 3 * super::BYTES_PER_FLOAT;
+        if input.len() != expected_len {
+            Err(ProtocolParseError::InvalidLength(expected_len, input.len()))
+        } else {
+            Ok(GyroEvent {
+                x: try_f32_from_le_bytes(&input[0..4])?,
+                y: try_f32_from_le_bytes(&input[4..8])?,
+                z: try_f32_from_le_bytes(&input[8..12])?,
+            })
+        }
+    }
+}

src/bluefruit_protocol/location_event.rs

@@ -0,0 +1,29 @@
+use super::{try_f32_from_le_bytes, ProtocolParseError};
+
+/// Represents a location event from the protocol.
+#[derive(Debug, defmt::Format)]
+pub struct LocationEvent {
+    latitude: f32,
+    longitude: f32,
+    altitude: f32,
+}
+
+impl TryFrom<&[u8]> for LocationEvent {
+    type Error = ProtocolParseError;
+
+    /// Parse the data section of a location event.
+    ///
+    /// The full command is not validated here, identifying the command as a location event and CRC validation is the responsibility of the caller!
+    fn try_from(input: &[u8]) -> Result<Self, Self::Error> {
+        let expected_len = 3 * super::BYTES_PER_FLOAT;
+        if input.len() != expected_len {
+            Err(ProtocolParseError::InvalidLength(expected_len, input.len()))
+        } else {
+            Ok(LocationEvent {
+                latitude: try_f32_from_le_bytes(&input[0..4])?,
+                longitude: try_f32_from_le_bytes(&input[4..8])?,
+                altitude: try_f32_from_le_bytes(&input[8..12])?,
+            })
+        }
+    }
+}

src/bluefruit_protocol/magnetometer_event.rs

@@ -0,0 +1,29 @@
+use super::{try_f32_from_le_bytes, ProtocolParseError};
+
+/// Represents a magnetometer event from the protocol.
+#[derive(Debug, defmt::Format)]
+pub struct MagnetometerEvent {
+    x: f32,
+    y: f32,
+    z: f32,
+}
+
+impl TryFrom<&[u8]> for MagnetometerEvent {
+    type Error = ProtocolParseError;
+
+    /// Parse the data section of a magnetometer event.
+    ///
+    /// The full command is not validated here, identifying the command as a magnetometer event and CRC validation is the responsibility of the caller!
+    fn try_from(input: &[u8]) -> Result<Self, Self::Error> {
+        let expected_len = 3 * super::BYTES_PER_FLOAT;
+        if input.len() != expected_len {
+            Err(ProtocolParseError::InvalidLength(expected_len, input.len()))
+        } else {
+            Ok(MagnetometerEvent {
+                x: try_f32_from_le_bytes(&input[0..4])?,
+                y: try_f32_from_le_bytes(&input[4..8])?,
+                z: try_f32_from_le_bytes(&input[8..12])?,
+            })
+        }
+    }
+}