mirrors/embedded-trainings-2020
1
0
Fork 0
mirror of https://github.com/ferrous-systems/embedded-trainings-2020.git synced 2024-05-18 16:28:22 +00:00
Code Issues Projects Releases Wiki Activity

convert all beginner code snippets

Browse source
This commit is contained in:
Lotte Steenbrink 2021-04-12 11:51:44 +02:00
parent e1f740caba
commit 622707bab7
11 changed files with 73 additions and 56 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
beginner/apps/src/bin/radio-puzzle-3.rs
View file

@ -5,7 +5,8 @@
use cortex_m_rt::entry; use cortex_m_rt::entry;
use dk::ieee802154::{Channel, Packet}; use dk::ieee802154::{Channel, Packet};
use heapless::{consts, LinearMap}; use heapless::{consts, LinearMap};
use panic_log as _; // the panicking behavior // this imports `beginner/apps/lib.rs` to retrieve our global logger + panicking-behavior
use apps as _;
const TEN_MS: u32 = 10_000; const TEN_MS: u32 = 10_000;
@ -36,16 +37,18 @@ fn main() -> ! {
// TODO insert the key-value pair // TODO insert the key-value pair
// dict.insert(/* ? */, /* ? */).expect("dictionary full"); // dict.insert(/* ? */, /* ? */).expect("dictionary full");
} else { } else {
log::error!("response packet was not a single byte"); defmt::error!("response packet was not a single byte");
dk::exit() dk::exit()
} }
} else { } else {
log::error!("no response or response packet was corrupted"); defmt::error!("no response or response packet was corrupted");
dk::exit() dk::exit()
} }
} }
log::info!("{:?}", dict); defmt::info!("{:?}", defmt::Debug2Format(&dict));
// ^^^^^^^^^^^^^^^^^^^ this adapter iscurrently needed to log `heapless`
// data structures (like `LinearMap` here) with `defmt`
dk::exit() dk::exit()
} }

12
beginner/apps/src/bin/radio-puzzle-4.rs
View file

