FBIT Test Reference¶

Complete reference for all 9 Factory Built-In Tests (FBIT).

FBIT tests are comprehensive hardware validation tests intended for factory testing and depot-level maintenance. They perform deep hardware testing and may require specialized equipment or test fixtures.

Factory Testing

FBIT tests are designed for controlled factory environments. Some tests may:

Require specialized hardware or test fixtures
Stress hardware beyond normal operating conditions
Take extended time to complete
Require hardware resets or reboots
Need physical access to the device under test

Hardware Validation Tests¶

fbit_can_data¶

Purpose: Comprehensive CAN bus data transmission and reception testing.

What it tests: - CAN interface initialization - Message transmission accuracy - Reception verification - Error handling - Bus load testing - Timing validation

Test method: - Sends known test patterns - Verifies received data - Tests different baud rates - Validates error frames - Checks arbitration - Measures latency

Hardware requirements: - CAN transceiver hardware - Loopback cable or CAN bus simulator - Second CAN device for full-duplex testing

Configuration:

[fbit_can_data]
enabled = true

[[can_test]]
interface = "can0"
test_messages = 1000
baud_rate = 500000
loopback_mode = true

[[can_test]]
interface = "can1"
test_messages = 1000
baud_rate = 500000
loopback_mode = true

Pass conditions: - All test messages sent successfully - All messages received correctly - No CRC errors - Timing within specifications - Error recovery successful

Typical duration: 2-5 minutes per interface

Common issues: - Missing loopback cable - Incorrect termination (120Ω) - Baud rate mismatch - Ground issues - Cable length limits

fbit_gpio_data¶

Purpose: Comprehensive GPIO pin functionality testing.

What it tests: - Pin output capabilities - Pin input reading - Pull-up/pull-down functionality - Pin state transitions - Signal integrity - Pin-to-pin isolation

Test method: - Configures pins as outputs - Sets HIGH/LOW states - Reads back states on connected pins - Tests all pin combinations - Validates voltage levels - Checks for shorts/opens

Hardware requirements: - GPIO test fixture or loopback cable - Pins must be connected in pairs for testing - Voltage measurement capability (optional)

Configuration:

[fbit_gpio_data]
enabled = true

[[gpio_pair]]
output_pin = 17
input_pin = 27
test_iterations = 100

[[gpio_pair]]
output_pin = 22
input_pin = 23
test_iterations = 100

Pass conditions: - All outputs toggle correctly - All inputs read correctly - No pin conflicts - Clean signal transitions - No crosstalk between pins

Typical duration: 1-3 minutes

Safety considerations: - Don't short power pins - Respect maximum pin current - Verify voltage levels before testing - Use current-limiting resistors

fbit_pci¶

Purpose: Comprehensive PCI/PCIe device enumeration and testing.

What it tests: - Bus enumeration - Device configuration space - BAR (Base Address Register) allocation - Interrupt handling - Link speed and width - Power management

Test method: - Scans all PCI buses - Reads device configuration - Validates vendor/device IDs - Tests link negotiation - Verifies power states - Checks error reporting

Hardware requirements: - PCI/PCIe devices installed - Known-good hardware configuration - Access to configuration space

Configuration:

[fbit_pci]
enabled = true
full_enumeration = true

[[expected_device]]
vendor_id = "8086"
device_id = "15d7"
bus = 0
device = 31
function = 6
expected_link_speed = "2.5 GT/s"
expected_link_width = "x1"

Pass conditions: - All expected devices found - Configuration valid - Link speeds correct - No device errors - Power states functional

Typical duration: 30 seconds - 2 minutes

Troubleshooting: - Reseat cards if not detected - Check PCIe slot compatibility - Verify power connections - Update firmware if needed

fbit_serial_data¶

Purpose: Comprehensive serial port data transmission testing.

What it tests: - Data transmission accuracy - Reception verification - Baud rate support - Flow control - Parity and stop bits - Error detection

Test method: - Sends known data patterns - Receives and verifies data - Tests multiple baud rates - Validates error handling - Checks flow control signals - Measures timing accuracy

Hardware requirements: - Serial loopback adapter (TX→RX, RTS→CTS) - Or second serial device for testing - Proper cabling and connectors

Configuration:

[fbit_serial_data]
enabled = true

[[serial_test]]
device = "/dev/ttyS0"
baud_rates = [9600, 19200, 38400, 115200]
test_data_size = 4096
loopback = true

[[serial_test]]
device = "/dev/ttyUSB0"
baud_rates = [9600, 115200]
test_data_size = 4096
loopback = true

Pass conditions: - All data transmitted correctly - All data received correctly - No parity errors - No framing errors - Timing accurate at all baud rates

Typical duration: 2-5 minutes per port

Common issues: - Missing loopback adapter - Incorrect pinout (null modem vs straight) - Baud rate not supported - Buffer overflow at high speeds

fbit_ssd¶

Purpose: Comprehensive SSD/storage device testing.

What it tests: - Read/write performance - Data integrity - TRIM support (SSD) - Wear leveling - Error correction - Sustained throughput - Random vs sequential I/O

Test method: - Writes test patterns - Reads back and verifies - Measures throughput - Tests random access - Validates SMART data - Stress tests endurance

Hardware requirements: - Storage device to test - Sufficient free space (20% of device) - Backup of critical data (destructive test option)

Configuration:

[fbit_ssd]
enabled = true

[[storage_test]]
device = "/dev/sda"
test_size_mb = 1024
sequential_test = true
random_test = true
verify_writes = true
destructive = false  # Set true for full surface test

Pass conditions: - Write speed within spec - Read speed within spec - All data verified correctly - SMART status healthy - No bad sectors

Typical duration: 10-30 minutes (longer for full tests)

⚠️ Warning: Destructive mode will erase all data on the device!

Performance expectations: - SSD Sequential Read: >500 MB/s (SATA), >2000 MB/s (NVMe) - SSD Sequential Write: >400 MB/s (SATA), >1500 MB/s (NVMe) - HDD Sequential: 100-200 MB/s - Random IOPS vary significantly

fbit_system_data¶

Purpose: Comprehensive system-level data path validation.

What it tests: - Memory subsystem integrity - CPU data path - Cache coherency - DMA operations - System bus functionality - Memory bandwidth

Test method: - Large memory allocations - Pattern writes and verification - Cache flush testing - Multi-core data sharing - Bandwidth measurement - Error injection (if supported)

Hardware requirements: - Adequate system memory - Multi-core CPU - System load should be minimal

Configuration:

[fbit_system_data]
enabled = true
test_memory_mb = 1024
test_iterations = 10
pattern_types = ["sequential", "random", "checkerboard"]
test_cache_coherency = true

Pass conditions: - All memory patterns verified - No data corruption - Cache coherency maintained - Bandwidth within expectations - No ECC errors (if available)

Typical duration: 5-15 minutes

Memory patterns tested: - Sequential (0x01, 0x02, 0x03, ...) - Walking ones (0x01, 0x02, 0x04, 0x08, ...) - Walking zeros (0xFE, 0xFD, 0xFB, ...) - Checkerboard (0x55, 0xAA) - Random data

fbit_tcp_data¶

Purpose: Comprehensive TCP/IP networking validation.

What it tests: - TCP connection establishment - Data transmission accuracy - Throughput performance - Error handling - Connection teardown - Concurrent connections

Test method: - Establishes TCP connections - Transfers known data - Verifies received data - Measures bandwidth - Tests error conditions - Validates timeouts

Hardware requirements: - Network interface - Network connectivity (loopback or remote server) - Test server or loopback configuration

Configuration:

[fbit_tcp_data]
enabled = true

[[tcp_test]]
interface = "eth0"
test_server = "127.0.0.1"  # or remote test server
test_port = 5001
test_data_mb = 100
concurrent_connections = 10

Pass conditions: - All connections successful - All data transmitted correctly - All data received correctly - Throughput meets minimum - No packet loss

Typical duration: 5-10 minutes

Test scenarios: - Small packet transfer - Large bulk transfer - Many concurrent connections - Connection under load - Error recovery

fbit_usb¶

Purpose: Comprehensive USB port functionality testing.

What it tests: - Port enumeration - Device detection - Data transfer - Power delivery - USB version support (2.0/3.0/3.1) - Hot-plug detection

Test method: - Enumerates all ports - Tests device connection - Transfers test data - Verifies transfer rates - Tests power delivery - Validates hot-plug

Hardware requirements: - USB test devices or loopback adapters - Known-good USB devices - USB hubs for port testing

Configuration:

[fbit_usb]
enabled = true

[[usb_test]]
port = "1-1"
expected_speed = "5000"  # Mbps (USB 3.0)
test_device_vid = "1d6b"
test_device_pid = "0003"
data_transfer_test = true

Pass conditions: - All ports enumerate correctly - Device detection successful - Transfer speeds meet expectations - No enumeration errors - Hot-plug works correctly

Typical duration: 3-7 minutes

USB speeds: - USB 1.1: 12 Mbps - USB 2.0: 480 Mbps - USB 3.0: 5 Gbps - USB 3.1: 10 Gbps

fbit_video¶

Purpose: Comprehensive video/display output testing.

What it tests: - Display detection - Resolution support - Color accuracy - Refresh rates - Multiple displays - Hardware acceleration

Test method: - Enumerates displays - Tests resolution changes - Renders test patterns - Validates output signal - Tests mode switching - Checks GPU capabilities

Hardware requirements: - Display connected (HDMI/DP/VGA) - Graphics card with driver - Display cable

Configuration:

[fbit_video]
enabled = true

[[display_test]]
output = "HDMI-1"
expected_resolutions = ["1920x1080", "2560x1440"]
test_refresh_rates = [60, 75, 144]
test_pattern = true

Pass conditions: - Display detected - All resolutions work - Refresh rates supported - Test pattern displayed correctly - No signal loss

Typical duration: 2-5 minutes

Test patterns: - Color bars - Grayscale ramp - Checkerboard - Pure white/black - Moving patterns (motion test)

Note: Some tests require manual visual verification unless automated test equipment is available.

Running FBIT Tests¶

All FBIT Tests¶

# Run all factory tests (caution: may be destructive)
bit-manager -f

# Run with confirmation prompts
bit-manager -f --interactive

Safe FBIT Tests¶

# Non-destructive hardware tests only
bit-manager -t fbit_pci -t fbit_usb -t fbit_video -f

# Skip storage tests
bit-manager -f --skip fbit_ssd

Individual FBIT Test¶

# Test specific hardware
bit-manager -t fbit_serial_data -f

# With verbose output
bit-manager -t fbit_gpio_data -f -v

Factory Test Sequence¶

Recommended order for comprehensive factory validation:

System-level tests first:
```
bit-manager -t fbit_system_data -f
```
Storage validation:
```
bit-manager -t fbit_ssd -f
```
Interface tests:
```
bit-manager -t fbit_pci -t fbit_usb -f
```

Communication tests:

bit-manager -t fbit_serial_data -t fbit_can_data -t fbit_tcp_data -f

I/O tests:
```
bit-manager -t fbit_gpio_data -f
```
Display validation:
```
bit-manager -t fbit_video -f
```

Test Fixtures¶

Many FBIT tests require test fixtures:

Serial Loopback¶

Connect pins 2-3 (TX-RX) and 7-8 (RTS-CTS) on DB9 connector.

CAN Loopback¶

Connect CAN_H and CAN_L between interfaces with 120Ω termination.

GPIO Test Fixture¶

Create paired connections based on test configuration. Use current-limiting resistors (1kΩ recommended).

USB Test Devices¶

Use known-good USB flash drives or specialized USB test equipment.

Safety Precautions¶

⚠️ Before running FBIT tests:

Back up all critical data
Disconnect production networks
Ensure adequate cooling
Verify test fixture connections
Have hardware documentation available
Plan for extended test time
Monitor test progress
Review test logs

Test Results¶

FBIT tests generate detailed logs:

# View test results
cat /var/log/bit-fbit.log

# Real-time monitoring
tail -f /var/log/bit-fbit.log

# Filter failures only
grep -i "fail" /var/log/bit-fbit.log

Next Steps¶

PBIT Tests - Power-on validation
CBIT Tests - Continuous monitoring
Test Overview - Complete catalog
Running Tests - Execution guide
Configuration - Test setup

Edit this page on GitHub