Reader

CC Anti-Canape: Python-CAN Reading Interface Application

Author: Chris Hinkson
Email: Christopher.Hinkson@clubcar.com

Desc: This application is designed to provide reading access to CAN communication from within python as a standalone application.

Github: https://github.com/chrisInTheCode/CC-Anti-Canape
--> To get access to the github repository, please send me an email at the above address

References:
--> https://python-can.readthedocs.io/en/stable/
--> https://cantools.readthedocs.io/en/latest/

`ACReader`

Provides a thread-based approach for high-level CAN reading.

This class provides total reading functionality for CAN communication, and by extension, SDO protocol. It provides a variety of methods to complete various reading tasks and offers extensive capability in terms of data acquisition and handling. It provides a reading object for CAN messages, implements the python-can module as the backend API for CAN communication, uses can-tools for message decoding, CC DBC-Auto-Parse for custom dbc parsing, CC DOT-Auto-Parse for custom dot parsing, and ACWriter for SDO writing (when getting SDO responses). See each individual method for further documentation on method functionality.

Examples:

myNewWriter = ACWriter(myBusInstance)

Attributes:

Name	Type	Description
`bus`		The instance's can.Bus object to read CAN messages on.

Source code in drivers\readers.py

class ACReader:
    ''' Provides a thread-based approach for high-level CAN reading.

    This class provides total reading functionality for CAN communication, and by extension, SDO protocol. It provides a variety of methods to complete various reading tasks and offers extensive capability in terms of data acquisition and handling. It provides a reading object for CAN messages, implements the python-can module as the backend API for CAN communication, uses can-tools for message decoding, CC DBC-Auto-Parse for custom dbc parsing, CC DOT-Auto-Parse for custom dot parsing, and ACWriter for SDO writing (when getting SDO responses). See each individual method for further documentation on method functionality.

    Examples:
        myNewWriter = ACWriter(myBusInstance)

    Attributes:
        bus: The instance's can.Bus object to read CAN messages on.
    '''
    #########################
    # OBJECT INITIALIZATION #
    #########################
    def __init__(self, busIn:Bus) -> None:
        ''' Initializes the reader class.

        Args:
            busIn (Bus): The bus object to read CAN messages on.
        '''
        # Set the bus
        # NOTE: The bus can be closed at the end of main program execution. If the bus is closed, the same bus object will need to be opened or this class will need
        #       to be reinitialized.
        self.bus = busIn

        # Configure the DBC
        # [https://cantools.readthedocs.io/en/latest/]
        self.dbc = cantools.db.load_file(filename='ccPythonDBC.dbc', cache_dir='./CANcache') #DBC Database

        # Creates a Buffered Reader - All messages go into a queue
        # [https://python-can.readthedocs.io/en/stable/listeners.html#bufferedreader]
        self.bufferReader = NewBufferedReader()

        # Creates a Notifier - Enables the listener to hear the configured Bus
        # [https://python-can.readthedocs.io/en/stable/listeners.html#notifier]
        self.bufferNotifier = Notifier(bus=self.bus, listeners=[self.bufferReader], timeout=None, loop=None)

        # In case SDO support enabled, load the DOT parser here
        self.dotParser = None

        # Terminal Message
        print("CC Anti-Canape: Reader Object Has Been Initialized!")


    ##################
    # QUICK ENCODING #
    ##################
    def encodeitlol(self, IDIn:int, signalDictIn:dict) -> Message:
        ''' A quick support method for encoding an arbitration ID and signal dictionary into a CAN message.

        Args:
            IDIn (int): The CAN Arbitration ID.
            signalDictIn (dict): A dictionary of signal-value pairs.

        Returns:
            Message: Encoded CAN Message including the arbitration ID and signal dictionary.
        '''            
        # Encode data into byte array for CAN communication using the DBC file
        # [https://cantools.readthedocs.io/en/latest/#cantools.database.can.Database.encode_message]
        encodedData = self.dbc.encode_message(IDIn, signalDictIn)
        return encodedData


    ##############################
    # SINGLE READING FROM CANBUS #
    ##############################
    def singleCanScanOnBus(self, timeoutIn:int = None) -> list:
        ''' Gets the next available message in the CAN message buffer.

        Args:
            timeoutIn (int): The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.

        Raises:
            AntiCanapeError: Custom Exception that allows for general exception handling and debugging information.

        Returns:
            list: Messsage Information Array [ID, Data, Timestamp]
        '''        
        from drivers.automator import BusOverloadError, AntiCanapeError 
        # Get the next available message and decode it
        try:
            # Grab the message from the buffer that has been there the longest (FIFO)
            # [https://python-can.readthedocs.io/en/stable/listeners.html#can.BufferedReader.get_message]
            currentMessage = self.bufferReader.get_message(timeout=timeoutIn)
            # Decode the message into usable information
            # [https://cantools.readthedocs.io/en/latest/#cantools.database.can.Database.decode_message]
            decodedData = self.dbc.decode_message(currentMessage.arbitration_id, currentMessage.data) #Decodes using .dbc

        ##############################
        # GENERAL EXCEPTION HANDLING #
        ##############################
        except (KeyboardInterrupt) as exc: #For when user interrupts program
            print("CC Anti-Canape: Program Execution Halted by Keyboard Interrupt!")
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
                raise AntiCanapeError(exc)
            raise # If debug mode off, still raise the error as is
        except (BusOverloadError) as exc: # For when the bus is overloaded / in error state
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except (PcanError, PcanCanOperationError, PcanCanInitializationError) as exc: # For when pcan has issues
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A PCAN Error was detected!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except (CanError, CanInitializationError, CanInterfaceNotImplementedError, CanOperationError, CanTimeoutError) as exc: # Any CAN error
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A CAN Error was detected!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except (AttributeError) as exc: # Silly attribute errors
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: There has been an error when scanning for the ID!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except(AntiCanapeError) as exc: # For an Anti-Canape error deeper down
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: An Error was detected!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
                raise

        # Return decoded data
        return [currentMessage.arbitration_id, decodedData, currentMessage.timestamp]


    ###################################
    # FIND NEXT MESSAGE WITH GIVEN ID #
    ###################################
    def singleCanScanOnID(self, IDIn: int, timeoutIn:int = None) -> list:
        ''' Will get the next available message in the CAN message buffer for the given ID. This method is preferred when searching for an ID because it will keep the BUS, channel, reader, and notifier open UNTIL the message is found, versus opening and closing it for every message. 

        Args:
            IDIn (int): The ID to scan for on the CAN Bus Buffer.
            timeoutIn (int): The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.

        Raises:
            AntiCanapeError: Custom Exception that allows for general exception handling and debugging information.

        Returns:
            list: Messsage Information Array [ID, Data, Timestamp]
        '''        
        from drivers.automator import BusOverloadError, AntiCanapeError 
        # Get the next message and decode it
        try:
            # Grab the message from the buffer that has been there the longest (FIFO)
            # [https://python-can.readthedocs.io/en/stable/listeners.html#can.BufferedReader.get_message]
            currentMessage = self.bufferReader.get_message(timeout=timeoutIn)

            # Set a flag to use
            messageFoundFlag = False
            # While the correct message has not been found
            while messageFoundFlag == False:

                # Catch error/empty message with no ID
                try:
                    # Check if the message ID matches the wanted ID
                    if (int(currentMessage.arbitration_id) == int(IDIn)):
                        #Set the message found flag to true so it stops iterating
                        messageFoundFlag = True
                    # If the ID does not match, then get next message and iterate again
                    else:
                        currentMessage = self.bufferReader.get_message(timeout=10)

                ##############################
                # GENERAL EXCEPTION HANDLING #
                ##############################
                except (KeyboardInterrupt) as exc: #For when user interrupts program
                    print("CC Anti-Canape: Program Execution Halted by Keyboard Interrupt!")
                    if DEBUG_MODE:
                        logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
                        logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                        logging.error(exc)
                        raise AntiCanapeError(exc)
                    raise # If debug mode off, still raise the error as is
                except (BusOverloadError) as exc: # For when the bus is overloaded / in error state
                    if DEBUG_MODE:
                        logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
                        logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                        logging.error(exc)
                    raise AntiCanapeError(exc)
                except (PcanError, PcanCanOperationError, PcanCanInitializationError) as exc: # For when pcan has issues
                    if DEBUG_MODE:
                        logging.debug("CC Anti-Canape: A PCAN Error was detected!")
                        logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                        logging.error(exc)
                    raise AntiCanapeError(exc)
                except (CanError, CanInitializationError, CanInterfaceNotImplementedError, CanOperationError, CanTimeoutError) as exc: # Any CAN error
                    if DEBUG_MODE:
                        logging.debug("CC Anti-Canape: A CAN Error was detected!")
                        logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                        logging.error(exc)
                    raise AntiCanapeError(exc)
                except (AttributeError) as exc: # Silly attribute errors
                    if DEBUG_MODE:
                        logging.debug("CC Anti-Canape: There has been an error when scanning for the ID!")
                        logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                        logging.error(exc)
                    raise AntiCanapeError(exc)
                except(AntiCanapeError) as exc: # For an Anti-Canape error deeper down
                    if DEBUG_MODE:
                        logging.debug("CC Anti-Canape: An Error was detected!")
                        logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                        logging.error(exc)
                        raise

            # Decode the message into usable information
            # [https://cantools.readthedocs.io/en/latest/#cantools.database.can.Database.decode_message]
            decodedData = self.dbc.decode_message(currentMessage.arbitration_id, currentMessage.data) #Decodes using .dbc

        # All message handling, as long as DEBUG_MODE is on
        except(AntiCanapeError) as exc:
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: An Error was detected!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
                raise

        # Return decoded data
        return [currentMessage.arbitration_id, decodedData, currentMessage.timestamp]


    #######################################
    # FIND NEXT MESSAGE FROM GIVEN ID SET #
    #######################################
    def singleCanScanOnIDSet(self, IDArrayIn: list, timeoutIn:int = None) -> list:
        ''' Will get the next available message in the CAN message buffer for any of the given ID's. This method is preferred when searching for a message from a set of ID's because it will keep the BUS, channel, reader, and notifier open UNTIL the message is found, versus opening and closing it for every message. 

        Args:
            IDArrayIn (list[int]): List of ID's to scan for.
            timeoutIn (int): The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.

        Raises:
            AntiCanapeError: Custom Exception that allows for general exception handling and debugging information.

        Returns:
            list: Messsage Information Array [ID, Data, Timestamp].
        '''    
        from drivers.automator import BusOverloadError, AntiCanapeError    
        # Get the next message and decode it
        try:

            # Grab the message from the buffer that has been there the longest (FIFO)
            # [https://python-can.readthedocs.io/en/stable/listeners.html#can.BufferedReader.get_message]
            currentMessage = self.bufferReader.get_message(timeout=timeoutIn)

            # Set a flag to use
            messageFoundFlag = False
            # While the correct message has not been found
            while messageFoundFlag == False:
                # Check if the message ID is in the wanted ID array
                if int(currentMessage.arbitration_id) in IDArrayIn:
                    #Set the message found flag to true so it stops iterating
                    messageFoundFlag = True
                # If the ID does not match, then get next message and iterate again
                else:
                    currentMessage = self.bufferReader.get_message(timeout=None)

            # Decode the message into usable information
            # [https://cantools.readthedocs.io/en/latest/#cantools.database.can.Database.decode_message]
            decodedData = self.dbc.decode_message(currentMessage.arbitration_id, currentMessage.data) #Decodes using .dbc

        ##############################
        # GENERAL EXCEPTION HANDLING #
        ##############################
        except (KeyboardInterrupt) as exc: #For when user interrupts program
            print("CC Anti-Canape: Program Execution Halted by Keyboard Interrupt!")
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
                raise AntiCanapeError(exc)
            raise # If debug mode off, still raise the error as is
        except (BusOverloadError) as exc: # For when the bus is overloaded / in error state
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except (PcanError, PcanCanOperationError, PcanCanInitializationError) as exc: # For when pcan has issues
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A PCAN Error was detected!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except (CanError, CanInitializationError, CanInterfaceNotImplementedError, CanOperationError, CanTimeoutError) as exc: # Any CAN error
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A CAN Error was detected!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except (AttributeError) as exc: # Silly attribute errors
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: There has been an error when scanning for the ID!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except(AntiCanapeError) as exc: # For an Anti-Canape error deeper down
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: An Error was detected!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
                raise

        # Return decoded data
        return [currentMessage.arbitration_id, decodedData, currentMessage.timestamp]


    #################################
    # CONTINUAL READING FROM CANBUS #
    #################################
    def continualCanScanOnBus(self, timeoutIn:int=None) -> list:
        ''' Continues to get the next message from the CAN message buffer. This method is preferred when continously scanning for messages because it will keep the BUS, channel, reader, and notifier while iterating, instead of opening and closing them each for each message.

        Args:
            timeoutIn (int): The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.

        Raises:
            AntiCanapeError: Custom Exception that allows for general exception handling and debugging information.

        Returns:
            list: Array of Messsage Information Arrays [ [ID, Data, Timestamp], [ID, Data, Timestamp] ... ].
        '''    
        from drivers.automator import BusOverloadError, AntiCanapeError 
        # Get the next message and decode it
        try:
            #Create an array for storage of data arrays
            outputCanArray = []

            #Continue to iterate until keyboard interrupt is received
            try:
                while True:
                    # Grab the message from the buffer that has been there the longest (FIFO)
                    # [https://python-can.readthedocs.io/en/stable/listeners.html#can.BufferedReader.get_message]
                    currentMessage = self.bufferReader.get_message(timeout=timeoutIn)

                    # Decode the message into usable information
                    # [https://cantools.readthedocs.io/en/latest/#cantools.database.can.Database.decode_message]
                    decodedData = self.dbc.decode_message(currentMessage.arbitration_id, currentMessage.data) #Decodes using .dbc

                    # Add the decoded data and message information to a message-specific array, and store it inside output array
                    outputCanArray.append([currentMessage.arbitration_id, decodedData, currentMessage.timestamp])
                    # Print the decoded data and message information to the terminal
                    print("---------- ID: " + str(currentMessage.arbitration_id) + " ----------")

                    for signalName, value in decodedData.items():
                        print('Signal: ' + str(signalName) + ' = ' + str(value))

                    print("---------- TIME: " + str(currentMessage.timestamp) + " ----------")
                    print()

            except KeyboardInterrupt:
                print("CC Anti-Canape: KEYBOARD INTERRUPT DETECTED. HALTING SCAN EXECUTION.")

        ##############################
        # GENERAL EXCEPTION HANDLING #
        ##############################
        except (KeyboardInterrupt) as exc: #For when user interrupts program
            print("CC Anti-Canape: Program Execution Halted by Keyboard Interrupt!")
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
                raise AntiCanapeError(exc)
            raise # If debug mode off, still raise the error as is
        except (BusOverloadError) as exc: # For when the bus is overloaded / in error state
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except (PcanError, PcanCanOperationError, PcanCanInitializationError) as exc: # For when pcan has issues
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A PCAN Error was detected!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except (CanError, CanInitializationError, CanInterfaceNotImplementedError, CanOperationError, CanTimeoutError) as exc: # Any CAN error
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A CAN Error was detected!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except (AttributeError) as exc: # Silly attribute errors
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: There has been an error when scanning for the ID!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except(AntiCanapeError) as exc: # For an Anti-Canape error deeper down
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: An Error was detected!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
                raise

        # Return decoded data
        return outputCanArray


    ##################################
    # GET ALL MESSAGES WITH GIVEN ID #
    ##################################
    def continualCanScanOnID(self, IDIn: int, timeoutIn:int=None) -> list:
        ''' Will get the all available messages in the CAN message buffer for the given ID. This method is preferred when continually searching for an ID because it will keep the BUS, channel, reader, and notifier open UNTIL the message is found, versus opening and closing it for every message. 

        Args:
            IDIn (int): The ID to scan for.
            timeoutIn (int): The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.

        Raises:
            AntiCanapeError: Custom Exception that allows for general exception handling and debugging information.

        Returns:
            list: Array of Messsage Information Arrays [ [ID, Data, Timestamp] ... ].
        '''        
        from drivers.automator import BusOverloadError, AntiCanapeError 
        # Get the next message and decode it
        try:
            #Create an array for storage of data arrays
            outputCanArray = []

            #Continue to iterate until keyboard interrupt is received
            try:
                while True:
                    # Grab the message from the buffer that has been there the longest (FIFO)
                    # [https://python-can.readthedocs.io/en/stable/listeners.html#can.BufferedReader.get_message]
                    currentMessage = self.bufferReader.get_message(timeout=timeoutIn)

                    # Check if the message ID matches the wanted ID
                    if (int(currentMessage.arbitration_id) == int(IDIn)):
                        # Decode the message into usable information
                        # [https://cantools.readthedocs.io/en/latest/#cantools.database.can.Database.decode_message]
                        decodedData = self.dbc.decode_message(currentMessage.arbitration_id, currentMessage.data) #Decodes using .dbc

                        # Add the decoded data and message information to a message-specific array, and store it inside output array
                        outputCanArray.append([[currentMessage.arbitration_id, decodedData, currentMessage.timestamp]])
                        # Print the decoded data and message information to the terminal
                        print("---------- ID: " + str(currentMessage.arbitration_id) + " ----------")

                        for signalName, value in decodedData.items():
                            print('Signal: ' + str(signalName) + ' = ' + str(value))

                        print("---------- TIME: " + str(currentMessage.timestamp) + " ----------")
                        print()

            except KeyboardInterrupt:
                print("CC Anti-Canape: KEYBOARD INTERRUPT DETECTED. HALTING SCAN EXECUTION.")


        ##############################
        # GENERAL EXCEPTION HANDLING #
        ##############################
        except (KeyboardInterrupt) as exc: #For when user interrupts program
            print("CC Anti-Canape: Program Execution Halted by Keyboard Interrupt!")
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
                raise AntiCanapeError(exc)
            raise # If debug mode off, still raise the error as is
        except (BusOverloadError) as exc: # For when the bus is overloaded / in error state
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except (PcanError, PcanCanOperationError, PcanCanInitializationError) as exc: # For when pcan has issues
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A PCAN Error was detected!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except (CanError, CanInitializationError, CanInterfaceNotImplementedError, CanOperationError, CanTimeoutError) as exc: # Any CAN error
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A CAN Error was detected!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except (AttributeError) as exc: # Silly attribute errors
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: There has been an error when scanning for the ID!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except(AntiCanapeError) as exc: # For an Anti-Canape error deeper down
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: An Error was detected!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
                raise

        # Return decoded data
        return outputCanArray


    ######################################
    # GET ALL MESSAGES FROM GIVEN ID SET #
    ######################################
    def continualCanScanOnIDSet(self, IDArrayIn: list, timeoutIn:int=None) -> list:
        ''' Will get the all available messages in the CAN message buffer for the given ID set. This method is preferred when continually searching for multiple ID's because it will keep the BUS, channel, reader, and notifier open UNTIL a message is found, versus opening and closing it for every message. 

        Args:
            IDArrayIn (list): List of ID's to scan for.
            timeoutIn (int): The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.

        Raises:
            AntiCanapeError: Custom Exception that allows for general exception handling and debugging information.

        Returns:
            list: Array of Messsage Information Arrays [ [ID, Data, Timestamp] ... ].
        '''        
        from drivers.automator import BusOverloadError, AntiCanapeError 
        # Get the next message and decode it
        try:
            #Create an array for storage of data arrays
            outputCanArray = []

            #Continue to iterate until keyboard interrupt is received
            try:
                while True:
                    # Grab the message from the buffer that has been there the longest (FIFO)
                    # [https://python-can.readthedocs.io/en/stable/listeners.html#can.BufferedReader.get_message]
                    currentMessage = self.bufferReader.get_message(timeout=timeoutIn)

                    # Check if the message ID is in the wanted ID array
                    if int(currentMessage.arbitration_id) in IDArrayIn:
                        # Decode the message into usable information
                        # [https://cantools.readthedocs.io/en/latest/#cantools.database.can.Database.decode_message]
                        decodedData = self.dbc.decode_message(currentMessage.arbitration_id, currentMessage.data) #Decodes using .dbc

                        # Add the decoded data and message information to a message-specific array, and store it inside output array
                        outputCanArray.append([[currentMessage.arbitration_id, decodedData, currentMessage.timestamp]])
                        # Print the decoded data and message information to the terminal
                        print("---------- ID: " + str(currentMessage.arbitration_id) + " ----------")

                        for signalName, value in decodedData.items():
                            print('Signal: ' + str(signalName) + ' = ' + str(value))

                        print("---------- TIME: " + str(currentMessage.timestamp) + " ----------")
                        print()

            except KeyboardInterrupt:
                print("CC Anti-Canape: KEYBOARD INTERRUPT DETECTED. HALTING SCAN EXECUTION.")


        ##############################
        # GENERAL EXCEPTION HANDLING #
        ##############################
        except (KeyboardInterrupt) as exc: #For when user interrupts program
            print("CC Anti-Canape: Program Execution Halted by Keyboard Interrupt!")
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
                raise AntiCanapeError(exc)
            raise # If debug mode off, still raise the error as is
        except (BusOverloadError) as exc: # For when the bus is overloaded / in error state
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except (PcanError, PcanCanOperationError, PcanCanInitializationError) as exc: # For when pcan has issues
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A PCAN Error was detected!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except (CanError, CanInitializationError, CanInterfaceNotImplementedError, CanOperationError, CanTimeoutError) as exc: # Any CAN error
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A CAN Error was detected!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except (AttributeError) as exc: # Silly attribute errors
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: There has been an error when scanning for the ID!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except(AntiCanapeError) as exc: # For an Anti-Canape error deeper down
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: An Error was detected!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
                raise

        # Return decoded data
        return outputCanArray


    ###################################
    # LOAD A DOT PARSER INTO INSTANCE #
    ###################################
    def loadDotParser(self, dotParser:object) -> True:
        '''This method is designed to load a DOT parser object into the writer instance for use with SDO messages. Specifically, it is used in singleSdoWrite() to lookup a hex index for a given SDO parameter name.

        Args:
            dotParser (dotParse): The dotAutoParse dotParse() object to use as for instance dot parsing.

        Returns:
            bool: True if method completed without error, False otherwise.
        '''        
        self.dotParser = dotParser
        return True


    ####################
    # GET SDO RESPONSE #
    ####################
    def getSdoResponse(self, doPrint:bool=True, timeoutIn:int=None) -> list:
        ''' Will scan the bus for any message with the SDO response ID, used for all SDO responses to all commands.

        Args:
            doPrint (bool, optional): Determines if response output should be printed to the terminal. Defaults to True.
            timeoutIn (int): The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.

        Raises:
            AntiCanapeError: Custom Exception that allows for general exception handling and debugging information.

        Returns:
            list: List containing SDO response information including raw message, type identifier, and payload.
        '''        
        from automator import BusOverloadError, AntiCanapeError # For exception handling
        try:
            # Response on ID 1461 (response ID: Hex 05b5)
            try:
                rawResponse = self.singleCanScanOnID(IDIn=1461, timeoutIn=timeoutIn)

            ##############################
            # GENERAL EXCEPTION HANDLING #
            ##############################
            except (KeyboardInterrupt) as exc: #For when user interrupts program
                print("CC Anti-Canape: Program Execution Halted by Keyboard Interrupt!")
                if DEBUG_MODE:
                    logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
                    logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                    logging.error(exc)
                    raise AntiCanapeError(exc)
                raise # If debug mode off, still raise the error as is
            except (BusOverloadError) as exc: # For when the bus is overloaded / in error state
                if DEBUG_MODE:
                    logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
                    logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                    logging.error(exc)
                raise AntiCanapeError(exc)
            except (PcanError, PcanCanOperationError, PcanCanInitializationError) as exc: # For when pcan has issues
                if DEBUG_MODE:
                    logging.debug("CC Anti-Canape: A PCAN Error was detected!")
                    logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                    logging.error(exc)
                raise AntiCanapeError(exc)
            except (CanError, CanInitializationError, CanInterfaceNotImplementedError, CanOperationError, CanTimeoutError) as exc: # Any CAN error
                if DEBUG_MODE:
                    logging.debug("CC Anti-Canape: A CAN Error was detected!")
                    logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                    logging.error(exc)
                raise AntiCanapeError(exc)
            except (AttributeError) as exc: # Silly attribute errors
                if DEBUG_MODE:
                    logging.debug("CC Anti-Canape: There has been an error when scanning for the ID!")
                    logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                    logging.error(exc)
                raise AntiCanapeError(exc)
            except(AntiCanapeError) as exc: # For an Anti-Canape error deeper down
                if DEBUG_MODE:
                    logging.debug("CC Anti-Canape: An Error was detected!")
                    logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                    logging.error(exc)
                    raise

            rawResponseDict = rawResponse[1]
            # If the value is 96 in decimal, then successful write has been performed
            if (rawResponseDict['SDO_VCM_Response_CMD'] == 96):
                if doPrint:
                    print("CC Anti-Canape: Write Success Has Been Detected!")
                return [rawResponse, rawResponseDict, 'writesuccess', rawResponseDict["SDO_VCM_Response_Payload"]]

            # If the value is 67 in decimal, then successful read has been performed
            elif (rawResponseDict['SDO_VCM_Response_CMD'] == 67):
                if doPrint:
                    print("CC Anti-Canape: Read Success Has Been Detected With 4-Byte Payload!")
                    print("The value of", self.dotParser.getParameterNameFromDecId(str(rawResponseDict["SDO_VCM_Response_Index"])), "is currently", rawResponseDict["SDO_VCM_Response_Payload"])
                return [rawResponse, rawResponseDict, 'readsuccess', rawResponseDict["SDO_VCM_Response_Payload"]]

            # If the value is 71 in decimal, then successful read has been performed
            elif (rawResponseDict['SDO_VCM_Response_CMD'] == 71):
                if doPrint:
                    print("CC Anti-Canape: Read Success Has Been Detected With 3-Byte Payload!")
                    print("The value of", self.dotParser.getParameterNameFromDecId(str(rawResponseDict["SDO_VCM_Response_Index"])), "is currently", rawResponseDict["SDO_VCM_Response_Payload"])
                return [rawResponse, rawResponseDict, 'readsuccess', rawResponseDict["SDO_VCM_Response_Payload"]]

            # If the value is 75 in decimal, then successful read has been performed
            elif (rawResponseDict['SDO_VCM_Response_CMD'] == 75):
                if doPrint:
                    print("CC Anti-Canape: Read Success Has Been Detected With 2-Byte Payload!")
                    print("The value of", self.dotParser.getParameterNameFromDecId(str(rawResponseDict["SDO_VCM_Response_Index"])), "is currently", rawResponseDict["SDO_VCM_Response_Payload"])
                return [rawResponse, rawResponseDict, 'readsuccess', rawResponseDict["SDO_VCM_Response_Payload"]]

            # If the value is 79 in decimal, then successful read has been performed
            elif (rawResponseDict['SDO_VCM_Response_CMD'] == 79):
                if doPrint:
                    print("CC Anti-Canape: Read Success Has Been Detected With 1-Byte Payload!")
                    print("The value of",  self.dotParser.getParameterNameFromDecId(str(rawResponseDict["SDO_VCM_Response_Index"])), "is currently", rawResponseDict["SDO_VCM_Response_Payload"])
                return [rawResponse, rawResponseDict, 'readsuccess', rawResponseDict["SDO_VCM_Response_Payload"]]

            # If the value is 128 in decimal, then write failed
            elif (rawResponseDict['SDO_VCM_Response_CMD'] == 128):
                if doPrint:
                    print("CC Anti-Canape: Message Failure Has Been Detected!")
                return [rawResponse, rawResponseDict, 'failure']


        except(AntiCanapeError) as exc: # For an Anti-Canape error deeper down
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: An Error was detected!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
                raise

        except KeyError as exc:
            print("CC Anti-Canape: There was an issue getting SDO response!")
            print(exc)
            raise KeyboardInterrupt



    ###################
    # SINGLE SDO READ #
    ###################
    def singleSdoRead(self, mainId:Union[str, int], subId:str="00", writer:ACWriter=None, timeoutIn:int=None) -> bool:
        """ Will perform a read command to the VCM over the CAN Bus for a given SDO ID.

        Args:
            mainId (str or int): The SDO ID to read on the VCM [NOT the CAN Arbitration ID].
            subId (str, optional): The SDO sub-ID if it has been changed for a message. Defaults to "00".
            writer(ACWriter): The writer to use for the SDO read command.
            timeoutIn (int): The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.

        Raises:
            AntiCanapeError: Custom Exception that allows for general exception handling and debugging information. 

        Returns:
            bool: True if method completed without error, False otherwise.
        """        
        from drivers.automator import BusOverloadError, AntiCanapeError 
        # Catch any exceptions
        try:
            # Import writer

            localWriter = writer

            # Redefine the ID to be a string for checking
            strId = str(mainId)

            # Initialize a blank splitHexId for Endian conversion
            hexId = ""

            # Initialize a blank finalId for post-conversion
            finalPayload = ""

            # If the id begins with '0x', it is hex ID
            if (strId[0] == '0') and (strId[1] == 'x'):
                hexId = strId

            # If the id is all numbers, it is decimal
            elif (strId.isdigit()):
                # Convert to int and save
                hexId = hex(int(strId))

            # Else, it is a parameter name, so call for hex ID
            else:
                # If the DOT parser has not been loaded, tell user to load it first
                if (self.dotParser == None):
                    print("CC Anti-Canape: Please load DOT parser before writing using parameter names!")
                    return False

                # If the DOT parser has been loaded, use it to find hex ID
                else:
                    hexId = self.dotParser.getHexIdFromParameterName(strId)

            # Add initial write command identifier to payload
            finalPayload += "43"

            # Convert to Little Endian and add to final payload 
            finalPayload += hexId[4]
            finalPayload += hexId[5]
            finalPayload += hexId[2]
            finalPayload += hexId[3]

            # Add the sub index to the final payload
            finalPayload += subId

            # Add empty payload to the final payload
            finalPayload += "00000000"

            # Send the SDO Message
            localWriter.singleCanWriteRawOnID(IDIn=1589, bytes=finalPayload, timeoutIn=timeoutIn)

            # Return True if it has made it this far
            return True

        except(AntiCanapeError) as exc: # For an Anti-Canape error deeper down
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: An Error was detected!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
                raise

