py-uds-demo 26.0.1__py3-none-any.whl

py_uds_demo/core/utils/services/input_output_contol.py

@@ -0,0 +1,63 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from py_uds_demo.core.server import UdsServer
+
+
+class InputOutputControlByIdentifier:
+    """
+    Handles Input Output Control By Identifier (0x2F) service requests.
+
+    What:
+        This service allows a client to take control of a server's (ECU's)
+        inputs and outputs.
+
+    Why:
+        It's used for testing and diagnostics. For example, a technician can
+        use it to manually activate an actuator (like a fan or a motor) to
+        verify its operation, or to simulate a sensor input to see how the
+        ECU responds.
+
+    How:
+        The client sends a request with the SID 0x2F, a Data Identifier (DID)
+        to specify the I/O channel, and a control option (e.g., return
+        control to ECU, freeze current state, short term adjustment).
+
+    Real-world example:
+        A technician suspects a radiator fan is faulty. They use a diagnostic
+        tool to send an Input Output Control By Identifier request to the
+        engine control unit, commanding it to turn on the fan. If the fan
+        starts, the technician knows the fan motor is working and the issue
+        lies elsewhere, perhaps with the temperature sensor or control logic.
+
+    Attributes:
+        uds_server: The UDS server instance.
+        io_control_status: A dictionary to store the status of I/O controls.
+    """
+    def __init__(self, uds_server: 'UdsServer') -> None:
+        self.uds_server: 'UdsServer' = uds_server
+        self.io_control_status = {}
+
+    def process_request(self, data_stream: list) -> list:
+        """
+        Processes an Input Output Control By Identifier request.
+
+        Args:
+            data_stream: The request data stream.
+
+        Returns:
+            A list of bytes representing the response.
+        """
+        if len(data_stream) < 4:
+            return self.uds_server.negative_response.report_negative_response(
+                self.uds_server.SID.IOCBI, self.uds_server.NRC.INCORRECT_MESSAGE_LENGTH_OR_INVALID_FORMAT
+            )
+
+        did = (data_stream[1] << 8) | data_stream[2]
+        control_option = data_stream[3]
+
+        # In a real ECU, you would check if the DID is valid for I/O control
+        # and if the control option is supported.
+
+        self.io_control_status[did] = control_option
+
+        return self.uds_server.positive_response.report_positive_response(self.uds_server.SID.IOCBI, data_stream[1:3])

py_uds_demo/core/utils/services/negative_response.py

@@ -0,0 +1 @@
+

py_uds_demo/core/utils/services/remote_activation_of_routine.py

