lanyard.payload.GimbalStatus.1.0

Attitude and mode of the camera gimbal, published at 20 Hz.
Full name lanyard.payload.GimbalStatus
Version 1.0
Kind Message
Fixed port ID 6230
Least supported transport CAN FD

Wire layout

Section Extent (bytes) Max serialized (bytes)
Message 25 25

A sealed type reports its extent as its exact serialised size; a delimited type reports the declared @extent, which bounds what a reader must be prepared to receive.

Definition

# Attitude and mode of the camera gimbal, published at 20 Hz.
#
# LEAST SUPPORTED TRANSPORT: CAN FD.
#
# WHY SEALED: the gimbal controller is a small microcontroller with a
# static receive buffer, and this message has been stable across three
# airframes. A sealed definition lets the generated decoder be a
# straight-line series of loads with no length header to interpret and
# no skip path to implement.

uavcan.si.unit.angle.Vector3.1.0 orientation_body
# Gimbal orientation relative to the airframe body frame, as roll,
# pitch, and yaw in radians.

uavcan.si.unit.angular_velocity.Vector3.1.0 rate_body
# Gimbal angular rate about the same three axes, in radians per second.

uint3 mode
# Active stabilisation mode; one of the constants below.

uint3 MODE_STOWED = 0
# The gimbal is parked and mechanically locked; motors are unpowered.

uint3 MODE_FOLLOW = 1
# Yaw follows the airframe heading; roll and pitch are
# horizon-stabilized.

uint3 MODE_LOCK = 2
# All three axes are earth-referenced; the gimbal holds a fixed
# geographic pointing direction.

uint3 MODE_TRACK = 3
# The gimbal is slaved to a tracker running on the payload computer.

uint3 MODE_FAULT = 4
# The gimbal has faulted and is not stabilising; see error_flags.

uint4 error_flags
# Latched faults.
#   bit 0 - an axis reached its mechanical limit
#   bit 1 - motor driver over-temperature
#   bit 2 - inertial sensor failure
#   bit 3 - lost the airframe attitude reference

bool recording
# True when the payload is writing to storage. Carried here rather than
# in a separate message so that an operator watching gimbal telemetry
# sees the recording state at the same rate and latency.

@assert _offset_.max <= 63 * 8
# Must remain a single CAN FD frame.

@sealed

Generated code

Declaration excerpts only -- the serialisation bodies are omitted for length. Build the showroom target for the complete output in every language and profile.

C

/* Attitude and mode of the camera gimbal, published at 20 Hz. */
/*  */
/* LEAST SUPPORTED TRANSPORT: CAN FD. */
/*  */
/* WHY SEALED: the gimbal controller is a small microcontroller with a */
/* static receive buffer, and this message has been stable across three */
/* airframes. A sealed definition lets the generated decoder be a */
/* straight-line series of loads with no length header to interpret and */
/* no skip path to implement. */
typedef struct lanyard__payload__GimbalStatus_1_0 {
  /* Gimbal orientation relative to the airframe body frame, as roll, */
  /* pitch, and yaw in radians. */
  struct uavcan__si__unit__angle__Vector3_1_0 orientation_body;
  /* Gimbal angular rate about the same three axes, in radians per second. */
  struct uavcan__si__unit__angular_velocity__Vector3_1_0 rate_body;
  /* Active stabilisation mode; one of the constants below. */
  uint8_t mode;
  /* Latched faults. */
  /*   bit 0 - an axis reached its mechanical limit */
  /*   bit 1 - motor driver over-temperature */
  /*   bit 2 - inertial sensor failure */
  /*   bit 3 - lost the airframe attitude reference */
  uint8_t error_flags;
  /* True when the payload is writing to storage. Carried here rather than */
  /* in a separate message so that an operator watching gimbal telemetry */
  /* sees the recording state at the same rate and latency. */
  bool recording;
} lanyard__payload__GimbalStatus_1_0;

C++ (std)

