mirror/rtic
1
0
Fork 0
mirror of https://github.com/rtic-rs/rtic.git synced 2025-12-16 21:05:35 +01:00
Code Issues Projects Releases Packages Wiki Activity

Add rtic-timer (timerqueue + monotonic) and rtic-monotonics (systick-monotonic)

Browse source
This commit is contained in:
Emil Fresk 2023-01-23 20:05:47 +01:00 • committed by Henrik Tjäder
parent b8b881f446
commit 306aa47170
276 changed files with 607 additions and 713 deletions
Download patch file Download diff file Expand all files Collapse all files

9
xtask/Cargo.toml
View file

@ -1,9 +0,0 @@
[package]
name = "xtask"
version = "0.1.0"
edition = "2018"
[dependencies]
anyhow = "1.0.43"
os_pipe = "1.1.2"
structopt = "0.3.22"

13
xtask/src/build.rs
View file

@ -1,13 +0,0 @@
use std::{fs, path::Path};
const HEX_BUILD_ROOT: &str = "ci/builds";
/// make sure we're starting with a clean,but existing slate
pub fn init_build_dir() -> anyhow::Result<()> {
if Path::new(HEX_BUILD_ROOT).exists() {
fs::remove_dir_all(HEX_BUILD_ROOT)
.map_err(|_| anyhow::anyhow!("Could not clear out directory: {}", HEX_BUILD_ROOT))?;
}
fs::create_dir_all(HEX_BUILD_ROOT)
.map_err(|_| anyhow::anyhow!("Could not create directory: {}", HEX_BUILD_ROOT))
}

172
xtask/src/command.rs
View file

@ -1,172 +0,0 @@
use crate::{RunResult, TestRunError};
use core::fmt;
use os_pipe::pipe;
use std::{fs::File, io::Read, process::Command};
#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum BuildMode {
Release,
Debug,
}
#[derive(Debug)]
pub enum CargoCommand<'a> {
Run {
example: &'a str,
target: &'a str,
features: Option<&'a str>,
mode: BuildMode,
},
BuildAll {
target: &'a str,
features: Option<&'a str>,
mode: BuildMode,
},
// Size {
// example_paths: Vec<&'a Path>,
// },
// Clean,
}
impl<'a> CargoCommand<'a> {
fn name(&self) -> &str {
match self {
CargoCommand::Run { .. } => "run",
// CargoCommand::Size { example_paths: _ } => "rust-size",
CargoCommand::BuildAll { .. } => "build",
}
}
pub fn args(&self) -> Vec<&str> {
match self {
CargoCommand::Run {
example,
target,
features,
mode,
} => {
let mut args = vec![
"+nightly",
self.name(),
"--example",
example,
"--target",
target,
"--features",
"test-critical-section",
];
if let Some(feature_name) = features {
args.extend_from_slice(&["--features", feature_name]);
}
if let Some(flag) = mode.to_flag() {
args.push(flag);
}
args
}
CargoCommand::BuildAll {
target,
features,
mode,
} => {
let mut args = vec![
"+nightly",
self.name(),
"--examples",
"--target",
target,
"--features",
"test-critical-section",
];
if let Some(feature_name) = features {
args.extend_from_slice(&["--features", feature_name]);
}
if let Some(flag) = mode.to_flag() {
args.push(flag);
}
args
} // CargoCommand::Size { example_paths } => {
// example_paths.iter().map(|p| p.to_str().unwrap()).collect()
// }
}
}
pub fn command(&self) -> &str {
match self {
// we need to cheat a little here:
// `cargo size` can't be ran on multiple files, so we're using `rust-size` instead –
// which isn't a command that starts wizh `cargo`. So we're sneakily swapping them out :)
// CargoCommand::Size { .. } => "rust-size",
_ => "cargo",
}
}
}
impl BuildMode {
pub fn to_flag(&self) -> Option<&str> {
match self {
BuildMode::Release => Some("--release"),
BuildMode::Debug => None,
}
}
}
impl fmt::Display for BuildMode {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let cmd = match self {
BuildMode::Release => "release",
BuildMode::Debug => "debug",
};
write!(f, "{}", cmd)
}
}
pub fn run_command(command: &CargoCommand) -> anyhow::Result<RunResult> {
let (mut reader, writer) = pipe()?;
println!("👟 {} {}", command.command(), command.args().join(" "));
let mut handle = Command::new(command.command())
.args(command.args())
.stdout(writer)
.spawn()?;
// retrieve output and clean up
let mut output = String::new();
reader.read_to_string(&mut output)?;
let exit_status = handle.wait()?;
Ok(RunResult {
exit_status,
output,
})
}
/// Check if `run` was successful.
/// returns Ok in case the run went as expected,
/// Err otherwise
pub fn run_successful(run: &RunResult, expected_output_file: String) -> Result<(), TestRunError> {
let mut file_handle =
File::open(expected_output_file.clone()).map_err(|_| TestRunError::FileError {
file: expected_output_file.clone(),
})?;
let mut expected_output = String::new();
file_handle
.read_to_string(&mut expected_output)
.map_err(|_| TestRunError::FileError {
file: expected_output_file.clone(),
})?;
if expected_output != run.output {
Err(TestRunError::FileCmpError {
expected: expected_output.clone(),
got: run.output.clone(),
})
} else if !run.exit_status.success() {
Err(TestRunError::CommandError(run.clone()))
} else {
Ok(())
}
}

