From 40a073d6c4eafe451903d18714e1cbd4ee25a11a Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Mon, 8 Nov 2021 09:52:18 +0100 Subject: [PATCH] Added tests example --- CHANGELOG.md | 1 + examples/tests.rs | 166 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 167 insertions(+) create mode 100644 examples/tests.rs diff --git a/CHANGELOG.md b/CHANGELOG.md index 0381e9f..6964561 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,3 +12,4 @@ and this project adheres to [Semantic Versioning](http://semver.org/). - First version of the HAL which adds the GPIO implementation and timer implementation. - Also adds some examples and helper files to set up new binary crates +- Added basic test binary in form of an example diff --git a/examples/tests.rs b/examples/tests.rs new file mode 100644 index 0000000..fec7915 --- /dev/null +++ b/examples/tests.rs @@ -0,0 +1,166 @@ +//! Test image +//! +//! It would be nice to use a test framework like defmt-test, but I have issues +//! with probe run and it would be better to make the RTT work first +#![no_main] +#![no_std] + +use cortex_m_rt::entry; +use embedded_hal::digital::v2::{InputPin, OutputPin, StatefulOutputPin, ToggleableOutputPin}; +use panic_rtt_target as _; +use rtt_target::{rprintln, rtt_init_print}; +use va108xx_hal::gpio::{porta, portb, PinState}; +use va108xx_hal::prelude::*; + +#[allow(dead_code)] +#[derive(Debug)] +enum TestCase { + // Tie PORTA[0] to PORTA[1] for these tests! + TestBasic, + TestPullup, + TestPulldown, + TestMask, + Perid, + // Tie PA0 to an oscilloscope and configure pulse detection + Pulse, + // Tie PA0, PA1 and PA3 to an oscilloscope + Delay, +} + +#[entry] +fn main() -> ! { + rtt_init_print!(); + rprintln!("-- VA108xx Test Application --"); + let mut dp = va108xx::Peripherals::take().unwrap(); + let porta = dp.PORTA.split(&mut dp.SYSCONFIG).unwrap(); + let _portb = dp.PORTB.split(&mut dp.SYSCONFIG).unwrap(); + let mut led1 = porta + .pa10 + .into_push_pull_output(&mut dp.IOCONFIG, &mut dp.PORTA); + let test_case = TestCase::Delay; + + match test_case { + TestCase::TestBasic + | TestCase::TestPulldown + | TestCase::TestPullup + | TestCase::TestMask => { + rprintln!( + "Test case {:?}. Make sure to tie PORTA[0] to PORTA[1]", + test_case + ); + } + _ => { + rprintln!("Test case {:?}", test_case); + } + } + match test_case { + TestCase::TestBasic => { + // Tie PORTA[0] to PORTA[1] for these tests! + let mut out = porta + .pa0 + .into_push_pull_output(&mut dp.IOCONFIG, &mut dp.PORTA) + .enable_input(&mut dp.IOCONFIG, true); + let input = porta + .pa1 + .into_floating_input(&mut dp.IOCONFIG, &mut dp.PORTA); + out.set_high().unwrap(); + assert!(out.is_set_high().unwrap()); + assert!(input.is_high().unwrap()); + out.set_low().unwrap(); + assert!(out.is_set_low().unwrap()); + assert!(input.is_low().unwrap()); + } + TestCase::TestPullup => { + // Tie PORTA[0] to PORTA[1] for these tests! + let input = porta.pa1.into_pull_up_input(&mut dp.IOCONFIG); + assert!(input.is_high().unwrap()); + let mut out = porta + .pa0 + .into_push_pull_output(&mut dp.IOCONFIG, &mut dp.PORTA); + out.set_low().unwrap(); + assert!(input.is_low().unwrap()); + out.set_high().unwrap(); + assert!(input.is_high().unwrap()); + out.into_floating_input(&mut dp.IOCONFIG, &mut dp.PORTA); + assert!(input.is_high().unwrap()); + } + TestCase::TestPulldown => { + // Tie PORTA[0] to PORTA[1] for these tests! + let input = porta + .pa1 + .into_pull_down_input(&mut dp.IOCONFIG, &mut dp.PORTA); + assert!(input.is_low().unwrap()); + let mut out = porta + .pa0 + .into_push_pull_output(&mut dp.IOCONFIG, &mut dp.PORTA); + out.set_low().unwrap(); + assert!(input.is_low().unwrap()); + out.set_high().unwrap(); + assert!(input.is_high().unwrap()); + out.into_floating_input(&mut dp.IOCONFIG, &mut dp.PORTA); + assert!(input.is_low().unwrap()); + } + TestCase::TestMask => { + // Tie PORTA[0] to PORTA[1] for these tests! + let input = porta + .pa1 + .into_pull_down_input(&mut dp.IOCONFIG, &mut dp.PORTA) + .clear_datamask(&mut dp.PORTA); + assert!(!input.datamask(&dp.PORTA)); + let out = porta + .pa0 + .into_push_pull_output(&mut dp.IOCONFIG, &mut dp.PORTA) + .clear_datamask(&mut dp.PORTA); + assert!(input.is_low_masked(&mut dp.PORTA).is_err()); + assert!(out.set_high_masked(&mut dp.PORTA).is_err()); + } + TestCase::Perid => { + assert_eq!(porta::get_perid(&dp.PORTA), 0x004007e1); + assert_eq!(portb::get_perid(&dp.PORTB), 0x004007e1); + } + TestCase::Pulse => { + let mut output_pulsed = porta + .pa0 + .into_push_pull_output(&mut dp.IOCONFIG, &mut dp.PORTA) + .pulse_mode(&mut dp.PORTA, true, PinState::Low); + rprintln!("Pulsing high 10 times.."); + output_pulsed.set_low().unwrap(); + for _ in 0..10 { + output_pulsed.set_high().unwrap(); + cortex_m::asm::delay(25_000_000); + } + let mut output_pulsed = output_pulsed.pulse_mode(&mut dp.PORTA, true, PinState::High); + rprintln!("Pulsing low 10 times.."); + for _ in 0..10 { + output_pulsed.set_low().unwrap(); + cortex_m::asm::delay(25_000_000); + } + } + TestCase::Delay => { + let mut out_0 = porta + .pa0 + .into_push_pull_output(&mut dp.IOCONFIG, &mut dp.PORTA) + .delay(&mut dp.PORTA, true, false); + let mut out_1 = porta + .pa1 + .into_push_pull_output(&mut dp.IOCONFIG, &mut dp.PORTA) + .delay(&mut dp.PORTA, false, true); + let mut out_2 = porta + .pa3 + .into_push_pull_output(&mut dp.IOCONFIG, &mut dp.PORTA) + .delay(&mut dp.PORTA, true, true); + for _ in 0..20 { + out_0.toggle().unwrap(); + out_1.toggle().unwrap(); + out_2.toggle().unwrap(); + cortex_m::asm::delay(25_000_000); + } + } + } + + rprintln!("Test success"); + loop { + led1.toggle().ok(); + cortex_m::asm::delay(25_000_000); + } +}