// Attitude and mode of the camera gimbal, published at 20 Hz.
//
// LEAST SUPPORTED TRANSPORT: CAN FD.
//
// WHY SEALED: the gimbal controller is a small microcontroller with a
// static receive buffer, and this message has been stable across three
// airframes. A sealed definition lets the generated decoder be a
// straight-line series of loads with no length header to interpret and
// no skip path to implement.
struct GimbalStatus_1_0 {
  // Gimbal orientation relative to the airframe body frame, as roll,
  // pitch, and yaw in radians.
  ::uavcan::si::unit::angle::Vector3_1_0 orientation_body{};
  // Gimbal angular rate about the same three axes, in radians per second.
  ::uavcan::si::unit::angular_velocity::Vector3_1_0 rate_body{};
  // Active stabilisation mode; one of the constants below.
  std::uint8_t mode{};
  // Latched faults.
  //   bit 0 - an axis reached its mechanical limit
  //   bit 1 - motor driver over-temperature
  //   bit 2 - inertial sensor failure
  //   bit 3 - lost the airframe attitude reference
  std::uint8_t error_flags{};
  // True when the payload is writing to storage. Carried here rather than
  // in a separate message so that an operator watching gimbal telemetry
  // sees the recording state at the same rate and latency.
  bool recording{};
  static constexpr const char* FULL_NAME = "lanyard.payload.GimbalStatus";
  static constexpr bool IS_DEPRECATED = false;
  static constexpr const char* FULL_NAME_AND_VERSION = "lanyard.payload.GimbalStatus.1.0";
  static constexpr std::size_t EXTENT_BYTES = 25U;
  static constexpr std::size_t SERIALIZATION_BUFFER_SIZE_BYTES = 25U;
  static constexpr bool WIRE_FLAT = false;
  static constexpr const char* WIRE_FLAT_REASON = "sub-byte-field";
  static constexpr bool HOST_IMAGE = false;
  static constexpr const char* HOST_IMAGE_REASON = "sub-byte-field";
  static constexpr bool HAS_FIXED_PORT_ID = true;
  static constexpr std::uint16_t FIXED_PORT_ID = 6230U;
  // The gimbal is parked and mechanically locked; motors are unpowered.
  static constexpr auto MODE_STOWED = 0;
  // Yaw follows the airframe heading; roll and pitch are
  // horizon-stabilized.
  static constexpr auto MODE_FOLLOW = 1;
  // All three axes are earth-referenced; the gimbal holds a fixed
  // geographic pointing direction.
  static constexpr auto MODE_LOCK = 2;
  // The gimbal is slaved to a tracker running on the payload computer.
  static constexpr auto MODE_TRACK = 3;
  // The gimbal has faulted and is not stabilising; see error_flags.
  static constexpr auto MODE_FAULT = 4;
  LLVMDSDL_NODISCARD inline std::int8_t serialize(std::uint8_t* buffer, std::size_t* inout_buffer_size_bytes) const {
    return GimbalStatus_1_0_serialize_(this, buffer, inout_buffer_size_bytes);
  }
  LLVMDSDL_NODISCARD inline std::int8_t deserialize(const std::uint8_t* buffer, std::size_t* inout_buffer_size_bytes) {
    return GimbalStatus_1_0_deserialize_(this, buffer, inout_buffer_size_bytes);
  }
};

C++ (pmr)

Polymorphic-allocator profile: variable-length fields route through std::pmr.