`init(busIn)`

Initializes the reader class.

Parameters:

Name	Type	Description	Default
`busIn`	`Bus`	The bus object to read CAN messages on.	required

Source code in drivers\readers.py

def __init__(self, busIn:Bus) -> None:
    ''' Initializes the reader class.

    Args:
        busIn (Bus): The bus object to read CAN messages on.
    '''
    # Set the bus
    # NOTE: The bus can be closed at the end of main program execution. If the bus is closed, the same bus object will need to be opened or this class will need
    #       to be reinitialized.
    self.bus = busIn

    # Configure the DBC
    # [https://cantools.readthedocs.io/en/latest/]
    self.dbc = cantools.db.load_file(filename='ccPythonDBC.dbc', cache_dir='./CANcache') #DBC Database

    # Creates a Buffered Reader - All messages go into a queue
    # [https://python-can.readthedocs.io/en/stable/listeners.html#bufferedreader]
    self.bufferReader = NewBufferedReader()

    # Creates a Notifier - Enables the listener to hear the configured Bus
    # [https://python-can.readthedocs.io/en/stable/listeners.html#notifier]
    self.bufferNotifier = Notifier(bus=self.bus, listeners=[self.bufferReader], timeout=None, loop=None)

    # In case SDO support enabled, load the DOT parser here
    self.dotParser = None

    # Terminal Message
    print("CC Anti-Canape: Reader Object Has Been Initialized!")

