2708741885

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/google/OpenSK/commit/<a class=hub.com/google/OpenSK/commit/<a class="double-link" href="https://git"><a class=hub.com/google/OpenSK/commit/<a class="double-link" href="https://git"><a class=hub.com/google/OpenSK/commit/<a class="double-link" href="https://git"><a class=hub.com/google/OpenSK/commit/4473747279bee24e1196f4c982a98eca57e8332b">447374727">&lt;a href=&quot;https://github.com/google/OpenSK/commit/</a><a class="double-link" href="https://github.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/4473747279bee24e1196f4c982a98eca57e8332b">447374727</a><a href="https://github.com/google/OpenSK/commit/4473747279bee24e1196f4c982a98eca57e8332b">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/google/OpenSK/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/4473747279bee24e1196f4c982a98eca57e8332b&quot;&gt;447374727&lt;/a&gt;&lt;a href=&quot;https://github.com/google/OpenSK/commit/4473747279bee24e1196f4c982a98eca57e8332b&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/google/OpenSK/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/google/OpenSK/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;htt... (continued)

Pull Request Pull Request #515: Interleave sending and receiving of packets to reduce rx latency

Run Details

5 of 5 new or added lines in 2 files covered. (100.0%)

14371 of 16337 relevant lines covered (87.97%)

534531.99 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/env/tock/mod.rs

// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

pub use self::storage::{TockStorage, TockUpgradeStorage};
use crate::api::attestation_store::AttestationStore;
use crate::api::connection::{HidConnection, SendOrRecvError, SendOrRecvResult, SendOrRecvStatus};
use crate::api::customization::{CustomizationImpl, DEFAULT_CUSTOMIZATION};
use crate::api::firmware_protection::FirmwareProtection;
use crate::api::user_presence::{UserPresence, UserPresenceError, UserPresenceResult};
use crate::api::{attestation_store, key_store};
use crate::clock::{ClockInt, KEEPALIVE_DELAY_MS};
use crate::env::Env;
use core::cell::Cell;
use core::sync::atomic::{AtomicBool, Ordering};
use embedded_time::duration::Milliseconds;
use embedded_time::fixed_point::FixedPoint;
use libtock_core::result::{CommandError, EALREADY};
use libtock_drivers::buttons::{self, ButtonState};
use libtock_drivers::console::Console;
use libtock_drivers::result::{FlexUnwrap, TockError};
use libtock_drivers::timer::Duration;
use libtock_drivers::usb_ctap_hid::{self, UsbEndpoint};
use libtock_drivers::{crp, led, timer};
use persistent_store::{StorageResult, Store};
use rng256::TockRng256;

mod storage;

pub struct TockHidConnection {
    endpoint: UsbEndpoint,
}

impl HidConnection for TockHidConnection {
    fn send_or_recv_with_timeout(
        &mut self,
        buf: &mut [u8; 64],
        timeout: Milliseconds<ClockInt>,
    ) -> SendOrRecvResult {
        match usb_ctap_hid::send_or_recv_with_timeout(
            buf,
            timer::Duration::from_ms(timeout.integer() as isize),
            self.endpoint,
        ) {
            Ok(usb_ctap_hid::SendOrRecvStatus::Timeout) => Ok(SendOrRecvStatus::Timeout),
            Ok(usb_ctap_hid::SendOrRecvStatus::Sent) => Ok(SendOrRecvStatus::Sent),
            Ok(usb_ctap_hid::SendOrRecvStatus::Received(recv_endpoint)) => {
                Ok(SendOrRecvStatus::Received(recv_endpoint))
            }
            _ => Err(SendOrRecvError),
        }
    }
}

pub struct TockEnv {
    rng: TockRng256,
    store: Store<TockStorage>,
    upgrade_storage: Option<TockUpgradeStorage>,
    main_connection: TockHidConnection,
    #[cfg(feature = "vendor_hid")]
    vendor_connection: TockHidConnection,
    blink_pattern: usize,
}