// Attitude and mode of the camera gimbal, published at 20 Hz.
//
// LEAST SUPPORTED TRANSPORT: CAN FD.
//
// WHY SEALED: the gimbal controller is a small microcontroller with a
// static receive buffer, and this message has been stable across three
// airframes. A sealed definition lets the generated decoder be a
// straight-line series of loads with no length header to interpret and
// no skip path to implement.
struct GimbalStatus_1_0 {
  // Gimbal orientation relative to the airframe body frame, as roll,
  // pitch, and yaw in radians.
  ::uavcan::si::unit::angle::Vector3_1_0 orientation_body{};
  // Gimbal angular rate about the same three axes, in radians per second.
  ::uavcan::si::unit::angular_velocity::Vector3_1_0 rate_body{};
  // Active stabilisation mode; one of the constants below.
  std::uint8_t mode{};
  // Latched faults.
  //   bit 0 - an axis reached its mechanical limit
  //   bit 1 - motor driver over-temperature
  //   bit 2 - inertial sensor failure
  //   bit 3 - lost the airframe attitude reference
  std::uint8_t error_flags{};
  // True when the payload is writing to storage. Carried here rather than
  // in a separate message so that an operator watching gimbal telemetry
  // sees the recording state at the same rate and latency.
  bool recording{};
  ::llvmdsdl::cpp::MemoryResource* _memory_resource{::llvmdsdl::cpp::default_memory_resource()};
  GimbalStatus_1_0() = default;
  explicit GimbalStatus_1_0(::llvmdsdl::cpp::MemoryResource* memory_resource) { set_memory_resource(memory_resource); }
  void set_memory_resource(::llvmdsdl::cpp::MemoryResource* memory_resource) {
    _memory_resource = (memory_resource != nullptr) ? memory_resource : ::llvmdsdl::cpp::default_memory_resource();
    orientation_body.set_memory_resource(_memory_resource);
    rate_body.set_memory_resource(_memory_resource);
  }
  static constexpr const char* FULL_NAME = "lanyard.payload.GimbalStatus";
  static constexpr bool IS_DEPRECATED = false;
  static constexpr const char* FULL_NAME_AND_VERSION = "lanyard.payload.GimbalStatus.1.0";
  static constexpr std::size_t EXTENT_BYTES = 25U;
  static constexpr std::size_t SERIALIZATION_BUFFER_SIZE_BYTES = 25U;
  static constexpr bool WIRE_FLAT = false;
  static constexpr const char* WIRE_FLAT_REASON = "sub-byte-field";
  static constexpr bool HOST_IMAGE = false;
  static constexpr const char* HOST_IMAGE_REASON = "sub-byte-field";
  static constexpr bool HAS_FIXED_PORT_ID = true;
  static constexpr std::uint16_t FIXED_PORT_ID = 6230U;
  // The gimbal is parked and mechanically locked; motors are unpowered.
  static constexpr auto MODE_STOWED = 0;
  // Yaw follows the airframe heading; roll and pitch are
  // horizon-stabilized.
  static constexpr auto MODE_FOLLOW = 1;
  // All three axes are earth-referenced; the gimbal holds a fixed
  // geographic pointing direction.
  static constexpr auto MODE_LOCK = 2;
  // The gimbal is slaved to a tracker running on the payload computer.
  static constexpr auto MODE_TRACK = 3;
  // The gimbal has faulted and is not stabilising; see error_flags.
  static constexpr auto MODE_FAULT = 4;
  LLVMDSDL_NODISCARD inline std::int8_t serialize(std::uint8_t* buffer, std::size_t* inout_buffer_size_bytes) const {
    return GimbalStatus_1_0_serialize_(this, buffer, inout_buffer_size_bytes, _memory_resource);
  }
  LLVMDSDL_NODISCARD inline std::int8_t deserialize(const std::uint8_t* buffer, std::size_t* inout_buffer_size_bytes) {
    return GimbalStatus_1_0_deserialize_(this, buffer, inout_buffer_size_bytes, _memory_resource);
  }
  LLVMDSDL_NODISCARD inline std::int8_t serialize(std::uint8_t* buffer, std::size_t* inout_buffer_size_bytes, ::llvmdsdl::cpp::MemoryResource* memory_resource) const {
    return GimbalStatus_1_0_serialize_(this, buffer, inout_buffer_size_bytes, memory_resource);
  }
  LLVMDSDL_NODISCARD inline std::int8_t deserialize(const std::uint8_t* buffer, std::size_t* inout_buffer_size_bytes, ::llvmdsdl::cpp::MemoryResource* memory_resource) {
    return GimbalStatus_1_0_deserialize_(this, buffer, inout_buffer_size_bytes, memory_resource);
  }
};

C++ (autosar)

AUTOSAR C++14 subset profile.

