+255

Cargo.lock

··· 1 1 + # This file is automatically @generated by Cargo. 2 2 + # It is not intended for manual editing. 3 3 + version = 4 4 4 + 5 5 + [[package]] 6 6 + name = "byteorder" 7 7 + version = "1.5.0" 8 8 + source = "registry+https://github.com/rust-lang/crates.io-index" 9 9 + checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" 10 10 + 11 11 + [[package]] 12 12 + name = "cfg-if" 13 13 + version = "1.0.4" 14 14 + source = "registry+https://github.com/rust-lang/crates.io-index" 15 15 + checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" 16 16 + 17 17 + [[package]] 18 18 + name = "critical-section" 19 19 + version = "1.2.0" 20 20 + source = "registry+https://github.com/rust-lang/crates.io-index" 21 21 + checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b" 22 22 + 23 23 + [[package]] 24 24 + name = "document-features" 25 25 + version = "0.2.12" 26 26 + source = "registry+https://github.com/rust-lang/crates.io-index" 27 27 + checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61" 28 28 + dependencies = [ 29 29 + "litrs", 30 30 + ] 31 31 + 32 32 + [[package]] 33 33 + name = "embassy-executor-timer-queue" 34 34 + version = "0.1.0" 35 35 + source = "registry+https://github.com/rust-lang/crates.io-index" 36 36 + checksum = "2fc328bf943af66b80b98755db9106bf7e7471b0cf47dc8559cd9a6be504cc9c" 37 37 + 38 38 + [[package]] 39 39 + name = "embassy-strike-driver" 40 40 + version = "0.1.0" 41 41 + dependencies = [ 42 42 + "critical-section", 43 43 + "embassy-sync", 44 44 + "embassy-time", 45 45 + "pollster", 46 46 + ] 47 47 + 48 48 + [[package]] 49 49 + name = "embassy-sync" 50 50 + version = "0.7.2" 51 51 + source = "registry+https://github.com/rust-lang/crates.io-index" 52 52 + checksum = "73974a3edbd0bd286759b3d483540f0ebef705919a5f56f4fc7709066f71689b" 53 53 + dependencies = [ 54 54 + "cfg-if", 55 55 + "critical-section", 56 56 + "embedded-io-async", 57 57 + "futures-core", 58 58 + "futures-sink", 59 59 + "heapless", 60 60 + ] 61 61 + 62 62 + [[package]] 63 63 + name = "embassy-time" 64 64 + version = "0.5.0" 65 65 + source = "registry+https://github.com/rust-lang/crates.io-index" 66 66 + checksum = "f4fa65b9284d974dad7a23bb72835c4ec85c0b540d86af7fc4098c88cff51d65" 67 67 + dependencies = [ 68 68 + "cfg-if", 69 69 + "critical-section", 70 70 + "document-features", 71 71 + "embassy-time-driver", 72 72 + "embassy-time-queue-utils", 73 73 + "embedded-hal 0.2.7", 74 74 + "embedded-hal 1.0.0", 75 75 + "embedded-hal-async", 76 76 + "futures-core", 77 77 + ] 78 78 + 79 79 + [[package]] 80 80 + name = "embassy-time-driver" 81 81 + version = "0.2.1" 82 82 + source = "registry+https://github.com/rust-lang/crates.io-index" 83 83 + checksum = "a0a244c7dc22c8d0289379c8d8830cae06bb93d8f990194d0de5efb3b5ae7ba6" 84 84 + dependencies = [ 85 85 + "document-features", 86 86 + ] 87 87 + 88 88 + [[package]] 89 89 + name = "embassy-time-queue-utils" 90 90 + version = "0.3.0" 91 91 + source = "registry+https://github.com/rust-lang/crates.io-index" 92 92 + checksum = "80e2ee86063bd028a420a5fb5898c18c87a8898026da1d4c852af2c443d0a454" 93 93 + dependencies = [ 94 94 + "embassy-executor-timer-queue", 95 95 + "heapless", 96 96 + ] 97 97 + 98 98 + [[package]] 99 99 + name = "embedded-hal" 100 100 + version = "0.2.7" 101 101 + source = "registry+https://github.com/rust-lang/crates.io-index" 102 102 + checksum = "35949884794ad573cf46071e41c9b60efb0cb311e3ca01f7af807af1debc66ff" 103 103 + dependencies = [ 104 104 + "nb 0.1.3", 105 105 + "void", 106 106 + ] 107 107 + 108 108 + [[package]] 109 109 + name = "embedded-hal" 110 110 + version = "1.0.0" 111 111 + source = "registry+https://github.com/rust-lang/crates.io-index" 112 112 + checksum = "361a90feb7004eca4019fb28352a9465666b24f840f5c3cddf0ff13920590b89" 113 113 + 114 114 + [[package]] 115 115 + name = "embedded-hal-async" 116 116 + version = "1.0.0" 117 117 + source = "registry+https://github.com/rust-lang/crates.io-index" 118 118 + checksum = "0c4c685bbef7fe13c3c6dd4da26841ed3980ef33e841cddfa15ce8a8fb3f1884" 119 119 + dependencies = [ 120 120 + "embedded-hal 1.0.0", 121 121 + ] 122 122 + 123 123 + [[package]] 124 124 + name = "embedded-io" 125 125 + version = "0.6.1" 126 126 + source = "registry+https://github.com/rust-lang/crates.io-index" 127 127 + checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d" 128 128 + 129 129 + [[package]] 130 130 + name = "embedded-io-async" 131 131 + version = "0.6.1" 132 132 + source = "registry+https://github.com/rust-lang/crates.io-index" 133 133 + checksum = "3ff09972d4073aa8c299395be75161d582e7629cd663171d62af73c8d50dba3f" 134 134 + dependencies = [ 135 135 + "embedded-io", 136 136 + ] 137 137 + 138 138 + [[package]] 139 139 + name = "futures-core" 140 140 + version = "0.3.31" 141 141 + source = "registry+https://github.com/rust-lang/crates.io-index" 142 142 + checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e" 143 143 + 144 144 + [[package]] 145 145 + name = "futures-sink" 146 146 + version = "0.3.31" 147 147 + source = "registry+https://github.com/rust-lang/crates.io-index" 148 148 + checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7" 149 149 + 150 150 + [[package]] 151 151 + name = "hash32" 152 152 + version = "0.3.1" 153 153 + source = "registry+https://github.com/rust-lang/crates.io-index" 154 154 + checksum = "47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606" 155 155 + dependencies = [ 156 156 + "byteorder", 157 157 + ] 158 158 + 159 159 + [[package]] 160 160 + name = "heapless" 161 161 + version = "0.8.0" 162 162 + source = "registry+https://github.com/rust-lang/crates.io-index" 163 163 + checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad" 164 164 + dependencies = [ 165 165 + "hash32", 166 166 + "stable_deref_trait", 167 167 + ] 168 168 + 169 169 + [[package]] 170 170 + name = "litrs" 171 171 + version = "1.0.0" 172 172 + source = "registry+https://github.com/rust-lang/crates.io-index" 173 173 + checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092" 174 174 + 175 175 + [[package]] 176 176 + name = "nb" 177 177 + version = "0.1.3" 178 178 + source = "registry+https://github.com/rust-lang/crates.io-index" 179 179 + checksum = "801d31da0513b6ec5214e9bf433a77966320625a37860f910be265be6e18d06f" 180 180 + dependencies = [ 181 181 + "nb 1.1.0", 182 182 + ] 183 183 + 184 184 + [[package]] 185 185 + name = "nb" 186 186 + version = "1.1.0" 187 187 + source = "registry+https://github.com/rust-lang/crates.io-index" 188 188 + checksum = "8d5439c4ad607c3c23abf66de8c8bf57ba8adcd1f129e699851a6e43935d339d" 189 189 + 190 190 + [[package]] 191 191 + name = "pollster" 192 192 + version = "0.4.0" 193 193 + source = "registry+https://github.com/rust-lang/crates.io-index" 194 194 + checksum = "2f3a9f18d041e6d0e102a0a46750538147e5e8992d3b4873aaafee2520b00ce3" 195 195 + dependencies = [ 196 196 + "pollster-macro", 197 197 + ] 198 198 + 199 199 + [[package]] 200 200 + name = "pollster-macro" 201 201 + version = "0.4.0" 202 202 + source = "registry+https://github.com/rust-lang/crates.io-index" 203 203 + checksum = "ac5da421106a50887c5b51d20806867db377fbb86bacf478ee0500a912e0c113" 204 204 + dependencies = [ 205 205 + "proc-macro2", 206 206 + "quote", 207 207 + "syn", 208 208 + ] 209 209 + 210 210 + [[package]] 211 211 + name = "proc-macro2" 212 212 + version = "1.0.106" 213 213 + source = "registry+https://github.com/rust-lang/crates.io-index" 214 214 + checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" 215 215 + dependencies = [ 216 216 + "unicode-ident", 217 217 + ] 218 218 + 219 219 + [[package]] 220 220 + name = "quote" 221 221 + version = "1.0.44" 222 222 + source = "registry+https://github.com/rust-lang/crates.io-index" 223 223 + checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4" 224 224 + dependencies = [ 225 225 + "proc-macro2", 226 226 + ] 227 227 + 228 228 + [[package]] 229 229 + name = "stable_deref_trait" 230 230 + version = "1.2.1" 231 231 + source = "registry+https://github.com/rust-lang/crates.io-index" 232 232 + checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" 233 233 + 234 234 + [[package]] 235 235 + name = "syn" 236 236 + version = "2.0.114" 237 237 + source = "registry+https://github.com/rust-lang/crates.io-index" 238 238 + checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a" 239 239 + dependencies = [ 240 240 + "proc-macro2", 241 241 + "quote", 242 242 + "unicode-ident", 243 243 + ] 244 244 + 245 245 + [[package]] 246 246 + name = "unicode-ident" 247 247 + version = "1.0.22" 248 248 + source = "registry+https://github.com/rust-lang/crates.io-index" 249 249 + checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5" 250 250 + 251 251 + [[package]] 252 252 + name = "void" 253 253 + version = "1.0.2" 254 254 + source = "registry+https://github.com/rust-lang/crates.io-index" 255 255 + checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"

