ccsds_tc_services — Logtalk 3.100.1

object

# `ccsds_tc_services`

Helpers for CCSDS telecommand segment extraction, insertion, and cross-frame TC service reassembly.

Availability:
`logtalk_load(ccsds_tc_services(loader))`
Author: Paulo Moura
Version: 0:1:0
Date: 2026-05-08
Compilation flags:
`static, context_switching_calls`
Uses:
list
type
Remarks:
(none)
Inherited public predicates:
(none)

## Public predicates

### `valid_segment/1`

True if the argument is a valid CCSDS telecommand segment term.

Compilation flags:
`static`
Template:
`valid_segment(Segment)`
Mode and number of proofs:
`valid_segment(@compound)` - `zero_or_one`

### `sequence_flags/2`

Extracts the telecommand segment sequence flags.

Compilation flags:
`static`
Template:
`sequence_flags(Segment,SequenceFlags)`
Mode and number of proofs:
`sequence_flags(+compound,-atom)` - `one`

### `map_id/2`

Extracts the telecommand service-unit MAP identifier from either a telecommand segment term or a provenance-aware reassembled telecommand service-unit term.

Compilation flags:
`static`
Template:
`map_id(ServiceUnit,MapId)`
Mode and number of proofs:
`map_id(+compound,-integer)` - `one`

### `valid_map_dispatch/1`

True if the argument is a valid MAP-aware dispatch term grouping complete telecommand service units for a single MAP identifier.

Compilation flags:
`static`
Template:
`valid_map_dispatch(Dispatch)`
Mode and number of proofs:
`valid_map_dispatch(@compound)` - `zero_or_one`

### `dispatch_map_id/2`

Extracts the MAP identifier from a MAP-aware dispatch term.

Compilation flags:
`static`
Template:
`dispatch_map_id(Dispatch,MapId)`
Mode and number of proofs:
`dispatch_map_id(+compound,-integer)` - `one`

### `dispatch_service_units/2`

Extracts the complete telecommand service units from a MAP-aware dispatch term.

Compilation flags:
`static`
Template:
`dispatch_service_units(Dispatch,ServiceUnits)`
Mode and number of proofs:
`dispatch_service_units(+compound,-list(compound))` - `one`

### `segment_header_suffix/2`

Extracts the mission-specific segment-header suffix bytes. Returns the empty list when the segment has no mission-specific suffix.

Compilation flags:
`static`
Template:
`segment_header_suffix(Segment,HeaderSuffix)`
Mode and number of proofs:
`segment_header_suffix(+compound,-list(byte))` - `one`

### `valid_reassembled_segment/1`

True if the argument is a valid provenance-aware reassembled telecommand service-unit term.

Compilation flags:
`static`
Template:
`valid_reassembled_segment(ReassembledSegment)`
Mode and number of proofs:
`valid_reassembled_segment(@compound)` - `zero_or_one`

### `segment_header_suffixes/2`

Extracts the ordered list of per-frame mission-specific segment-header suffixes that contributed to a provenance-aware reassembled telecommand service-unit term.

Compilation flags:
`static`
Template:
`segment_header_suffixes(ReassembledSegment,HeaderSuffixes)`
Mode and number of proofs:
`segment_header_suffixes(+compound,-list(list(byte)))` - `one`

### `segment_data/2`

Extracts the telecommand segment data bytes.

Compilation flags:
`static`
Template:
`segment_data(Segment,Data)`
Mode and number of proofs:
`segment_data(+compound,-list(byte))` - `one`

### `valid_reassembly_state/1`

True if the argument is a valid telecommand segment reassembly state term.

Compilation flags:
`static`
Template:
`valid_reassembly_state(State)`
Mode and number of proofs:
`valid_reassembly_state(@compound)` - `zero_or_one`

### `initial_reassembly_state/1`

Returns the initial telecommand segment reassembly state.

Compilation flags:
`static`
Template:
`initial_reassembly_state(State)`
Mode and number of proofs:
`initial_reassembly_state(-compound)` - `one`

### `pending_fragments/2`

Extracts the pending segmented telecommand data fragments keyed by spacecraft, virtual channel, and MAP identifier.

Compilation flags:
`static`
Template:
`pending_fragments(State,PendingFragments)`
Mode and number of proofs:
`pending_fragments(+compound,-list(compound))` - `one`

### `valid_discontinuity_policy/1`

True if the argument is a valid discontinuity recovery policy atom. Valid values are `throw`, `drop`, and `resynchronize`.

Compilation flags:
`static`
Template:
`valid_discontinuity_policy(Policy)`
Mode and number of proofs:
`valid_discontinuity_policy(@atom)` - `zero_or_one`

### `extract_tc_segment/2`

Extracts a telecommand segment from a telecommand transfer frame using the representation `tc_segment(SequenceFlags, MapId, HeaderSuffix, Data)`. When mission-specific segment headers use multiple octets, only the first octet is interpreted for the standard MAP and sequence semantics and the remaining octets are returned as `HeaderSuffix`.

Compilation flags:
`static`
Template:
`extract_tc_segment(Frame,Segment)`
Mode and number of proofs:
`extract_tc_segment(+compound,-compound)` - `one_or_error`

### `insert_tc_segment/3`

Updates a telecommand transfer frame from a telecommand segment term by encoding the standard MAP and sequence semantics in the first segment-header octet and preserving any remaining mission-specific segment-header octets.

Compilation flags:
`static`
Template:
`insert_tc_segment(Segment,Frame,UpdatedFrame)`
Mode and number of proofs:
`insert_tc_segment(+compound,+compound,-compound)` - `one_or_error`

### `reassemble_tc_frame/4`

Reassembles complete telecommand service units from a single telecommand transfer frame using the default `throw` discontinuity recovery policy.