@@ -0,0 +1,80 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from py_uds_demo.core.server import UdsServer
+
+
+class RoutineControl:
+    """
+    Handles Routine Control (0x31) service requests.
+
+    What:
+        This service is used to start, stop, and request the results of a
+        routine in the server (ECU).
+
+    Why:
+        Routines are used to perform more complex tasks than what can be
+        achieved with a simple read or write service. This can include
+        things like running a self-test, erasing memory, or learning new
+        adaptive values.
+
+    How:
+        The client sends a request with the SID 0x31, a sub-function
+        (e.g., startRoutine, stopRoutine, requestRoutineResults), and a
+        2-byte routine identifier.
+
+    Real-world example:
+        A technician wants to perform a self-test on the ABS. They use a
+        diagnostic tool to send a Routine Control request with the
+        'startRoutine' sub-function and the routine identifier for the ABS
+        self-test. After the routine completes, they send another request
+        with 'requestRoutineResults' to check if the test passed.
+
+    Attributes:
+        uds_server: The UDS server instance.
+        routine_status: A dictionary to store the status of routines.
+    """
+    def __init__(self, uds_server: 'UdsServer') -> None:
+        self.uds_server: 'UdsServer' = uds_server
+        self.routine_status = {}
+
+    def process_request(self, data_stream: list) -> list:
+        """
+        Processes a Routine Control request.
+
+        Args:
+            data_stream: The request data stream.
+
+        Returns:
+            A list of bytes representing the response.
+        """
+        if len(data_stream) < 4:
+            return self.uds_server.negative_response.report_negative_response(
+                self.uds_server.SID.RC, self.uds_server.NRC.INCORRECT_MESSAGE_LENGTH_OR_INVALID_FORMAT
+            )
+
+        sub_function = data_stream[1]
+        routine_id = (data_stream[2] << 8) | data_stream[3]
+
+        if sub_function == self.uds_server.SFID.START_ROUTINE:
+            self.routine_status[routine_id] = "Started"
+            return self.uds_server.positive_response.report_positive_response(self.uds_server.SID.RC, data_stream[1:4])
+
+        elif sub_function == self.uds_server.SFID.STOP_ROUTINE:
+            self.routine_status[routine_id] = "Stopped"
+            return self.uds_server.positive_response.report_positive_response(self.uds_server.SID.RC, data_stream[1:4])
+
+        elif sub_function == self.uds_server.SFID.REQUEST_ROUTINE_RESULT:
+            if routine_id in self.routine_status:
+                # Returning a dummy result
+                return self.uds_server.positive_response.report_positive_response(
+                    self.uds_server.SID.RC, data_stream[1:4] + [0x01, 0x02, 0x03]
+                )
+            else:
+                return self.uds_server.negative_response.report_negative_response(
+                    self.uds_server.SID.RC, self.uds_server.NRC.REQUEST_OUT_OF_RANGE
+                )
+
+        else:
+            return self.uds_server.negative_response.report_negative_response(
+                self.uds_server.SID.RC, self.uds_server.NRC.SUB_FUNCTION_NOT_SUPPORTED
+            )

py_uds_demo/core/utils/services/stored_data_transmission.py

