ex_command_sequence.py

ex_command.py ex_command_sequence.py

"""
Example TReK Command Sequence Demonstration
 
Binary Command Sequences are created using the TReK Command Sequence Editor.
"""
import time
import trek
 
# Number of completed command sequences we sent.
completed_count = 0
 
def command_callback(token, status, command, count, ret_code, command_token):
    # Called by command API from a different thread.
    if ret_code == 0:
        print(f"Command #{count}, '{command}' executed with status {status}.")
    else:
        print(f"Error command #{count}, '{command}', code={ret_code}.")
 
 
def stop_callback(token, status, count, ret_code):
    # Called when a command sequence concludes.
    if ret_code == 0:
        print(f"Command Sequence {token}, completed.")
    else:
        print(f"Command Sequence {token} errored.")
 
    completed_count = completed_count + 1
 
 
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.
 
        # Register callbacks to be notified of the status of command sequences.
        api.register_sequence_command_callback(command_callback)
        api.register_sequence_stop_callback(stop_callback)
    
        # Absolute path to the binary file created by the sequence editor.
        sequences_sent = sequences_sent + 1
        api.start_sequence('SequenceBinaryFile')
 
        # It is okay to start a sequences and exit without monitoring for callbacks.
        # Execution of the sequence happens within the commanding systems.
 
        # However, if you want to recieve the callbacks, you must keep your Python
        # script running until the sequence completes.
 
        # In this example, we are waiting for the stop_callback to be called for each
        # started sequence.
        while completed_count < sequences_sent:
            time.sleep(1)
 
        #
        #  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()