// Attitude and mode of the camera gimbal, published at 20 Hz.
//
// LEAST SUPPORTED TRANSPORT: CAN FD.
//
// WHY SEALED: the gimbal controller is a small microcontroller with a
// static receive buffer, and this message has been stable across three
// airframes. A sealed definition lets the generated decoder be a
// straight-line series of loads with no length header to interpret and
// no skip path to implement.
struct GimbalStatus_1_0 {
  // Gimbal orientation relative to the airframe body frame, as roll,
  // pitch, and yaw in radians.
  ::uavcan::si::unit::angle::Vector3_1_0 orientation_body{};
  // Gimbal angular rate about the same three axes, in radians per second.
  ::uavcan::si::unit::angular_velocity::Vector3_1_0 rate_body{};
  // Active stabilisation mode; one of the constants below.
  std::uint8_t mode{};
  // Latched faults.
  //   bit 0 - an axis reached its mechanical limit
  //   bit 1 - motor driver over-temperature
  //   bit 2 - inertial sensor failure
  //   bit 3 - lost the airframe attitude reference
  std::uint8_t error_flags{};
  // True when the payload is writing to storage. Carried here rather than
  // in a separate message so that an operator watching gimbal telemetry
  // sees the recording state at the same rate and latency.
  bool recording{};
  static constexpr const char* FULL_NAME = "lanyard.payload.GimbalStatus";
  static constexpr bool IS_DEPRECATED = false;
  static constexpr const char* FULL_NAME_AND_VERSION = "lanyard.payload.GimbalStatus.1.0";
  static constexpr std::size_t EXTENT_BYTES = 25U;
  static constexpr std::size_t SERIALIZATION_BUFFER_SIZE_BYTES = 25U;
  static constexpr bool WIRE_FLAT = false;
  static constexpr const char* WIRE_FLAT_REASON = "sub-byte-field";
  static constexpr bool HOST_IMAGE = false;
  static constexpr const char* HOST_IMAGE_REASON = "sub-byte-field";
  static constexpr bool HAS_FIXED_PORT_ID = true;
  static constexpr std::uint16_t FIXED_PORT_ID = 6230U;
  // The gimbal is parked and mechanically locked; motors are unpowered.
  static constexpr auto MODE_STOWED = 0;
  // Yaw follows the airframe heading; roll and pitch are
  // horizon-stabilized.
  static constexpr auto MODE_FOLLOW = 1;
  // All three axes are earth-referenced; the gimbal holds a fixed
  // geographic pointing direction.
  static constexpr auto MODE_LOCK = 2;
  // The gimbal is slaved to a tracker running on the payload computer.
  static constexpr auto MODE_TRACK = 3;
  // The gimbal has faulted and is not stabilising; see error_flags.
  static constexpr auto MODE_FAULT = 4;
  LLVMDSDL_NODISCARD inline std::int8_t serialize(std::uint8_t* buffer, std::size_t* inout_buffer_size_bytes) const {
    return GimbalStatus_1_0_serialize_(this, buffer, inout_buffer_size_bytes);
  }
  LLVMDSDL_NODISCARD inline std::int8_t deserialize(const std::uint8_t* buffer, std::size_t* inout_buffer_size_bytes) {
    return GimbalStatus_1_0_deserialize_(this, buffer, inout_buffer_size_bytes);
  }
};

Rust (std)

/// Attitude and mode of the camera gimbal, published at 20 Hz.
///
/// LEAST SUPPORTED TRANSPORT: CAN FD.
///
/// WHY SEALED: the gimbal controller is a small microcontroller with a
/// static receive buffer, and this message has been stable across three
/// airframes. A sealed definition lets the generated decoder be a
/// straight-line series of loads with no length header to interpret and
/// no skip path to implement.
#[derive(Clone, Debug, PartialEq)]
pub struct lanyard_payload_GimbalStatus_1_0 {
    /// Gimbal orientation relative to the airframe body frame, as roll,
    /// pitch, and yaw in radians.
    pub orientation_body: uavcan_si_unit_angle_Vector3_1_0,
    /// Gimbal angular rate about the same three axes, in radians per second.
    pub rate_body: uavcan_si_unit_angular_velocity_Vector3_1_0,
    /// Active stabilisation mode; one of the constants below.
    pub mode: u8,
    /// Latched faults.
    ///   bit 0 - an axis reached its mechanical limit
    ///   bit 1 - motor driver over-temperature
    ///   bit 2 - inertial sensor failure
    ///   bit 3 - lost the airframe attitude reference
    pub error_flags: u8,
    /// True when the payload is writing to storage. Carried here rather than
    /// in a separate message so that an operator watching gimbal telemetry
    /// sees the recording state at the same rate and latency.
    pub recording: bool,
}

Rust (no-std)

no_std + alloc profile, as a flight-controller firmware build would use.

/// Attitude and mode of the camera gimbal, published at 20 Hz.
///
/// LEAST SUPPORTED TRANSPORT: CAN FD.
///
/// WHY SEALED: the gimbal controller is a small microcontroller with a
/// static receive buffer, and this message has been stable across three
/// airframes. A sealed definition lets the generated decoder be a
/// straight-line series of loads with no length header to interpret and
/// no skip path to implement.
#[derive(Clone, Debug, PartialEq)]
pub struct lanyard_payload_GimbalStatus_1_0 {
    /// Gimbal orientation relative to the airframe body frame, as roll,
    /// pitch, and yaw in radians.
    pub orientation_body: uavcan_si_unit_angle_Vector3_1_0,
    /// Gimbal angular rate about the same three axes, in radians per second.
    pub rate_body: uavcan_si_unit_angular_velocity_Vector3_1_0,
    /// Active stabilisation mode; one of the constants below.
    pub mode: u8,
    /// Latched faults.
    ///   bit 0 - an axis reached its mechanical limit
    ///   bit 1 - motor driver over-temperature
    ///   bit 2 - inertial sensor failure
    ///   bit 3 - lost the airframe attitude reference
    pub error_flags: u8,
    /// True when the payload is writing to storage. Carried here rather than
    /// in a separate message so that an operator watching gimbal telemetry
    /// sees the recording state at the same rate and latency.
    pub recording: bool,
}

