Merge pull request #81 from torfmaster/feature/heapless-ble

Remove unnecessary usage of heap in BLE implememtation.

Author: Woyten

README.md

@@ -76,6 +76,7 @@ This script does the following steps for you:
 
 ## Running the Integration Tests
 Having an nRF52-DK board at hand, integration tests can be run using `./run_hardware_tests.sh`.
+The pins P0.03 and P0.04 need to be connected (on a nRF52-DK).
 The expected output on the UART console will be as follows.
 ```
 [test-results]

examples/adc_buffer.rs

@@ -15,7 +15,7 @@ fn main() {
     let adc_buffer = libtock::adc::Adc::init_buffer(&mut adc_buffer).unwrap();
 
     let mut with_callback = adc::with_callback(|_, _| {
-        adc_buffer.read_bytes(&mut temp_buffer);
+        adc_buffer.read_bytes(&mut temp_buffer[..]);
         writeln!(console, "First sample in buffer: {}", temp_buffer[0]).unwrap();
     });
 

examples/ble_scanning.rs

@@ -22,7 +22,7 @@ fn main() {
     let shared_memory = BleDriver::share_memory(&mut shared_buffer).unwrap();
 
     let mut callback = BleCallback::new(|_: usize, _: usize| {
-        shared_memory.read_bytes(&mut my_buffer);
+        shared_memory.read_bytes(&mut my_buffer[..]);
         ble_parser::find(&my_buffer, simple_ble::gap_data::SERVICE_DATA as u8)
             .and_then(|service_data| ble_parser::extract_for_service([91, 79], service_data))
             .and_then(|payload| corepack::from_bytes::<LedCommand>(&payload).ok())

examples/simple_ble.rs

@@ -24,15 +24,21 @@ fn main() {
 
     let mut buffer = BleAdvertisingDriver::create_advertising_buffer();
     let mut gap_payload = BlePayload::new();
-    gap_payload.add_flag(ble_composer::flags::LE_GENERAL_DISCOVERABLE);
-
-    gap_payload.add(ble_composer::gap_types::UUID, &uuid);
-
-    gap_payload.add(
-        ble_composer::gap_types::COMPLETE_LOCAL_NAME,
-        "Tock!".as_bytes(),
-    );
-    gap_payload.add_service_payload([91, 79], &payload);
+    gap_payload
+        .add_flag(ble_composer::flags::LE_GENERAL_DISCOVERABLE)
+        .unwrap();
+
+    gap_payload
+        .add(ble_composer::gap_types::UUID, &uuid)
+        .unwrap();
+
+    gap_payload
+        .add(
+            ble_composer::gap_types::COMPLETE_LOCAL_NAME,
+            "Tock!".as_bytes(),
+        )
+        .unwrap();
+    gap_payload.add_service_payload([91, 79], &payload).unwrap();
 
     let handle = BleAdvertisingDriver::initialize(100, &gap_payload, &mut buffer).unwrap();
 

src/ble_composer.rs

@@ -1,5 +1,3 @@
-use alloc::vec::Vec;
-
 pub mod gap_types {
     pub static COMPLETE_LOCAL_NAME: u8 = 0x09;
     pub static SERVICE_DATA: u8 = 0x16;
@@ -12,56 +10,104 @@ pub mod flags {
 }
 
 pub struct BlePayload {
-    pub bytes: Vec<u8>,
+    bytes: [u8; 39],
+    occupied: usize,
 }
 
 impl BlePayload {
-    pub fn add(&mut self, kind: u8, content: &[u8]) {
-        self.bytes.push((content.len() + 1) as u8);
-        self.bytes.push(kind);
-        for e in content {
-            self.bytes.push(*e);
-        }
+    pub fn add(&mut self, kind: u8, content: &[u8]) -> Result<(), ()> {
+        self.check_can_write_num_bytes(content.len() + 2)?;
+
+        self.bytes[self.occupied] = (content.len() + 1) as u8;
+        self.bytes[self.occupied + 1] = kind;
+        let write = &mut self.bytes[self.occupied + 2..(self.occupied + content.len() + 2)];
+        write.clone_from_slice(content);
+        self.occupied += 2 + content.len();
+        Ok(())
     }
 
-    pub fn add_flag(&mut self, flag: u8) {
-        self.bytes.push(2);
-        self.bytes.push(gap_types::FLAGS);
-        self.bytes.push(flag);
+    pub fn add_flag(&mut self, flag: u8) -> Result<(), ()> {
+        self.check_can_write_num_bytes(3)?;
+
+        self.bytes[self.occupied] = 2;
+        self.bytes[self.occupied + 1] = gap_types::FLAGS;
+        self.bytes[self.occupied + 2] = flag;
+        self.occupied += 3;
+        Ok(())
     }
 
     pub fn new() -> Self {
-        BlePayload { bytes: Vec::new() }
+        BlePayload {
+            bytes: [0; 39],
+            occupied: 0,
+        }
     }
 
-    pub fn add_service_payload(&mut self, uuid: [u8; 2], content: &[u8]) {
-        self.bytes.push((content.len() + 3) as u8);
-        self.bytes.push(gap_types::SERVICE_DATA);
-        self.bytes.push(uuid[0]);
-        self.bytes.push(uuid[1]);
-        for e in content {
-            self.bytes.push(*e);
+    pub fn add_service_payload(&mut self, uuid: [u8; 2], content: &[u8]) -> Result<(), ()> {
+        self.check_can_write_num_bytes(4 + content.len())?;
+        self.bytes[self.occupied] = (content.len() + 3) as u8;
+        self.bytes[self.occupied + 1] = gap_types::SERVICE_DATA;
+        self.bytes[self.occupied + 2] = uuid[0];
+        self.bytes[self.occupied + 3] = uuid[1];
+
+        let write = &mut self.bytes[self.occupied + 4..(self.occupied + content.len() + 4)];
+        write.clone_from_slice(content);
+        self.occupied += 4 + content.len();
+        Ok(())
+    }
+
+    fn check_can_write_num_bytes(&self, number: usize) -> Result<(), ()> {
+        if self.occupied + number <= self.bytes.len() {
+            Ok(())
+        } else {
+            Err(())
         }
     }
 }
 
+impl AsRef<[u8]> for BlePayload {
+    fn as_ref(&self) -> &[u8] {
+        &self.bytes[0..self.occupied]
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
 
-    use alloc::vec;
-
     #[test]
-    pub fn test_add() {
+    fn test_add() {
         let mut pld = BlePayload::new();
         pld.add(1, &[2]);
-        assert_eq!(pld.bytes, vec![2, 1, 2])
+        assert_eq!(pld.as_ref().len(), 3);
+        assert_eq!(pld.as_ref(), &mut [2, 1, 2])
     }
 
     #[test]
-    pub fn test_add_service_payload() {
+    fn test_add_service_payload() {
         let mut pld = BlePayload::new();
         pld.add_service_payload([1, 2], &[2]);
-        assert_eq!(pld.bytes, &[4, 0x16, 1, 2, 2])
+        assert_eq!(pld.as_ref(), &[4, 0x16, 1, 2, 2])
+    }
+
+    #[test]
+    fn test_add_service_payload_two_times() {
+        let mut pld = BlePayload::new();
+        pld.add_service_payload([1, 2], &[2]);
+        pld.add_service_payload([1, 2], &[2, 3]);
+
+        assert_eq!(pld.as_ref(), &[4, 0x16, 1, 2, 2, 5, 0x16, 1, 2, 2, 3])
+    }
+
+    #[test]
+    fn big_data_causes_error() {
+        let mut pld = BlePayload::new();
+        assert!(pld.add_service_payload([1, 2], &[0; 36]).is_err());
+    }
+
+    #[test]
+    fn initial_size_is_zero() {
+        let pld = BlePayload::new();
+        assert_eq!(pld.as_ref().len(), 0);
     }
 }

src/ble_parser.rs

@@ -45,7 +45,7 @@ mod test {
     use crate::simple_ble::BUFFER_SIZE_SCAN;
 
     #[test]
-    pub fn extracts_data_for_ids_correctly() {
+    fn extracts_data_for_ids_correctly() {
         let mut buf = [0; BUFFER_SIZE_SCAN];
         {
             let slice = &mut buf[8..23];
@@ -62,7 +62,7 @@ mod test {
     }
 
     #[test]
-    pub fn doesnt_panic_for_defect_packets() {
+    fn doesnt_panic_for_defect_packets() {
         let mut buf = [0; BUFFER_SIZE_SCAN];
         {
             let slice = &mut buf[8..18];
@@ -72,7 +72,7 @@ mod test {
     }
 
     #[test]
-    pub fn ignores_illegal_lengths_in_packets() {
+    fn ignores_illegal_lengths_in_packets() {
         let mut buf = [0; 11];
         {
             let slice = &mut buf[8..10];

src/shared_memory.rs

@@ -20,12 +20,12 @@ impl<'a> SharedMemory<'a> {
         }
     }
 
-    pub fn read_bytes(&self, destination: &mut [u8]) {
-        safe_copy(self.buffer_to_share, destination);
+    pub fn read_bytes<T: AsMut<[u8]>>(&self, mut destination: T) {
+        safe_copy(self.buffer_to_share, destination.as_mut());
     }
 
-    pub fn write_bytes(&mut self, source: &[u8]) {
-        safe_copy(source, self.buffer_to_share);
+    pub fn write_bytes<T: AsRef<[u8]>>(&mut self, source: T) {
+        safe_copy(source.as_ref(), self.buffer_to_share);
     }
 }
 

src/simple_ble.rs

@@ -45,7 +45,7 @@ impl BleAdvertisingDriver {
             ble_commands::ALLOW_ADVERTISMENT_BUFFER,
             advertising_buffer,
         )?;
-        shared_memory.write_bytes(&service_payload.bytes);
+        shared_memory.write_bytes(service_payload);
         Self::start_advertising(gap_flags::BLE_DISCOVERABLE, interval)?;
         Ok(shared_memory)
     }