@@ -0,0 +1,132 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from py_uds_demo.core.server import UdsServer
+
+
+class ClearDiagnosticInformation:
+    """
+    Handles Clear Diagnostic Information (0x14) service requests.
+
+    What:
+        This service is used to clear Diagnostic Trouble Codes (DTCs) from
+        the server's (ECU's) memory.
+
+    Why:
+        After a vehicle has been repaired, the stored DTCs related to the
+        fixed issue need to be cleared. This service provides the means to
+        do so.
+
+    How:
+        The client sends a request with the SID 0x14, followed by a 3-byte
+        groupOfDTC parameter, which specifies which DTCs to clear. A value
+        of 0xFFFFFF is typically used to clear all DTCs.
+
+    Real-world example:
+        A "Check Engine" light is on. A technician reads the DTCs and finds
+        a code for a faulty sensor. After replacing the sensor, the technician
+        uses this service to clear the DTC, which turns off the light.
+
+    Attributes:
+        uds_server: The UDS server instance.
+    """
+    def __init__(self, uds_server: 'UdsServer') -> None:
+        self.uds_server: 'UdsServer' = uds_server
+
+    def process_request(self, data_stream: list) -> list:
+        """
+        Processes a Clear Diagnostic Information request.
+
+        Args:
+            data_stream: The request data stream.
+
+        Returns:
+            A list of bytes representing the response.
+        """
+        if self.uds_server.control_dtc_setting.dtc_setting == self.uds_server.SFID.OFF:
+            return self.uds_server.negative_response.report_negative_response(
+                self.uds_server.SID.CDTCI, self.uds_server.NRC.CONDITIONS_NOT_CORRECT
+            )
+
+        self.uds_server.memory.dtcs = []
+        return self.uds_server.positive_response.report_positive_response(self.uds_server.SID.CDTCI, [])
+
+
+class ReadDtcInformation:
+    """
+    Handles Read DTC Information (0x19) service requests.
+
+    What:
+        This service is used to read Diagnostic Trouble Codes (DTCs) and
+        related data from the server's (ECU's) memory.
+
+    Why:
+        It's the primary service for diagnosing vehicle problems. By reading
+        DTCs, a technician can identify the system or component that is
+        faulty. It also allows reading additional data, like "freeze frames"
+        or "snapshot data," which is a snapshot of the vehicle's state at
+        the time the fault occurred.
+
+    How:
+        The client sends a request with the SID 0x19 and a sub-function that
+        specifies what information to read (e.g., number of DTCs, DTCs by
+        status mask, snapshot data).
+
+    Real-world example:
+        A technician connects a diagnostic tool to a car with the "Check
+        Engine" light on. The tool uses this service with the
+        'reportDTCByStatusMask' sub-function to retrieve all active DTCs.
+        The tool might then use another sub-function to read the snapshot
+        data for a specific DTC to get more context about when the fault
+        occurred.
+
+    Attributes:
+        uds_server: The UDS server instance.
+    """
+    def __init__(self, uds_server: 'UdsServer') -> None:
+        self.uds_server: 'UdsServer' = uds_server
+
+    def process_request(self, data_stream: list) -> list:
+        """
+        Processes a Read DTC Information request.
+
+        Args:
+            data_stream: The request data stream.
+
+        Returns:
+            A list of bytes representing the response.
+        """
+        if len(data_stream) < 2:
+            return self.uds_server.negative_response.report_negative_response(
+                self.uds_server.SID.RDTCI, self.uds_server.NRC.INCORRECT_MESSAGE_LENGTH_OR_INVALID_FORMAT
+            )
+
+        sub_function = data_stream[1]
+
+        if sub_function == self.uds_server.SFID.REPORT_NUMBER_OF_DTC_BY_STATUS_MASK:
+            if len(data_stream) != 3:
+                return self.uds_server.negative_response.report_negative_response(
+                    self.uds_server.SID.RDTCI, self.uds_server.NRC.INCORRECT_MESSAGE_LENGTH_OR_INVALID_FORMAT
+                )
+            status_mask = data_stream[2]
+            # In this simulation, we'll just count all DTCs regardless of status mask
+            num_dtcs = len(self.uds_server.memory.dtcs)
+            return self.uds_server.positive_response.report_positive_response(
+                self.uds_server.SID.RDTCI, [sub_function, status_mask, 0x01, num_dtcs]
+            )
+
+        elif sub_function == self.uds_server.SFID.REPORT_DTC_BY_STATUS_MASK:
+            if len(data_stream) != 3:
+                return self.uds_server.negative_response.report_negative_response(
+                    self.uds_server.SID.RDTCI, self.uds_server.NRC.INCORRECT_MESSAGE_LENGTH_OR_INVALID_FORMAT
+                )
+            status_mask = data_stream[2]
+            # In this simulation, we'll return all DTCs regardless of status mask
+            response_data = [sub_function, status_mask]
+            for dtc in self.uds_server.memory.dtcs:
+                response_data.extend(dtc)
+            return self.uds_server.positive_response.report_positive_response(self.uds_server.SID.RDTCI, response_data)
+
+        else:
+            return self.uds_server.negative_response.report_negative_response(
+                self.uds_server.SID.RDTCI, self.uds_server.NRC.SUB_FUNCTION_NOT_SUPPORTED
+            )

py_uds_demo/core/utils/services/upload_download.py