@ -6,7 +6,8 @@ use core::str;
use cortex_m_rt::entry; use cortex_m_rt::entry;
use heapless::{consts, Vec}; use heapless::{consts, Vec};
use panic_log as _; // the panicking behavior // this imports `beginner/apps/lib.rs` to retrieve our global logger + panicking-behavior
use apps as _;
#[entry] #[entry]
fn main() -> ! { fn main() -> ! {
@ -21,10 +22,13 @@ fn main() -> ! {
buffer.push(b'i').expect("buffer full"); buffer.push(b'i').expect("buffer full");
// look into the contents so far // look into the contents so far
log::info!("{:?}", buffer); defmt::info!("{:?}", defmt::Debug2Format(&buffer));
// ^^^^^^^^^^^^^^^^^^^ this adapter iscurrently needed to log `heapless`
// data structures (like `Vec` here) with `defmt`
// or more readable // or more readable
// NOTE as long as you only push bytes in the ASCII range (0..=127) the conversion should work // NOTE utf-8 conversion works as long as you only push bytes in the ASCII range (0..=127)
log::info!( defmt::info!(
"{}", "{}",
str::from_utf8(&buffer).expect("content was not UTF-8") str::from_utf8(&buffer).expect("content was not UTF-8")
); );

9
beginner/apps/src/bin/radio-puzzle-5.rs
View file

@ -7,7 +7,8 @@ use core::str;
use cortex_m_rt::entry; use cortex_m_rt::entry;
use dk::ieee802154::{Channel, Packet}; use dk::ieee802154::{Channel, Packet};
use heapless::{consts, Vec}; use heapless::{consts, Vec};
use panic_log as _; // the panicking behavior // this imports `beginner/apps/lib.rs` to retrieve our global logger + panicking-behavior
use apps as _;
const TEN_MS: u32 = 10_000; const TEN_MS: u32 = 10_000;
@ -27,11 +28,11 @@ fn main() -> ! {
radio.send(&mut packet); radio.send(&mut packet);
if radio.recv_timeout(&mut packet, &mut timer, TEN_MS).is_err() { if radio.recv_timeout(&mut packet, &mut timer, TEN_MS).is_err() {
log::error!("no response or response packet was corrupted"); defmt::error!("no response or response packet was corrupted");
dk::exit() dk::exit()
} }
log::info!( defmt::info!(
"ciphertext: {}", "ciphertext: {}",
str::from_utf8(&packet).expect("packet was not valid UTF-8") str::from_utf8(&packet).expect("packet was not valid UTF-8")
); );
@ -47,7 +48,7 @@ fn main() -> ! {
buf.push(output).expect("buffer full"); buf.push(output).expect("buffer full");
} }
log::info!( defmt::info!(
"plaintext: {}", "plaintext: {}",
str::from_utf8(&buf).expect("buffer contains non-UTF-8 data") str::from_utf8(&buf).expect("buffer contains non-UTF-8 data")
); );

13
beginner/apps/src/bin/radio-puzzle-6.rs
View file

@ -7,7 +7,8 @@ use core::str;
use cortex_m_rt::entry; use cortex_m_rt::entry;
use dk::ieee802154::{Channel, Packet}; use dk::ieee802154::{Channel, Packet};
use heapless::{consts, LinearMap, Vec}; use heapless::{consts, LinearMap, Vec};
use panic_log as _; // the panicking behavior // this imports `beginner/apps/lib.rs` to retrieve our global logger + panicking-behavior
use apps as _;
const TEN_MS: u32 = 10_000; const TEN_MS: u32 = 10_000;
@ -37,11 +38,11 @@ fn main() -> ! {
// TODO insert the key-value pair // TODO insert the key-value pair
// dict.insert(/* ? */, /* ? */).expect("dictionary full"); // dict.insert(/* ? */, /* ? */).expect("dictionary full");
} else { } else {
log::error!("response packet was not a single byte"); defmt::error!("response packet was not a single byte");
dk::exit() dk::exit()
} }
} else { } else {
log::error!("no response or response packet was corrupted"); defmt::error!("no response or response packet was corrupted");
dk::exit() dk::exit()
} }
} }
@ -51,11 +52,11 @@ fn main() -> ! {
radio.send(&mut packet); radio.send(&mut packet);
if radio.recv_timeout(&mut packet, &mut timer, TEN_MS).is_err() { if radio.recv_timeout(&mut packet, &mut timer, TEN_MS).is_err() {
log::error!("no response or response packet was corrupted"); defmt::error!("no response or response packet was corrupted");
dk::exit() dk::exit()
} }
log::info!( defmt::info!(
"ciphertext: {}", "ciphertext: {}",
str::from_utf8(&packet).expect("packet was not valid UTF-8") str::from_utf8(&packet).expect("packet was not valid UTF-8")
); );
@ -71,7 +72,7 @@ fn main() -> ! {
buffer.push(value).expect("buffer full"); buffer.push(value).expect("buffer full");
} }
log::info!( defmt::info!(
"plaintext: {}", "plaintext: {}",
str::from_utf8(&buffer).expect("buffer contains non-UTF-8 data") str::from_utf8(&buffer).expect("buffer contains non-UTF-8 data")
); );

17
beginner/apps/src/bin/radio-puzzle-7.rs
View file