`continualCanScanOnBus(timeoutIn=None)`

Continues to get the next message from the CAN message buffer. This method is preferred when continously scanning for messages because it will keep the BUS, channel, reader, and notifier while iterating, instead of opening and closing them each for each message.

Parameters:

Name	Type	Description	Default
`timeoutIn`	`int`	The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.	`None`

Raises:

Type	Description
`AntiCanapeError`	Custom Exception that allows for general exception handling and debugging information.

Returns:

Name	Type	Description
`list`	`list`	Array of Messsage Information Arrays [ [ID, Data, Timestamp], [ID, Data, Timestamp] ... ].

Source code in drivers\readers.py

def continualCanScanOnBus(self, timeoutIn:int=None) -> list:
    ''' Continues to get the next message from the CAN message buffer. This method is preferred when continously scanning for messages because it will keep the BUS, channel, reader, and notifier while iterating, instead of opening and closing them each for each message.

    Args:
        timeoutIn (int): The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.

    Raises:
        AntiCanapeError: Custom Exception that allows for general exception handling and debugging information.

    Returns:
        list: Array of Messsage Information Arrays [ [ID, Data, Timestamp], [ID, Data, Timestamp] ... ].
    '''    
    from drivers.automator import BusOverloadError, AntiCanapeError 
    # Get the next message and decode it
    try:
        #Create an array for storage of data arrays
        outputCanArray = []

        #Continue to iterate until keyboard interrupt is received
        try:
            while True:
                # Grab the message from the buffer that has been there the longest (FIFO)
                # [https://python-can.readthedocs.io/en/stable/listeners.html#can.BufferedReader.get_message]
                currentMessage = self.bufferReader.get_message(timeout=timeoutIn)

                # Decode the message into usable information
                # [https://cantools.readthedocs.io/en/latest/#cantools.database.can.Database.decode_message]
                decodedData = self.dbc.decode_message(currentMessage.arbitration_id, currentMessage.data) #Decodes using .dbc

                # Add the decoded data and message information to a message-specific array, and store it inside output array
                outputCanArray.append([currentMessage.arbitration_id, decodedData, currentMessage.timestamp])
                # Print the decoded data and message information to the terminal
                print("---------- ID: " + str(currentMessage.arbitration_id) + " ----------")

                for signalName, value in decodedData.items():
                    print('Signal: ' + str(signalName) + ' = ' + str(value))

                print("---------- TIME: " + str(currentMessage.timestamp) + " ----------")
                print()

        except KeyboardInterrupt:
            print("CC Anti-Canape: KEYBOARD INTERRUPT DETECTED. HALTING SCAN EXECUTION.")

    ##############################
    # GENERAL EXCEPTION HANDLING #
    ##############################
    except (KeyboardInterrupt) as exc: #For when user interrupts program
        print("CC Anti-Canape: Program Execution Halted by Keyboard Interrupt!")
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
            raise AntiCanapeError(exc)
        raise # If debug mode off, still raise the error as is
    except (BusOverloadError) as exc: # For when the bus is overloaded / in error state
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
        raise AntiCanapeError(exc)
    except (PcanError, PcanCanOperationError, PcanCanInitializationError) as exc: # For when pcan has issues
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: A PCAN Error was detected!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
        raise AntiCanapeError(exc)
    except (CanError, CanInitializationError, CanInterfaceNotImplementedError, CanOperationError, CanTimeoutError) as exc: # Any CAN error
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: A CAN Error was detected!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
        raise AntiCanapeError(exc)
    except (AttributeError) as exc: # Silly attribute errors
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: There has been an error when scanning for the ID!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
        raise AntiCanapeError(exc)
    except(AntiCanapeError) as exc: # For an Anti-Canape error deeper down
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: An Error was detected!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
            raise

    # Return decoded data
    return outputCanArray