@@ -0,0 +1,189 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from py_uds_demo.core.server import UdsServer
+
+
+class RequestDownload:
+    """
+    Handles Request Download (0x34) service requests.
+
+    What:
+        This service is used to initiate a data download from the client to
+        the server (ECU). It's the first step in the process of flashing new
+        software or writing a large block of data to the ECU.
+
+    Why:
+        It prepares the ECU to receive data, and the ECU can specify the
+        maximum size of the data blocks it can accept at a time.
+
+    How:
+        The client sends a request with the SID 0x34, the memory address
+        where the data should be stored, and the total size of the data.
+
+    Note:
+        This service is not fully implemented in this simulator.
+    """
+    def __init__(self, uds_server: 'UdsServer') -> None:
+        self.uds_server: 'UdsServer' = uds_server
+
+    def process_request(self, data_stream: list) -> list:
+        """
+        Processes a Request Download request.
+
+        Args:
+            data_stream: The request data stream.
+
+        Returns:
+            A negative response, as this service is not supported.
+        """
+        return self.uds_server.negative_response.report_negative_response(
+            self.uds_server.SID.RD, self.uds_server.NRC.SERVICE_NOT_SUPPORTED
+        )
+
+
+class RequestUpload:
+    """
+    Handles Request Upload (0x35) service requests.
+
+    What:
+        This service is used to initiate a data upload from the server (ECU)
+        to the client.
+
+    Why:
+        It's used to read large blocks of data from the ECU, such as log
+        files, calibration data, or the entire memory content.
+
+    How:
+        The client sends a request with the SID 0x35, the memory address
+        of the data to be uploaded, and the size of the data.
+
+    Note:
+        This service is not fully implemented in this simulator.
+    """
+    def __init__(self, uds_server: 'UdsServer') -> None:
+        self.uds_server: 'UdsServer' = uds_server
+
+    def process_request(self, data_stream: list) -> list:
+        """
+        Processes a Request Upload request.
+
+        Args:
+            data_stream: The request data stream.
+
+        Returns:
+            A negative response, as this service is not supported.
+        """
+        return self.uds_server.negative_response.report_negative_response(
+            self.uds_server.SID.RU, self.uds_server.NRC.SERVICE_NOT_SUPPORTED
+        )
+
+
+class TransferData:
+    """
+    Handles Transfer Data (0x36) service requests.
+
+    What:
+        This service is used to transfer data blocks between the client and
+        the server during an upload or download operation.
+
+    Why:
+        It's the workhorse of the data transfer process, responsible for
+        moving the actual data in chunks.
+
+    How:
+        After a download or upload is initiated, the client (for downloads)
+        or server (for uploads) sends a sequence of Transfer Data requests,
+        each containing a block of data.
+
+    Note:
+        This service is not fully implemented in this simulator.
+    """
+    def __init__(self, uds_server: 'UdsServer') -> None:
+        self.uds_server: 'UdsServer' = uds_server
+
+    def process_request(self, data_stream: list) -> list:
+        """
+        Processes a Transfer Data request.
+
+        Args:
+            data_stream: The request data stream.
+
+        Returns:
+            A negative response, as this service is not supported.
+        """
+        return self.uds_server.negative_response.report_negative_response(
+            self.uds_server.SID.TD, self.uds_server.NRC.SERVICE_NOT_SUPPORTED
+        )
+
+
+class RequestTransferExit:
+    """
+    Handles Request Transfer Exit (0x37) service requests.
+
+    What:
+        This service is used to terminate a data transfer sequence.
+
+    Why:
+        It signals the end of the upload or download process, allowing the
+        server to perform any necessary cleanup or verification.
+
+    How:
+        The client sends a request with the SID 0x37 to indicate that the
+        transfer is complete.
+
+    Note:
+        This service is not fully implemented in this simulator.
+    """
+    def __init__(self, uds_server: 'UdsServer') -> None:
+        self.uds_server: 'UdsServer' = uds_server
+
+    def process_request(self, data_stream: list) -> list:
+        """
+        Processes a Request Transfer Exit request.
+
+        Args:
+            data_stream: The request data stream.
+
+        Returns:
+            A negative response, as this service is not supported.
+        """
+        return self.uds_server.negative_response.report_negative_response(
+            self.uds_server.SID.RTE, self.uds_server.NRC.SERVICE_NOT_SUPPORTED
+        )
+
+
+class RequestFileTransfer:
+    """
+    Handles Request File Transfer (0x38) service requests.
+
+    What:
+        This service provides a more advanced and flexible way to transfer
+        files between the client and the server, often with file-system-like
+        operations.
+
+    Why:
+        It's designed to be more powerful than the older upload/download
+        services, supporting more complex use cases.
+
+    How:
+        The specifics are complex and can vary between implementations.
+
+    Note:
+        This service is not fully implemented in this simulator.
+    """
+    def __init__(self, uds_server: 'UdsServer') -> None:
+        self.uds_server: 'UdsServer' = uds_server
+
+    def process_request(self, data_stream: list) -> list:
+        """
+        Processes a Request File Transfer request.
+
+        Args:
+            data_stream: The request data stream.
+
+        Returns:
+            A negative response, as this service is not supported.
+        """
+        return self.uds_server.negative_response.report_negative_response(
+            self.uds_server.SID.RFT, self.uds_server.NRC.SERVICE_NOT_SUPPORTED
+        )