Compilation flags:
`static`
Template:
`reassemble_tc_frame(Frame,State,Segments,UpdatedState)`
Mode and number of proofs:
`reassemble_tc_frame(+compound,+compound,-list(compound),-compound)` - `one_or_error`

### `reassemble_tc_frame/5`

Reassembles complete telecommand service units from a single telecommand transfer frame using the selected discontinuity recovery policy.

Compilation flags:
`static`
Template:
`reassemble_tc_frame(Frame,Policy,State,Segments,UpdatedState)`
Mode and number of proofs:
`reassemble_tc_frame(+compound,+atom,+compound,-list(compound),-compound)` - `one_or_error`

### `reassemble_tc_frame/6`

Reassembles complete telecommand service units from a single telecommand transfer frame using the selected discontinuity recovery policy and returns any recovery events.

Compilation flags:
`static`
Template:
`reassemble_tc_frame(Frame,Policy,State,Segments,UpdatedState,Events)`
Mode and number of proofs:
`reassemble_tc_frame(+compound,+atom,+compound,-list(compound),-compound,-list(compound))` - `one_or_error`

### `reassemble_tc_frames/4`

Reassembles complete telecommand service units across a sequence of telecommand transfer frames using the default `throw` discontinuity recovery policy.

Compilation flags:
`static`
Template:
`reassemble_tc_frames(Frames,State,Segments,UpdatedState)`
Mode and number of proofs:
`reassemble_tc_frames(+list(compound),+compound,-list(compound),-compound)` - `one_or_error`

### `reassemble_tc_frames/5`

Reassembles complete telecommand service units across a sequence of telecommand transfer frames using the selected discontinuity recovery policy.

Compilation flags:
`static`
Template:
`reassemble_tc_frames(Frames,Policy,State,Segments,UpdatedState)`
Mode and number of proofs:
`reassemble_tc_frames(+list(compound),+atom,+compound,-list(compound),-compound)` - `one_or_error`

### `reassemble_tc_frames/6`

Reassembles complete telecommand service units across a sequence of telecommand transfer frames using the selected discontinuity recovery policy and returns any recovery events in frame order.

Compilation flags:
`static`
Template:
`reassemble_tc_frames(Frames,Policy,State,Segments,UpdatedState,Events)`
Mode and number of proofs:
`reassemble_tc_frames(+list(compound),+atom,+compound,-list(compound),-compound,-list(compound))` - `one_or_error`

### `reassemble_tc_frame_with_provenance/5`

Reassembles complete telecommand service units from a single telecommand transfer frame using the default `throw` discontinuity recovery policy and returns provenance-aware reassembled service-unit terms.

Compilation flags:
`static`
Template:
`reassemble_tc_frame_with_provenance(Frame,State,ReassembledSegments,UpdatedState,Events)`
Mode and number of proofs:
`reassemble_tc_frame_with_provenance(+compound,+compound,-list(compound),-compound,-list(compound))` - `one_or_error`

### `reassemble_tc_frame_with_provenance/6`

Reassembles complete telecommand service units from a single telecommand transfer frame using the selected discontinuity recovery policy and returns provenance-aware reassembled service-unit terms plus any recovery events.

Compilation flags:
`static`
Template:
`reassemble_tc_frame_with_provenance(Frame,Policy,State,ReassembledSegments,UpdatedState,Events)`
Mode and number of proofs:
`reassemble_tc_frame_with_provenance(+compound,+atom,+compound,-list(compound),-compound,-list(compound))` - `one_or_error`

### `reassemble_tc_frames_with_provenance/5`

Reassembles complete telecommand service units across a sequence of telecommand transfer frames using the default `throw` discontinuity recovery policy and returns provenance-aware reassembled service-unit terms.

Compilation flags:
`static`
Template:
`reassemble_tc_frames_with_provenance(Frames,State,ReassembledSegments,UpdatedState,Events)`
Mode and number of proofs:
`reassemble_tc_frames_with_provenance(+list(compound),+compound,-list(compound),-compound,-list(compound))` - `one_or_error`

### `reassemble_tc_frames_with_provenance/6`

Reassembles complete telecommand service units across a sequence of telecommand transfer frames using the selected discontinuity recovery policy and returns provenance-aware reassembled service-unit terms plus any recovery events in frame order.

Compilation flags:
`static`
Template:
`reassemble_tc_frames_with_provenance(Frames,Policy,State,ReassembledSegments,UpdatedState,Events)`
Mode and number of proofs:
`reassemble_tc_frames_with_provenance(+list(compound),+atom,+compound,-list(compound),-compound,-list(compound))` - `one_or_error`

### `dispatch_service_units_by_map/2`

Groups complete telecommand service-unit terms by MAP identifier, preserving the original service-unit order within each MAP bucket and the first-seen order of MAP buckets. Accepts both telecommand segment terms and provenance-aware reassembled telecommand service-unit terms.

Compilation flags:
`static`
Template:
`dispatch_service_units_by_map(ServiceUnits,Dispatches)`
Mode and number of proofs:
`dispatch_service_units_by_map(+list(compound),-list(compound))` - `one_or_error`

### `dispatch_service_units_by_map/3`

Extracts the complete telecommand service units for a specific MAP identifier from a list of complete telecommand service-unit terms.

Compilation flags:
`static`
Template:
`dispatch_service_units_by_map(ServiceUnits,MapId,DispatchedServiceUnits)`
Mode and number of proofs:
`dispatch_service_units_by_map(+list(compound),+integer,-list(compound))` - `one_or_error`

## Protected predicates

(no local declarations; see entity ancestors if any)

## Private predicates

(no local declarations; see entity ancestors if any)

## Operators

(none)