`continualCanScanOnID(IDIn, timeoutIn=None)`

Will get the all available messages in the CAN message buffer for the given ID. This method is preferred when continually searching for an ID because it will keep the BUS, channel, reader, and notifier open UNTIL the message is found, versus opening and closing it for every message.

Parameters:

Name	Type	Description	Default
`IDIn`	`int`	The ID to scan for.	required
`timeoutIn`	`int`	The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.	`None`

Raises:

Type	Description
`AntiCanapeError`	Custom Exception that allows for general exception handling and debugging information.

Returns:

Name	Type	Description
`list`	`list`	Array of Messsage Information Arrays [ [ID, Data, Timestamp] ... ].

Source code in drivers\readers.py

def continualCanScanOnID(self, IDIn: int, timeoutIn:int=None) -> list:
    ''' Will get the all available messages in the CAN message buffer for the given ID. This method is preferred when continually searching for an ID because it will keep the BUS, channel, reader, and notifier open UNTIL the message is found, versus opening and closing it for every message. 

    Args:
        IDIn (int): The ID to scan for.
        timeoutIn (int): The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.

    Raises:
        AntiCanapeError: Custom Exception that allows for general exception handling and debugging information.

    Returns:
        list: Array of Messsage Information Arrays [ [ID, Data, Timestamp] ... ].
    '''        
    from drivers.automator import BusOverloadError, AntiCanapeError 
    # Get the next message and decode it
    try:
        #Create an array for storage of data arrays
        outputCanArray = []

        #Continue to iterate until keyboard interrupt is received
        try:
            while True:
                # Grab the message from the buffer that has been there the longest (FIFO)
                # [https://python-can.readthedocs.io/en/stable/listeners.html#can.BufferedReader.get_message]
                currentMessage = self.bufferReader.get_message(timeout=timeoutIn)

                # Check if the message ID matches the wanted ID
                if (int(currentMessage.arbitration_id) == int(IDIn)):
                    # Decode the message into usable information
                    # [https://cantools.readthedocs.io/en/latest/#cantools.database.can.Database.decode_message]
                    decodedData = self.dbc.decode_message(currentMessage.arbitration_id, currentMessage.data) #Decodes using .dbc

                    # Add the decoded data and message information to a message-specific array, and store it inside output array
                    outputCanArray.append([[currentMessage.arbitration_id, decodedData, currentMessage.timestamp]])
                    # Print the decoded data and message information to the terminal
                    print("---------- ID: " + str(currentMessage.arbitration_id) + " ----------")

                    for signalName, value in decodedData.items():
                        print('Signal: ' + str(signalName) + ' = ' + str(value))

                    print("---------- TIME: " + str(currentMessage.timestamp) + " ----------")
                    print()

        except KeyboardInterrupt:
            print("CC Anti-Canape: KEYBOARD INTERRUPT DETECTED. HALTING SCAN EXECUTION.")


    ##############################
    # GENERAL EXCEPTION HANDLING #
    ##############################
    except (KeyboardInterrupt) as exc: #For when user interrupts program
        print("CC Anti-Canape: Program Execution Halted by Keyboard Interrupt!")
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
            raise AntiCanapeError(exc)
        raise # If debug mode off, still raise the error as is
    except (BusOverloadError) as exc: # For when the bus is overloaded / in error state
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
        raise AntiCanapeError(exc)
    except (PcanError, PcanCanOperationError, PcanCanInitializationError) as exc: # For when pcan has issues
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: A PCAN Error was detected!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
        raise AntiCanapeError(exc)
    except (CanError, CanInitializationError, CanInterfaceNotImplementedError, CanOperationError, CanTimeoutError) as exc: # Any CAN error
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: A CAN Error was detected!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
        raise AntiCanapeError(exc)
    except (AttributeError) as exc: # Silly attribute errors
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: There has been an error when scanning for the ID!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
        raise AntiCanapeError(exc)
    except(AntiCanapeError) as exc: # For an Anti-Canape error deeper down
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: An Error was detected!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
            raise

    # Return decoded data
    return outputCanArray

