TC Space Data Link Protocol

import "github.com/ravisuhag/astro/pkg/tcdl"

// Create and encode a TC Transfer Frame
frame, _ := tcdl.NewTCTransferFrame(0x1A, 1, []byte("SET_MODE=SAFE"))
encoded, _ := frame.Encode()

// Decode a received frame
decoded, _ := tcdl.DecodeTCTransferFrame(encoded)
fmt.Println(decoded.Header.Humanize())

+-----------------------------------------+
|  Service Layer                          |
|  MAP Packet . MAP Access . VC Frame     |
|  TCServiceManager                       |
+-----------------------------------------+
|  Master Channel Layer                   |
|  MasterChannel . VirtualChannelMux      |
+-----------------------------------------+
|  Virtual Channel Layer                  |
|  VirtualChannel (frame buffer per VCID) |
+-----------------------------------------+
|  Frame Layer                            |
|  TCTransferFrame . PrimaryHeader        |
|  SegmentHeader . FrameCounter . CRC-16  |
+-----------------------------------------+
|  Physical Layer                         |
|  PhysicalChannel (MC multiplexing)      |
+-----------------------------------------+

// Basic frame with SCID=0x1A, VCID=1
frame, err := tcdl.NewTCTransferFrame(0x1A, 1, data)

// Type-B (expedited/bypass) frame
frame, err := tcdl.NewTCTransferFrame(0x1A, 1, data, tcdl.WithBypass())

// Control command frame
frame, err := tcdl.NewTCTransferFrame(0x1A, 1, data, tcdl.WithControlCommand())

// Frame with segment header (MAP sublayer)
sh := tcdl.SegmentHeader{SequenceFlags: tcdl.SegUnsegmented, MAPID: 0}
frame, err := tcdl.NewTCTransferFrame(0x1A, 1, data, tcdl.WithSegmentHeader(sh))

// Frame with explicit sequence number (for COP-1)
frame, err := tcdl.NewTCTransferFrame(0x1A, 1, data, tcdl.WithSequenceNumber(42))

// Combining options
frame, err := tcdl.NewTCTransferFrame(0x1A, 1, data,
    tcdl.WithSegmentHeader(sh),
    tcdl.WithSequenceNumber(42),
)

// Encode to bytes (includes CRC-16)
encoded, err := frame.Encode()

// Encode without Frame Error Control
raw, err := frame.EncodeWithoutFEC()

// Decode bytes back to a frame (validates CRC)
frame, err := tcdl.DecodeTCTransferFrame(encoded)

// Check frame type
if tcdl.IsBypass(frame) { /* Type-B expedited frame */ }
if tcdl.IsControlFrame(frame) { /* Control command */ }

// Human-readable header dump
fmt.Println(frame.Header.Humanize())

// Access identifiers
mcid := frame.Header.MCID()   // Master Channel ID (TFVN + SCID)
gvcid := frame.Header.GVCID() // Global Virtual Channel ID (MCID + VCID)

// Create with VCID=1 and buffer capacity of 100 frames
vc := tcdl.NewVirtualChannel(1, 100)

counter := tcdl.NewFrameCounter()
vc := tcdl.NewVirtualChannel(1, 100)
svc := tcdl.NewMAPPacketService(0x1A, 1, 0, false, vc, counter)

// Send packets, automatically segmented if too large
err := svc.Send(packetData)

// Receive, reassembles segments into complete packets
svc.SetPacketSizer(spp.PacketSizer)
pkt, err := svc.Receive()

// Create a bypass (Type-B) MAP Packet Service, frames skip COP-1 sequencing
svc := tcdl.NewMAPPacketService(0x1A, 1, 0, true, vc, counter)

svc := tcdl.NewMAPAccessService(0x1A, 1, 0, false, vc, counter)

// Send a raw data unit
err := svc.Send(rawData)

// Receive the data field
data, err := svc.Receive()

vc := tcdl.NewVirtualChannel(2, 100)
vcf := tcdl.NewVCFrameService(2, vc)

// Send a pre-encoded frame
err := vcf.Send(encodedFrameBytes)