impl TockEnv {
    /// Returns the unique instance of the Tock environment.
    ///
    /// # Panics
    ///
    /// - If called a second time.
    pub fn new() -> Self {
        // We rely on `take_storage` to ensure that this function is called only once.
        let storage = take_storage().unwrap();
        let store = Store::new(storage).ok().unwrap();
        let upgrade_storage = TockUpgradeStorage::new().ok();
        TockEnv {
            rng: TockRng256 {},
            store,
            upgrade_storage,
            main_connection: TockHidConnection {
                endpoint: UsbEndpoint::MainHid,
            },
            #[cfg(feature = "vendor_hid")]
            vendor_connection: TockHidConnection {
                endpoint: UsbEndpoint::VendorHid,
            },
            blink_pattern: 0,
        }
    }
}

/// Returns the unique storage instance.
///
/// # Panics
///
/// - If called a second time.
pub fn take_storage() -> StorageResult<TockStorage> {
    // Make sure the storage was not already taken.
    static TAKEN: AtomicBool = AtomicBool::new(false);
    assert!(!TAKEN.fetch_or(true, Ordering::SeqCst));
    TockStorage::new()
}

impl UserPresence for TockEnv {
    fn check_init(&mut self) {
        self.blink_pattern = 0;
    }
    fn wait_with_timeout(&mut self, timeout: Milliseconds<ClockInt>) -> UserPresenceResult {
        if timeout.integer() == 0 {
            return Err(UserPresenceError::Timeout);
        }
        blink_leds(self.blink_pattern);
        self.blink_pattern += 1;

        let button_touched = Cell::new(false);
        let mut buttons_callback = buttons::with_callback(|_button_num, state| {
            match state {
                ButtonState::Pressed => button_touched.set(true),
                ButtonState::Released => (),
            };
        });
        let mut buttons = buttons_callback.init().flex_unwrap();
        for mut button in &mut buttons {
            button.enable().flex_unwrap();
        }

        // Setup a keep-alive callback.
        let keepalive_expired = Cell::new(false);
        let mut keepalive_callback = timer::with_callback(|_, _| {
            keepalive_expired.set(true);
        });
        let mut keepalive = keepalive_callback.init().flex_unwrap();
        let keepalive_alarm = keepalive
            .set_alarm(timer::Duration::from_ms(timeout.integer() as isize))
            .flex_unwrap();

        // Wait for a button touch or an alarm.
        libtock_drivers::util::yieldk_for(|| button_touched.get() || keepalive_expired.get());

        // Cleanup alarm callback.
        match keepalive.stop_alarm(keepalive_alarm) {
            Ok(()) => (),
            Err(TockError::Command(CommandError {
                return_code: EALREADY,
                ..
            })) => assert!(keepalive_expired.get()),
            Err(_e) => {
                #[cfg(feature = "debug_ctap")]
                panic!("Unexpected error when stopping alarm: {:?}", _e);
                #[cfg(not(feature = "debug_ctap"))]
                panic!("Unexpected error when stopping alarm: <error is only visible with the debug_ctap feature>");
            }
        }

        for mut button in &mut buttons {
            button.disable().flex_unwrap();
        }

        if button_touched.get() {
            Ok(())
        } else if keepalive_expired.get() {
            Err(UserPresenceError::Timeout)
        } else {
            panic!("Unexpected exit condition");
        }
    }

    fn check_complete(&mut self) {
        switch_off_leds();
    }
}

impl FirmwareProtection for TockEnv {
    fn lock(&mut self) -> bool {
        matches!(
            crp::set_protection(crp::ProtectionLevel::FullyLocked),
            Ok(())
                | Err(TockError::Command(CommandError {
                    return_code: EALREADY,
                    ..
                }))
        )
    }
}

impl key_store::Helper for TockEnv {}

