Built-In Test (BIT) System Benefits

Overview

The Built-In Test (BIT) system is a comprehensive, modular, and extensible testing framework designed for Linux-based embedded systems. It provides automated hardware and software diagnostics through a plugin-based architecture, ensuring system reliability, integrity, and operational readiness.

Key Benefits

🛡️ Enhanced System Reliability

• Proactive fault detection before failures impact operations
• Continuous monitoring of critical system resources
• Early warning system for potential hardware degradation

⚡ Reduced Downtime

• Automated diagnostics eliminate manual testing overhead
• Scheduled test execution runs in the background
• Immediate fault notification enables rapid response

📊 Comprehensive Coverage

• Hardware validation (PCI, USB, GPIO, Serial, CAN, Ethernet)
• System resource monitoring (CPU, Memory, Disk)
• Data path verification (TCP, CAN bus, Serial ports)

🔌 Plug-and-Play Architecture

• Dynamic plugin loading at runtime
• Configuration-driven test parameters
• No core system modifications required to add new tests

📋 Systemd Integration

• Runs as a native Linux service
• Automatic startup on boot
• Standard service management (systemctl start/stop/status)

Test Types & Coverage

The BIT system implements three primary test categories aligned with industry-standard Built-In Test methodologies:

Power-On BIT (PBIT)

Tests executed once at system startup to verify hardware integrity before normal operations begin.

Continuous BIT (CBIT)

Tests that run periodically during normal operations to detect runtime faults and resource exhaustion.

Factory BIT (FBIT)

Comprehensive hardware tests used during manufacturing and maintenance to validate all system interfaces.

Test Summary Table

Power-On BIT (PBIT) Tests

Continuous BIT (CBIT) Tests

Factory BIT (FBIT) Tests

Total: 57 Built-In Tests covering hardware validation, system monitoring, and security verification.

Plugin Architecture

The BIT system is built on a powerful plugin architecture that enables seamless extensibility without modifying core system code.

How It Works

The BIT system uses Zenoh as its messaging middleware, enabling real-time test result distribution to monitoring clients and seamless integration with GVA (Generic Vehicle Architecture) systems via protocol bridging.

Message Flow Architecture

Detailed Message Sequence

Protocol Bridge Details

Plugin Features

Creating a New Plugin

Creating a custom BIT plugin is straightforward:

1. Implement the TestRun trait:

impl TestRun for MyCustomTest {
    fn run(&mut self) {
        // Your test logic here
        self.base_test.status = TestStatus::Success;
    }
}

1. Export the plugin interface:

#[no_mangle]
pub extern "C" fn create_test() -> Box<dyn TestRun> {
    Box::new(MyCustomTest::new())
}

1. Create a configuration file (optional):

[my_custom_test]
frequency = 60
enabled = true
threshold = 90

1. Build and deploy the shared library to /usr/local/lib/bit_manager/

Rust Language Safety Features

The BIT system is implemented in Rust, providing unparalleled safety guarantees critical for embedded and safety-critical systems.

Memory Safety

Why Rust for BIT?

🔒 Compile-Time Safety

Rust catches entire categories of bugs at compile time that would cause runtime failures in C/C++:

• Memory leaks
• Buffer overflows
• Race conditions
• Null pointer dereferences

⚡ Zero-Cost Abstractions

High-level safety features compile to efficient machine code with no runtime overhead, matching C/C++ performance.

🔧 Fearless Concurrency

The ownership model enables safe multi-threaded test execution without data races:

// Thread-safe shared state with Arc<Mutex<T>>
let shared_state = Arc::new(Mutex::new(TestState::new()));

📦 Modern Dependency Management

• Cargo package manager ensures reproducible builds
• Automated dependency resolution
• Built-in testing framework

🛡️ Type-Safe Configuration

Configuration parsing leverages Rust's type system to catch errors early:

let threshold: f32 = config.get("threshold")?;  // Type-checked at compile time

Safety Statistics

Integration & Deployment

Systemd Service

# Enable automatic startup
sudo systemctl enable bit_manager

# Start the service
sudo systemctl start bit_manager

# Check status
sudo systemctl status bit_manager

Debian Package Installation

cargo deb -p bit_manager
sudo dpkg -i target/debian/bit_manager_*.deb

Configuration Paths

Inspection & Monitoring

The bit_inspect utility provides detailed information about loaded tests:

# List all available tests
bit_inspect

# Get detailed information about a specific test
bit_inspect cbit_disk_usage

Example Output:

Details:
  Long-Name              Disk utilization test
  Author                 Ross Newman <[email protected]>
  Description            Check the disk is not nearing full
  Status                 NotRun

Plugin Details:
  Plugin Name            cbit_disk_usage
  Version                1.0.0
  Date Built             2025-03-09 01:42:11
  Run Frequency          Periodic(30s)

Summary

The BIT system delivers:

✅ Comprehensive hardware and software diagnostics
✅ Extensible plugin architecture for custom tests
✅ Memory-safe implementation in Rust
✅ Industry-standard PBIT/CBIT/FBIT methodology
✅ Native Linux/systemd integration
✅ Configuration-driven test parameters
✅ Real-time monitoring and logging