py_uds_demo/interface/api.py

@@ -0,0 +1,30 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import List
+
+from py_uds_demo.core.client import UdsClient
+
+app = FastAPI()
+client = UdsClient()
+
+class UdsRequest(BaseModel):
+    data: List[int]
+
+@app.post("/send_request")
+async def send_request(request: UdsRequest):
+    """
+    Sends a UDS request to the server.
+    """
+    response = client.send_request(request.data, False)
+    return {"response": response}
+
+@app.get("/help/{sid}")
+async def get_help(sid: int):
+    """
+    Returns the docstring for a given service ID.
+    """
+    service = client.server.service_map.get(sid)
+    if service:
+        return {"docstring": service.__doc__}
+    else:
+        raise HTTPException(status_code=404, detail=f"No help found for SID 0x{sid:02X}")

py_uds_demo/interface/cli.py

@@ -0,0 +1,51 @@
+from py_uds_demo.core.client import UdsClient
+
+
+class Cli:
+    def __init__(self):
+        self.client = UdsClient()
+
+    def _help(self):
+        print("💡 Displaying help information.")
+        print("💡 UDS CLI Help:")
+        print("💡   Enter diagnostic requests in hex format (e.g., 22 F1 87).")
+        print("💡   Type 'exit' or 'q' to quit the CLI.")
+        print("💡   Type 'help' or 'h' or '?' for general help.")
+        print("💡   Type 'help <SID>' for help on a specific service (e.g., 'help 10').")
+
+    def run(self):
+        print("🏃‍➡️ Running UDS Simulation in CLI mode.")
+        self._help()
+        while True:
+            user_input = input("💉 ")
+            if user_input.lower() in ['exit', 'q']:
+                print("👋 Closed UDS Simulation CLI mode.")
+                break
+            if user_input.lower().startswith('help '):
+                try:
+                    sid_str = user_input.split(' ')[1]
+                    sid = int(sid_str, 16)
+                    service = self.client.server.service_map.get(sid)
+                    if service:
+                        print(service.__doc__)
+                    else:
+                        print(f"😡 No help found for SID 0x{sid:02X}.")
+                except (ValueError, IndexError):
+                    print("😡 Invalid help command. Use 'help <SID_in_hex>' (e.g., 'help 10').")
+                continue
+            if user_input.lower() in ['help', 'h', '?']:
+                self._help()
+                continue
+            diagnostic_request_clean = user_input.replace(" ", "")
+            try:
+                diagnostic_request_stream = [int(diagnostic_request_clean[i:i+2], 16) for i in range(0, len(diagnostic_request_clean), 2)]
+                response = self.client.send_request(diagnostic_request_stream, True)
+                print(response)
+            except ValueError:
+                print(f"😡 Invalid input({user_input}). Please enter a valid hex string.")
+                continue
+
+
+if __name__ == "__main__":
+    cli = Cli()
+    cli.run()

py_uds_demo/interface/gui.py