176
xtask/src/main.rs
View file

@ -1,176 +0,0 @@
mod build;
mod command;
use anyhow::bail;
use core::fmt;
use std::{
error::Error,
ffi::OsString,
path::{Path, PathBuf},
process,
process::ExitStatus,
str,
};
use structopt::StructOpt;
use crate::{
build::init_build_dir,
command::{run_command, run_successful, BuildMode, CargoCommand},
};
const ARMV6M: &str = "thumbv6m-none-eabi";
const ARMV7M: &str = "thumbv7m-none-eabi";
#[derive(Debug, StructOpt)]
struct Options {
#[structopt(short, long)]
target: String,
}
#[derive(Debug, Clone)]
pub struct RunResult {
exit_status: ExitStatus,
output: String,
}
#[derive(Debug)]
pub enum TestRunError {
FileCmpError { expected: String, got: String },
FileError { file: String },
PathConversionError(OsString),
CommandError(RunResult),
IncompatibleCommand,
}
impl fmt::Display for TestRunError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
TestRunError::FileCmpError { expected, got } => {
writeln!(f, "Differing output in files.")?;
writeln!(f, "")?;
writeln!(f, "Expected:")?;
writeln!(f, "{}", expected)?;
writeln!(f, "")?;
writeln!(f, "Got:")?;
write!(f, "{}", got)
}
TestRunError::FileError { file } => {
write!(f, "File error on: {}", file)
}
TestRunError::CommandError(e) => {
write!(
f,
"Command failed with exit status {}: {}",
e.exit_status, e.output
)
}
TestRunError::PathConversionError(p) => {
write!(f, "Can't convert path from `OsString` to `String`: {:?}", p)
}
TestRunError::IncompatibleCommand => {
write!(f, "Can't run that command in this context")
}
}
}
}
impl Error for TestRunError {}
fn main() -> anyhow::Result<()> {
// if there's an `xtask` folder, we're *probably* at the root of this repo (we can't just
// check the name of `env::current_dir()` because people might clone it into a different name)
let probably_running_from_repo_root = Path::new("./xtask").exists();
if probably_running_from_repo_root == false {
bail!("xtasks can only be executed from the root of the `cortex-m-rtic` repository");
}
let targets = [ARMV7M, ARMV6M];
let examples: Vec<_> = std::fs::read_dir("./examples")?
.filter_map(|p| p.ok())
.map(|p| p.path())
.filter(|p| p.display().to_string().ends_with(".rs"))
.map(|path| path.file_stem().unwrap().to_str().unwrap().to_string())
.collect();
println!("examples: {examples:?}");
let opts = Options::from_args();
let target = &opts.target;
init_build_dir()?;
if target == "all" {
for t in targets {
run_test(t, &examples)?;
}
} else if targets.contains(&target.as_str()) {
run_test(&target, &examples)?;
} else {
eprintln!(
"The target you specified is not available. Available targets are:\
\n{:?}\n\
as well as `all` (testing on all of the above)",
targets
);
process::exit(1);
}
Ok(())
}
fn run_test(target: &str, examples: &[String]) -> anyhow::Result<()> {
arm_example(&CargoCommand::BuildAll {
target,
features: None,
mode: BuildMode::Release,
})?;
for example in examples {
let cmd = CargoCommand::Run {
example,
target,
features: None,
mode: BuildMode::Release,
};
arm_example(&cmd)?;
}
Ok(())
}
// run example binary `example`
fn arm_example(command: &CargoCommand) -> anyhow::Result<()> {
match *command {
CargoCommand::Run { example, .. } => {
let run_file = format!("{}.run", example);
let expected_output_file = ["ci", "expected", &run_file]
.iter()
.collect::<PathBuf>()
.into_os_string()
.into_string()
.map_err(|e| TestRunError::PathConversionError(e))?;
// command is either build or run
let cargo_run_result = run_command(&command)?;
println!("{}", cargo_run_result.output);
match &command {
CargoCommand::Run { .. } => {
run_successful(&cargo_run_result, expected_output_file)?;
}
_ => (),
}
Ok(())
}
CargoCommand::BuildAll { .. } => {
// command is either build or run
let cargo_run_result = run_command(&command)?;
println!("{}", cargo_run_result.output);
Ok(())
} // _ => Err(anyhow::Error::new(TestRunError::IncompatibleCommand)),
}
}