@ -7,7 +7,8 @@ use core::str;
use cortex_m_rt::entry; use cortex_m_rt::entry;
use dk::ieee802154::{Channel, Packet}; use dk::ieee802154::{Channel, Packet};
use heapless::{consts, LinearMap, Vec}; use heapless::{consts, LinearMap, Vec};
use panic_log as _; // the panicking behavior // this imports `beginner/apps/lib.rs` to retrieve our global logger + panicking-behavior
use apps as _;
const TEN_MS: u32 = 10_000; const TEN_MS: u32 = 10_000;
@ -37,11 +38,11 @@ fn main() -> ! {
// TODO insert the key-value pair // TODO insert the key-value pair
// dict.insert(/* ? */, /* ? */).expect("dictionary full"); // dict.insert(/* ? */, /* ? */).expect("dictionary full");
} else { } else {
log::error!("response packet was not a single byte"); defmt::error!("response packet was not a single byte");
dk::exit() dk::exit()
} }
} else { } else {
log::error!("no response or response packet was corrupted"); defmt::error!("no response or response packet was corrupted");
dk::exit() dk::exit()
} }
} }
@ -51,11 +52,11 @@ fn main() -> ! {
radio.send(&mut packet); radio.send(&mut packet);
if radio.recv_timeout(&mut packet, &mut timer, TEN_MS).is_err() { if radio.recv_timeout(&mut packet, &mut timer, TEN_MS).is_err() {
log::error!("no response or response packet was corrupted"); defmt::error!("no response or response packet was corrupted");
dk::exit() dk::exit()
} }
log::info!( defmt::info!(
"ciphertext: {}", "ciphertext: {}",
str::from_utf8(&packet).expect("packet was not valid UTF-8") str::from_utf8(&packet).expect("packet was not valid UTF-8")
); );
@ -71,7 +72,7 @@ fn main() -> ! {
buffer.push(value).expect("buffer full"); buffer.push(value).expect("buffer full");
} }
log::info!( defmt::info!(
"plaintext: {}", "plaintext: {}",
str::from_utf8(&buffer).expect("buffer contains non-UTF-8 data") str::from_utf8(&buffer).expect("buffer contains non-UTF-8 data")
); );
@ -82,11 +83,11 @@ fn main() -> ! {
radio.send(&mut packet); radio.send(&mut packet);
if radio.recv_timeout(&mut packet, &mut timer, TEN_MS).is_err() { if radio.recv_timeout(&mut packet, &mut timer, TEN_MS).is_err() {
log::error!("no response or response packet was corrupted"); defmt::error!("no response or response packet was corrupted");
dk::exit() dk::exit()
} }
log::info!( defmt::info!(
"Dongle response: {}", "Dongle response: {}",
str::from_utf8(&packet).expect("response was not UTF-8") str::from_utf8(&packet).expect("response was not UTF-8")
); );

17
beginner/apps/src/bin/radio-puzzle-solution-2.rs
View file

@ -7,7 +7,8 @@ use core::str;
use cortex_m_rt::entry; use cortex_m_rt::entry;
use dk::ieee802154::{Channel, Packet}; use dk::ieee802154::{Channel, Packet};
use heapless::{consts, LinearMap}; use heapless::{consts, LinearMap};
use panic_log as _; // the panicking behavior // this imports `beginner/apps/lib.rs` to retrieve our global logger + panicking-behavior
use apps as _;
const TEN_MS: u32 = 10_000; const TEN_MS: u32 = 10_000;
@ -37,11 +38,11 @@ fn main() -> ! {
dict.insert(cipherletter, plainletter) dict.insert(cipherletter, plainletter)
.expect("dictionary full"); .expect("dictionary full");
} else { } else {
log::error!("response packet was not a single byte"); defmt::error!("response packet was not a single byte");
dk::exit() dk::exit()
} }
} else { } else {
log::error!("no response or response packet was corrupted"); defmt::error!("no response or response packet was corrupted");
dk::exit() dk::exit()
} }
} }
@ -51,11 +52,11 @@ fn main() -> ! {
radio.send(&mut packet); radio.send(&mut packet);
if radio.recv_timeout(&mut packet, &mut timer, TEN_MS).is_err() { if radio.recv_timeout(&mut packet, &mut timer, TEN_MS).is_err() {
log::error!("no response or response packet was corrupted"); defmt::error!("no response or response packet was corrupted");
dk::exit() dk::exit()
} }
log::info!( defmt::info!(
"ciphertext: {}", "ciphertext: {}",
str::from_utf8(&packet).expect("packet was not valid UTF-8") str::from_utf8(&packet).expect("packet was not valid UTF-8")
); );
@ -73,7 +74,7 @@ fn main() -> ! {
*spot = plainletter; *spot = plainletter;
} }
log::info!( defmt::info!(
"plaintext: {}", "plaintext: {}",
str::from_utf8(&packet).expect("buffer contains non-UTF-8 data") str::from_utf8(&packet).expect("buffer contains non-UTF-8 data")
); );
@ -82,11 +83,11 @@ fn main() -> ! {
radio.send(&mut packet); radio.send(&mut packet);
if radio.recv_timeout(&mut packet, &mut timer, TEN_MS).is_err() { if radio.recv_timeout(&mut packet, &mut timer, TEN_MS).is_err() {
log::error!("no response or response packet was corrupted"); defmt::error!("no response or response packet was corrupted");
dk::exit() dk::exit()
} }
log::info!( defmt::info!(
"Dongle response: {}", "Dongle response: {}",
str::from_utf8(&packet).expect("response was not UTF-8") str::from_utf8(&packet).expect("response was not UTF-8")
); );

17
beginner/apps/src/bin/radio-puzzle-solution.rs
View file

@ -7,7 +7,8 @@ use core::str;
use cortex_m_rt::entry; use cortex_m_rt::entry;
use dk::ieee802154::{Channel, Packet}; use dk::ieee802154::{Channel, Packet};
use heapless::{consts, LinearMap, Vec}; use heapless::{consts, LinearMap, Vec};
use panic_log as _; // the panicking behavior // this imports `beginner/apps/lib.rs` to retrieve our global logger + panicking-behavior
use apps as _;
const TEN_MS: u32 = 10_000; const TEN_MS: u32 = 10_000;
@ -40,11 +41,11 @@ fn main() -> ! {
dict.insert(cipherletter, plainletter) dict.insert(cipherletter, plainletter)
.expect("dictionary full"); .expect("dictionary full");
} else { } else {
log::error!("response packet was not a single byte"); defmt::error!("response packet was not a single byte");
dk::exit() dk::exit()
} }
} else { } else {
log::error!("no response or response packet was corrupted"); defmt::error!("no response or response packet was corrupted");
dk::exit() dk::exit()
} }
} }
@ -54,11 +55,11 @@ fn main() -> ! {
radio.send(&mut packet); radio.send(&mut packet);
if radio.recv_timeout(&mut packet, &mut timer, TEN_MS).is_err() { if radio.recv_timeout(&mut packet, &mut timer, TEN_MS).is_err() {
log::error!("no response or response packet was corrupted"); defmt::error!("no response or response packet was corrupted");
dk::exit() dk::exit()
} }
log::info!( defmt::info!(
"ciphertext: {}", "ciphertext: {}",
str::from_utf8(&packet).expect("packet was not valid UTF-8") str::from_utf8(&packet).expect("packet was not valid UTF-8")
); );
@ -75,7 +76,7 @@ fn main() -> ! {
buffer.push(plainletter).expect("buffer full"); buffer.push(plainletter).expect("buffer full");
} }
log::info!( defmt::info!(
"plaintext: {}", "plaintext: {}",
str::from_utf8(&buffer).expect("buffer contains non-UTF-8 data") str::from_utf8(&buffer).expect("buffer contains non-UTF-8 data")
); );
@ -86,11 +87,11 @@ fn main() -> ! {
radio.send(&mut packet); radio.send(&mut packet);
if radio.recv_timeout(&mut packet, &mut timer, TEN_MS).is_err() { if radio.recv_timeout(&mut packet, &mut timer, TEN_MS).is_err() {
log::error!("no response or response packet was corrupted"); defmt::error!("no response or response packet was corrupted");
dk::exit() dk::exit()
} }
log::info!( defmt::info!(
"Dongle response: {}", "Dongle response: {}",
str::from_utf8(&packet).expect("response was not UTF-8") str::from_utf8(&packet).expect("response was not UTF-8")
); );

9
beginner/apps/src/bin/radio-puzzle.rs
View file

@ -6,7 +6,8 @@ use core::str;
use cortex_m_rt::entry; use cortex_m_rt::entry;
use dk::ieee802154::{Channel, Packet}; use dk::ieee802154::{Channel, Packet};
use panic_log as _; // the panicking behavior // this imports `beginner/apps/lib.rs` to retrieve our global logger + panicking-behavior
use apps as _;
const TEN_MS: u32 = 10_000; const TEN_MS: u32 = 10_000;
@ -33,19 +34,19 @@ fn main() -> ! {
// let msg = b"Hello?"; // let msg = b"Hello?";
packet.copy_from_slice(msg); packet.copy_from_slice(msg);
log::info!( defmt::info!(
"sending: {}", "sending: {}",
str::from_utf8(msg).expect("msg was not valid UTF-8 data") str::from_utf8(msg).expect("msg was not valid UTF-8 data")
); );
radio.send(&mut packet); radio.send(&mut packet);
if radio.recv_timeout(&mut packet, &mut timer, TEN_MS).is_ok() { if radio.recv_timeout(&mut packet, &mut timer, TEN_MS).is_ok() {
log::info!( defmt::info!(
"received: {}", "received: {}",
str::from_utf8(&packet).expect("response was not valid UTF-8 data") str::from_utf8(&packet).expect("response was not valid UTF-8 data")
); );
} else { } else {
log::error!("no response or response packet was corrupted"); defmt::error!("no response or response packet was corrupted");
} }
dk::exit() dk::exit()
} }

