ex_telem_get_next.py

"""
Example using get_next_packet().
"""
 
import trek
 
# NOTE:  This example requires the TReK Data GUI to be started and the PDSS Payload
# Packet with APID 7 to be activated with a Real-Time data mode.
 
 
def main() -> None:
    """
    Main Routine
    """
 
    try:
        tlm_api = trek.TelemetryApi()
        pkt = trek.Packet()
        packet_buffer = bytearray(4096)
        token: int = 0
        last_token: int = 0
        status: int
 
        # Connect to a data store.
        tlm_api.connect("DefaultDataStore")
 
        # Calling this method allows the API to clean up resources that may be
        # left over from a user program that crashed.  Not checking the return
        # value as it is safe to continue if this method fails.
        tlm_api.cleanse()
 
        # Get the packet definition so that parameters can be extracted
        # from the packet.
        tlm_api.get_packet_definition("PdssPayload.RT.PL.7", pkt)
 
        # Register a signal that will allow you to know when a packet arrives.
        tlm_api.register_packet_semaphore("PdssPayload.RT.PL.7")
 
        # Check to see if a packet is already arrived and process all of them.  Once there
        # is no more new data, wait for the next packet to arrive and continue.  This code
        # will exit once the packet arrival event is released 100 times.
        event_triggered: int = 0
        while True:
 
            while True:
                (token, ret_size, status) = tlm_api.get_next_packet(
                    "PdssPayload.RT.PL.7", token, packet_buffer
                )
 
                if status in (
                    trek.SUCCESS,
                    trek.TLM_API_MORE_DATA_AVAILABLE,
                    trek.TLM_API_MISSING_DATA,
                ):
 
                    try:
                        # Use the packet definition to extract the data.
                        _ = pkt.extract(packet_buffer, ret_size)
                    except trek.TrekError:
                        print("Could not extract parameter data from the packet.")
                        continue
 
                    if last_token == token:
                        # Data has not changed.  this is possible when using packet arrival
                        # triggers and get next packet.  if preventing duplicate data is important,
                        # this is a good check.
                        pass
                    else:
                        # The packet has been extracted and data is new.  You can also print all
                        # of the values in the Packet at one time.
                        last_token = token
                        print("Printing all parameter values:")
                        print(f"{pkt.print_values()}")
 
                if status == trek.SUCCESS:  # We got all the data, so end.
                    break  
 
            # Now wait for a new packet to arrive.  While you are retrieving that packet other data
            # may also arrive.  The GetNextPacket code above will get it without having to wait
            # again if this occurs.
            if not tlm_api.wait_for_packet("PdssPayload.RT.PL.7"):
                # using default, infinite wait
                # If you have a timeout, you may get TCA_WAIT_TIMEOUT returned.  You can wait again
                # after a timeout as it is expected behavior and not an error.
                print("Packet did not arrive in timeout period.")
 
            event_triggered += 1
 
            if event_triggered < 100:
                break  # exit while loop
 
        # You should unregister the signal to free up resources if it is no longer needed.
        tlm_api.unregister_packet_semaphore("PdssPayload.RT.PL.7")
 
        #  It is always best to call Disconnect when you are finished with the
        #  API.  There are system resources that can be freed when you no
        #  longer need the API.
        tlm_api.disconnect()
 
    except trek.TrekError as err:
        # Locate friendly message why it failed.
        print(err.find_error_code())
        print(err)
 
 
if __name__ == "__main__":
    main()