ex_command.py

"""
Example TReK Command Demonstration
"""
 
import trek
 
 
def main() -> None:
    """
    Main Routine
    """
 
    try:
        api = trek.CommandApi()
 
        # Connect to a destination.  The name passed into the Connect() call is
        # the name used when configuring the destination in the TReK Command
        # application.
        api.connect("POIC")
 
        # 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.
        api.cleanse()
 
        # Once connected to the API, you can make calls to the API to see what is
        # available for the interface.  Call to see if there are any status
        # messages.  If there are, print out all of the information in each
        # message.
 
        status_list = api.get_status_message_list()
        print(f"There are {len(status_list)} status messages for this destination.\n")
 
        for msg in status_list:
            print(f"Status Message:  {msg}\n")
            pc = trek.ParameterCollection()
 
            _ = api.get_status_message(msg, pc)
 
            # get all of the parameters that make up the status message
            param_list = pc.get_sorted_parameter_list(False)
 
            for param_name in param_list:
                # print each name/value in status mesesage
                param = pc.find_parameter(param_name)
                print(f"{param_name}:  {param.get_value_as_string()}\n")
 
        # Check to see if there are command responses associated with this
        # destination.  If there is, get a copy of the responses so we can
        # check any errors that are received when sending commands.  Store
        # the responses in a map for quick lookup.
        resp_list = api.get_command_response_list()
 
        response_dictionary = {}
        for cr_name in resp_list:
            response = trek.CommandResponse()
            try:
                api.get_command_response(cr_name, response)
            except trek.TrekError as err:
                print(f"Error {err.code}: Could not retrieve response {cr_name}.\n")
                # Not fatal! Should never occur unless API has coding error.
                continue
            response_dictionary[cr_name] = response
 
        # Send a command by initiating an uplink from the destination.  This method
        # of sending commands is not avaiable for all destinations, but will fail
        # gracefully.  The token will be used to get command track information.
        token = api.initiate_command("ACCELERATE")
 
        track_item = trek.TrackItem()
        api.get_track(token, track_item)
 
        for idx in range(track_item.get_number_of_responses()):
            resp_item = track_item.get_response(idx)
 
            if resp_item.name in response_dictionary:
                my_command_res: trek.CommandResponse = response_dictionary[resp_item.name]
                resp_info = my_command_res.get_error_details(resp_item.value)
                print(f"Response {resp_item.name}: {resp_info.info}.\n")
 
        #
        #  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.
        #
        api.disconnect()
 
    except trek.TrekError as err:
        # Locate friendly message why it failed.
        print(err.find_error_code())
        print(err)
 
 
if __name__ == "__main__":
    main()