OxiCtl — Pure Rust Real-Time Control Systems Framework

Comprehensive, no_std-compatible control systems framework for embedded robotics and industrial automation. Pure Rust — no C/Fortran dependencies.

Status

Features

• no_std compatible — Core, PID, estimator, motor, and most modules run on bare metal with zero heap allocation (uses heapless for fixed-size buffers, libm for math)
• Pure Rust — No C/Fortran dependencies; no openblas, no bindgen
• Generic scalar — All algorithms are generic over ControlScalar (f32 or f64); choose precision per use-case
• No unwrap() — All public APIs return Result<_, E> or Option<_>; safe for safety-critical embedded targets
• Industrial protocols — Modbus RTU/TCP, CANopen NMT/SDO/PDO/OD, EtherCAT master/slave/DC
• 40+ control domains — PID, LQR, H∞, MPC (8 variants), FOC, MRAC, ILC, Koopman, geometric, passivity, fuzzy, neural, and more

Modules

Quickstart

Add to Cargo.toml:

[dependencies]
oxictl = { version = "0.1", features = ["pid", "sim", "safety"] }

Basic closed-loop temperature control:

use oxictl::pid::{PidConfig, AntiWindup};
use oxictl::safety::SafetyMonitor;
use oxictl::sim::ThermalPlant;

let mut pid = PidConfig::<f64>::new(2.0, 0.5, 0.1)
    .with_limits(-100.0, 100.0)
    .with_anti_windup(AntiWindup::BackCalculation { gain: 0.1 })
    .build();

let mut plant = ThermalPlant::new(1.0, 10.0, 20.0); // tau, gain, ambient
let dt = 0.01_f64;
let setpoint = 80.0_f64;

for _ in 0..1000 {
    let temp = plant.temperature();
    let u = pid.update(setpoint, temp, dt);
    plant.step(u, dt);
}

Kalman filter for position tracking:

use oxictl::estimator::KalmanFilter;
use oxictl::core::Matrix;

// State: [position, velocity], Measurement: [position]
let mut kf = KalmanFilter::<f64, 2, 1, 1>::new(
    Matrix::identity(),     // F (state transition)
    Matrix::from([[1.0, 0.0]]), // H (observation)
    Matrix::identity() * 0.01, // Q (process noise)
    Matrix::identity() * 0.1,  // R (measurement noise)
    Matrix::identity(),     // P0 (initial covariance)
)?;

let measurement = Matrix::from([[3.5_f64]]);
kf.predict(None)?;
kf.update(&measurement)?;

Feature Flags

Enable all features for full functionality:

[dependencies]
oxictl = { version = "0.1", features = ["__all"] }

Or in Cargo.toml dev/example context:

cargo build --all-features
cargo nextest run --all-features

no_std Usage

Most modules are no_std compatible. Only sim requires std (for file I/O in scope recorder).

[dependencies]
oxictl = { version = "0.1", default-features = false, features = ["pid", "safety", "estimator", "motor"] }

Internals use:

• heapless::Vec for fixed-size buffers (no heap allocation)
• libm for transcendental math (sin, cos, sqrt, exp, ln, …)
• num-traits with libm backend for generic float operations

Examples

Run any example:

cargo run --all-features --example pid_temperature
cargo run --features "state_feedback" --example adrc_servo

Protocol Support

Modbus RTU/TCP

use oxictl::protocol::modbus::{RtuMaster, TcpSession, RegisterBank};

CANopen

use oxictl::protocol::canopen::{NmtState, SdoServer, PdoMapper, ObjectDictionary};

EtherCAT

use oxictl::protocol::ethercat::{EtherCatMaster, SlaveConfig, DcConfig, MailboxProtocol};

ROS2 CDR

use oxictl::protocol::ros2::{CdrSerializer, QosProfile, SpscTopic};

Architecture

oxictl/src/
  core/               ControlScalar trait, Matrix, state-space, transfer functions
  core/filters/       Butterworth, Chebyshev, FIR, moving-average, median
  core/adaptive_filters/ LMS, NLMS, VSLMS, RLS, APA
  core/frequency_domain/ Bode, Nyquist, sensitivity, root locus
  pid/                Standard, cascade, auto-tune, gain-schedule, incremental, fractional
  pid/fractional/     GL operator, PI^λD^μ, Tustin approximation
  state_feedback/     LQR, H∞, ADRC, ISMC, backstepping, SMC variants, servo
  estimator/          KF, EKF, UKF, information, sqrt-KF, ensemble, particle, smoothers
  mpc/                Linear, economic, tracking, tube, robust, stochastic, MPPI, MHE
  motor/              FOC pipeline, BLDC, stepper, SRM, encoder, param_id
  adaptive/           MRAC, gain scheduling, STR, adaptive KF
  trajectory/         Bezier, clothoid, B-spline, polynomial, RRT*, Dubins, TOTP
  sim/                Thermal, DC motor, pendulum, quadrotor, battery, bicycle, platoon
  safety/             Watchdog, monitors, SIL, redundancy, fault tree, safe state
  power/              PLL, converters, MPPT, VSI/LCL, active filter, SPWM/SVPWM
  scheduler/          Fixed-rate, multi-rate, timing, deadline monitor
  kinematics/         FK/IK, Jacobian, SCARA, 6-DOF, dynamics, workspace
  protocol/           Modbus RTU/TCP, CANopen NMT/SDO/PDO/OD, EtherCAT, ROS2
  fuzzy/              Membership functions, Mamdani/Sugeno, defuzzification, fuzzy PID
  optimal/            ODE solvers, single/multiple shooting, Pontryagin
  neural/             Activations, DenseLayer, MLP, RBF, neural PID
  imc/                IMC, Smith predictor, PFC
  flatness/           Quadrotor/unicycle/manipulator flat maps, min-snap
  networked/          Event-triggered, self-triggered, consensus
  geometric/          SO(3), quaternion, geometric PD, SE(3)
  passivity/          Port-Hamiltonian, IDA-PBC, Lyapunov verifier
  disturbance/        Q-filter DOB, NDOB, UDE
  gp/                 RBF/Matern/linear kernels, exact GP, sparse FITC
  allocation/         Weighted pseudo-inverse, prioritized, LP-based
  ilc/                P-type, D-type, norm-optimal ILC
  navigation/         Dead reckoning, EKF-SLAM, pose graph
  fdi/                Parity space, observer-based, chi-squared, SPRT
  extremum/           Gradient ESC, Newton ESC
  comm/               Quantizers, dropout, delay, Padé
  repetitive/         Plug-in RC, 2-DOF PID, feedforward
  optim/              PSO, genetic algorithm, simulated annealing
  data_driven/        VRFT, CbT, FRIT
  koopman/            Lifting functions, EDMD, Koopman-MPC
  antiwindup/         Linear AW compensator, conditioning, observer-based
  hybrid/             Hybrid automaton, switched LTI, PWA
  sysid/              ARX, ARMAX, IV, N4SID, validation
  io/                 Kizzasi bridge, JSON export

License

Apache-2.0 — Copyright COOLJAPAN OU (Team Kitasan)