From 6b09939aa06fe98498ec6d9703fc6534333ab9f7 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 13 Nov 2023 04:07:09 +0000 Subject: [PATCH 1/2] build(deps): bump heapless from 0.7.16 to 0.8.0 Bumps [heapless](https://github.com/rust-embedded/heapless) from 0.7.16 to 0.8.0. - [Changelog](https://github.com/rust-embedded/heapless/blob/main/CHANGELOG.md) - [Commits](https://github.com/rust-embedded/heapless/compare/v0.7.16...v0.8.0) --- updated-dependencies: - dependency-name: heapless dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] --- Cargo.lock | 38 +++++++++++++++++++++++++++++--------- Cargo.toml | 2 +- 2 files changed, 30 insertions(+), 10 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 0589da15d..fa0d3d85e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -181,7 +181,7 @@ dependencies = [ "bare-metal 1.0.0", "cortex-m 0.7.7", "cortex-m-rtic-macros", - "heapless", + "heapless 0.7.16", "rtic-core", "rtic-monotonic", "version_check", @@ -237,7 +237,7 @@ version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "447416d161ba378782c13e82b11b267d6d2104b4913679a7c5640e7e94f96ea7" dependencies = [ - "heapless", + "heapless 0.7.16", "nb 1.1.0", "no-std-net", ] @@ -329,6 +329,15 @@ dependencies = [ "byteorder", ] +[[package]] +name = "hash32" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606" +dependencies = [ + "byteorder", +] + [[package]] name = "hashbrown" version = "0.12.3" @@ -342,13 +351,24 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "db04bc24a18b9ea980628ecf00e6c0264f3c1426dac36c00cb49b6fbad8b0743" dependencies = [ "atomic-polyfill 0.1.11", - "hash32", + "hash32 0.2.1", "rustc_version 0.4.0", "serde", "spin", "stable_deref_trait", ] +[[package]] +name = "heapless" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad" +dependencies = [ + "hash32 0.3.1", + "serde", + "stable_deref_trait", +] + [[package]] name = "idsp" version = "0.13.0" @@ -432,7 +452,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9df2d7bdba3acb28460c347b21e1e88d869f2716ebe060eb6a79f7b76b57de72" dependencies = [ "embedded-io", - "heapless", + "heapless 0.7.16", "itoa", "log", "miniconf_derive", @@ -462,7 +482,7 @@ dependencies = [ "bit_field", "embedded-nal", "embedded-time", - "heapless", + "heapless 0.7.16", "num_enum 0.7.1", "serde", "smlang", @@ -798,7 +818,7 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3c9e1ab533c0bc414c34920ec7e5f097101d126ed5eac1a1aac711222e0bbb33" dependencies = [ - "heapless", + "heapless 0.7.16", "ryu", "serde", ] @@ -867,7 +887,7 @@ dependencies = [ "bitflags 1.3.2", "byteorder", "cfg-if", - "heapless", + "heapless 0.7.16", "managed", ] @@ -879,7 +899,7 @@ checksum = "6dd2ed2f8e7643a170506863ed0f52ad1dc5762abdcff27de825dde14fc8025f" dependencies = [ "embedded-nal", "embedded-time", - "heapless", + "heapless 0.7.16", "nanorand", "shared-bus 0.2.5", "smoltcp", @@ -906,7 +926,7 @@ dependencies = [ "embedded-hal", "enum-iterator", "fugit", - "heapless", + "heapless 0.8.0", "idsp", "lm75", "log", diff --git a/Cargo.toml b/Cargo.toml index e1f95e4da..edbec9519 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -40,7 +40,7 @@ log = { version = "0.4", features = ["max_level_trace", "release_max_level_info" rtt-target = "0.3" serde = { version = "1.0", features = ["derive"], default-features = false } serde-json-core = "0.5" -heapless = { version = "0.7.16", features = ["serde"] } +heapless = { version = "0.8.0", features = ["serde"] } cortex-m-rtic = "1.0" embedded-hal = "0.2.7" num_enum = { version = "0.7.1", default-features = false } From a52e7d11be75ed6b389b45ffafa1fb058438f2d4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Robert=20J=C3=B6rdens?= Date: Mon, 13 Nov 2023 10:15:19 +0100 Subject: [PATCH 2/2] heapless 0.8 changes --- src/net/data_stream.rs | 50 +++++++++++++++++++----------------------- src/net/mod.rs | 4 ++-- src/net/telemetry.rs | 7 +++--- 3 files changed, 28 insertions(+), 33 deletions(-) diff --git a/src/net/data_stream.rs b/src/net/data_stream.rs index 728bd1234..36b1014d9 100644 --- a/src/net/data_stream.rs +++ b/src/net/data_stream.rs @@ -24,7 +24,8 @@ //! of livestreamed data. use core::mem::MaybeUninit; use heapless::{ - pool::{Box, Init, Pool, Uninit}, + box_pool, + pool::boxed::{Box, BoxBlock}, spsc::{Consumer, Producer, Queue}, }; use num_enum::IntoPrimitive; @@ -53,13 +54,14 @@ const FRAME_SIZE: usize = 1500 - 40 - 8; // allocated frame buffer should fit in the queue. const FRAME_QUEUE_SIZE: usize = FRAME_COUNT * 2; -// Static storage used for a heapless::Pool of frame buffers. -static mut FRAME_DATA: [u8; core::mem::size_of::() - * FRAME_SIZE - * FRAME_COUNT] = [0; core::mem::size_of::() * FRAME_SIZE * FRAME_COUNT]; - type Frame = [MaybeUninit; FRAME_SIZE]; +box_pool!(FRAME_POOL: Frame); + +// Static storage used for a heapless::Pool of frame buffers. +const BLOCK: BoxBlock = BoxBlock::new(); +static mut FRAME_DATA: [BoxBlock; FRAME_COUNT] = [BLOCK; FRAME_COUNT]; + /// Represents the destination for the UDP stream to send data to. /// /// # Miniconf @@ -129,34 +131,32 @@ pub fn setup_streaming( .unwrap(); let (producer, consumer) = queue.split(); - let frame_pool = cortex_m::singleton!(: Pool = Pool::new()).unwrap(); - // Note(unsafe): We guarantee that FRAME_DATA is only accessed once in this function. - let memory = unsafe { &mut FRAME_DATA }; - frame_pool.grow(memory); + let blocks = unsafe { &mut FRAME_DATA }; + for block in blocks { + FRAME_POOL.manage(block); + } - let generator = FrameGenerator::new(producer, frame_pool); + let generator = FrameGenerator::new(producer); - let stream = DataStream::new(stack, consumer, frame_pool); + let stream = DataStream::new(stack, consumer); (generator, stream) } #[derive(Debug)] struct StreamFrame { - buffer: Box, + buffer: Box, offset: usize, batches: u8, } impl StreamFrame { pub fn new( - buffer: Box, + mut buffer: Box, format_id: u8, sequence_number: u32, ) -> Self { - let mut buffer = buffer.init([MaybeUninit::uninit(); FRAME_SIZE]); - for (byte, buf) in MAGIC .to_le_bytes() .iter() @@ -197,20 +197,15 @@ impl StreamFrame { /// The data generator for a stream. pub struct FrameGenerator { queue: Producer<'static, StreamFrame, FRAME_QUEUE_SIZE>, - pool: &'static Pool, current_frame: Option, sequence_number: u32, format: u8, } impl FrameGenerator { - fn new( - queue: Producer<'static, StreamFrame, FRAME_QUEUE_SIZE>, - pool: &'static Pool, - ) -> Self { + fn new(queue: Producer<'static, StreamFrame, FRAME_QUEUE_SIZE>) -> Self { Self { queue, - pool, format: StreamFormat::Unknown.into(), current_frame: None, sequence_number: 0, @@ -242,7 +237,9 @@ impl FrameGenerator { self.sequence_number = self.sequence_number.wrapping_add(1); if self.current_frame.is_none() { - if let Some(buffer) = self.pool.alloc() { + if let Ok(buffer) = + FRAME_POOL.alloc([MaybeUninit::uninit(); FRAME_SIZE]) + { self.current_frame.replace(StreamFrame::new( buffer, self.format, @@ -276,7 +273,6 @@ pub struct DataStream { stack: NetworkReference, socket: Option<::UdpSocket>, queue: Consumer<'static, StreamFrame, FRAME_QUEUE_SIZE>, - frame_pool: &'static Pool, remote: SocketAddr, } @@ -290,14 +286,12 @@ impl DataStream { fn new( stack: NetworkReference, consumer: Consumer<'static, StreamFrame, FRAME_QUEUE_SIZE>, - frame_pool: &'static Pool, ) -> Self { Self { stack, socket: None, remote: StreamTarget::default().into(), queue: consumer, - frame_pool, } } @@ -350,7 +344,7 @@ impl DataStream { if self.open().is_ok() { // If we just successfully opened the socket, flush old data from queue. while let Some(frame) = self.queue.dequeue() { - self.frame_pool.free(frame.buffer); + drop(frame.buffer); } } } @@ -365,7 +359,7 @@ impl DataStream { ) }; self.stack.send(handle, data).ok(); - self.frame_pool.free(frame.buffer) + drop(frame.buffer); } } } diff --git a/src/net/mod.rs b/src/net/mod.rs index 7e3b7b66b..1394251e6 100644 --- a/src/net/mod.rs +++ b/src/net/mod.rs @@ -205,9 +205,9 @@ where // `settings_path` has to be at least as large as `miniconf::mqtt_client::MAX_TOPIC_LENGTH`. let mut settings_path: String<128> = String::new(); match self.miniconf.handled_update(|path, old, new| { - settings_path = path.into(); + settings_path = path.try_into().or(Err("path too long"))?; *old = new.clone(); - Result::<(), &'static str>::Ok(()) + Result::<_, &'static str>::Ok(()) }) { Ok(true) => NetworkState::SettingsChanged(settings_path), _ => poll_result, diff --git a/src/net/telemetry.rs b/src/net/telemetry.rs index e5efd28ef..a1d6386ae 100644 --- a/src/net/telemetry.rs +++ b/src/net/telemetry.rs @@ -10,7 +10,7 @@ //! sampling frequency. Instead, the raw codes are stored and the telemetry is generated as //! required immediately before transmission. This ensures that any slower computation required //! for unit conversion can be off-loaded to lower priority tasks. -use heapless::{String, Vec}; +use heapless::String; use serde::Serialize; use super::NetworkReference; @@ -115,7 +115,8 @@ impl TelemetryClient { >, prefix: &str, ) -> Self { - let mut telemetry_topic: String<128> = String::from(prefix); + let mut telemetry_topic: String<128> = + String::try_from(prefix).unwrap(); telemetry_topic.push_str("/telemetry").unwrap(); Self { @@ -134,7 +135,7 @@ impl TelemetryClient { /// # Args /// * `telemetry` - The telemetry to report pub fn publish(&mut self, telemetry: &T) { - let telemetry: Vec = + let telemetry: serde_json_core::heapless::Vec = serde_json_core::to_vec(telemetry).unwrap(); self.mqtt .client()