agentleFS
nasanasa/fprime/.github/skills/fprime-fpp-navigation/SKILL.md

fprime-fpp-navigation

Skill12k starsChanged 21 months agoApache-2.0View on GitHub

Answer questions about an F Prime component or topology from the FPP model instead of reading autocoded C++. Covers grep recipes for the `.fpp` keywords, the FPP-to-C++ naming table (handlers, commands, events, telemetry, parameters, tester base), where autocode lives, and codegen gotchas. Use before opening a `*Ac.hpp`, before guessing a handler or macro name, and when tracing wiring across a topology. Keywords: F Prime, FPP, grep, handler name, autocode, Ac.hpp, TesterBase, topology wiring, port type.

Trending

More talk lately.about the whole repository

Dec 2025: 0 mentionsJan 2026: 0 mentionsFeb 2026: 0 mentionsMar 2026: 1 mentionApr 2026: 0 mentionsMay 2026: 22 mentionsJun 2026: 3 mentionsJul 2026: 7 mentionsAug 2026: 2 mentionsSep 2026: 7 mentionsOct 2026: 11 mentionsNov 2026: 1 mention
Dec 2025Jun 2026Nov 2026
Mentions a month of the nasa/fprime repository that our weekly crawl found. There is no adoption data for this file yet.

Who's talking about nasa/fprime

The biggest 5 of 71 mentions linking to the repository that our crawl found. Each line is their own headline.

See all 71

Talked about on GitHub, YouTube, Hacker News and the web (71 times).

On GitHub · 50

45 more on GitHub

On YouTube · 13

8 more on YouTube

On the web · 2

The file

We split this skill into the rules it gives an agent

