4261570218

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/<a class="double-link" href="https://git"><a class=hub.com/google/OpenSK/commit/07f3686d1d71a840d8d72a87ec6e23e32ff73bbe">07f3686d1">&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/07f3686d1d71a840d8d72a87ec6e23e32ff73bbe">07f3686d1</a><a href="https://github.com/google/OpenSK/commit/07f3686d1d71a840d8d72a87ec6e23e32ff73bbe">&lt;a href=&quot;https://github.com/google/OpenSK/commit/07f3686d1d71a840d8d72a87ec6e23e32ff73bbe&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;https://git&amp;quot;&amp;gt;&amp;amp;lt;a class=&amp;lt;/a&amp;gt;hub.com/google/OpenSK/commit/07f3686d1d71a840d8d72a87ec6e23e32ff73bbe&amp;quot;&amp;gt;07f3686d1&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/google/OpenSK/commit/07f3686d1d71a840d8d72a87ec6e23e32ff73bbe&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/google/OpenSK/commit/07f3686d1d71a840d8d72a87ec6e23e3&amp;lt;/a&amp;gt;2</a>ff73bbe&quot;&gt;&amp;quot;&amp;gt;Merge &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;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/google/OpenSK/commit/4584282f6&quot;&gt;4584282f6&lt;/a&gt;&lt;a href=&quot;https://github.com/google/OpenSK/co... (continued)

Pull Request Pull Request #596: Clock trait

Run Details

718 of 718 new or added lines in 17 files covered. (100.0%)

14554 of 16625 relevant lines covered (87.54%)

809785.13 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::env::Env;
use clock::TockClock;
use core::cell::Cell;
use core::sync::atomic::{AtomicBool, Ordering};
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 clock;
mod storage;

pub struct TockHidConnection {
    endpoint: UsbEndpoint,
}

impl HidConnection for TockHidConnection {
    fn send_and_maybe_recv(&mut self, buf: &mut [u8; 64], timeout: usize) -> SendOrRecvResult {
        match usb_ctap_hid::send_or_recv_with_timeout(
            buf,
            Duration::from_ms(timeout 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,
    clock: TockClock,
}

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,
            clock: TockClock::new(),
        }
    }
}

/// 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: usize) -> UserPresenceResult {
        if timeout == 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(Duration::from_ms(timeout 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 Clock = TockClock;
    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 clock(&mut self) -> &mut Self::Clock {
        &mut self.clock
    }

    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();
    }
}

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

google / OpenSK / 4261570218

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