`continualCanScanOnIDSet(IDArrayIn, timeoutIn=None)`

Will get the all available messages in the CAN message buffer for the given ID set. This method is preferred when continually searching for multiple ID's because it will keep the BUS, channel, reader, and notifier open UNTIL a message is found, versus opening and closing it for every message.

Parameters:

Name	Type	Description	Default
`IDArrayIn`	`list`	List of ID's to scan for.	required
`timeoutIn`	`int`	The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.	`None`

Raises:

Type	Description
`AntiCanapeError`	Custom Exception that allows for general exception handling and debugging information.

Returns:

Name	Type	Description
`list`	`list`	Array of Messsage Information Arrays [ [ID, Data, Timestamp] ... ].

Source code in drivers\readers.py

def continualCanScanOnIDSet(self, IDArrayIn: list, timeoutIn:int=None) -> list:
    ''' Will get the all available messages in the CAN message buffer for the given ID set. This method is preferred when continually searching for multiple ID's because it will keep the BUS, channel, reader, and notifier open UNTIL a message is found, versus opening and closing it for every message. 

    Args:
        IDArrayIn (list): List of ID's to scan for.
        timeoutIn (int): The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.

    Raises:
        AntiCanapeError: Custom Exception that allows for general exception handling and debugging information.

    Returns:
        list: Array of Messsage Information Arrays [ [ID, Data, Timestamp] ... ].
    '''        
    from drivers.automator import BusOverloadError, AntiCanapeError 
    # Get the next message and decode it
    try:
        #Create an array for storage of data arrays
        outputCanArray = []

        #Continue to iterate until keyboard interrupt is received
        try:
            while True:
                # Grab the message from the buffer that has been there the longest (FIFO)
                # [https://python-can.readthedocs.io/en/stable/listeners.html#can.BufferedReader.get_message]
                currentMessage = self.bufferReader.get_message(timeout=timeoutIn)

                # Check if the message ID is in the wanted ID array
                if int(currentMessage.arbitration_id) in IDArrayIn:
                    # Decode the message into usable information
                    # [https://cantools.readthedocs.io/en/latest/#cantools.database.can.Database.decode_message]
                    decodedData = self.dbc.decode_message(currentMessage.arbitration_id, currentMessage.data) #Decodes using .dbc

                    # Add the decoded data and message information to a message-specific array, and store it inside output array
                    outputCanArray.append([[currentMessage.arbitration_id, decodedData, currentMessage.timestamp]])
                    # Print the decoded data and message information to the terminal
                    print("---------- ID: " + str(currentMessage.arbitration_id) + " ----------")

                    for signalName, value in decodedData.items():
                        print('Signal: ' + str(signalName) + ' = ' + str(value))

                    print("---------- TIME: " + str(currentMessage.timestamp) + " ----------")
                    print()

        except KeyboardInterrupt:
            print("CC Anti-Canape: KEYBOARD INTERRUPT DETECTED. HALTING SCAN EXECUTION.")


    ##############################
    # GENERAL EXCEPTION HANDLING #
    ##############################
    except (KeyboardInterrupt) as exc: #For when user interrupts program
        print("CC Anti-Canape: Program Execution Halted by Keyboard Interrupt!")
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
            raise AntiCanapeError(exc)
        raise # If debug mode off, still raise the error as is
    except (BusOverloadError) as exc: # For when the bus is overloaded / in error state
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
        raise AntiCanapeError(exc)
    except (PcanError, PcanCanOperationError, PcanCanInitializationError) as exc: # For when pcan has issues
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: A PCAN Error was detected!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
        raise AntiCanapeError(exc)
    except (CanError, CanInitializationError, CanInterfaceNotImplementedError, CanOperationError, CanTimeoutError) as exc: # Any CAN error
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: A CAN Error was detected!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
        raise AntiCanapeError(exc)
    except (AttributeError) as exc: # Silly attribute errors
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: There has been an error when scanning for the ID!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
        raise AntiCanapeError(exc)
    except(AntiCanapeError) as exc: # For an Anti-Canape error deeper down
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: An Error was detected!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
            raise

    # Return decoded data
    return outputCanArray

