refactor: move firmware workspace under firmware

firmware/libs/kaptan-flight-config/src/profile/control.rs

@@ -0,0 +1,223 @@
+use kaptan_config::{ConfigValidate, ConfigViolation, ValidationRule};
+
+use super::ids;
+
+#[derive(Clone, Copy, ConfigValidate)]
+pub(super) struct AidingCandidate {
+    #[config(
+        id = 6,
+        key = "aiding.position_variance_m2",
+        unit = "m2",
+        default = 0.04,
+        finite,
+        range(min = 0.000_001, max = 10_000.0)
+    )]
+    pub(super) position_variance_m2: f32,
+    #[config(
+        id = 7,
+        key = "aiding.velocity_variance_m2ps2",
+        unit = "m2/s2",
+        default = 0.04,
+        finite,
+        range(min = 0.000_001, max = 10_000.0)
+    )]
+    pub(super) velocity_variance_m2_per_second_squared: f32,
+}
+
+#[derive(Clone, Copy, ConfigValidate)]
+pub(super) struct ControlCandidate {
+    #[config(
+        id = 8,
+        key = "control.position_gain_per_s2",
+        unit = "1/s2",
+        default = 0.8,
+        finite,
+        range(min = 0.0, max = 100.0)
+    )]
+    pub(super) position_gain_per_second_squared: f32,
+    #[config(
+        id = 9,
+        key = "control.velocity_gain_per_s",
+        unit = "1/s",
+        default = 1.2,
+        finite,
+        range(min = 0.0, max = 100.0)
+    )]
+    pub(super) velocity_gain_per_second: f32,
+    #[config(
+        id = 10,
+        key = "control.maximum_horizontal_acceleration_mps2",
+        unit = "m/s2",
+        default = 3.0,
+        finite,
+        range(min = 0.001, max = 100.0)
+    )]
+    pub(super) maximum_horizontal_acceleration_mps2: f32,
+    #[config(
+        id = 11,
+        key = "control.maximum_upward_acceleration_mps2",
+        unit = "m/s2",
+        default = 2.0,
+        finite,
+        range(min = 0.001, max = 100.0)
+    )]
+    pub(super) maximum_upward_acceleration_mps2: f32,
+    #[config(
+        id = 12,
+        key = "control.maximum_downward_acceleration_mps2",
+        unit = "m/s2",
+        default = 2.0,
+        finite,
+        range(min = 0.001, max = 100.0)
+    )]
+    pub(super) maximum_downward_acceleration_mps2: f32,
+}
+#[derive(Clone, Copy, ConfigValidate)]
+#[config(post = Self::validate_thrust)]
+pub(super) struct ThrustCandidate {
+    #[config(
+        id = 13,
+        key = "thrust.mass_kg",
+        unit = "kg",
+        default = 1.2,
+        finite,
+        range(min = 0.01, max = 100.0)
+    )]
+    pub(super) mass_kg: f32,
+    #[config(
+        id = 14,
+        key = "thrust.maximum_collective_thrust_n",
+        unit = "N",
+        default = 18.0,
+        finite,
+        range(min = 0.1, max = 10_000.0)
+    )]
+    pub(super) maximum_collective_thrust_newtons: f32,
+    #[config(
+        id = 15,
+        key = "thrust.maximum_tilt_tangent",
+        unit = "",
+        default = 0.700_207_53,
+        finite,
+        range(min = 0.001, max = 10.0)
+    )]
+    pub(super) maximum_tilt_tangent: f32,
+}
+impl ThrustCandidate {
+    fn validate_thrust(&self) -> Result<(), ConfigViolation> {
+        if self.maximum_collective_thrust_newtons <= self.mass_kg * 9.806_65 {
+            return Err(ConfigViolation::related(
+                ids::MAXIMUM_COLLECTIVE_THRUST_NEWTONS,
+                ids::MASS_KG,
+                ValidationRule::Inconsistent,
+            ));
+        }
+        Ok(())
+    }
+}
+
+#[derive(Clone, Copy, ConfigValidate)]
+#[config(post = Self::validate_pid)]
+pub(super) struct PidCandidate {
+    #[config(
+        id = 16,
+        key = "control.rate_pid.proportional",
+        unit = "",
+        default = 0.035,
+        finite,
+        range(min = 0.0, max = 10.0)
+    )]
+    pub(super) proportional: f32,
+    #[config(
+        id = 17,
+        key = "control.rate_pid.integral",
+        unit = "",
+        default = 0.006,
+        finite,
+        range(min = 0.0, max = 10.0)
+    )]
+    pub(super) integral: f32,
+    #[config(
+        id = 18,
+        key = "control.rate_pid.derivative",
+        unit = "",
+        default = 0.0,
+        finite,
+        range(min = 0.0, max = 10.0)
+    )]
+    pub(super) derivative: f32,
+    #[config(
+        id = 19,
+        key = "control.rate_pid.output_limit",
+        unit = "",
+        default = 0.10,
+        finite,
+        range(min = 0.001, max = 1.0)
+    )]
+    pub(super) output_limit: f32,
+    #[config(
+        id = 20,
+        key = "control.rate_pid.integral_limit",
+        unit = "",
+        default = 0.025,
+        finite,
+        range(min = 0.0, max = 1.0)
+    )]
+    pub(super) integral_limit: f32,
+}
+impl PidCandidate {
+    fn validate_pid(&self) -> Result<(), ConfigViolation> {
+        if self.integral_limit > self.output_limit {
+            return Err(ConfigViolation::related(
+                ids::RATE_PID_INTEGRAL_LIMIT,
+                ids::RATE_PID_OUTPUT_LIMIT,
+                ValidationRule::Inconsistent,
+            ));
+        }
+        Ok(())
+    }
+}
+
+#[derive(Clone, Copy, ConfigValidate)]
+#[config(post = Self::validate_actuator_limits)]
+pub(super) struct ActuatorLimitsCandidate {
+    #[config(
+        id = 21,
+        key = "actuator.minimum",
+        unit = "",
+        default = 0.0,
+        finite,
+        range(min = 0.0, max = 1.0)
+    )]
+    pub(super) minimum: f32,
+    #[config(
+        id = 22,
+        key = "actuator.maximum",
+        unit = "",
+        default = 1.0,
+        finite,
+        range(min = 0.0, max = 1.0)
+    )]
+    pub(super) maximum: f32,
+    #[config(
+        id = 23,
+        key = "actuator.slew_per_second",
+        unit = "1/s",
+        default = 8.0,
+        finite,
+        range(min = 0.001, max = 100.0)
+    )]
+    pub(super) slew_per_second: f32,
+}
+impl ActuatorLimitsCandidate {
+    fn validate_actuator_limits(&self) -> Result<(), ConfigViolation> {
+        if self.minimum >= self.maximum {
+            return Err(ConfigViolation::related(
+                ids::ACTUATOR_MINIMUM,
+                ids::ACTUATOR_MAXIMUM,
+                ValidationRule::Inconsistent,
+            ));
+        }
+        Ok(())
+    }
+}