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

4 files changed, 0 insertions, 370 deletions

diff --git a/xtask/Cargo.toml b/xtask/Cargo.toml
deleted file mode 100644
index f1c468e..0000000
--- a/xtask/Cargo.toml
+++ /dev/null
@@ -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"
diff --git a/xtask/src/build.rs b/xtask/src/build.rs
deleted file mode 100644
index 148a9fd..0000000
--- a/xtask/src/build.rs
+++ /dev/null
@@ -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))
-}
diff --git a/xtask/src/command.rs b/xtask/src/command.rs
deleted file mode 100644
index 4e90369..0000000
--- a/xtask/src/command.rs
+++ /dev/null
@@ -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(())
-    }
-}
diff --git a/xtask/src/main.rs b/xtask/src/main.rs
deleted file mode 100644
index 7eada91..0000000
--- a/xtask/src/main.rs
+++ /dev/null
@@ -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)),
-    }
-}