14
beginner/apps/src/bin/radio-recv.rs
View file

@ -6,7 +6,8 @@ use core::str;
use cortex_m_rt::entry; use cortex_m_rt::entry;
use dk::ieee802154::{Channel, Error, Packet}; use dk::ieee802154::{Channel, Error, Packet};
use panic_log as _; // the panicking behavior // this imports `beginner/apps/lib.rs` to retrieve our global logger + panicking-behavior
use apps as _;
const TEN_MS: u32 = 10_000; const TEN_MS: u32 = 10_000;
@ -24,7 +25,7 @@ fn main() -> ! {
let msg = b"olleh"; let msg = b"olleh";
packet.copy_from_slice(msg); packet.copy_from_slice(msg);
log::info!( defmt::info!(
"sending: {}", "sending: {}",
str::from_utf8(msg).expect("message is not valid UTF-8") str::from_utf8(msg).expect("message is not valid UTF-8")
); );
@ -37,14 +38,15 @@ fn main() -> ! {
match res { match res {
Ok(crc) => { Ok(crc) => {
log::info!( defmt::info!(
"received: {} (CRC={})", "received: {} (CRC = {:X})",
// ^^ print as uppercase hexadecimal
str::from_utf8(&*packet).expect("response is not valid UTF-8"), str::from_utf8(&*packet).expect("response is not valid UTF-8"),
crc crc
); );
} }
Err(Error::Crc(crc)) => log::error!("invalid CRC: {:06x}", crc), Err(Error::Crc(crc)) => defmt::error!("invalid CRC: {=u16:x}", crc),
Err(Error::Timeout) => log::error!("no response within {} ms", TEN_MS / 1_000), Err(Error::Timeout) => defmt::error!("no response within {} ms", TEN_MS / 1_000),
} }
dk::exit() dk::exit()

5
beginner/apps/src/bin/radio-send.rs
View file

@ -6,7 +6,8 @@ use core::str;
use cortex_m_rt::entry; use cortex_m_rt::entry;
use dk::ieee802154::{Channel, Packet, TxPower}; use dk::ieee802154::{Channel, Packet, TxPower};
use panic_log as _; // the panicking behavior // this imports `beginner/apps/lib.rs` to retrieve our global logger + panicking-behavior
use apps as _;
#[entry] #[entry]
fn main() -> ! { fn main() -> ! {
@ -25,7 +26,7 @@ fn main() -> ! {
// let msg: &[u8; 5] = &[b'H', b'e', b'l', b'l', b'o']; // let msg: &[u8; 5] = &[b'H', b'e', b'l', b'l', b'o'];
// let msg: &[u8; 5] = b"Hello"; // let msg: &[u8; 5] = b"Hello";
log::info!( defmt::info!(
"sending: {}", "sending: {}",
str::from_utf8(msg).expect("msg is not valid UTF-8 data") str::from_utf8(msg).expect("msg is not valid UTF-8 data")
); );

5
beginner/apps/src/bin/stack_overflow.rs
View file

@ -3,14 +3,15 @@
use cortex_m::asm; use cortex_m::asm;
use cortex_m_rt::entry; use cortex_m_rt::entry;
use panic_log as _; // panic handler // this imports `beginner/apps/lib.rs` to retrieve our global logger + panicking-behavior
use apps as _;
#[entry] #[entry]
fn main() -> ! { fn main() -> ! {
// board initialization // board initialization
dk::init().unwrap(); dk::init().unwrap();
log::info!("fib(100) = {:?}", fib(100)); defmt::info!("fib(100) = {:?}", fib(100));
loop { loop {
asm::bkpt(); asm::bkpt();