AutoRally Platform: High-Speed Robotics Testbed

• AutoRally is a scalable autonomous vehicle platform for aggressive, high-speed robotics research, facilitating data collection and algorithm testing.
• The platform integrates a robust mechanical chassis, advanced sensor suite, and modular software, making it ideal for testing dynamics, perception, and control algorithms.
• Open-source resources, including build instructions and datasets, enable reproducibility and collaborative development in robotics research.

AutoRally is an open-source, 1:5-scale autonomous vehicle platform engineered to facilitate aggressive, high-speed robotics research in outdoor environments. Designed for reproducibility and operational simplicity, it enables small teams to construct, deploy, and collect extensive real-world data for autonomous driving tasks. The platform integrates a robust mechanical chassis, comprehensive sensor suite, high-performance onboard computing, and a modular software stack, rendering it a comprehensive testbed for dynamics modeling, state estimation, perception, and advanced control algorithm benchmarking (Goldfain et al., 2018).

1. Mechanical and Electrical Configuration

AutoRally employs a reinforced HPI Baja 5SC trophy truck chassis, extended with billet-aluminum steering links and side-rail guards to withstand payload stresses and demanding maneuvers. The electric powertrain consists of a Castle Creations brushless motor with a peak output of 10 hp and electronic speed controller (ESC), powered by dual 14.8 V, 6500 mAh LiPo batteries in series. The rear-wheel drivetrain uses the stock differential, while hydraulic disk brakes on the front axle are servo-actuated at 7.4 V.

Suspension modifications include replacement of stock dampers with stiffer springs (front: 15 lb/in, rear: 19.09 lb/in) and higher-viscosity shock oils (850 cSt front/rear) to accommodate a payload increase of 58%. Ackermann steering geometry is realized using a hobby-standard 50 Hz PWM servo, supporting precise lateral dynamics during aggressive maneuvers.

The compute box (mini-ITX, loaded weight ≈8.8 kg) houses:

• Intel i7-6700 quad-core CPU (3.4 GHz, 65 W)
• NVIDIA GTX 750 Ti SC GPU (640 CUDA cores, 2 GB VRAM)
• 32 GB DDR4 RAM
• 512 GB M.2 SSD (OS/fast scratch) + 1 TB SATA3 SSD (logging/data)
• Power supply: Mini-Box M4-ATX 250 W, 22.2 V 11 Ah LiPo

Communication interfaces include USB2/3 (IMU, GPS, cameras, Arduino), CAN (ESC telemetry), PWM (motor/steering/brake actuation), XBee 900 MHz (RTK corrections/runstop), and high-bandwidth 802.11ac WiFi (telemetry, images, logs).

2. Integrated Sensor Suite

AutoRally’s sensory array supports both high-rate state estimation and perception:

• IMU: Lord Microstrain 3DM-GX4-25, 200 Hz 3-axis acceleration/gyroscope, PPS-synced, mounted inside the compute box
• GPS: Hemisphere P307 Real-Time Kinematic (RTK), 20 Hz, ±2 cm accuracy, antenna mounted on an acrylic-copper ground plane atop the vehicle
• Cameras: Dual PointGrey Flea3 FL3-U3-13E4C-C, 60 Hz global shutter, 70° FOV, USB3, external hardware trigger, plate-mounted on the roof
• Wheel encoders: Hallogic OH090U Hall Effect, per wheel hub, read via Arduino Due at 70 Hz
• ESC telemetry and RC input: tracked at 50 Hz

All sensor topics are interfaced via ROS, facilitating synchronization and modularity in online and offline experiments.

3. Software Architecture and Real-Time Control

AutoRally’s OS environment is Ubuntu LTS Desktop, leveraging Robot Operating System (ROS) middleware for inter-process communication and modularity. Precise time synchronization is achieved using GPS-PPS and NMEA sentences (gpsd → Chrony), with cameras externally triggered and IMU PPS-synced.

Safety is supported by a tripartite system:

1. “Deadman” RF-independent throttle relay
2. Radio-controlled PWM multiplexer for manual/autonomous mode selection
3. Runstop software layer via ROS/XBee/WiFi broadcast

A dedicated ROS nodelet (“chassis_interface”) communicates with Arduino Due over USB, ingesting sensor topics (/imu, /gps/fix, /camera, /wheel_speeds, /esc_diagnostics, /rc_input) and actuating the chassis via /chassisCommand {steer, throttle, brake} ∈ [–1,1]. Controller priors are runtime-configurable per actuator; higher-priority modules override lower ones, allowing dynamic mixing of waypoint, velocity, MPC, and user controllers. Command output rate is 50 Hz; state estimation runs at the IMU rate (200 Hz), with optimized updates propagated at 10 Hz.