`encodeitlol(IDIn, signalDictIn)`

A quick support method for encoding an arbitration ID and signal dictionary into a CAN message.

Parameters:

Name	Type	Description	Default
`IDIn`	`int`	The CAN Arbitration ID.	required
`signalDictIn`	`dict`	A dictionary of signal-value pairs.	required

Returns:

Name	Type	Description
`Message`	`Message`	Encoded CAN Message including the arbitration ID and signal dictionary.

Source code in drivers\readers.py

def encodeitlol(self, IDIn:int, signalDictIn:dict) -> Message:
    ''' A quick support method for encoding an arbitration ID and signal dictionary into a CAN message.

    Args:
        IDIn (int): The CAN Arbitration ID.
        signalDictIn (dict): A dictionary of signal-value pairs.

    Returns:
        Message: Encoded CAN Message including the arbitration ID and signal dictionary.
    '''            
    # Encode data into byte array for CAN communication using the DBC file
    # [https://cantools.readthedocs.io/en/latest/#cantools.database.can.Database.encode_message]
    encodedData = self.dbc.encode_message(IDIn, signalDictIn)
    return encodedData

`getSdoResponse(doPrint=True, timeoutIn=None)`

Will scan the bus for any message with the SDO response ID, used for all SDO responses to all commands.

Parameters:

Name	Type	Description	Default
`doPrint`	`bool`	Determines if response output should be printed to the terminal. Defaults to True.	`True`
`timeoutIn`	`int`	The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.	`None`

Raises:

Type	Description
`AntiCanapeError`	Custom Exception that allows for general exception handling and debugging information.

Returns:

Name	Type	Description
`list`	`list`	List containing SDO response information including raw message, type identifier, and payload.

Source code in drivers\readers.py

def getSdoResponse(self, doPrint:bool=True, timeoutIn:int=None) -> list:
    ''' Will scan the bus for any message with the SDO response ID, used for all SDO responses to all commands.

    Args:
        doPrint (bool, optional): Determines if response output should be printed to the terminal. Defaults to True.
        timeoutIn (int): The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.

    Raises:
        AntiCanapeError: Custom Exception that allows for general exception handling and debugging information.

    Returns:
        list: List containing SDO response information including raw message, type identifier, and payload.
    '''        
    from automator import BusOverloadError, AntiCanapeError # For exception handling
    try:
        # Response on ID 1461 (response ID: Hex 05b5)
        try:
            rawResponse = self.singleCanScanOnID(IDIn=1461, timeoutIn=timeoutIn)

        ##############################
        # GENERAL EXCEPTION HANDLING #
        ##############################
        except (KeyboardInterrupt) as exc: #For when user interrupts program
            print("CC Anti-Canape: Program Execution Halted by Keyboard Interrupt!")
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
                raise AntiCanapeError(exc)
            raise # If debug mode off, still raise the error as is
        except (BusOverloadError) as exc: # For when the bus is overloaded / in error state
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except (PcanError, PcanCanOperationError, PcanCanInitializationError) as exc: # For when pcan has issues
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A PCAN Error was detected!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except (CanError, CanInitializationError, CanInterfaceNotImplementedError, CanOperationError, CanTimeoutError) as exc: # Any CAN error
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: A CAN Error was detected!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except (AttributeError) as exc: # Silly attribute errors
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: There has been an error when scanning for the ID!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
            raise AntiCanapeError(exc)
        except(AntiCanapeError) as exc: # For an Anti-Canape error deeper down
            if DEBUG_MODE:
                logging.debug("CC Anti-Canape: An Error was detected!")
                logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                logging.error(exc)
                raise

        rawResponseDict = rawResponse[1]
        # If the value is 96 in decimal, then successful write has been performed
        if (rawResponseDict['SDO_VCM_Response_CMD'] == 96):
            if doPrint:
                print("CC Anti-Canape: Write Success Has Been Detected!")
            return [rawResponse, rawResponseDict, 'writesuccess', rawResponseDict["SDO_VCM_Response_Payload"]]

        # If the value is 67 in decimal, then successful read has been performed
        elif (rawResponseDict['SDO_VCM_Response_CMD'] == 67):
            if doPrint:
                print("CC Anti-Canape: Read Success Has Been Detected With 4-Byte Payload!")
                print("The value of", self.dotParser.getParameterNameFromDecId(str(rawResponseDict["SDO_VCM_Response_Index"])), "is currently", rawResponseDict["SDO_VCM_Response_Payload"])
            return [rawResponse, rawResponseDict, 'readsuccess', rawResponseDict["SDO_VCM_Response_Payload"]]

        # If the value is 71 in decimal, then successful read has been performed
        elif (rawResponseDict['SDO_VCM_Response_CMD'] == 71):
            if doPrint:
                print("CC Anti-Canape: Read Success Has Been Detected With 3-Byte Payload!")
                print("The value of", self.dotParser.getParameterNameFromDecId(str(rawResponseDict["SDO_VCM_Response_Index"])), "is currently", rawResponseDict["SDO_VCM_Response_Payload"])
            return [rawResponse, rawResponseDict, 'readsuccess', rawResponseDict["SDO_VCM_Response_Payload"]]

        # If the value is 75 in decimal, then successful read has been performed
        elif (rawResponseDict['SDO_VCM_Response_CMD'] == 75):
            if doPrint:
                print("CC Anti-Canape: Read Success Has Been Detected With 2-Byte Payload!")
                print("The value of", self.dotParser.getParameterNameFromDecId(str(rawResponseDict["SDO_VCM_Response_Index"])), "is currently", rawResponseDict["SDO_VCM_Response_Payload"])
            return [rawResponse, rawResponseDict, 'readsuccess', rawResponseDict["SDO_VCM_Response_Payload"]]

        # If the value is 79 in decimal, then successful read has been performed
        elif (rawResponseDict['SDO_VCM_Response_CMD'] == 79):
            if doPrint:
                print("CC Anti-Canape: Read Success Has Been Detected With 1-Byte Payload!")
                print("The value of",  self.dotParser.getParameterNameFromDecId(str(rawResponseDict["SDO_VCM_Response_Index"])), "is currently", rawResponseDict["SDO_VCM_Response_Payload"])
            return [rawResponse, rawResponseDict, 'readsuccess', rawResponseDict["SDO_VCM_Response_Payload"]]

        # If the value is 128 in decimal, then write failed
        elif (rawResponseDict['SDO_VCM_Response_CMD'] == 128):
            if doPrint:
                print("CC Anti-Canape: Message Failure Has Been Detected!")
            return [rawResponse, rawResponseDict, 'failure']


    except(AntiCanapeError) as exc: # For an Anti-Canape error deeper down
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: An Error was detected!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
            raise

    except KeyError as exc:
        print("CC Anti-Canape: There was an issue getting SDO response!")
        print(exc)
        raise KeyboardInterrupt

`loadDotParser(dotParser)`

This method is designed to load a DOT parser object into the writer instance for use with SDO messages. Specifically, it is used in singleSdoWrite() to lookup a hex index for a given SDO parameter name.

Parameters:

Name	Type	Description	Default
`dotParser`	`dotParse`	The dotAutoParse dotParse() object to use as for instance dot parsing.	required

Returns:

Name	Type	Description
`bool`	`True`	True if method completed without error, False otherwise.

Source code in drivers\readers.py

def loadDotParser(self, dotParser:object) -> True:
    '''This method is designed to load a DOT parser object into the writer instance for use with SDO messages. Specifically, it is used in singleSdoWrite() to lookup a hex index for a given SDO parameter name.

    Args:
        dotParser (dotParse): The dotAutoParse dotParse() object to use as for instance dot parsing.

    Returns:
        bool: True if method completed without error, False otherwise.
    '''        
    self.dotParser = dotParser
    return True

`singleCanScanOnBus(timeoutIn=None)`

Gets the next available message in the CAN message buffer.

Parameters:

Name	Type	Description	Default
`timeoutIn`	`int`	The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.	`None`

Raises:

Type	Description
`AntiCanapeError`	Custom Exception that allows for general exception handling and debugging information.

