Struct AxisMap 

pub struct AxisMap {
    pub x: Axis,
    pub y: Axis,
    pub z: Axis,
}

Which sensor axis each board axis reads.

use oxstack_drivers::axes::{Axis, AxisMap};

// Sensor rotated 90° clockwise on the board: board +X is sensor −Y.
let map = AxisMap { x: Axis::NegY, y: Axis::PosX, z: Axis::PosZ };
assert_eq!(map.apply([1.0, 0.0, 0.0]), [0.0, 1.0, 0.0]);
assert!(map.is_right_handed());

Fields

x: Axis

The sensor axis the board’s +X reads.

y: Axis

The sensor axis the board’s +Y reads.

z: Axis

The sensor axis the board’s +Z reads.

Implementations

impl AxisMap

pub const IDENTITY: AxisMap

Board frame equals sensor frame.

pub const fn apply(&self, v: [f32; 3]) -> [f32; 3]

Translates a sensor-frame vector into the board frame.

pub const fn is_permutation(&self) -> bool

Whether every sensor axis is used exactly once.

pub const fn is_right_handed(&self) -> bool

Whether the map is a rotation (determinant +1) rather than a reflection. A sensor soldered flat on a board always gives a rotation; a reflection means one pose was misread.

pub fn from_gravity( x_up: [f32; 3], y_up: [f32; 3], z_up: [f32; 3], ) -> Result<AxisMap, GravityError>

Works the map out from gravity. Each argument is one resting accelerometer reading (in g, sensor frame) with the named board axis pointing straight up, so that it reads about +1 g:

• x_up: board stood on its left edge (+X up),
• y_up: board stood on its bottom edge (+Y up),
• z_up: board lying flat, face up (+Z up).

use oxstack_drivers::axes::{Axis, AxisMap};

let map = AxisMap::from_gravity(
    [0.02, -0.98, 0.05],   // +X up: sensor −Y reads gravity
    [0.99, 0.01, -0.03],   // +Y up: sensor +X
    [-0.04, 0.0, 1.01],    // +Z up: sensor +Z
)
.unwrap();
assert_eq!(map, AxisMap { x: Axis::NegY, y: Axis::PosX, z: Axis::PosZ });

Trait Implementations

impl Clone for AxisMap

fn clone(&self) -> AxisMap

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AxisMap

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Format for AxisMap

where Axis: Format,

fn format(&self, f: Formatter<'_>)

Writes the defmt representation of self to fmt.

impl PartialEq for AxisMap

fn eq(&self, other: &AxisMap) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for AxisMap

impl Eq for AxisMap

impl StructuralPartialEq for AxisMap