impl AttestationStore for TockEnv {
    fn get(
        &mut self,
        id: &attestation_store::Id,
    ) -> Result<Option<attestation_store::Attestation>, attestation_store::Error> {
        if !matches!(id, attestation_store::Id::Batch) {
            return Err(attestation_store::Error::NoSupport);
        }
        attestation_store::helper_get(self)
    }

    fn set(
        &mut self,
        id: &attestation_store::Id,
        attestation: Option<&attestation_store::Attestation>,
    ) -> Result<(), attestation_store::Error> {
        if !matches!(id, attestation_store::Id::Batch) {
            return Err(attestation_store::Error::NoSupport);
        }
        attestation_store::helper_set(self, attestation)
    }
}

impl Env for TockEnv {
    type Rng = TockRng256;
    type UserPresence = Self;
    type Storage = TockStorage;
    type KeyStore = Self;
    type AttestationStore = Self;
    type UpgradeStorage = TockUpgradeStorage;
    type FirmwareProtection = Self;
    type Write = Console;
    type Customization = CustomizationImpl;
    type HidConnection = TockHidConnection;

    fn rng(&mut self) -> &mut Self::Rng {
        &mut self.rng
    }

    fn user_presence(&mut self) -> &mut Self::UserPresence {
        self
    }

    fn store(&mut self) -> &mut Store<Self::Storage> {
        &mut self.store
    }

    fn key_store(&mut self) -> &mut Self {
        self
    }

    fn attestation_store(&mut self) -> &mut Self {
        self
    }

    fn upgrade_storage(&mut self) -> Option<&mut Self::UpgradeStorage> {
        self.upgrade_storage.as_mut()
    }

    fn firmware_protection(&mut self) -> &mut Self::FirmwareProtection {
        self
    }

    fn write(&mut self) -> Self::Write {
        Console::new()
    }

    fn customization(&self) -> &Self::Customization {
        &DEFAULT_CUSTOMIZATION
    }

    fn main_hid_connection(&mut self) -> &mut Self::HidConnection {
        &mut self.main_connection
    }

    #[cfg(feature = "vendor_hid")]
    fn vendor_hid_connection(&mut self) -> &mut Self::HidConnection {
        &mut self.vendor_connection
    }
}

pub fn blink_leds(pattern_seed: usize) {
    for l in 0..led::count().flex_unwrap() {
        if (pattern_seed ^ l).count_ones() & 1 != 0 {
            led::get(l).flex_unwrap().on().flex_unwrap();
        } else {
            led::get(l).flex_unwrap().off().flex_unwrap();
        }
    }
}

pub fn wink_leds(pattern_seed: usize) {
    // This generates a "snake" pattern circling through the LEDs.
    // Fox example with 4 LEDs the sequence of lit LEDs will be the following.
    // 0 1 2 3
    // * *
    // * * *
    //   * *
    //   * * *
    //     * *
    // *   * *
    // *     *
    // * *   *
    // * *
    let count = led::count().flex_unwrap();
    let a = (pattern_seed / 2) % count;
    let b = ((pattern_seed + 1) / 2) % count;
    let c = ((pattern_seed + 3) / 2) % count;

    for l in 0..count {
        // On nRF52840-DK, logically swap LEDs 3 and 4 so that the order of LEDs form a circle.
        let k = match l {
            2 => 3,
            3 => 2,
            _ => l,
        };
        if k == a || k == b || k == c {
            led::get(l).flex_unwrap().on().flex_unwrap();
        } else {
            led::get(l).flex_unwrap().off().flex_unwrap();
        }
    }
}

pub fn switch_off_leds() {
    for l in 0..led::count().flex_unwrap() {
        led::get(l).flex_unwrap().off().flex_unwrap();
    }
}

pub const KEEPALIVE_DELAY_TOCK: Duration<isize> = Duration::from_ms(KEEPALIVE_DELAY_MS as isize);