Returns:

Name	Type	Description
`list`	`list`	Messsage Information Array [ID, Data, Timestamp]

Source code in drivers\readers.py

def singleCanScanOnBus(self, timeoutIn:int = None) -> list:
    ''' Gets the next available message in the CAN message buffer.

    Args:
        timeoutIn (int): The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.

    Raises:
        AntiCanapeError: Custom Exception that allows for general exception handling and debugging information.

    Returns:
        list: Messsage Information Array [ID, Data, Timestamp]
    '''        
    from drivers.automator import BusOverloadError, AntiCanapeError 
    # Get the next available message and decode it
    try:
        # Grab the message from the buffer that has been there the longest (FIFO)
        # [https://python-can.readthedocs.io/en/stable/listeners.html#can.BufferedReader.get_message]
        currentMessage = self.bufferReader.get_message(timeout=timeoutIn)
        # Decode the message into usable information
        # [https://cantools.readthedocs.io/en/latest/#cantools.database.can.Database.decode_message]
        decodedData = self.dbc.decode_message(currentMessage.arbitration_id, currentMessage.data) #Decodes using .dbc

    ##############################
    # GENERAL EXCEPTION HANDLING #
    ##############################
    except (KeyboardInterrupt) as exc: #For when user interrupts program
        print("CC Anti-Canape: Program Execution Halted by Keyboard Interrupt!")
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
            raise AntiCanapeError(exc)
        raise # If debug mode off, still raise the error as is
    except (BusOverloadError) as exc: # For when the bus is overloaded / in error state
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
        raise AntiCanapeError(exc)
    except (PcanError, PcanCanOperationError, PcanCanInitializationError) as exc: # For when pcan has issues
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: A PCAN Error was detected!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
        raise AntiCanapeError(exc)
    except (CanError, CanInitializationError, CanInterfaceNotImplementedError, CanOperationError, CanTimeoutError) as exc: # Any CAN error
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: A CAN Error was detected!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
        raise AntiCanapeError(exc)
    except (AttributeError) as exc: # Silly attribute errors
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: There has been an error when scanning for the ID!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
        raise AntiCanapeError(exc)
    except(AntiCanapeError) as exc: # For an Anti-Canape error deeper down
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: An Error was detected!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
            raise

    # Return decoded data
    return [currentMessage.arbitration_id, decodedData, currentMessage.timestamp]

`singleCanScanOnID(IDIn, timeoutIn=None)`

Will get the next available message in the CAN message buffer for the given ID. This method is preferred when searching for an ID because it will keep the BUS, channel, reader, and notifier open UNTIL the message is found, versus opening and closing it for every message.

Parameters:

Name	Type	Description	Default
`IDIn`	`int`	The ID to scan for on the CAN Bus Buffer.	required
`timeoutIn`	`int`	The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.	`None`

Raises:

Type	Description
`AntiCanapeError`	Custom Exception that allows for general exception handling and debugging information.

Returns:

Name	Type	Description
`list`	`list`	Messsage Information Array [ID, Data, Timestamp]

Source code in drivers\readers.py

def singleCanScanOnID(self, IDIn: int, timeoutIn:int = None) -> list:
    ''' Will get the next available message in the CAN message buffer for the given ID. This method is preferred when searching for an ID because it will keep the BUS, channel, reader, and notifier open UNTIL the message is found, versus opening and closing it for every message. 

    Args:
        IDIn (int): The ID to scan for on the CAN Bus Buffer.
        timeoutIn (int): The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.

    Raises:
        AntiCanapeError: Custom Exception that allows for general exception handling and debugging information.

    Returns:
        list: Messsage Information Array [ID, Data, Timestamp]
    '''        
    from drivers.automator import BusOverloadError, AntiCanapeError 
    # Get the next message and decode it
    try:
        # Grab the message from the buffer that has been there the longest (FIFO)
        # [https://python-can.readthedocs.io/en/stable/listeners.html#can.BufferedReader.get_message]
        currentMessage = self.bufferReader.get_message(timeout=timeoutIn)

        # Set a flag to use
        messageFoundFlag = False
        # While the correct message has not been found
        while messageFoundFlag == False:

            # Catch error/empty message with no ID
            try:
                # Check if the message ID matches the wanted ID
                if (int(currentMessage.arbitration_id) == int(IDIn)):
                    #Set the message found flag to true so it stops iterating
                    messageFoundFlag = True
                # If the ID does not match, then get next message and iterate again
                else:
                    currentMessage = self.bufferReader.get_message(timeout=10)

            ##############################
            # GENERAL EXCEPTION HANDLING #
            ##############################
            except (KeyboardInterrupt) as exc: #For when user interrupts program
                print("CC Anti-Canape: Program Execution Halted by Keyboard Interrupt!")
                if DEBUG_MODE:
                    logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
                    logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                    logging.error(exc)
                    raise AntiCanapeError(exc)
                raise # If debug mode off, still raise the error as is
            except (BusOverloadError) as exc: # For when the bus is overloaded / in error state
                if DEBUG_MODE:
                    logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
                    logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                    logging.error(exc)
                raise AntiCanapeError(exc)
            except (PcanError, PcanCanOperationError, PcanCanInitializationError) as exc: # For when pcan has issues
                if DEBUG_MODE:
                    logging.debug("CC Anti-Canape: A PCAN Error was detected!")
                    logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                    logging.error(exc)
                raise AntiCanapeError(exc)
            except (CanError, CanInitializationError, CanInterfaceNotImplementedError, CanOperationError, CanTimeoutError) as exc: # Any CAN error
                if DEBUG_MODE:
                    logging.debug("CC Anti-Canape: A CAN Error was detected!")
                    logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                    logging.error(exc)
                raise AntiCanapeError(exc)
            except (AttributeError) as exc: # Silly attribute errors
                if DEBUG_MODE:
                    logging.debug("CC Anti-Canape: There has been an error when scanning for the ID!")
                    logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                    logging.error(exc)
                raise AntiCanapeError(exc)
            except(AntiCanapeError) as exc: # For an Anti-Canape error deeper down
                if DEBUG_MODE:
                    logging.debug("CC Anti-Canape: An Error was detected!")
                    logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
                    logging.error(exc)
                    raise

        # Decode the message into usable information
        # [https://cantools.readthedocs.io/en/latest/#cantools.database.can.Database.decode_message]
        decodedData = self.dbc.decode_message(currentMessage.arbitration_id, currentMessage.data) #Decodes using .dbc

    # All message handling, as long as DEBUG_MODE is on
    except(AntiCanapeError) as exc:
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: An Error was detected!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
            raise

    # Return decoded data
    return [currentMessage.arbitration_id, decodedData, currentMessage.timestamp]

`singleCanScanOnIDSet(IDArrayIn, timeoutIn=None)`

Will get the next available message in the CAN message buffer for any of the given ID's. This method is preferred when searching for a message from a set of ID's because it will keep the BUS, channel, reader, and notifier open UNTIL the message is found, versus opening and closing it for every message.

Parameters:

Name	Type	Description	Default
`IDArrayIn`	`list[int]`	List of ID's to scan for.	required
`timeoutIn`	`int`	The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.	`None`

Raises:

Type	Description
`AntiCanapeError`	Custom Exception that allows for general exception handling and debugging information.

Returns:

Name	Type	Description
`list`	`list`	Messsage Information Array [ID, Data, Timestamp].

Source code in drivers\readers.py