@@ -0,0 +1,83 @@
+from dearpygui import dearpygui as dpg
+from py_uds_demo.core.client import UdsClient
+
+class Gui:
+    def __init__(self):
+        self.client = UdsClient()
+        self._setup_ui()
+
+    def _setup_ui(self):
+        dpg.create_context()
+        dpg.create_viewport(title="UDS Simulation GUI", width=920, height=500)
+
+        with dpg.window(label="UDS Simulation GUI", width=900, height=480, tag="main_window"):
+            with dpg.group(horizontal=True):
+                dpg.add_checkbox(label="Tester Present", callback=self._toggle_tester_present, tag="tester_present_checkbox")
+
+            with dpg.child_window(border=True, autosize_x=True, autosize_y=False, height=120):
+                with dpg.group(horizontal=True):
+                    dpg.add_text("Tx Request")
+                    dpg.add_input_text(label="", width=400, tag="request_entry", on_enter=True, callback=self._send_request_callback)
+                    dpg.add_button(label="Send", callback=self._send_request_callback)
+                dpg.add_text("Rx Response")
+                dpg.add_input_text(label="", width=850, height=50, multiline=True, tag="response_textbox", readonly=True)
+
+            with dpg.child_window(border=True, autosize_x=True, autosize_y=False, height=120):
+                dpg.add_text("History")
+                dpg.add_input_text(multiline=True, width=850, height=80, tag="history_textbox", readonly=True)
+
+            with dpg.group(horizontal=True):
+                dpg.add_text("Help")
+                dpg.add_input_text(label="", width=200, tag="help_entry", hint="Enter SID (e.g., 10)", on_enter=True, callback=self._show_help_callback)
+                dpg.add_button(label="Get Help", callback=self._show_help_callback)
+
+        dpg.setup_dearpygui()
+        dpg.show_viewport()
+        dpg.set_primary_window("main_window", True)
+        dpg.start_dearpygui()
+        dpg.destroy_context()
+
+    def _show_help_callback(self, sender, app_data, user_data):
+        sid_str = dpg.get_value("help_entry")
+        try:
+            sid = int(sid_str, 16)
+            service = self.client.server.service_map.get(sid)
+            if service:
+                title = f"Help for SID 0x{sid:02X}"
+                message = service.__doc__ or "No documentation available."
+            else:
+                title = "Error"
+                message = f"No help found for SID 0x{sid:02X}"
+        except ValueError:
+            title = "Error"
+            message = "Invalid SID. Please enter a valid hex value."
+
+        if dpg.does_item_exist("help_modal"):
+            dpg.delete_item("help_modal")
+        with dpg.window(label=title, modal=True, tag="help_modal", no_close=False, width=700, height=300):
+            dpg.add_text(message)
+            dpg.add_button(label="Close", callback=lambda: dpg.delete_item("help_modal"))
+
+    def _send_request_callback(self, sender=None, app_data=None, user_data=None):
+        request_data = dpg.get_value("request_entry").replace(" ", "")
+        try:
+            request_data_stream = [int(request_data[i:i+2], 16) for i in range(0, len(request_data), 2)]
+            request_data_formatted = " ".join(f"{b:02X}" for b in request_data_stream)
+            response_data = self.client.send_request(request_data_stream, False)
+            response_data_formatted = " ".join(f"{b:02X}" for b in response_data)
+        except ValueError:
+            request_data_formatted = f"😡 Invalid input({request_data}). Please enter a valid hex string."
+            response_data_formatted = ""
+        except Exception as e:
+            request_data_formatted = f"😡 An error occurred: {e}"
+            response_data_formatted = ""
+        dpg.set_value("response_textbox", response_data_formatted)
+        current_history = dpg.get_value("history_textbox")
+        new_entry = f"-> {request_data_formatted}\n<- {response_data_formatted}\n"
+        dpg.set_value("history_textbox", new_entry + current_history)
+
+    def _toggle_tester_present(self, sender, app_data, user_data):
+        self.client.server.diagnostic_session_control.tester_present_active = bool(dpg.get_value("tester_present_checkbox"))
+
+if __name__ == "__main__":
+    Gui()