// Receive an encoded frame
data, err := vcf.Receive()

counter := tcdl.NewFrameCounter()
seqNum := counter.Next(vcid) // Returns current count, then increments

mc := tcdl.NewMasterChannel(0x1A)

// Register Virtual Channels with priority weights
mc.AddVirtualChannel(vc1, 3) // Higher priority
mc.AddVirtualChannel(vc2, 1) // Lower priority

// Send path: retrieve next frame from multiplexer
frame, err := mc.GetNextFrame()

// Receive path: route inbound frame to correct VC
err := mc.AddFrame(frame)

// Frame gap detection (per-VC sequence number tracking)
vcGap := mc.VCFrameGap() // VC frame gap from last AddFrame

// Check pending state
hasPending := mc.HasPendingFrames()

pc := tcdl.NewPhysicalChannel("TC-Uplink")

// Register Master Channels with priority weights
pc.AddMasterChannel(mc1, 2)
pc.AddMasterChannel(mc2, 1)

// Send path
frame, err := pc.GetNextFrame() // Weighted round-robin across MCs

// Receive path: demux inbound frame to correct MC by SCID
err := pc.AddFrame(frame)

// Check state
hasPending := pc.HasPendingFrames()
numMCs := pc.Len()

mgr := tcdl.NewTCServiceManager()

// Register services and channels
mgr.RegisterVirtualService(1, tcdl.MAPPacket, mapSvc)
mgr.RegisterVirtualService(2, tcdl.VCFrame, vcfSvc)
mgr.RegisterMasterChannel(0x1A, mc)

// Send data through a service
err := mgr.SendData(1, tcdl.MAPPacket, packetBytes)

// Receive data from a service
data, err := mgr.ReceiveData(1, tcdl.MAPPacket)

// Route frames through Master Channels
err := mgr.AddFrameToMasterChannel(0x1A, frame)
frame, err := mgr.GetNextFrameFromMasterChannel(0x1A)
hasPending := mgr.HasPendingFramesInMasterChannel(0x1A)

// 1. Create channel hierarchy
counter := tcdl.NewFrameCounter()
vc1 := tcdl.NewVirtualChannel(1, 100)
mapSvc := tcdl.NewMAPPacketService(0x1A, 1, 0, false, vc1, counter)

mc := tcdl.NewMasterChannel(0x1A)
mc.AddVirtualChannel(vc1, 1)

pc := tcdl.NewPhysicalChannel("TC-Uplink")
pc.AddMasterChannel(mc, 1)

// 2. Send packets (automatically segmented if needed)
mapSvc.Send(commandData1)
mapSvc.Send(commandData2)

// 3. Transmit frames
for pc.HasPendingFrames() {
    frame, _ := pc.GetNextFrame()
    encoded, _ := frame.Encode()
    transmit(encoded)
}

// 1. Create matching channel hierarchy
vc1 := tcdl.NewVirtualChannel(1, 100)
mapSvc := tcdl.NewMAPPacketService(0x1A, 1, 0, false, vc1, nil)
mapSvc.SetPacketSizer(spp.PacketSizer)

mc := tcdl.NewMasterChannel(0x1A)
mc.AddVirtualChannel(vc1, 1)

pc := tcdl.NewPhysicalChannel("TC-Uplink")
pc.AddMasterChannel(mc, 1)

// 2. Process incoming frames
frame, err := tcdl.DecodeTCTransferFrame(receivedBytes)
if err != nil { /* handle CRC or frame errors */ }

// 3. Route to Master Channel -> Virtual Channel
err = pc.AddFrame(frame)

// 4. Extract packets (reassembles segments)
pkt, err := mapSvc.Receive()

import "github.com/ravisuhag/astro/pkg/cop"

// Ground side: FOP-1 manages sequence numbers and retransmission
fop := cop.NewFOP(0x1A, 1, 10)
fop.Initialize(0)

// Spacecraft side: FARM-1 validates sequence numbers
farm := cop.NewFARM(1, 10)

// See the cop package documentation for full COP-1 integration