+16

Cargo.toml

··· 1 1 + [workspace] 2 2 + resolver = "3" 3 3 + members = ["embassy-strike-driver"] 4 4 + 5 5 + [workspace.package] 6 6 + authors = ["Sachy.dev <sachymetsu@tutamail.com>"] 7 7 + edition = "2024" 8 8 + repository = "https://tangled.org/sachy.dev/strike-sensor" 9 9 + version = "0.1.0" 10 10 + license = "AGPL-3.0-only" 11 11 + rust-version = "1.92.0" 12 12 + 13 13 + [workspace.dependencies] 14 14 + embassy-time = "0.5" 15 15 + embassy-sync = "0.7" 16 16 + defmt = "1"

+4

README.md

··· 4 4 5 5 The sensor designs can be found in the [kicad](./kicad) folder. 6 6 7 7 + ## Driver 8 8 + 9 9 + Currently, the driver needs to be tested and coded according to how the new PCB/circuit behaves, so this will require a bit of work before considered "ready". 10 10 + 7 11 ## Licenses 8 12 9 13 The sensor hardware designs are licensed under the [CERN Open Hardware Licence Version 2 - Strongly Reciprocal](./kicad/LICENSE-CERN-OHL-S) license.

+17

embassy-strike-driver/Cargo.toml