Go

// Attitude and mode of the camera gimbal, published at 20 Hz.
//
// LEAST SUPPORTED TRANSPORT: CAN FD.
//
// WHY SEALED: the gimbal controller is a small microcontroller with a
// static receive buffer, and this message has been stable across three
// airframes. A sealed definition lets the generated decoder be a
// straight-line series of loads with no length header to interpret and
// no skip path to implement.
type GimbalStatus_1_0 struct {
    // Gimbal orientation relative to the airframe body frame, as roll,
    // pitch, and yaw in radians.
    OrientationBody pkg_uavcan_si_unit_angle.Vector3_1_0
    // Gimbal angular rate about the same three axes, in radians per second.
    RateBody pkg_uavcan_si_unit_angular_velocity.Vector3_1_0
    // Active stabilisation mode; one of the constants below.
    Mode uint8
    // Latched faults.
    //
    //  bit 0 - an axis reached its mechanical limit
    //  bit 1 - motor driver over-temperature
    //  bit 2 - inertial sensor failure
    //  bit 3 - lost the airframe attitude reference
    ErrorFlags uint8
    // True when the payload is writing to storage. Carried here rather than
    // in a separate message so that an operator watching gimbal telemetry
    // sees the recording state at the same rate and latency.
    Recording bool
}

TypeScript

// Attitude and mode of the camera gimbal, published at 20 Hz.
//
// LEAST SUPPORTED TRANSPORT: CAN FD.
//
// WHY SEALED: the gimbal controller is a small microcontroller with a
// static receive buffer, and this message has been stable across three
// airframes. A sealed definition lets the generated decoder be a
// straight-line series of loads with no length header to interpret and
// no skip path to implement.
export interface GimbalStatus_1_0 {
  // Gimbal orientation relative to the airframe body frame, as roll,
  // pitch, and yaw in radians.
  orientation_body: Vector3_1_0__uavcan_si_unit_angle;
  // Gimbal angular rate about the same three axes, in radians per second.
  rate_body: Vector3_1_0__uavcan_si_unit_angular_velocity;
  // Active stabilisation mode; one of the constants below.
  mode: number;
  // Latched faults.
  //   bit 0 - an axis reached its mechanical limit
  //   bit 1 - motor driver over-temperature
  //   bit 2 - inertial sensor failure
  //   bit 3 - lost the airframe attitude reference
  error_flags: number;
  // True when the payload is writing to storage. Carried here rather than
  // in a separate message so that an operator watching gimbal telemetry
  // sees the recording state at the same rate and latency.
  recording: boolean;
}

Python

# Attitude and mode of the camera gimbal, published at 20 Hz.
#
# LEAST SUPPORTED TRANSPORT: CAN FD.
#
# WHY SEALED: the gimbal controller is a small microcontroller with a
# static receive buffer, and this message has been stable across three
# airframes. A sealed definition lets the generated decoder be a
# straight-line series of loads with no length header to interpret and
# no skip path to implement.
@dataclass(slots=True)
class GimbalStatus_1_0:
    # Gimbal orientation relative to the airframe body frame, as roll,
    # pitch, and yaw in radians.
    orientation_body: Vector3_1_0 = field(default_factory=lambda: Vector3_1_0())
    # Gimbal angular rate about the same three axes, in radians per second.
    rate_body: Vector3_1_0 = field(default_factory=lambda: Vector3_1_0())
    # Active stabilisation mode; one of the constants below.
    mode: int = 0
    # Latched faults.
    #   bit 0 - an axis reached its mechanical limit
    #   bit 1 - motor driver over-temperature
    #   bit 2 - inertial sensor failure
    #   bit 3 - lost the airframe attitude reference
    error_flags: int = 0
    # True when the payload is writing to storage. Carried here rather than
    # in a separate message so that an operator watching gimbal telemetry
    # sees the recording state at the same rate and latency.
    recording: bool = False

Every build recipe compiles this definition along with the rest of the namespace.