rp-hal-boards/boards/rp-pico/examples/pico_interpolator.rs

442 lines
13 KiB
Rust
Raw Normal View History

//! # Pico Interpolator Example
//!
//! Example demonstrating the usage of the hardware interpolator.
//!
//! Runs several test programs, outputs the result on LEDs.
//! Green led for successful test connects to GPIO3.
//! Red led for unsuccessful test connects to GPIO4.
//! In case of failure, the system LED blinks the number of the test.
//! In case of success, the system LED stays lit.
//!
//! See the `Cargo.toml` file for Copyright and license details.
#![no_std]
#![no_main]
// The macro for our start-up function
use rp_pico::entry;
// Time handling traits
use embedded_time::rate::*;
// GPIO traits
use embedded_hal::digital::v2::OutputPin;
// Ensure we halt the program on panic (if we don't mention this crate it won't
// be linked)
use panic_halt as _;
// A shorter alias for the Peripheral Access Crate, which provides low-level
// register access
use rp_pico::hal::pac;
// A shorter alias for the Hardware Abstraction Layer, which provides
// higher-level drivers.
use rp_pico::hal;
// Pull in any important traits
use rp_pico::hal::prelude::*;
use rp_pico::hal::sio::{Interp, Interp0, Interp1, Lane, LaneCtrl};
/// Entry point to our bare-metal application.
///
/// The `#[entry]` macro ensures the Cortex-M start-up code calls this function
/// as soon as all global variables are initialised.
///
/// The function configures the RP2040 peripherals, then just reads the button
/// and sets the LED appropriately.
#[entry]
fn main() -> ! {
// Grab our singleton objects
let mut pac = pac::Peripherals::take().unwrap();
let core = pac::CorePeripherals::take().unwrap();
// Set up the watchdog driver - needed by the clock setup code
let mut watchdog = hal::Watchdog::new(pac.WATCHDOG);
// Configure the clocks
//
// The default is to generate a 125 MHz system clock
let clocks = hal::clocks::init_clocks_and_plls(
rp_pico::XOSC_CRYSTAL_FREQ,
pac.XOSC,
pac.CLOCKS,
pac.PLL_SYS,
pac.PLL_USB,
&mut pac.RESETS,
&mut watchdog,
)
.ok()
.unwrap();
// The delay object lets us wait for specified amounts of time (in
// milliseconds)
let mut delay = cortex_m::delay::Delay::new(core.SYST, clocks.system_clock.freq().integer());
// The single-cycle I/O block controls our GPIO pins
let mut sio = hal::Sio::new(pac.SIO);
// Set the pins up according to their function on this particular board
let pins = rp_pico::Pins::new(
pac.IO_BANK0,
pac.PADS_BANK0,
sio.gpio_bank0,
&mut pac.RESETS,
);
// Our LED outputs
let mut system_led_pin = pins.led.into_push_pull_output();
let mut green_led_pin = pins.gpio3.into_push_pull_output();
let mut red_led_pin = pins.gpio4.into_push_pull_output();
system_led_pin.set_low().unwrap();
green_led_pin.set_low().unwrap();
red_led_pin.set_low().unwrap();
let mut choose_led = |index: u32, result: bool| {
if result {
// blink the green led once to indicate success
green_led_pin.set_high().unwrap();
delay.delay_ms(500);
green_led_pin.set_low().unwrap();
delay.delay_ms(500);
} else {
// turn the red led on to indicate failure
// and blink the on board led to indicate which test failed, looping forever
red_led_pin.set_high().unwrap();
loop {
for _ in 0..index {
system_led_pin.set_high().unwrap();
delay.delay_ms(200);
system_led_pin.set_low().unwrap();
delay.delay_ms(200);
}
delay.delay_ms(1000);
}
}
};
// Run forever, setting the LED according to the button
choose_led(1, multiplication_table(&mut sio.interp0));
choose_led(2, moving_mask(&mut sio.interp0));
choose_led(3, cross_lanes(&mut sio.interp0));
choose_led(4, simple_blend1(&mut sio.interp0));
choose_led(5, simple_blend2(&mut sio.interp0));
choose_led(6, clamp(&mut sio.interp1));
choose_led(7, texture_mapping(&mut sio.interp0));
// turn the on board led on to indicate testing is done
system_led_pin.set_high().unwrap();
loop {
delay.delay_ms(1000);
}
}
fn multiplication_table(interp: &mut Interp0) -> bool {
//get the default configuration that just keep adding base into accum
let config = LaneCtrl::new();
//write the configuration to the hardware.
interp.get_lane0().set_ctrl(config.encode());
//set the accumulator to 0 and the base to 9
interp.get_lane0().set_accum(0);
interp.get_lane0().set_base(9);
//the expected output for comparison
let expected = [9, 18, 27, 36, 45, 54, 63, 72, 81, 90];
for i in expected {
//returns the value of accum + base and sets accum to the same value
let value = interp.get_lane0().pop();
if value != i {
return false; //inform that the interpolator did not return the expected value
}
}
true
}
fn moving_mask(interp: &mut Interp0) -> bool {
//get the default configuration that just keep adding base into accum
let mut config = LaneCtrl::new();
interp.get_lane0().set_accum(0x1234ABCD);
let expected = [
0x0000_000D,
0x0000_00C0,
0x0000_0B00,
0x0000_A000,
0x0004_0000,
0x0030_0000,
0x0200_0000,
0x1000_0000,
];
for i in 0..8 {
// LSB, then MSB. These are inclusive, so 0,31 means "the entire 32 bit register"
config.mask_lsb = i * 4;
config.mask_msb = i * 4 + 3;
interp.get_lane0().set_ctrl(config.encode());
// Reading read_raw() returns the lane data
// after shifting, masking and sign extending, without adding base
if interp.get_lane0().read_raw() != expected[i as usize] {
return false;
}
}
let signed_expected = [
0xFFFF_FFFD,
0xFFFF_FFC0,
0xFFFF_FB00,
0xFFFF_A000,
0x0004_0000,
0x0030_0000,
0x0200_0000,
0x1000_0000,
];
config.signed = true;
for i in 0..8 {
config.mask_lsb = i * 4;
config.mask_msb = i * 4 + 3;
interp.get_lane0().set_ctrl(config.encode());
if interp.get_lane0().read_raw() != signed_expected[i as usize] {
return false;
}
}
true
}
fn cross_lanes(interp: &mut Interp0) -> bool {
// this configuration will at the time of pop()
// when applied to lane0 : set lane0 accumulator to the result from lane1
// when applied to lane1 : set lane1 accumulator to the result from lane0
let config = LaneCtrl {
cross_result: true,
..LaneCtrl::new()
};
let encoded_config = config.encode();
// each lane is used through an accessor,
// as lanes mutate each other, they can not be borrowed at the same time
interp.get_lane0().set_ctrl(encoded_config);
interp.get_lane1().set_ctrl(encoded_config);
interp.get_lane0().set_accum(123);
interp.get_lane1().set_accum(456);
// lane0 will add 1 to its result, lane1 will add nothing
interp.get_lane0().set_base(1);
interp.get_lane1().set_base(0);
let expected = [
(124, 456),
(457, 124),
(125, 457),
(458, 125),
(126, 458),
(459, 126),
(127, 459),
(460, 127),
(128, 460),
(461, 128),
];
for i in expected {
if i != (interp.get_lane0().peek(), interp.get_lane1().pop()) {
return false;
}
}
true
}
fn simple_blend1(interp: &mut Interp0) -> bool {
let config = LaneCtrl {
blend: true,
..LaneCtrl::new()
};
//enable blend mode
interp.get_lane0().set_ctrl(config.encode());
//make sure the default configuration is in lane1 as the value may be shifted and masked.
interp.get_lane1().set_ctrl(LaneCtrl::new().encode());
//set the minimum value for interp.get_lane0().set_accum(0) 0/256
interp.get_lane0().set_base(500);
//set the maximum value which is inaccessible
// as the blend is done between 0/256 and 255/256
interp.get_lane1().set_base(1000);
let expected = [500, 582, 666, 748, 832, 914, 998];
for i in 0..=6 {
interp.get_lane1().set_accum(255 * i / 6);
if expected[i as usize] != interp.get_lane1().peek() {
return false;
}
}
true
}
fn simple_blend2(interp: &mut Interp0) -> bool {
let config = LaneCtrl {
blend: true,
..LaneCtrl::new()
};
//enable blend mode
interp.get_lane0().set_ctrl(config.encode());
interp.get_lane0().set_base((-1000i32) as u32);
interp.get_lane1().set_base(1000);
let mut config1 = LaneCtrl {
signed: true,
..LaneCtrl::new()
};
interp.get_lane1().set_ctrl(config1.encode());
let expected_signed = [-1000, -672, -336, -8, 328, 656, 992];
for i in 0..=6 {
// write a value between 0 and 256 (exclusive)
interp.get_lane1().set_accum(255 * i / 6);
// reads it as a value between -1000 and 1000 (exclusive)
if interp.get_lane1().peek() as i32 != expected_signed[i as usize] {
return false;
}
}
config1.signed = false;
interp.get_lane1().set_ctrl(config1.encode());
let expected_unsigned = [
0xfffffc18, 0xd5fffd60, 0xaafffeb0, 0x80fffff8, 0x56000148, 0x2c000290, 0x010003e0,
];
for i in 0..=6 {
interp.get_lane1().set_accum(255 * i / 6);
// reads a value between 4294966296 and 1000
if interp.get_lane1().peek() != expected_unsigned[i as usize] {
return false;
}
}
true
}
///Divides by 4 and clamp the value between 0 and 255 inclusive
fn clamp(interp: &mut Interp1) -> bool {
// Enables Clamp ONLY AVAILABLE ON Interp1
// shift two bits to the right and mask the two most significant bits
// because sign extension is made after the mask
let config = LaneCtrl {
clamp: true,
shift: 2,
mask_lsb: 0,
mask_msb: 29,
signed: true,
..LaneCtrl::new()
};
interp.get_lane0().set_ctrl(config.encode());
//set minimum value of result
interp.get_lane0().set_base(0);
//set maximum value of result
interp.get_lane1().set_base(255);
let values: [(i32, i32); 9] = [
(-1024, 0),
(-768, 0),
(-512, 0),
(-256, 0),
(0, 0),
(256, 64),
(512, 128),
(768, 192),
(1024, 255),
];
for (arg, result) in values {
interp.get_lane0().set_accum(arg as u32);
if result != interp.get_lane0().peek() as i32 {
return false;
}
}
true
}
fn texture_mapping(interp: &mut Interp0) -> bool {
#[rustfmt::skip]
let texture: [u8;16] = [
0x00, 0x01, 0x02, 0x03,
0x10, 0x11, 0x12, 0x13,
0x20, 0x21, 0x22, 0x23,
0x30, 0x31, 0x32, 0x33,
];
// the position will be given in fixed point with 16 bits
// fractional part
let uv_fractional_bits = 16;
let texture_width_bits = 2;
let texture_height_bits = 2;
// bits
// 3322222222221111 1111110000000000
// 1098765432109876 5432109876543210
// accum0 u axis coordinate xx xxxxxxxxxxxxxxxx 18 bits
// after shift and mask xx
// accum1 v axis xx xxxxxxxxxxxxxxxx 18 bits
// after shift and mask xx
// add_raw make the interpolator increment the accumulator
// with the base value without masking or shifting
let config0 = LaneCtrl {
add_raw: true,
shift: uv_fractional_bits,
mask_lsb: 0,
mask_msb: texture_width_bits - 1,
..LaneCtrl::new()
};
interp.get_lane0().set_ctrl(config0.encode());
let config1 = LaneCtrl {
add_raw: true,
shift: uv_fractional_bits - texture_width_bits,
mask_lsb: texture_width_bits,
mask_msb: texture_width_bits + texture_height_bits - 1,
..LaneCtrl::new()
};
interp.get_lane1().set_ctrl(config1.encode());
interp.set_base(0);
// set starting position to 0x0
// will move 1/2 a pixel horizontally
// and 1/3 a pixel vertically per call to pop()
interp.get_lane0().set_accum(0);
interp.get_lane0().set_base(65536 / 2);
interp.get_lane1().set_accum(0);
interp.get_lane1().set_base(65536 / 3);
let expected = [
0x00, 0x00, 0x01, 0x01, 0x12, 0x12, 0x13, 0x23, 0x20, 0x20, 0x31, 0x31,
];
for i in expected {
if i != texture[interp.pop() as usize] {
return false;
}
}
// reset the starting position
interp.get_lane0().set_accum(0);
interp.get_lane1().set_accum(0);
interp.set_base(texture.as_ptr() as u32);
for i in expected {
// This is unsafe and should be done extremely carefully
// remember to follow memory alignment,
// reading or writing an unaligned address will crash
if i != unsafe { *(interp.pop() as *const u8) } {
return false;
}
}
true
}
// End of file