··· 1 1 + [package] 2 2 + name = "embassy-strike-driver" 3 3 + authors.workspace = true 4 4 + edition.workspace = true 5 5 + repository.workspace = true 6 6 + version.workspace = true 7 7 + license.workspace = true 8 8 + rust-version.workspace = true 9 9 + 10 10 + [dependencies] 11 11 + embassy-time.workspace = true 12 12 + embassy-sync.workspace = true 13 13 + 14 14 + [dev-dependencies] 15 15 + embassy-time = { workspace = true, features = ["mock-driver", "generic-queue-8"] } 16 16 + critical-section = { version = "1.1", features = ["std"] } 17 17 + pollster = { version = "0.4", features = ["macro"] }

+415

embassy-strike-driver/src/lib.rs

··· 1 1 + #![no_std] 2 2 + 3 3 + use core::cell::Cell; 4 4 + 5 5 + use embassy_sync::{ 6 6 + blocking_mutex::raw::NoopRawMutex, 7 7 + zerocopy_channel::{Channel, Receiver, Sender}, 8 8 + }; 9 9 + use embassy_time::{Duration, Instant, Ticker, Timer}; 10 10 + 11 11 + pub const BLOCK_SIZE: usize = 512; 12 12 + pub type ZeroCopyChannel<'device> = Channel<'device, NoopRawMutex, (i64, [u16; BLOCK_SIZE])>; 13 13 + 14 14 + pub trait TimeSource { 15 15 + fn timestamp(&self) -> i64; 16 16 + fn get_source() -> Self; 17 17 + } 18 18 + 19 19 + pub trait AdcSource { 20 20 + fn sample_average(&self, samples: &mut [u16]) -> impl Future<Output = u16>; 21 21 + fn sample(&self, samples: &mut [u16]) -> impl Future<Output = ()>; 22 22 + } 23 23 + 24 24 + pub trait PwmSource { 25 25 + fn set_duty(&mut self, duty: u16); 26 26 + } 27 27 + 28 28 + pub trait BufferMut<T> { 29 29 + fn push(&mut self, value: T); 30 30 + fn clear(&mut self); 31 31 + fn as_slice(&self) -> &[T]; 32 32 + fn len(&self) -> usize; 33 33 + fn is_empty(&self) -> bool; 34 34 + } 35 35 + 36 36 + #[derive(Debug)] 37 37 + struct DetectorState { 38 38 + max_duty: Cell<u8>, 39 39 + duty: Cell<u8>, 40 40 + avg: Cell<u16>, 41 41 + strikes: Cell<u16>, 42 42 + warn_level: Cell<u16>, 43 43 + } 44 44 + 45 45 + impl Default for DetectorState { 46 46 + fn default() -> Self { 47 47 + Self { 48 48 + max_duty: Cell::new(0), 49 49 + duty: Cell::new(0), 50 50 + avg: Cell::new(0), 51 51 + strikes: Cell::new(0), 52 52 + warn_level: Cell::new(255), 53 53 + } 54 54 + } 55 55 + } 56 56 + 57 57 + #[derive(Debug)] 58 58 + pub struct DetectorConfig { 59 59 + blip_threshold: Cell<u16>, 60 60 + blip_size: Cell<usize>, 61 61 + } 62 62 + 63 63 + impl Default for DetectorConfig { 64 64 + fn default() -> Self { 65 65 + Self { 66 66 + blip_threshold: Cell::new(14), 67 67 + blip_size: Cell::new(2), 68 68 + } 69 69 + } 70 70 + } 71 71 + 72 72 + #[derive(Debug, Clone, Copy, PartialEq, Eq)] 73 73 + pub enum DetectorUpdate<'a> { 74 74 + Tick { 75 75 + timestamp: i64, 76 76 + level: u16, 77 77 + }, 78 78 + Detection { 79 79 + timestamp: i64, 80 80 + samples: &'a [u16], 81 81 + peaks: &'a [usize], 82 82 + }, 83 83 + } 84 84 + 85 85 + pub struct DetectorDriver<T: TimeSource, P: PwmSource, A: AdcSource> { 86 86 + state: DetectorState, 87 87 + config: DetectorConfig, 88 88 + timer_source: T, 89 89 + pwm: P, 90 90 + adc: A, 91 91 + } 92 92 + 93 93 + impl<T, P, A> DetectorDriver<T, P, A> 94 94 + where 95 95 + T: TimeSource, 96 96 + P: PwmSource, 97 97 + A: AdcSource, 98 98 + { 99 99 + pub fn new(config: DetectorConfig, timer_source: T, pwm: P, adc: A) -> Self { 100 100 + Self { 101 101 + state: Default::default(), 102 102 + config, 103 103 + timer_source, 104 104 + pwm, 105 105 + adc, 106 106 + } 107 107 + } 108 108 + 109 109 + pub fn reset_timer_source(&mut self) { 110 110 + self.timer_source = T::get_source(); 111 111 + } 112 112 + 113 113 + pub fn get_timestamp(&self) -> i64 { 114 114 + self.timer_source.timestamp() 115 115 + } 116 116 + 117 117 + pub fn set_blip_threshold(&self, threshold: u16) { 118 118 + self.config.blip_threshold.set(threshold); 119 119 + } 120 120 + 121 121 + pub fn set_blip_size(&self, size: usize) { 122 122 + self.config.blip_size.set(size); 123 123 + } 124 124 + 125 125 + pub async fn tune(&mut self, samples: &mut [u16]) { 126 126 + // info!("Tuning Detector for correct voltage settings"); 127 127 + let mut duty = 0; 128 128 + self.pwm.set_duty(duty); 129 129 + Timer::after_secs(2).await; 130 130 + let mut act_value = self.adc.sample_average(samples).await; 131 131 + 132 132 + // info!("initial ACT: {}", act_value); 133 133 + 134 134 + while act_value < 1364 { 135 135 + duty += 2; 136 136 + if duty >= 256 { 137 137 + duty = 0; 138 138 + self.pwm.set_duty(duty); 139 139 + Timer::after_secs(2).await; 140 140 + act_value = self.adc.sample_average(samples).await; 141 141 + // info!("Restarting tuning"); 142 142 + continue; 143 143 + } 144 144 + self.pwm.set_duty(duty); 145 145 + Timer::after_millis(250).await; 146 146 + act_value = self.adc.sample_average(samples).await; 147 147 + // info!("ACT: {}, Duty: {}", act_value, duty); 148 148 + } 149 149 + self.state.max_duty.set(duty as u8); 150 150 + duty = (duty / 3) * 2; 151 151 + self.pwm.set_duty(duty); 152 152 + self.state.duty.set(duty as u8); 153 153 + // info!("Set detection duty to: {}", duty); 154 154 + // Allow voltage level to stabilize after tuning 155 155 + Timer::after_secs(2).await; 156 156 + let avg = self.adc.sample_average(samples).await; 157 157 + self.state.avg.set(avg); 158 158 + } 159 159 + 160 160 + /// Samples and returns an `i64` timestamp. 161 161 + pub async fn sample_with_zerocopy<'a>( 162 162 + &self, 163 163 + dma: &mut Sender<'a, NoopRawMutex, (i64, [u16; BLOCK_SIZE])>, 164 164 + ) { 165 165 + loop { 166 166 + let (time, samples) = dma.send().await; 167 167 + *time = self.timer_source.timestamp(); 168 168 + self.adc.sample(samples).await; 169 169 + dma.send_done(); 170 170 + } 171 171 + } 172 172 + 173 173 + pub fn detect_from_sample<B, F>( 174 174 + &self, 175 175 + timestamp: i64, 176 176 + samples: &[u16], 177 177 + peaks: &mut B, 178 178 + update: F, 179 179 + ) where 180 180 + B: BufferMut<usize>, 181 181 + F: Fn(DetectorUpdate<'_>), 182 182 + { 183 183 + peaks.clear(); 184 184 + 185 185 + let new_avg = analyse_buffer_by_stepped_windows( 186 186 + self.config.blip_threshold.get(), 187 187 + samples, 188 188 + self.state.avg.get(), 189 189 + peaks, 190 190 + ); 191 191 + 192 192 + let blips = peaks.len(); 193 193 + 194 194 + if blips >= self.config.blip_size.get() { 195 195 + self.state 196 196 + .strikes 197 197 + .update(|strike| strike.saturating_add(32)); 198 198 + 199 199 + update(DetectorUpdate::Detection { 200 200 + timestamp, 201 201 + samples, 202 202 + peaks: peaks.as_slice(), 203 203 + }); 204 204 + } 205 205 + 206 206 + self.state.avg.set(new_avg); 207 207 + } 208 208 + 209 209 + pub async fn detect_with_zerocopy<'a, 'd, B, F>( 210 210 + &self, 211 211 + dma: &mut Receiver<'a, NoopRawMutex, (i64, [u16; BLOCK_SIZE])>, 212 212 + peaks: &'d mut B, 213 213 + update: F, 214 214 + ) where 215 215 + B: BufferMut<usize>, 216 216 + F: Fn(DetectorUpdate<'_>), 217 217 + { 218 218 + loop { 219 219 + let (timestamp, samples) = dma.receive().await; 220 220 + 221 221 + self.detect_from_sample(*timestamp, samples, peaks, &update); 222 222 + 223 223 + dma.receive_done(); 224 224 + } 225 225 + } 226 226 + 227 227 + pub async fn tick<F>(&self, update: F) 228 228 + where 229 229 + F: Fn(DetectorUpdate), 230 230 + { 231 231 + let mut inactive: Option<Instant> = None; 232 232 + let mut interval = Ticker::every(Duration::from_secs(1)); 233 233 + 234 234 + loop { 235 235 + interval.next().await; 236 236 + let strikes = self.state.strikes.get(); 237 237 + let mut warn_level = self.state.warn_level.get(); 238 238 + 239 239 + if strikes > 32 { 240 240 + warn_level = warn_level.saturating_add(strikes); 241 241 + } 242 242 + 243 243 + let decay = warn_level >> 8; 244 244 + 245 245 + self.state.strikes.set(0); 246 246 + self.state.warn_level.set(warn_level - decay); 247 247 + 248 248 + match inactive { 249 249 + Some(_) if decay > 0 => { 250 250 + inactive = None; 251 251 + } 252 252 + Some(val) if val.elapsed() >= Duration::from_secs(3600) => break, 253 253 + None if decay == 0 => { 254 254 + inactive = Some(Instant::now()); 255 255 + } 256 256 + None => { 257 257 + update(DetectorUpdate::Tick { 258 258 + timestamp: self.timer_source.timestamp(), 259 259 + level: warn_level - 255, 260 260 + }); 261 261 + } 262 262 + _ => continue, 263 263 + } 264 264 + } 265 265 + } 266 266 + } 267 267 + 268 268 + fn analyse_buffer_by_stepped_windows<B: BufferMut<usize>>( 269 269 + threshold: u16, 270 270 + buf: &[u16], 271 271 + average: u16, 272 272 + peaks: &mut B, 273 273 + ) -> u16 { 274 274 + const CHUNK_SIZE: usize = BLOCK_SIZE / 32; 275 275 + const CHUNK_STEP: usize = CHUNK_SIZE / 2; 276 276 + 277 277 + let mut total = 0u32; 278 278 + let mut len = 0u32; 279 279 + 280 280 + for (i, window) in buf.windows(CHUNK_SIZE).enumerate().step_by(CHUNK_STEP) { 281 281 + let window_total = window.iter().copied().sum::<u16>(); 282 282 + let window_avg = window_total / CHUNK_SIZE as u16; 283 283 + let diff = average.saturating_sub(window_avg); 284 284 + 285 285 + if diff > threshold { 286 286 + peaks.push(i); 287 287 + } else { 288 288 + total += window_total as u32; 289 289 + len += CHUNK_SIZE as u32; 290 290 + } 291 291 + } 292 292 + 293 293 + (total / len) as u16 294 294 + } 295 295 + 296 296 + #[cfg(test)] 297 297 + mod tests { 298 298 + use core::future::poll_fn; 299 299 + 300 300 + use embassy_time::MockDriver; 301 301 + 302 302 + use super::*; 303 303 + 304 304 + #[derive(Debug, Default)] 305 305 + struct MockMachine { 306 306 + pwm: Cell<u16>, 307 307 + } 308 308 + 309 309 + impl MockMachine { 310 310 + fn adc_sample_avg(&self) -> u16 { 311 311 + self.pwm.get().saturating_mul(14) 312 312 + } 313 313 + } 314 314 + 315 315 + struct MockPwm<'a>(&'a MockMachine); 316 316 + 317 317 + impl PwmSource for MockPwm<'_> { 318 318 + fn set_duty(&mut self, duty: u16) { 319 319 + self.0.pwm.set(duty); 320 320 + } 321 321 + } 322 322 + 323 323 + struct MockAdc<'a>(&'a MockMachine); 324 324 + 325 325 + impl AdcSource for MockAdc<'_> { 326 326 + async fn sample(&self, samples: &mut [u16]) { 327 327 + samples.fill(self.0.adc_sample_avg()); 328 328 + } 329 329 + 330 330 + async fn sample_average(&self, _samples: &mut [u16]) -> u16 { 331 331 + self.0.adc_sample_avg() 332 332 + } 333 333 + } 334 334 + 335 335 + struct MockTimeSource; 336 336 + 337 337 + impl TimeSource for MockTimeSource { 338 338 + fn get_source() -> Self { 339 339 + Self 340 340 + } 341 341 + fn timestamp(&self) -> i64 { 342 342 + 0 343 343 + } 344 344 + } 345 345 + 346 346 + async fn tune_detector_manually<'a>(detector: &mut DetectorDriver<MockTimeSource, MockPwm<'a>, MockAdc<'a>>, buf: &mut [u16], driver: &MockDriver) { 347 347 + let mut tuning = core::pin::pin!(detector.tune(buf)); 348 348 + 349 349 + poll_fn(|cx| match tuning.as_mut().poll(cx) { 350 350 + core::task::Poll::Ready(_) => core::task::Poll::Ready(()), 351 351 + core::task::Poll::Pending => { 352 352 + cx.waker().wake_by_ref(); 353 353 + driver.advance(Duration::from_secs(2)); 354 354 + 355 355 + core::task::Poll::Pending 356 356 + } 357 357 + }) 358 358 + .await; 359 359 + } 360 360 + 361 361 + #[pollster::test] 362 362 + async fn tuning_cycle_completes() { 363 363 + let driver = embassy_time::MockDriver::get(); 364 364 + driver.reset(); 365 365 + let device = MockMachine::default(); 366 366 + let pwm = MockPwm(&device); 367 367 + let adc = MockAdc(&device); 368 368 + 369 369 + let mut detector = DetectorDriver::new(Default::default(), MockTimeSource, pwm, adc); 370 370 + let mut buf = [0; 16]; 371 371 + 372 372 + tune_detector_manually(&mut detector, &mut buf, driver).await; 373 373 + 374 374 + assert_eq!(detector.state.max_duty.get(), 98); 375 375 + assert_eq!(detector.state.duty.get(), 64); 376 376 + assert_eq!(detector.adc.sample_average(&mut buf).await, 896); 377 377 + } 378 378 + 379 379 + #[pollster::test] 380 380 + async fn tick_updates_only_on_raised_levels() { 381 381 + let driver = embassy_time::MockDriver::get(); 382 382 + driver.reset(); 383 383 + let device = MockMachine::default(); 384 384 + let pwm = MockPwm(&device); 385 385 + let adc = MockAdc(&device); 386 386 + 387 387 + let mut detector = DetectorDriver::new(Default::default(), MockTimeSource, pwm, adc); 388 388 + let mut buf = [0; 16]; 389 389 + 390 390 + tune_detector_manually(&mut detector, &mut buf, driver).await; 391 391 + 392 392 + { 393 393 + let mut tick = core::pin::pin!(detector.tick(|a| { 394 394 + assert_eq!(a, DetectorUpdate::Tick { timestamp: 0, level: 300 }); 395 395 + })); 396 396 + 397 397 + poll_fn(|cx| { 398 398 + match tick.as_mut().poll(cx) { 399 399 + core::task::Poll::Ready(_) => core::task::Poll::Ready(()), 400 400 + core::task::Poll::Pending => { 401 401 + if detector.state.warn_level.get() > 255 { 402 402 + return core::task::Poll::Ready(()); 403 403 + } 404 404 + detector.state.strikes.set(300); 405 405 + driver.advance(Duration::from_secs(1)); 406 406 + cx.waker().wake_by_ref(); 407 407 + core::task::Poll::Pending 408 408 + }, 409 409 + } 410 410 + }).await; 411 411 + } 412 412 + 413 413 + assert_eq!(detector.state.warn_level.get(), 553); 414 414 + } 415 415 + }