Struct satrs::hal::std::udp_server::UdpTcServer

pub struct UdpTcServer<TcSender: PacketSenderRaw<Error = SendError>, SendError> {
    pub id: ComponentId,
    pub socket: UdpSocket,
    pub tc_sender: TcSender,
    /* private fields */
}

Available on crate feature std only.

This UDP server can be used to receive CCSDS space packet telecommands or any other telecommand format.

It caches all received telecomands into a vector. The maximum expected telecommand size should be declared upfront. This avoids dynamic allocation during run-time. The user can specify a TC sender in form of a special trait object which implements PacketSenderRaw. For example, this can be used to send the telecommands to a centralized TC source component for further processing and routing.

Examples

use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};
use std::sync::mpsc;
use spacepackets::ecss::WritablePusPacket;
use satrs::hal::std::udp_server::UdpTcServer;
use satrs::ComponentId;
use satrs::tmtc::PacketSenderRaw;
use spacepackets::SpHeader;
use spacepackets::ecss::tc::PusTcCreator;

const UDP_SERVER_ID: ComponentId = 0x05;

let (packet_sender, packet_receiver) = mpsc::channel();
let dest_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 7777);
let mut udp_tc_server = UdpTcServer::new(UDP_SERVER_ID, dest_addr, 2048, packet_sender)
      .expect("Creating UDP TMTC server failed");
let sph = SpHeader::new_from_apid(0x02);
let pus_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true);
// Can not fail.
let ping_tc_raw = pus_tc.to_vec().unwrap();

// Now create a UDP client and send the ping telecommand to the server.
let client = UdpSocket::bind("127.0.0.1:0").expect("creating UDP client failed");
client
    .send_to(&ping_tc_raw, dest_addr)
    .expect("Error sending PUS TC via UDP");
let recv_result = udp_tc_server.try_recv_tc();
assert!(recv_result.is_ok());
// The packet is received by the UDP TC server and sent via the mpsc channel.
let sent_packet_with_sender = packet_receiver.try_recv().expect("expected telecommand");
assert_eq!(sent_packet_with_sender.packet, ping_tc_raw);
assert_eq!(sent_packet_with_sender.sender_id, UDP_SERVER_ID);
// No more packets received.
matches!(packet_receiver.try_recv(), Err(mpsc::TryRecvError::Empty));

The satrs-example crate server code also includes example code on how to use this TC server. It uses the server to receive PUS telecommands on a specific port and then forwards them to a generic CCSDS packet receiver.

Fields

id: ComponentId

socket: UdpSocket

tc_sender: TcSender

Implementations

impl<TcSender: PacketSenderRaw<Error = SendError>, SendError: Debug + 'static> UdpTcServer<TcSender, SendError>

pub fn new<A: ToSocketAddrs>( id: ComponentId, addr: A, max_recv_size: usize, tc_sender: TcSender ) -> Result<Self, Error>

pub fn try_recv_tc( &mut self ) -> Result<(usize, SocketAddr), ReceiveResult<SendError>>

pub fn last_sender(&self) -> Option<SocketAddr>