4. Dynamics Modeling and Parameter Estimation

AutoRally supports multi-fidelity vehicle physics modeling:

• Single-track (bicycle) model: Governs longitudinal and lateral velocities ($v_x$, $v_y$), yaw rate ($r=\dot\psi$) via body-frame ODEs incorporating tire forces.
• Double-track model: Decomposes tire forces by side and axle, incorporates lateral load transfer.
• 11-DOF Full Model: Adds vertical motion ($z$), roll ($\phi$), pitch ($\theta$), incorporates air drag via $-\frac{1}{2}C_d\rho A v_x^2$ and detailed suspension/rotation/rigid body parameters.

Tire dynamics employ the Pacejka Magic Formula:

$$\mu = D\sin\left[C\arctan(BS_E - E(BS_E-\arctan S_E))\right] + S_v,\quad S_E = s - S_h$$

and force computation per axis:

$$f_{ijk} = -\frac{s_{ijk}}{s_{ij}} \mu_{ij} F_{ijz},\quad k\in\{x,y\}$$

Parameter estimation utilizes the Adaptive Limited-Memory Joint-State Unscented Kalman Filter (ALM-UKF), which augments state $x_k$ with parameter vector $p_k$ under random-walk dynamics $p_{k+1}=p_k+w_k^p$, and updates process/noise covariances with limited-memory statistics:

$$\hat R = \frac{1}{N-1}\sum_{k=1}^N(r_k - \bar r)(r_k - \bar r)^T - \frac{N-1}{N}(\mathbb{E}[hh^T] - \hat h \hat h^T)$$

Estimates for the single-track tire model, e.g., $B=1.1559$, $C=1.1924$, $D=0.9956$, $E=-0.8505$, $S_h=-0.0540$ m, $S_v=0.1444$ m, are validated by bifilar pendulum measurements (e.g., $I_z = 1.124$ kg·m²).

5. Online State Estimation and Perception

State estimation fuses IMU (200 Hz) and GPS (20 Hz) data via a factor graph using GTSAM’s iSAM2, optimized incrementally at 10 Hz. Variables $X_i=(p_i,v_i,b_i)$ represent pose, velocity, and bias at each node, with IMU/GPS/bias factors. The incrementally linearized MAP estimate:

$$\Theta^* = \arg\min_\Theta \frac{1}{2} \sum_i \| h_i(\Theta_i) - z_i \|_{\Sigma_i}^2$$

is interpolated to 200 Hz for closed-loop control.

Track surface perception is performed by a custom convolutional neural network for binary semantic segmentation (“track” / “not-track”) on 640×480 monocular input. The architecture consists of ten convolutional layers (3×3 kernels, channel sizes 32→64→96→128→256), two 2×2 max-pooling layers, and a concluding 5×5 convolutional logit layer. Training uses pixel-wise cross-entropy optimized with mini-batch SGD (batch size 10, 100,000 iterations) on ∼100,000 auto-labeled images constructed from state estimates and track surveys. Pixel accuracy reaches 97% on the test set and 91% on held-out days.

6. Experimental Validation and Data Release

Validation was conducted at the Georgia Tech Autonomous Racing Facility (GT-ARF), featuring a 68 m oval dirt/clay circuit with marked boundaries. Experiments include human-driven system ID (zig-zag, acceleration/brake, slides) and autonomous, aggressive operation up to 10 m/s using Model Predictive Path Integral (MPPI) control.

Reported performance metrics include:

• Lap time: ~10 s, at speeds of 8 m/s
• State estimation error: <0.05 m RMS (position), <0.2° RMS (heading)
• MPC tracking error: ~0.1 m RMS lateral

All experimental data are logged in ROS-bag format, synchronizing IMU, GPS, camera, wheel speed, ESC telemetry, and runstop/logs, with ground-truth track boundary annotation via RTK. The dataset is publicly accessible via the AutoRally GitHub repository.

7. Reproducibility, Resources, and Tooling

AutoRally provides comprehensive resources for reproducibility:

• Full build instructions (CAD, parts list, wiring, assembly) at https://github.com/autorally/autorally_instructions
• Software and simulation stack (ROS nodes, controllers, Gazebo world, datasets) at https://github.com/autorally/autorally_software
• Example controllers including MPPI (C++/CUDA), pure-pursuit and velocity controllers (Python/C++), data-logging and analysis scripts (MATLAB, Python), and Gazebo benchmark tracks replicating GT-ARF.

All mechanical CAD, electronics schematics, software, estimation pipelines, and datasets are released open-source, enabling rigorous benchmarking, modification, and algorithm development under realistic off-road and high-speed conditions (Goldfain et al., 2018).