1	// Copyright 2022 Google LLC
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	pub use self::storage::{TockStorage, TockUpgradeStorage};
16	use crate::api::attestation_store::AttestationStore;
17	use crate::api::connection::{HidConnection, SendOrRecvError, SendOrRecvResult, SendOrRecvStatus};
18	use crate::api::customization::{CustomizationImpl, DEFAULT_CUSTOMIZATION};
19	use crate::api::firmware_protection::FirmwareProtection;
20	use crate::api::user_presence::{UserPresence, UserPresenceError, UserPresenceResult};
21	use crate::api::{attestation_store, key_store};
22	use crate::clock::{ClockInt, KEEPALIVE_DELAY_MS};
23	use crate::env::Env;
24	use core::cell::Cell;
25	use core::sync::atomic::{AtomicBool, Ordering};
26	use embedded_time::duration::Milliseconds;
27	use embedded_time::fixed_point::FixedPoint;
28	use libtock_core::result::{CommandError, EALREADY};
29	use libtock_drivers::buttons::{self, ButtonState};
30	use libtock_drivers::console::Console;
31	use libtock_drivers::result::{FlexUnwrap, TockError};
32	use libtock_drivers::timer::Duration;
33	use libtock_drivers::usb_ctap_hid::{self, UsbEndpoint};
34	use libtock_drivers::{crp, led, timer};
35	use persistent_store::{StorageResult, Store};
36	use rng256::TockRng256;
37
38	mod storage;
39
40	pub struct TockHidConnection {
41	endpoint: UsbEndpoint,
42	}
43
44	impl HidConnection for TockHidConnection {
45	fn send_or_recv_with_timeout(	×
46	&mut self,	×
47	buf: &mut [u8; 64],	×
48	timeout: Milliseconds<ClockInt>,	×
49	) -> SendOrRecvResult {	×
50	match usb_ctap_hid::send_or_recv_with_timeout(	×
51	buf,	×
52	timer::Duration::from_ms(timeout.integer() as isize),	×
53	self.endpoint,	×
54	) {	×
55	Ok(usb_ctap_hid::SendOrRecvStatus::Timeout) => Ok(SendOrRecvStatus::Timeout),	×
56	Ok(usb_ctap_hid::SendOrRecvStatus::Sent) => Ok(SendOrRecvStatus::Sent),	×
57	Ok(usb_ctap_hid::SendOrRecvStatus::Received(recv_endpoint)) => {	×
58	Ok(SendOrRecvStatus::Received(recv_endpoint))	×
59	}
60	_ => Err(SendOrRecvError),	×
61	}
62	}	×
63	}
64
65	pub struct TockEnv {
66	rng: TockRng256,
67	store: Store<TockStorage>,
68	upgrade_storage: Option<TockUpgradeStorage>,
69	main_connection: TockHidConnection,
70	#[cfg(feature = "vendor_hid")]
71	vendor_connection: TockHidConnection,
72	blink_pattern: usize,
73	}
74
75	impl TockEnv {
76	/// Returns the unique instance of the Tock environment.
77	///
78	/// # Panics
79	///
80	/// - If called a second time.
81	pub fn new() -> Self {
82	// We rely on `take_storage` to ensure that this function is called only once.
83	let storage = take_storage().unwrap();
84	let store = Store::new(storage).ok().unwrap();
85	let upgrade_storage = TockUpgradeStorage::new().ok();
86	TockEnv {
87	rng: TockRng256 {},
88	store,
89	upgrade_storage,
90	main_connection: TockHidConnection {
91	endpoint: UsbEndpoint::MainHid,
92	},
93	#[cfg(feature = "vendor_hid")]
94	vendor_connection: TockHidConnection {
95	endpoint: UsbEndpoint::VendorHid,
96	},
97	blink_pattern: 0,
98	}
99	}
100	}
101
102	/// Returns the unique storage instance.
103	///
104	/// # Panics
105	///
106	/// - If called a second time.
107	pub fn take_storage() -> StorageResult<TockStorage> {	×
108	// Make sure the storage was not already taken.
109	static TAKEN: AtomicBool = AtomicBool::new(false);
110	assert!(!TAKEN.fetch_or(true, Ordering::SeqCst));	×
111	TockStorage::new()	×
112	}	×
113
114	impl UserPresence for TockEnv {
115	fn check_init(&mut self) {
116	self.blink_pattern = 0;
117	}
118	fn wait_with_timeout(&mut self, timeout: Milliseconds<ClockInt>) -> UserPresenceResult {	×
119	if timeout.integer() == 0 {	×
120	return Err(UserPresenceError::Timeout);	×
121	}	×
122	blink_leds(self.blink_pattern);	×
123	self.blink_pattern += 1;	×
124		×
125	let button_touched = Cell::new(false);	×
126	let mut buttons_callback = buttons::with_callback(\|_button_num, state\| {	×
127	match state {	×
128	ButtonState::Pressed => button_touched.set(true),	×
129	ButtonState::Released => (),	×
130	};
131	});	×
132	let mut buttons = buttons_callback.init().flex_unwrap();	×
133	for mut button in &mut buttons {	×
134	button.enable().flex_unwrap();	×
135	}	×
136
137	// Setup a keep-alive callback.
138	let keepalive_expired = Cell::new(false);	×
139	let mut keepalive_callback = timer::with_callback(\|_, _\| {	×
140	keepalive_expired.set(true);
141	});	×
142	let mut keepalive = keepalive_callback.init().flex_unwrap();	×
143	let keepalive_alarm = keepalive	×
144	.set_alarm(timer::Duration::from_ms(timeout.integer() as isize))	×
145	.flex_unwrap();	×
146		×
147	// Wait for a button touch or an alarm.	×
148	libtock_drivers::util::yieldk_for(\|\| button_touched.get() \|\| keepalive_expired.get());	×
149		×
150	// Cleanup alarm callback.	×
151	match keepalive.stop_alarm(keepalive_alarm) {	×
152	Ok(()) => (),	×
153	Err(TockError::Command(CommandError {	×
154	return_code: EALREADY,	×
155	..	×
156	})) => assert!(keepalive_expired.get()),	×
157	Err(_e) => {	×
158	#[cfg(feature = "debug_ctap")]	×
159	panic!("Unexpected error when stopping alarm: {:?}", _e);	×
160	#[cfg(not(feature = "debug_ctap"))]	×
161	panic!("Unexpected error when stopping alarm: <error is only visible with the debug_ctap feature>");	×
162	}
163	}
164
165	for mut button in &mut buttons {	×
166	button.disable().flex_unwrap();	×
167	}	×
168
169	if button_touched.get() {	×
170	Ok(())	×
171	} else if keepalive_expired.get() {	×
172	Err(UserPresenceError::Timeout)	×
173	} else {
174	panic!("Unexpected exit condition");	×
175	}
176	}	×
177
178	fn check_complete(&mut self) {
179	switch_off_leds();
180	}
181	}
182
183	impl FirmwareProtection for TockEnv {
184	fn lock(&mut self) -> bool {
185	matches!(
186	crp::set_protection(crp::ProtectionLevel::FullyLocked),
187	Ok(())
188	\| Err(TockError::Command(CommandError {
189	return_code: EALREADY,
190	..
191	}))
192	)
193	}
194	}
195
196	impl key_store::Helper for TockEnv {}
197
198	impl AttestationStore for TockEnv {
199	fn get(	×
200	&mut self,	×
201	id: &attestation_store::Id,	×
202	) -> Result<Option<attestation_store::Attestation>, attestation_store::Error> {	×
203	if !matches!(id, attestation_store::Id::Batch) {	×
204	return Err(attestation_store::Error::NoSupport);	×
205	}	×
206	attestation_store::helper_get(self)	×
207	}	×
208
209	fn set(	×
210	&mut self,	×
211	id: &attestation_store::Id,	×
212	attestation: Option<&attestation_store::Attestation>,	×
213	) -> Result<(), attestation_store::Error> {	×
214	if !matches!(id, attestation_store::Id::Batch) {	×
215	return Err(attestation_store::Error::NoSupport);	×
216	}	×
217	attestation_store::helper_set(self, attestation)	×
218	}	×
219	}
220
221	impl Env for TockEnv {
222	type Rng = TockRng256;
223	type UserPresence = Self;
224	type Storage = TockStorage;
225	type KeyStore = Self;
226	type AttestationStore = Self;
227	type UpgradeStorage = TockUpgradeStorage;
228	type FirmwareProtection = Self;
229	type Write = Console;
230	type Customization = CustomizationImpl;
231	type HidConnection = TockHidConnection;
232
233	fn rng(&mut self) -> &mut Self::Rng {
234	&mut self.rng
235	}
236
237	fn user_presence(&mut self) -> &mut Self::UserPresence {
238	self
239	}
240
241	fn store(&mut self) -> &mut Store<Self::Storage> {
242	&mut self.store
243	}
244
245	fn key_store(&mut self) -> &mut Self {
246	self
247	}
248
249	fn attestation_store(&mut self) -> &mut Self {
250	self
251	}
252
253	fn upgrade_storage(&mut self) -> Option<&mut Self::UpgradeStorage> {
254	self.upgrade_storage.as_mut()
255	}
256
257	fn firmware_protection(&mut self) -> &mut Self::FirmwareProtection {
258	self
259	}
260
261	fn write(&mut self) -> Self::Write {
262	Console::new()
263	}
264
265	fn customization(&self) -> &Self::Customization {
266	&DEFAULT_CUSTOMIZATION
267	}
268
269	fn main_hid_connection(&mut self) -> &mut Self::HidConnection {
270	&mut self.main_connection
271	}
272
273	#[cfg(feature = "vendor_hid")]
274	fn vendor_hid_connection(&mut self) -> &mut Self::HidConnection {
275	&mut self.vendor_connection
276	}
277	}
278
279	pub fn blink_leds(pattern_seed: usize) {	×
280	for l in 0..led::count().flex_unwrap() {	×
281	if (pattern_seed ^ l).count_ones() & 1 != 0 {	×
282	led::get(l).flex_unwrap().on().flex_unwrap();	×
283	} else {	×
284	led::get(l).flex_unwrap().off().flex_unwrap();	×
285	}	×
286	}
287	}	×
288
289	pub fn wink_leds(pattern_seed: usize) {	×
290	// This generates a "snake" pattern circling through the LEDs.	×
291	// Fox example with 4 LEDs the sequence of lit LEDs will be the following.	×
292	// 0 1 2 3	×
293	// * *	×
294	// * * *	×
295	// * *	×
296	// * * *	×
297	// * *	×
298	// * * *	×
299	// * *	×
300	// * * *	×
301	// * *	×
302	let count = led::count().flex_unwrap();	×
303	let a = (pattern_seed / 2) % count;	×
304	let b = ((pattern_seed + 1) / 2) % count;	×
305	let c = ((pattern_seed + 3) / 2) % count;	×
306
307	for l in 0..count {	×
308	// On nRF52840-DK, logically swap LEDs 3 and 4 so that the order of LEDs form a circle.
309	let k = match l {	×
310	2 => 3,	×
311	3 => 2,	×
312	_ => l,	×
313	};
314	if k == a \|\| k == b \|\| k == c {	×
315	led::get(l).flex_unwrap().on().flex_unwrap();	×
316	} else {	×
317	led::get(l).flex_unwrap().off().flex_unwrap();	×
318	}	×
319	}
320	}	×
321
322	pub fn switch_off_leds() {	×
323	for l in 0..led::count().flex_unwrap() {	×
324	led::get(l).flex_unwrap().off().flex_unwrap();	×
325	}	×
326	}	×
327
328	pub const KEEPALIVE_DELAY_TOCK: Duration<isize> = Duration::from_ms(KEEPALIVE_DELAY_MS as isize);

google / OpenSK / 2708741885

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous