nasa/fprime

Features

• Embedded Flight Software Frameworks - Provides a component-based architecture for building, testing, and deploying reliable software for spaceflight and embedded systems.
• Cross-Platform Build Systems - Automates code generation, dependency management, and cross-compilation for diverse hardware targets through a configurable build pipeline.
• Build Automation Systems - Orchestrates the compilation, dependency management, and deployment of embedded software through a configurable build system.
• Interface Definition Code Generation - Automates the generation of source code and interface definitions from architectural models to ensure system consistency.
• Component-Based Architectures - Implements a modular design pattern that decouples software logic from communication interfaces to facilitate system-wide reuse.
• Component Definition Generators - Automates the creation of component interface structures and build configurations from architectural models to ensure system-wide consistency.
• System Architecture Models - Models software components and their interconnections using a domain-specific language to generate structured code.
• Embedded System Management - Provides a ground-based interface to monitor, command, and interact with embedded software deployments.
• Ground System Plugins - Provides a suite of tools for monitoring telemetry, dispatching commands, and performing integration testing on embedded software.
• System Command Launchers - Provides a command-line interface to send spacecraft commands and receive telemetry or event data from ground systems.
• Architectural Modeling Languages - Defines software architecture using a domain-specific modeling language to generate code and structure for spaceflight and embedded applications.
• Code Generation - Translates component specifications and system connections into source code to accelerate development and ensure consistency across the application.
• Embedded Hardware Deployment - Supports execution on diverse architectures and operating systems including Linux, FreeRTOS, Zephyr, and VxWorks for spaceflight and embedded hardware.
• Ground System Interfaces - Provides network-based communication channels to connect onboard telemetry and command systems with external ground software for remote monitoring.
• System Service Abstraction Layers - Provides a uniform interface for system-level operations like threading and file management to ensure application portability.
• Compile-Time Code Generation - Translates architectural models and component specifications into source code to ensure consistency and automate boilerplate creation.
• Embedded Systems Development - Builds modular, reliable software for spaceflight and embedded systems using a component-based architecture.
• Topology Assembly Systems - Instantiates and connects software components into a functional graph at build or runtime to define system structure.
• Active-Passive Models - Separates execution logic into thread-safe active components with message queues and passive components for synchronous operations.
• Telemetry Visualization - Constructs custom graphical interfaces to display real-time telemetry, event logs, and command history.
• Topology Orchestrators - Connects multiple component instances into a defined topology to create the functional structure of a software system.
• Data Model File Generation - Automates the creation of software components and interface files by processing input models to ensure architectural consistency.
• Data Pipeline Automation - Manages runtime environments that automatically connect applications to ground system data pipelines.
• Architecture-Wide Type Definitions - Specifies complex data structures including arrays and enumerations to ensure consistent data modeling across the architecture.
• Autocoding Integrators - Orchestrates the generation of source artifacts and dependency tracking directly within the compilation pipeline to maintain system integrity.
• Sequence Executors - Executes ordered lists of commands from files, supporting time-based triggers and automatic termination on command failure.
• System Command Dispatchers - Routes serialized commands to target components based on unique identifiers and manages the lifecycle of command execution.
• Source Generators - Automates the creation of software components by processing input files through defined build rules.
• Cross-Compilation Toolchains - Enables targeting non-native hardware architectures by configuring custom toolchain files during the build process.
• Embedded Hardware Cross-Compilation - Configures build toolchains to target specific embedded processors and architectures, enabling deployment to diverse hardware environments.
• Sequence Compilers - Translates human-readable command sequence files into a minimized binary format required for execution by flight software.
• Build Configuration Management - Orchestrates the compilation and linking of software modules using a standardized interface for cross-platform deployment.
• Cross-Platform Execution - Supports deployment on various operating systems, real-time kernels, and bare-metal environments across multiple processor architectures.
• Hardware Communication - Connects external communication devices using standardized interfaces for packet transmission and buffer management.
• Cross-Address Space Bridges - Serializes typed port calls to transmit data across address spaces, hardware buses, or network interfaces and reconstructs them on the receiving side.
• Data Framing - Adapts raw byte streams into structured packets for specific hardware or protocols through custom assembly and disassembly logic.
• Schema Generation Engines - Automates the creation of serializable structures and enumerations from system models to ensure consistency across software communication.
• Hardware Drivers - Initializes and manages low-level communication protocols like UART to establish reliable data links between software and physical hardware.
• Type Safety - Enforces strict interface contracts between software components to ensure type safety and modularity across the system.
• Asynchronous Task Queues - Executes tasks in separate threads using active components and message queues to decouple component interactions and prevent blocking.
• Concurrency Primitives - Abstracts operating system primitives for threads, message queues, and mutexes to support robust component execution.
• Cross-Platform Abstractions - Provides a uniform interface for system-level services like threading and memory management to enable cross-platform portability.
• Runtime Parameter Configurators - Updates component settings at runtime via ground-commanded parameters to adjust behavior without requiring software redeployment.
• Non-Volatile Parameter Managers - Stores and retrieves non-volatile configuration values, providing default fallbacks and automated synchronization for system settings.
• Interface Definition Languages - Specifies component ports and data structures using a dedicated modeling language to ensure type-safe communication.
• Modular Software Design - Decomposes complex software into discrete, interconnected components to facilitate modular design and system-wide functionality.
• Embedded Component Modularization - Constructs reusable software units with custom ports and data types to facilitate the design and implementation of embedded applications.
• System Telemetry Collectors - Streams real-time events and telemetry channels from embedded systems to the console with filtering support.
• Software Testing - Validates system behavior through dedicated tools for unit and integration testing of embedded applications.
• Interface Verification Harnesses - Executes isolated tests against component interfaces to validate requirements, check telemetry, and ensure expected behavior through automated test harnesses.
• System Integration Test Runners - Validates system-level requirements by programmatically sending commands and monitoring telemetry or events across the assembled deployment.
• Unit Testing Frameworks - Validates the logic and reliability of individual software modules through automated test harnesses and code coverage analysis.
• Execution Context Configurators - Assigns execution contexts to modules by selecting passive, active, or queued types to manage threading and message processing requirements.
• Robotics Frameworks - Component-driven framework for spaceflight and embedded software.
• Robotics Frameworks - Component-driven framework for spaceflight and embedded software.
• System Data Product Managers - Coordinates the generation, storage, and downlink of system data by providing components for memory allocation, non-volatile storage writing, and cataloging.
• Data Serialization - Translates complex data types into architecture-independent buffers for generic data routing and communication across system boundaries.
• Data Structure Definitions - Specifies custom data records and containers using a modeling language to organize system information for storage and transmission.
• Cross-Platform Primitive Standards - Provides a consistent set of primitive type definitions that ensure cross-platform compatibility and exact bit-width representation.
• Decoupled Driver Architectures - Decouples hardware communication logic from device-specific operations by splitting drivers into platform-specific bus components and reusable device manager components.
• Build Toolchains - Registers external toolchain configurations to enable specialized compilation for diverse hardware targets.
• Build Configurations - Defines build environments and registers modules to enable the compilation of embedded applications.
• Dictionary Generators - Automates the creation of project-wide and module-level dictionary targets to support system configuration and telemetry mapping.
• Cross-Platform Build Configurations - Defines custom build configurations and toolchain settings to adapt software for specific hardware environments during compilation.
• Automated Test Execution - Runs defined test suites against components to verify functional correctness and ensure system reliability during development.
• Blocking Task Offloaders - Delegates long-running operations to a low-priority worker component to ensure the primary manager remains responsive to high-priority events.
• Baremetal System Deployment - Executes software components directly on hardware without an operating system by using an abstraction layer.
• Distributed Deployment - Links independent software deployments across physical devices to enable unified communication and data exchange.
• Port Serializers - Enables cross-node communication by serializing port calls, allowing components to be distributed across physical nodes.
• Managed Memory Allocators - Controls heap usage through specialized allocators and fixed-size buffer managers to ensure predictable memory consumption in embedded environments.
• Fixed-Size Memory Pool Managers - Allocates and deallocates fixed-size memory regions through a centralized manager to avoid heap fragmentation and ensure predictable memory usage.
• Process Isolation - Deploys software components into separate processes to ensure fault containment and stability.
• Hardware Partitioning Systems - Deploys independent software instances across hardware partitions managed by a hypervisor to ensure strong isolation.
• Reusable Component Packaging - Structures reusable code into independent packages that can be shared and maintained across different projects.
• Component Port Definitions - Links components by connecting input and output ports to facilitate data flow and message passing.
• Concurrent Execution Managers - Provides built-in support for message queues and multi-threading to handle asynchronous tasks and inter-component communication within embedded environments.
• Model-Based Verification - Validates software logic against defined models by executing tests before implementation to ensure requirements are met.
• Data Serialization - Translates complex data structures into architecture-independent binary buffers to enable communication across different address spaces or nodes.
• Decoupled Logic Layers - Structures complex systems into distinct application, manager, and driver layers to decouple logic from hardware interfaces.
• Build-Time Parameter Overrides - Overrides default configuration settings for imported modules at build time to adapt reusable components to specific project requirements without modifying the original source code.
• Distributed Systems Architectures - Bridges software components across different computing nodes to enable transparent communication in distributed system architectures.
• Runtime Type Guards - Encapsulates component communication using typed ports that ensure interface consistency and support various execution patterns.
• Event Monitoring Systems - Tracks component activity and internal state changes using real-time telemetry and event logging.
• Remote Hardware Controls - Sends operational commands to remote hardware directly through a configurable dashboard interface.
• System Dictionaries - Generates a structured representation of software components, types, and telemetry definitions to facilitate cross-tool integration.
• Component Testing - Executes unit tests to verify the functionality and reliability of individual software modules.
• Distributed Node Bridges - Enables distributed system architectures by serializing and transmitting component data across computing nodes without modifying internal logic.
• Component Lifecycle Management - Attaches initialization, startup, and teardown logic directly to component instances to maintain consistent behavior across system modules.
• Implementation Swapping Interfaces - Selects specific underlying code implementations for system concepts like operating systems or memory management at link time.
• Mission Control Plugin Architectures - Creates custom plugins to add specialized functionality or visualization tools to the mission control interface.
• Structured Mission Data Generation - Produces and stores large data packets on-board for later asynchronous downlink and scientific analysis.
• Custom System Executable Building - Compiles component designs and topologies into unique binaries tailored for specific embedded hardware platforms.
• Build Orchestrators - Extends the build system with user-defined commands for executing custom logic at global or module levels.
• Interactive Command Line Interfaces - Provides a command-line interface to send spacecraft commands and receive telemetry or event data.
• Flow Control - Regulates message transmission between components and hardware using status feedback to prevent interface overloading and ensure reliable data delivery.
• Embedded File Transfer Managers - Manages the bidirectional movement of files between the ground system and the embedded target for updates or data retrieval.
• Framework Type Overrides - Overrides default type definitions for system components to meet specific project requirements or hardware constraints.
• System Time Base Definitions - Specifies available clock sources and time contexts used for time-tagging telemetry and performing time-based operations.
• Task Schedulers - Triggers component execution at defined intervals by dividing a master clock signal into multiple repeating tick rates.
• Cross-Platform Deployment Targets - Cross-compiles and packages applications for target embedded systems to ensure consistent execution across diverse hardware environments.
• Deployment Configuration - Externalizes component properties into dedicated configuration modules to allow flexible tuning without modifying core logic.
• Deployment Targets - Registers executable modules and subdirectories to define the structure of complete software deployments.
• Remote Workspace Command Execution - Sends operational commands to embedded systems with support for arguments and command definitions.
• Queue Capacity Configurators - Configures message queue sizes for active components to manage task priorities and handle inter-component communication traffic effectively.
• Indexed Port Sets - Groups related input and output ports into indexed sets to ensure consistent routing and validation when communicating with multiple external components.
• Serial Communication Interfaces - Implements standard adapter interfaces to exchange raw data between ground systems and hardware interfaces like serial ports or radios.
• Data Product Transmitters - Sends filled data containers to storage or downlink services using standardized ports and automated time-tagging.
• Radio Adapter Managers - Handles bidirectional data transmission and reception by bridging software components with physical radio hardware via standardized adapters.
• Hardware Abstraction Layers - Provides abstraction layers to enable software execution on custom or non-standard embedded hardware.
• Component Memory Allocation Models - Creates component instances using flexible memory models including static, heap, or stack allocation to suit specific embedded system requirements.
• Interface Contract Implementations - Registers specific code implementations for defined interfaces to ensure correct linking and overriding of system-level components.
• Parameter Loading Interfaces - Retrieves and updates component parameters from storage via dedicated ports to support both initial startup and runtime configuration changes.
• Logic Encapsulation Interfaces - Defines modular software units that encapsulate commands, events, and telemetry through standardized interfaces.
• Component Encapsulation Wrappers - Wraps external library logic within a component to provide a standardized interface for other system parts.
• Platform Abstraction Layers - Adapts core software architecture to run on different hardware targets by implementing necessary abstraction layers.
• Polymorphic Memory Structures - Uses a unified storage structure to represent multiple primitive types interchangeably within the same memory space.
• Decoupled Logic Encapsulation - Decomposes software into isolated modules that interact exclusively through defined port interfaces to ensure loose coupling.
• State Machine Logic - Defines and executes state-based logic within components to manage complex system behaviors.
• System Model Generators - Produces representations of system modules to support external tooling and architectural analysis.
• System Logging - Records and transmits diagnostic events with severity levels for ground systems and local consoles.
• Dependency Mocking - Replaces real library dependencies with stubs or mocks during testing to simulate behaviors or fault conditions.
• Integration Testing Suites - Integrates component-level test suites into the build process to verify software logic and functionality.
• Component Initialization - Provides standardized lifecycle hooks for configuring component instances and queue depths during system startup.
• Telemetry - Collects and manages telemetry snapshots using double-buffering to ensure consistent data downlinking.
• Data Serialization Formats - Converts structured data into binary format within allocated containers using auto-generated serialization operations for efficient storage.
• Build Pipeline Customizers - Integrates external code generation tools directly into the build pipeline for automated source processing.
• Build-Time Optimizers - Enables or disables optional framework features at compile time to reduce memory usage in resource-constrained environments.
• Build Artifact Generators - Configures the build system to execute autocoder processes and produce necessary source files from defined input specifications.
• Build-Time Validation - Inspects link arguments and file references during build recursion to ensure all required components are correctly defined.
• Test Code Generators - Automates the creation of unit test scaffolding and build configurations to ensure consistent verification.
• Component Capacity Constants - Adjusts the capacity of system components and ports by setting global constants to match resource requirements.
• Build Environment Configurations - Integrates project components with the build system to enable automated code generation and standard compilation workflows.
• Source-Level Module Packaging - Organizes components, ports, and topologies into namespaced directories to share and integrate custom code across different software projects.
• Initialization Command Sequences - Executes a series of commands from a file, automatically validating responses and halting the sequence if any command fails.
• Build System Extensions - Registers custom build targets at global and module levels to execute user-defined tasks during the compilation process.
• Deployment Environments - Compiles component topologies into a single runnable software image for execution within target environments.
• Deployment Targets - Registers custom build targets for software modules and deployment packages to manage compilation and dependency resolution.
• Interface Scope Managers - Wraps standard linking and inclusion commands to automatically adjust scope requirements for interface-based software components.
• Plugin Distribution Packages - Bundles custom plugins as standard Python packages with entry points to enable local testing, installation, and distribution.
• Communication Optimization Layers - Provides specialized code generation for port connections to minimize runtime overhead during high-performance data exchange.
• Data Product Decoders - Translates binary data product files into readable formats using command-line tools for ground-based analysis and verification.
• Runtime Buffer Management - Facilitates safe sharing and reuse of pre-allocated memory pools to avoid heap allocation during operation.
• Operating System Service Abstractions - Provides an abstraction layer that mimics threads and message queues to support components requiring OS features in resource-constrained environments.
• External Library Integrations - Incorporates third-party code into the build system using source-tree inclusion, remote fetching, or pre-compiled binaries.
• Command History Trackers - Maintains a searchable history of sent operational commands for verification and retry.
• Asynchronous Request Handlers - Separates requests from responses using distinct ports to allow asynchronous processing.
• Build-System Library Integrators - Incorporates third-party software libraries into the build system to leverage existing functionality within the application.
• Library Dependency Managers - Automatically detects external library manifests and configures include directories for dependency integration.
• Module Encapsulation Patterns - Groups component instances and internal connections into reusable units to simplify complex system topologies.
• Framework Directory Registries - Registers the core framework directory structure within the build system to ensure all mainline components are correctly identified and included.
• Process Memory Spaces - Runs multiple software components within a single process address space to enable direct communication.
• Logging and Telemetry - Defines telemetry channels, event logs, and command interfaces for standardized monitoring and control.
• Diagnostic and Error Reporting - Reports system status through enumerated types and diagnostic events to track health and operational failures.
• Event Monitoring Systems - Verifies critical system components remain active by sending periodic ping requests and escalating on timeouts.
• System Monitoring Dashboards - Provides diagnostic interfaces for tracking and visualizing system health and operational status.
• Memory Leak Detection - Instruments the build to identify memory leaks and undefined behavior during execution for improved reliability.
• Runtime Verification - Validates software state during execution by checking specified conditions and reporting violations.
• System State Assertions - Validates that telemetry or event data matches expected criteria and raises an assertion error if conditions are not met.
• Test Report Aggregators - Collects and links unit tests from multiple modules into a single target for comprehensive system validation.
• Code Coverage Reportings - Generates reports identifying which source code lines were executed during testing to measure validation thoroughness.
• Inclusion Policies - Optimizes binary size and resource usage by selectively including or excluding system components.

Star history