2 rules. About 0 are common, 0 are distinctive, and 2 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈0

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 2

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Look inside connections blocks and at the pattern specifiers (command connections instance CdhCore.cmdDisp, event connections instance …

    line 78
  2. Very specific:

    Only deployment topology X autocodes <X>TopologyAc.*.

    line 150

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Skill: Querying the F Prime model

The .fpp file is the source of truth and is much smaller than the autocode it produces. Every generated C++ name is a deterministic function of the model, so read the model and derive the name; open the generated header only for an exact signature you cannot derive.

A component's model is usually more than one file:

  • include "Commands.fppi" pulls in a fragment. Half of Svc/ keeps commands, events, telemetry and parameters in .fppi files, so grep --include=*.fpp --include=*.fppi and follow every include line.
  • import Svc.Deframer inside a component pulls in an interface (Fw/Interfaces/, Svc/Interfaces/, Drv/Interfaces/, or the project's). Its ports belong to the component but are declared in the interface file, and interfaces can import other interfaces. Run the port recipes on the interface file too.
  • Inside a topology, import CdhCore.Subtopology is a subtopology, not an interface.
  • $ escapes a name that collides with a keyword ($health, $recv); the $ is dropped in C++.

1. Grep recipes

FPP keywords are multi-word and event, telemetry, param also start special-port lines (event port Log) and topology pattern specifiers (event connections instance events), so anchor on what follows the name. Patterns are grep -nE over *.fpp and *.fppi.

WantPattern
Input ports`^\s*(asyncsyncguarded) input port`
Output ports^\s*output port
Commands`^\s*(asyncsyncguarded) command`
Events`^\sevent +$?\w+\s((\severity$)`
Telemetry^\s*telemetry +\$?\w+\s*:
Parameters^\s*(external )?param +\$?\w+\s*:
Special ports`^\s*((asyncsyncguarded) )?(command (recvregresp)eventtext eventtelemetrytime getparam (getset)product (getrequestsendrecv)) port`
Internal ports^\s*internal port
Interfaces used^\s*import in a component file
Everything in a component`^\s*(asyncsyncguardedoutputinternalcommandtexttimeexternalparamproducteventtelemetryimportincludematchstate machine)\b`

The events pattern accepts the event Name \ line-continuation form. The same keywords in a topology.fpp are pattern specifiers and instance/connections lines, not declarations.

Port arrays are declared as port name: [N] Type; N is usually a constant from default/config/AcConstants.fpp (or the project's override), so follow the name there to get the number.

Across the tree (exclude build-fprime-* directories):

  • Who uses a port type: grep -rlE 'port +\$?\w+ *:.*\bPing\b' --include=*.fpp --include=*.fppi. Inside module Svc the type is written unqualified (Ping, not Svc.Ping), and components that get the port through an interface only show import <Module>.<Interface>; grep for that too.
  • Where a symbol is defined: grep -nE '^locate \w+ Svc\.Ping ' build-fprime-*/locs.fpp (needs a build cache). fpp-locate-defs <file> lists what that file defines, not where a used symbol lives.
  • Who is wired to an instance: grep the instance name across every .fpp of the deployment and of the subtopologies it imports (Svc/Subtopologies/*/*.fpp, under lib/fprime/ in a project). Look inside connections blocks and at the pattern specifiers (command connections instance CdhCore.cmdDisp, event connections instance CdhCore.events, health connections instance CdhCore.$health, ...). A pattern connects every instance in the topology, including the named one itself. Subtopologies themselves carry no pattern specifiers.

2. Name mapping (model → generated C++)

<Comp> is the FPP component name, not the directory (Svc/CmdDispatcher/ declares active component CommandDispatcher, so the base is CommandDispatcherComponentBase). <Comp>TesterBase / <Comp>GTestBase are the unit-test counterparts. Enum constants upper-case the model name: event OpcodeRegistered is EVENTID_OPCODEREGISTERED, command CMD_NO_OP is OPCODE_CMD_NO_OP. Full signatures and semantics: Autocoded Functions and Component Classes.

ModelImplementation must defineImplementation may callTester side
input port foofoo_handler(FwIndexType portNum, ...), returning the port's return type if it has one; async ports may add foo_preMsgHook, and hook ports must add foo_overflowHook(portNum, ...)invoke_to_foo(portNum, ...), connect_to_foo, isConnected_to_foo; doDispatch() drains an async queue
output port barbar_out(portNum, ...) (asserts on an unconnected or out-of-range port), isConnected_bar_OutputPort(portNum), getNum_bar_OutputPorts()from_bar_handler(...) (returns the port's return type), pushFromPortEntry_bar(...), ASSERT_from_bar_SIZE(n), ASSERT_from_bar(idx, ...)
serial port ss_handler(FwIndexType portNum, Fw::LinearBufferBase& buffer)s_out(portNum, buffer)from_s_handler(portNum, buffer)
command CMDCMD_cmdHandler(FwOpcodeType opCode, U32 cmdSeq, args...); async commands may add CMD_preMsgHook(opCode, cmdSeq)cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse), enum OPCODE_CMDsendCmd_CMD(instance, cmdSeq, args...), ASSERT_CMD_RESPONSE_SIZE(n), ASSERT_CMD_RESPONSE(idx, opcode, seq, resp)
event E (severity warning high)log_WARNING_HI_E(args...), enum EVENTID_E. Severities spell FATAL, WARNING_HI, WARNING_LO, COMMAND, ACTIVITY_HI, ACTIVITY_LO, DIAGNOSTIC. throttle N adds EVENTID_E_THROTTLE and log_WARNING_HI_E_ThrottleClear()ASSERT_EVENTS_E_SIZE(n), ASSERT_EVENTS_E(idx, args...) (only for events with arguments), ASSERT_EVENTS_SIZE(n)
telemetry TtlmWrite_T(value, timeTag = ...), enum CHANNELID_TASSERT_TLM_T_SIZE(n), ASSERT_TLM_T(idx, value), ASSERT_TLM_SIZE(n)
param Poptional parameterUpdated(FwPrmIdType id); external param needs registerExternalParameters(Fw::ParamExternalDelegate*) at initparamGet_P(Fw::ParamValid& valid), enum PARAMID_P. Each param also autocodes commands P_SET/P_SAVE (OPCODE_P_SET, OPCODE_P_SAVE; P_PRM_SET in the dictionary), numbered before the model's own commandsparamSet_P(value, valid), paramSend_P(instance, cmdSeq), paramSave_P(instance, cmdSeq)
product container C, record RdpRecv_C_handler(DpContainer&, Fw::Success::T) only with a product recv portdpGet_C(size, container), dpRequest_C(size), dpSend(container), container.serializeRecord_R(...)override productGet_handler(FwDpIdType, FwSizeType, Fw::Buffer&); ASSERT_PRODUCT_GET/REQUEST/SEND(...)
internal port ipip_internalInterfaceHandler(args...); hook adds ip_overflowHookip_internalInterfaceInvoke(args...)
state machine instance sm of M<M>_action_<a>(SmId smId, <M>::Signal signal, ...) and <M>_guard_<g>(...), where <M> is the fully qualified machine type with . replaced by _ (FppTest_SmInitial_Basic_action_a; a machine defined inside the component carries the component's name too)sm_sendSignal_<sig>(...), sm_getState()

Argument passing: primitives by value, enums/structs/arrays const T&, ref arguments T&. Command string arguments are const Fw::CmdStringArg&; event and port strings are const Fw::StringBase& (sendCmd_* takes const Fw::StringBase&). FwIndexType portNum is always first. Command handlers must end with cmdResponse_out.


3. Where autocode lives, and when to read it

  • The cache is build-fprime-automatic-<toolchain>[-ut]/ at the project root named in settings.ini (TestDeploymentsProject/ for Ref). Framework modules land under F-Prime/<module path>/; project and library modules under their path relative to the project root (build-fprime-automatic-native/LedBlinker/Components/Led/). fprime-util generate only writes locs.fpp; *Ac.* appear after fprime-util build (--ut for TesterBase/GTestBase). Never edit these files.
  • fprime-util impl writes <Comp>.template.{hpp,cpp}; --ut writes test/ut/<Comp>Tester.template.{hpp,cpp} and <Comp>TestMain.template.cpp. Each needs the matching (ut or non-ut) cache, as does fprime-util fpp-check.
  • Resolved opcodes, event/channel IDs and enum values are in <Deployment>TopologyDictionary.json, written by a normal deployment build under build-artifacts/; fprime-util fpp-to-dict from the Top/ directory regenerates it. Use it for GDS and integration-test work rather than computing base id + local id by hand.
  • fprime-util generate refuses to run when the installed fpp does not match cmake/required.cmake; build the venv from the framework's requirements.txt.

4. Codegen gotchas

  • Pattern specifiers (event connections instance X, telemetry connections instance X, command connections instance X) include the instance X itself; a sink component's own events and telemetry are routed back into it.
  • Only deployment topology X autocodes <X>TopologyAc.*; a bare topology block (every subtopology) does not, and the dictionary also needs register_fprime_deployment in CMake. A scratch fpp-to-cpp run on a plain topology cannot check pattern wiring.
  • Port numbers are compile-time constants: a port array of size N rejects portNum >= N with an assertion in the generated base class.
  • A project config/ directory shadows framework .fpp/.hpp configuration files by basename (AcConstants.fpp, FpConstants.fpp, *Cfg.fpp); check there before trusting the framework default.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.