def singleCanScanOnIDSet(self, IDArrayIn: list, timeoutIn:int = None) -> list:
    ''' Will get the next available message in the CAN message buffer for any of the given ID's. This method is preferred when searching for a message from a set of ID's because it will keep the BUS, channel, reader, and notifier open UNTIL the message is found, versus opening and closing it for every message. 

    Args:
        IDArrayIn (list[int]): List of ID's to scan for.
        timeoutIn (int): The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.

    Raises:
        AntiCanapeError: Custom Exception that allows for general exception handling and debugging information.

    Returns:
        list: Messsage Information Array [ID, Data, Timestamp].
    '''    
    from drivers.automator import BusOverloadError, AntiCanapeError    
    # Get the next message and decode it
    try:

        # Grab the message from the buffer that has been there the longest (FIFO)
        # [https://python-can.readthedocs.io/en/stable/listeners.html#can.BufferedReader.get_message]
        currentMessage = self.bufferReader.get_message(timeout=timeoutIn)

        # Set a flag to use
        messageFoundFlag = False
        # While the correct message has not been found
        while messageFoundFlag == False:
            # Check if the message ID is in the wanted ID array
            if int(currentMessage.arbitration_id) in IDArrayIn:
                #Set the message found flag to true so it stops iterating
                messageFoundFlag = True
            # If the ID does not match, then get next message and iterate again
            else:
                currentMessage = self.bufferReader.get_message(timeout=None)

        # Decode the message into usable information
        # [https://cantools.readthedocs.io/en/latest/#cantools.database.can.Database.decode_message]
        decodedData = self.dbc.decode_message(currentMessage.arbitration_id, currentMessage.data) #Decodes using .dbc

    ##############################
    # GENERAL EXCEPTION HANDLING #
    ##############################
    except (KeyboardInterrupt) as exc: #For when user interrupts program
        print("CC Anti-Canape: Program Execution Halted by Keyboard Interrupt!")
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
            raise AntiCanapeError(exc)
        raise # If debug mode off, still raise the error as is
    except (BusOverloadError) as exc: # For when the bus is overloaded / in error state
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: A heavy/overloaded bus was detected! Restarting script...")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
        raise AntiCanapeError(exc)
    except (PcanError, PcanCanOperationError, PcanCanInitializationError) as exc: # For when pcan has issues
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: A PCAN Error was detected!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
        raise AntiCanapeError(exc)
    except (CanError, CanInitializationError, CanInterfaceNotImplementedError, CanOperationError, CanTimeoutError) as exc: # Any CAN error
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: A CAN Error was detected!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
        raise AntiCanapeError(exc)
    except (AttributeError) as exc: # Silly attribute errors
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: There has been an error when scanning for the ID!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
        raise AntiCanapeError(exc)
    except(AntiCanapeError) as exc: # For an Anti-Canape error deeper down
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: An Error was detected!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
            raise

    # Return decoded data
    return [currentMessage.arbitration_id, decodedData, currentMessage.timestamp]

`singleSdoRead(mainId, subId='00', writer=None, timeoutIn=None)`

Will perform a read command to the VCM over the CAN Bus for a given SDO ID.

Parameters:

Name	Type	Description	Default
`mainId`	`str or int`	The SDO ID to read on the VCM [NOT the CAN Arbitration ID].	required
`subId`	`str`	The SDO sub-ID if it has been changed for a message. Defaults to "00".	`'00'`
`writer(ACWriter)`		The writer to use for the SDO read command.	required
`timeoutIn`	`int`	The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.	`None`

Raises:

Type	Description
`AntiCanapeError`	Custom Exception that allows for general exception handling and debugging information.

Returns:

Name	Type	Description
`bool`	`bool`	True if method completed without error, False otherwise.

Source code in drivers\readers.py

def singleSdoRead(self, mainId:Union[str, int], subId:str="00", writer:ACWriter=None, timeoutIn:int=None) -> bool:
    """ Will perform a read command to the VCM over the CAN Bus for a given SDO ID.

    Args:
        mainId (str or int): The SDO ID to read on the VCM [NOT the CAN Arbitration ID].
        subId (str, optional): The SDO sub-ID if it has been changed for a message. Defaults to "00".
        writer(ACWriter): The writer to use for the SDO read command.
        timeoutIn (int): The timeout in seconds for reading the message from the bus. Defaults to None. If None, thread continues indefinitely.

    Raises:
        AntiCanapeError: Custom Exception that allows for general exception handling and debugging information. 

    Returns:
        bool: True if method completed without error, False otherwise.
    """        
    from drivers.automator import BusOverloadError, AntiCanapeError 
    # Catch any exceptions
    try:
        # Import writer

        localWriter = writer

        # Redefine the ID to be a string for checking
        strId = str(mainId)

        # Initialize a blank splitHexId for Endian conversion
        hexId = ""

        # Initialize a blank finalId for post-conversion
        finalPayload = ""

        # If the id begins with '0x', it is hex ID
        if (strId[0] == '0') and (strId[1] == 'x'):
            hexId = strId

        # If the id is all numbers, it is decimal
        elif (strId.isdigit()):
            # Convert to int and save
            hexId = hex(int(strId))

        # Else, it is a parameter name, so call for hex ID
        else:
            # If the DOT parser has not been loaded, tell user to load it first
            if (self.dotParser == None):
                print("CC Anti-Canape: Please load DOT parser before writing using parameter names!")
                return False

            # If the DOT parser has been loaded, use it to find hex ID
            else:
                hexId = self.dotParser.getHexIdFromParameterName(strId)

        # Add initial write command identifier to payload
        finalPayload += "43"

        # Convert to Little Endian and add to final payload 
        finalPayload += hexId[4]
        finalPayload += hexId[5]
        finalPayload += hexId[2]
        finalPayload += hexId[3]

        # Add the sub index to the final payload
        finalPayload += subId

        # Add empty payload to the final payload
        finalPayload += "00000000"

        # Send the SDO Message
        localWriter.singleCanWriteRawOnID(IDIn=1589, bytes=finalPayload, timeoutIn=timeoutIn)

        # Return True if it has made it this far
        return True

    except(AntiCanapeError) as exc: # For an Anti-Canape error deeper down
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: An Error was detected!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)
            raise

`NewBufferedReader`

Bases: BufferedReader

Overrides the BufferedReader method from python-can. Allows for exception handling.

Parameters:

Name	Type	Description	Default
`BufferedReader`	`BufferedReader`	A BufferedReader object.	required

Raises:

Type	Description
`AntiCanapeError`	Custom Exception for all errors when debugging.

Source code in drivers\readers.py

class NewBufferedReader(BufferedReader):
    '''Overrides the BufferedReader method from python-can. Allows for exception handling.

    Args:
        BufferedReader (BufferedReader): A BufferedReader object.

    Raises:
        AntiCanapeError: Custom Exception for all errors when debugging.
    '''
    # Create an error queue
    exc = Queue()

    def on_error(self, exc: Exception) -> None:
        '''Override the on_error message, allowing us to catch exceptions before they are raided

        Args:
            exc (Exception): Exception from the thread.

        Raises:
            AntiCanapeError: Custom Exception for all errors when debugging.
        '''
        # Put the exception into the queue
        self.exc.put(exc)

        # If the debug queue is on, print it to the logs and raise a new error to stop execution
        if DEBUG_MODE:
            logging.debug("CC Anti-Canape: A CAN Error was detected!")
            logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
            logging.error(exc)

            # Custom Exception :)
            from drivers.automator import AntiCanapeError
            raise AntiCanapeError(exc)

`on_error(exc)`

Override the on_error message, allowing us to catch exceptions before they are raided

Parameters:

Name	Type	Description	Default
`exc`	`Exception`	Exception from the thread.	required

Raises:

Type	Description
`AntiCanapeError`	Custom Exception for all errors when debugging.

Source code in drivers\readers.py

def on_error(self, exc: Exception) -> None:
    '''Override the on_error message, allowing us to catch exceptions before they are raided

    Args:
        exc (Exception): Exception from the thread.

    Raises:
        AntiCanapeError: Custom Exception for all errors when debugging.
    '''
    # Put the exception into the queue
    self.exc.put(exc)

    # If the debug queue is on, print it to the logs and raise a new error to stop execution
    if DEBUG_MODE:
        logging.debug("CC Anti-Canape: A CAN Error was detected!")
        logging.debug("Error occured on line", cf.f_lineno, "of file", pythonfilename)
        logging.error(exc)

        # Custom Exception :)
        from drivers.automator import AntiCanapeError
        raise AntiCanapeError(exc)

Reader

ACReader

__init__(busIn)

continualCanScanOnBus(timeoutIn=None)

continualCanScanOnID(IDIn, timeoutIn=None)

continualCanScanOnIDSet(IDArrayIn, timeoutIn=None)

encodeitlol(IDIn, signalDictIn)

getSdoResponse(doPrint=True, timeoutIn=None)

loadDotParser(dotParser)

singleCanScanOnBus(timeoutIn=None)

singleCanScanOnID(IDIn, timeoutIn=None)

singleCanScanOnIDSet(IDArrayIn, timeoutIn=None)

singleSdoRead(mainId, subId='00', writer=None, timeoutIn=None)

NewBufferedReader

on_error(exc)

`ACReader`

`init(busIn)`

`continualCanScanOnBus(timeoutIn=None)`

`continualCanScanOnID(IDIn, timeoutIn=None)`

`continualCanScanOnIDSet(IDArrayIn, timeoutIn=None)`

`encodeitlol(IDIn, signalDictIn)`

`getSdoResponse(doPrint=True, timeoutIn=None)`

`loadDotParser(dotParser)`

`singleCanScanOnBus(timeoutIn=None)`

`singleCanScanOnID(IDIn, timeoutIn=None)`

`singleCanScanOnIDSet(IDArrayIn, timeoutIn=None)`

`singleSdoRead(mainId, subId='00', writer=None, timeoutIn=None)`

`NewBufferedReader`

`on_error(exc)`