Ejemplo n.º 1
0
 def connect(self):
     try:
         self.Func_addr = isotp.Address(isotp.AddressingMode.Normal_29bits,
                                        txid=0x18DB33F1,
                                        rxid=0x18DBF133)
         self.Phys_addr = isotp.Address(isotp.AddressingMode.Normal_29bits,
                                        txid=0x18DA87F1,
                                        rxid=0x18DAF187)
         self.Func_stack = isotp.CanStack(
             bus=self.bus, address=self.Func_addr, params=isotp_params_Func
         )  # Network/Transport layer (IsoTP protocol)
         self.Phys_stack = isotp.CanStack(
             bus=self.bus, address=self.Phys_addr, params=isotp_params_Phys
         )  # Network/Transport layer (IsoTP protocol)
         self.Func_conn = PythonIsoTpConnection(
             self.Func_stack
         )  # interface between Application and Transport layer
         self.Phys_conn = PythonIsoTpConnection(
             self.Phys_stack
         )  # interface between Application and Transport layer
     except:
         self.set_statusText(color='red', text='ISOTP Connection fail.')
         if self.Func_conn.is_open():
             self.Func_conn.close()
         if self.Phys_conn.is_open():
             self.Phys_conn.close()
     else:
         self.set_statusText(color='green',
                             text='ISOTP Connection Success.')
Ejemplo n.º 2
0
def get_DTC_byStatusMask(candevice='can0',
                         txid=0x7E0,
                         rxid=0x7E8,
                         statusMask=0xae):
    dtcdict = {}
    isotp_params = {
        'stmin': 32,
        # Will request the sender to wait 32ms between consecutive frame. 0-127ms or 100-900ns with values from 0xF1-0xF9
        'blocksize':
        8,  # Request the sender to send 8 consecutives frames before sending a new flow control message
        'wftmax': 0,  # Number of wait frame allowed before triggering an error
        'll_data_length':
        8,  # Link layer (CAN layer) works with 8 byte payload (CAN 2.0)
        'tx_padding':
        0x00,  # Will pad all transmitted CAN messages with byte 0x00. None means no padding # VW-AG need Padding !! M.M.
        'rx_flowcontrol_timeout': 1000,
        # Triggers a timeout if a flow control is awaited for more than 1000 milliseconds
        'rx_consecutive_frame_timeout': 1000,
        # Triggers a timeout if a consecutive frame is awaited for more than 1000 milliseconds
        'squash_stmin_requirement': True
        # When sending, respect the stmin requirement of the receiver. If set to True, go as fast as possible.
    }

    config = dict(udsoncan.configs.default_client_config)

    bus = can.interface.Bus(candevice, bustype='socketcan')
    tp_addr = isotp.Address(isotp.AddressingMode.Normal_11bits,
                            txid=txid,
                            rxid=rxid)
    stack = isotp.CanStack(bus=bus, address=tp_addr, params=isotp_params)

    conn = PythonIsoTpConnection(stack)
    try:
        with Client(
                conn, request_timeout=2,
                config=config) as client:  # Application layer (UDS protocol)

            #DiagnosticSessionControl.Session.extendedDiagnosticSession  ->überschneidung mit pyvituds
            client.change_session(3)
            response = client.get_dtc_by_status_mask(statusMask)
            print(
                response.service_data.dtc_count, response.service_data.dtcs
            )  # [<DTC ID=0x001ca4, Status=0x20, Severity=0x00 at 0xb3dceed0>]
            if response.service_data.dtc_count > 0:
                dtclist_str = []
                for el in response.service_data.dtcs:
                    dtclist_str.append("{}".format(el))
                dtcdict["DTC"] = dtclist_str
            else:
                dtcdict["DTC"] = [""]
        return dtcdict
    except NegativeResponseException as e:
        print(
            "NegativeResponseException"
        )  # print('Server refused our request for service %s with code "%s" (0x%02x)' % (e.response.service.get_name(), e.response.code_name, e.response.code))
    except (InvalidResponseException, UnexpectedResponseException) as e:
        print('Server sent an invalid payload : %s' %
              e.response.original_payload)
    except TimeoutException as e:
        print("Timeout")
Ejemplo n.º 3
0
 def configComm(self):
     if not self.commStatus:
         if self.sensor.get() != 'BEG':
             messagebox.showinfo('Error', 'Device not supported.')
         else:
             try:
                 tp_addr = isotp.Address(
                     isotp.AddressingMode.Normal_29bits,  # noqa: E501
                     txid=0x18DA2AF1,
                     rxid=0x18DAFA2A)
                 bus = Bus(bustype='pcan',
                           channel='PCAN_USBBUS1',
                           bitrate=500000)
                 stack = isotp.CanStack(bus=bus, address=tp_addr)
                 self.conn = PythonIsoTpConnection(stack)
                 self.requestTitleMenu.grid(row=3, column=0, pady=5)
                 self.begRequestMenu.grid(row=4, column=0, pady=5)
                 self.sendBtn.grid(row=5, column=0, pady=5)
                 self.commStatus = True
                 self.commButton.config(text='Disconnect')
                 self.terminalMenu.grid(row=6, column=0)
                 self.termPrint('Info - connected')
                 self.sensorOptions.config(state='disabled')
             except Exception:
                 messagebox.showinfo('Error', 'There is no connection')
                 self.commStatus = False
     else:
         try:
             self.commButton.config(text='Connect')
             self.requestTitleMenu.grid_forget()
             self.begRequestMenu.grid_forget()
             self.terminalMenu.grid_forget()
             self.sendBtn.grid_forget()
             self.commStatus = False
         except Exception:
             messagebox.showinfo('Error', 'Unable to disconnect')
     self.commStatuss.config(text=str(self.commStatus))
Ejemplo n.º 4
0
from can.interface import Bus
from udsoncan.connections import PythonIsoTpConnection
from udsoncan.client import Client
import isotp
from udsoncan import Response
import securityAlgo as sec
from time import sleep

tp_addr = isotp.Address(isotp.AddressingMode.Normal_29bits,
                        txid=0x18DA2AF1,
                        rxid=0x18DAFA2A)
bus = Bus(bustype='pcan', channel='PCAN_USBBUS1', bitrate=500000)
stack = isotp.CanStack(bus=bus, address=tp_addr)
conn = PythonIsoTpConnection(stack)
with Client(conn,
            request_timeout=1,
            config={'exception_on_unexpected_response': False}) as client:
    try:
        conn.send(b'\x10\x03')
        payload = conn.wait_frame(timeout=1)
        response = Response.from_payload(payload)
        print(response)
        conn.send(b'\x27\x63')
        payload = conn.wait_frame(timeout=1)
        response = Response.from_payload(payload)
        print('key: ' + response.data.hex()[2:])
        seed = (response.data.hex()[2:])
        sA = sec.securityAlgo(seed, 'series')
        sleep(.1)
        print('calculated key: ' + (sA.calculatedKey).hex())
        conn.send(b'\x27\x64' + sA.calculatedKey)
from can.interfaces.vector import VectorBus
from udsoncan.connections import PythonIsoTpConnection
from udsoncan.client import Client
import isotp

# Refer to isotp documentation for full details about parameters
isotp_params = {
   'stmin' : 32,                          # Will request the sender to wait 32ms between consecutive frame. 0-127ms or 100-900ns with values from 0xF1-0xF9
   'blocksize' : 8,                       # Request the sender to send 8 consecutives frames before sending a new flow control message
   'wftmax' : 0,                          # Number of wait frame allowed before triggering an error
   'll_data_length' : 8,                  # Link layer (CAN layer) works with 8 byte payload (CAN 2.0)
   'tx_padding' : 0,                      # Will pad all transmitted CAN messages with byte 0x00. None means no padding
   'rx_flowcontrol_timeout' : 1000,        # Triggers a timeout if a flow control is awaited for more than 1000 milliseconds
   'rx_consecutive_frame_timeout' : 1000, # Triggers a timeout if a consecutive frame is awaited for more than 1000 milliseconds
   'squash_stmin_requirement' : False     # When sending, respect the stmin requirement of the receiver. If set to True, go as fast as possible.
}

bus = VectorBus(channel=0, bitrate=9600)                                          # Link Layer (CAN protocol)
tp_addr = isotp.Address(isotp.AddressingMode.Normal_11bits, txid=0x123, rxid=0x79D) # Network layer addressing scheme
stack = isotp.CanStack(bus=bus, address=tp_addr, params=isotp_params)               # Network/Transport layer (IsoTP protocol)
conn = PythonIsoTpConnection(stack)                                                 # interface between Application and Transport layer
with Client(conn, request_timeout=1) as client:                                     # Application layer (UDS protocol)
   client.change_session(1)
   # ...
Ejemplo n.º 6
0
import can
import isotp
import udsoncan
from udsoncan.connections import PythonIsoTpConnection
from udsoncan.client import Client
from udsoncan.exceptions import *
from udsoncan.services import *

udsoncan.setup_logging()

bus = can.interface.Bus(bustype="cantact", channel="0", bitrate=500000)
addr = isotp.Address(addressing_mode=isotp.AddressingMode.Normal_11bits,
                     txid=0x123,
                     rxid=0x456)
tp = isotp.CanStack(bus, address=addr)
conn = PythonIsoTpConnection(tp)
client = Client(conn)

conn.open()
client.ecu_reset(ECUReset.ResetType.hardReset)
print("done")
conn.close()
Ejemplo n.º 7
0
class App(tk.Frame):
    def __init__(self, master):
        tk.Frame.__init__(self, master)
        self.winfo_toplevel().title("   BEG Config Tool")
        master.iconphoto(False, tk.PhotoImage(file='logo.png'))
        self.frame = tk.Frame(master)
        self.frame.pack(fill=tk.BOTH, expand=True)
        self.conn = None
        self.client = None
        self.tpTime = 0
        self.mpMessage = [  # mounting position message info
            [.0002, -3.2768, -3.2768, 3.2766],  # Sensor horizont. angle
            [.0002, -1.6384, -1.6384, 1.6382],  # Sensor verical. angle
            [
                .001, -32, -32, 31.999
            ],  # Vehicle coordinate system x-y-z, Sensor x-y-z-coordinate  # noqa: E501
            [.01, 0, .01, 10.23]  # Ground
        ]
        # ------ connection title
        self.connectionTitleMenu = tk.Canvas(self.frame,
                                             width=600,
                                             height=100,
                                             bd=0,
                                             highlightthickness=0)
        self.requestTitleLabel = tk.Label(self.connectionTitleMenu,
                                          text='Connection',
                                          relief=tk.RIDGE,
                                          font=('verdana', 10, 'bold'))
        self.requestTitleLabel.pack(pady=15)
        self.connectionTitleMenu.grid(row=0, column=0)
        # ------ communication menu
        self.communicationMenu = tk.Canvas(self.frame,
                                           width=600,
                                           height=100,
                                           bd=0,
                                           highlightthickness=0)
        self.sensor = tk.StringVar(window)
        self.sensors = ('SGU', 'BEG')
        self.sensor.set(self.sensors[1])
        self.sensorLabel = tk.Label(self.communicationMenu, text='Sensor:')
        self.sensorOptions = tk.OptionMenu(self.communicationMenu, self.sensor,
                                           *self.sensors)
        self.sensorOptions.config(state='disabled')
        self.confg = tk.StringVar(window)
        self.confgs = ('Default', 'Custom')
        self.confg.set(self.confgs[0])
        self.confgLabel = tk.Label(self.communicationMenu, text='Config:')
        self.confgOptions = tk.OptionMenu(self.communicationMenu, self.confg,
                                          *self.confgs)
        self.confgOptions.config(state='disabled')
        self.sensorLabel.grid(row=0, column=0)
        self.sensorOptions.grid(row=0, column=1)
        self.confgLabel.grid(row=0, column=2)
        self.confgOptions.grid(row=0, column=3)
        self.communicationMenu.grid(row=1, column=0, pady=5, padx=5)
        # ------ setup menu - disabled
        self.reqIdLabel = tk.Label(self.communicationMenu, text='Request ID:')
        self.reqId = tk.Entry(self.communicationMenu,
                              bd=5,
                              width=10,
                              justify='center')
        self.reqId.insert(0, '757')
        self.reqId.config(state='disabled')
        self.resIdLabel = tk.Label(self.communicationMenu, text='Response ID:')
        self.resId = tk.Entry(self.communicationMenu,
                              bd=5,
                              width=10,
                              justify='center')
        self.resId.insert(0, '7C1')
        self.resId.config(state='disabled')
        self.interface = tk.StringVar(window)
        self.interfaces = ('peak', )
        self.interface.set(self.interfaces[0])
        self.interfaceLabel = tk.Label(self.communicationMenu,
                                       text='Interface:')
        self.interfaceOptions = tk.OptionMenu(self.communicationMenu,
                                              self.interface,
                                              self.interfaces[0])
        self.interfaceOptions.config(state='disabled')
        self.device = tk.StringVar(window)
        self.devices = ('PCAN_USBBUS1', )
        self.device.set(self.devices[0])
        self.deviceLabel = tk.Label(self.communicationMenu, text='Device:')
        self.deviceOptions = tk.OptionMenu(self.communicationMenu, self.device,
                                           self.devices[0])
        self.deviceOptions.config(state='disabled')
        self.bdLabel = tk.Label(self.communicationMenu, text='Baudrate:')
        self.baudRate = tk.Entry(self.communicationMenu,
                                 bd=5,
                                 width=8,
                                 justify='center')
        self.baudRate.insert(0, '500')
        self.baudRate.config(state='disabled')
        '''self.reqIdLabel.grid(row=2, column=0)
        self.reqId.grid(row=2, column=1)
        self.resIdLabel.grid(row=2, column=2)
        self.resId.grid(row=2, column=3)
        self.interfaceLabel.grid(row=1, column=0)
        self.interfaceOptions.grid(row=1, column=1)
        self.deviceLabel.grid(row=1, column=2)
        self.deviceOptions.grid(row=1, column=3)
        self.bdLabel.grid(row=0, column=2)
        self.baudRate.grid(row=0, column=3)'''
        # ------ comm status
        self.commStatus = False
        self.commButton = tk.Button(
            self.communicationMenu,
            text="Connect",
            command=lambda *args, passed=self.configComm: self.startThread(
                passed, *args))

        self.commLabel = tk.Label(self.communicationMenu, text='Comm status:')
        self.commStatuss = tk.Label(self.communicationMenu,
                                    text=str(self.commStatus))
        self.commLabel.grid(row=3, column=0)
        self.commStatuss.grid(row=3, column=1)
        self.commButton.grid(row=3, column=3)
        # ------ request title
        self.requestTitleMenu = tk.Canvas(self.frame,
                                          width=600,
                                          height=100,
                                          bd=0,
                                          highlightthickness=0)
        self.requestTitle = tk.Label(self.requestTitleMenu,
                                     text='Select a service',
                                     relief=tk.RIDGE,
                                     font=('verdana', 10, 'bold'))
        self.requestTitle.pack(side=tk.TOP, pady=15)
        # self.requestTitleMenu.pack(side=tk.TOP)
        # ------ request menu for BEG
        self.begRequestMenu = tk.Canvas(self.frame,
                                        width=600,
                                        height=400,
                                        bd=0,
                                        highlightthickness=0)
        self.begServicesList = [['Read Data', b'\x22'],
                                ['Write Data', b'\x2E'],
                                ['Diagnostic Session Control', b'\x10'],
                                ['ECU Reset', b'\x11'],
                                ['Comunication Control', b'\x28'],
                                ['Tester Present', b'\x3E\x00'],
                                ['Read DTC Information', b'\x19'],
                                ['Clear Diagnostics Information', b'\x14'],
                                ['Control DTC Setting', b'\x85'],
                                ['Security Access', b'\x27']]
        self.begRDBIList = {
            'Read active diagnostic session': b'\x22\xF1\x86',
            'Read system supplier identifier': b'\x22\xF1\x8A',
            'Read ECU manufacturing date': b'\x22\xF1\x8B',
            'Read ECU serial number': b'\x22\xF1\x8C',
            'Read supplier ECU hardware number': b'\x22\xF1\x92',
            'Read system supplier ECU HW version number': b'\x22\xF1\x93',
            'Read system supplier ECU software number': b'\x22\xF1\x94',
            'Read ODXFileDataIdentifier': b'\x22\xF1\x9E',
            'Read enable/disable B messages': b'\x22\xFD\x11',
            'Read configured CAN1 baud rate': b'\x22\xFD\x12',
            'Read current CAN1 baud rate': b'\x22\xFD\x13',
            'Read CAN1 diagnostics messages IDs': b'\x22\xFD\x14',
            'Read object/filtered object message IDs': b'\x22\xFD\x15',
            'Read last configured single CAN message ID': b'\x22\xFD\x16',
            'Read radar ECU CAN message Ids': b'\x22\xFD\x17',
            'Read object/filtered object message prioritization':
            b'\x22\xFD\x18',
            'Read configured number of sent objects/filtered objects':
            b'\x22\xFD\x19',
            'Read antenna modulation combinations': b'\x22\xFD\x26',
            'Read CAN communication protocol': b'\x22\xFD\x27',
            'Read mounting position': b'\x22\xFD\x28',
            'Read current number of sent objects/filtered': b'\x22\xFD\x29',
            'Read zone configuration': b'\x22\xFD\x60',
            'Read layer': b'\x22\xFD\x61',
            'Read enable/disable object/filtered object and/or zone message':
            b'\x22\xFD\x62',
            'Read radar wave emission stop': b'\x22\xFD\x63',
            'Read output coordinate system': b'\x22\xFD\x64'
        }
        self.begWDBIList = {
            'Write enable/disable B messages': b'\x2E\xFD\x11',
            'Write CAN1 baud rate': b'\x2E\xFD\x12',
            'Write CAN1 diagnostics messages IDs': b'\x2E\xFD\x14',
            'Write configure object/filtered object message IDs':
            b'\x2E\xFD\x15',  # noqa: E501
            'Write configure single CAN message ID': b'\x2E\xFD\x16',
            'Write configure object/filtered object message prioritization':
            b'\x2E\xFD\x18',  # noqa: E501
            'Write configure number of objects/filtered objects to be sent':
            b'\x2E\xFD\x19',  # noqa: E501
            'Configure antenna modulation combinations': b'\x2E\xFD\x26',
            'Configure CAN communication protocol': b'\x2E\xFD\x27',
            'Configure mounting position': b'\x2E\xFD\x28',
            'Configure zone configuration': b'\x2E\xFD\x60',
            'Configure layer': b'\x2E\xFD\x61',
            'Configure enable/disable object/filtered object and/or zone message':
            b'\x2E\xFD\x62',  # noqa: E501
            'Configure radar wave emission stop': b'\x2E\xFD\x63',
            'Configure output coordinate system': b'\x2E\xFD\x64'
        }
        self.begDTWList = {
            b'\x2E\xFD\x11': {
                'disable B message': b'\x00',
                'enable B message': b'\x01'
            },
            b'\x2E\xFD\x12': {
                '125 kbaud': b'\x01',
                '250 kbaud': b'\x02',
                '500 kbaud': b'\x03',
                '1 Mbaud': b'\x04'
            },
            b'\x2E\xFD\x18': {
                'Processing': b'\x00',
                'Distance': b'\x01',
                'Velocity': b'\x02',
                'RCS': b'\x03',
                'Positive angle': b'\x04',
                'Negative angle': b'\x05'
            },
            b'\x2E\xFD\x26': {
                'Tx1 antenna with 208/462 MHz bandwidth': b'\x01',
                'Tx1 antenna with 462 MHz bandwidth': b'\x02',
                'Tx1 antenna with 740 MHz bandwidth': b'\x03',
                'Tx2 antenna with 462 MHz bandwidth': b'\x04',
                'Tx2 antenna with 740 MHz bandwidt': b'\x05'
            },
            b'\x2E\xFD\x27': {
                'Automotive CAN': b'\x00',
                'SAE J1939': b'\x02'
            },
            b'\x2E\xFD\x61': {
                'Filtered object layer': b'\x01',
                'Object layer': b'\x02'
            },
            b'\x2E\xFD\x62': {
                'Messages disabled': b'\x00',
                'Messages enabled': b'\x01'
            },
            b'\x2E\xFD\x63': {
                'Radar wave emission enabled': b'\x00',
                'Radar wave emission disabled': b'\x01'
            },
            b'\x2E\xFD\x64': {
                'Sensor coordinate system': b'\x00',
                'Vehicle coordinate system': b'\x01'
            },
            b'\x2E\xFD\x14': '',
            b'\x2E\xFD\x15': '',
            b'\x2E\xFD\x16': '',
            b'\x2E\xFD\x19': '',
            b'\x2E\xFD\x28': '',
            b'\x2E\xFD\x60': ''
        }
        self.dataOptions = {
            'Read Data': self.begRDBIList,
            'Write Data': self.begWDBIList
        }
        self.DSCSF = {
            'Default diagnostic session': 0x01,
            'Extended diagnostic session': 0x03
        }
        self.ECUR = {'Hard Reset': 0x01}
        self.RDTCI = {
            'reportDTCByStatusMask': 0x02,
            'reportDTCExtDataRecordByDTCNumber': 0x06
        }
        self.sfOptions = {
            'Diagnostic Session Control': self.DSCSF,
            'ECU Reset': self.ECUR,
            'Read DTC Information': self.RDTCI
        }
        self.begTPS = {'ON': b'\x3E\x00', 'OFF': ''}
        self.begDSCO = {'Default': b'\x10\x01', 'Extended': b'\x10\x03'}
        self.sendBtn = tk.Canvas(self.frame,
                                 width=600,
                                 height=400,
                                 bd=0,
                                 highlightthickness=0)
        self.begService = tk.IntVar(window)
        self.begRDBIs = tk.Radiobutton(self.begRequestMenu,
                                       text="Read Data By Identifier",
                                       command=self.begServices,
                                       variable=self.begService,
                                       value=False,
                                       indicatoron=0)
        self.begDID = tk.StringVar(self)
        self.begDID.trace('w', self.begDIDUpdate)
        self.begDIDOptions = tk.OptionMenu(self.begRequestMenu, self.begDID,
                                           *self.begRDBIList.keys())
        self.begDIDOptions.config(width=15)
        self.begWDBIs = tk.Radiobutton(self.begRequestMenu,
                                       text="Write Data By Identifier",
                                       command=self.begServices,
                                       variable=self.begService,
                                       value=True,
                                       indicatoron=0)
        self.begDTW = tk.StringVar(self)
        self.begDTWOptions = tk.OptionMenu(self.begRequestMenu, self.begDTW,
                                           '')
        self.begDTWOptions.config(width=15)
        self.begDataEntry = tk.Entry(self.begRequestMenu,
                                     bd=5,
                                     width=15,
                                     justify='center')
        self.begSend = tk.Button(self.sendBtn,
                                 text="Send",
                                 command=lambda *args, passed=self.sendMsg:
                                 self.startThread(passed, *args))
        self.begResponse = tk.Label(self.begRequestMenu, text='Response: ')
        self.begRDBIs.grid(row=2, column=0, pady=5)
        self.begWDBIs.grid(row=2, column=1, pady=5)
        self.begDIDOptions.grid(row=3, column=0)
        self.begSend.grid(row=0, column=0)
        # ------ response menu
        self.responseMenu = tk.Canvas(self.frame,
                                      width=600,
                                      height=100,
                                      bd=0,
                                      highlightthickness=0)
        self.response = tk.Label(self.responseMenu, text='Response: ')
        # self.response.pack(side=tk.TOP)
        # self.responseMenu.pack(side=tk.TOP)
        # ------ log menu
        self.terminalMenu = tk.Canvas(self.frame,
                                      width=100,
                                      height=50,
                                      bd=0,
                                      highlightthickness=0)
        self.term = tkst.ScrolledText(master=self.terminalMenu,
                                      wrap=tk.WORD,
                                      width=40,
                                      height=10)
        self.term.pack()


# ------

    def configComm(self):
        if not self.commStatus:
            if self.sensor.get() != 'BEG':
                messagebox.showinfo('Error', 'Device not supported.')
            else:
                try:
                    tp_addr = isotp.Address(
                        isotp.AddressingMode.Normal_29bits,  # noqa: E501
                        txid=0x18DA2AF1,
                        rxid=0x18DAFA2A)
                    bus = Bus(bustype='pcan',
                              channel='PCAN_USBBUS1',
                              bitrate=500000)
                    stack = isotp.CanStack(bus=bus, address=tp_addr)
                    self.conn = PythonIsoTpConnection(stack)
                    self.requestTitleMenu.grid(row=3, column=0, pady=5)
                    self.begRequestMenu.grid(row=4, column=0, pady=5)
                    self.sendBtn.grid(row=5, column=0, pady=5)
                    self.commStatus = True
                    self.commButton.config(text='Disconnect')
                    self.terminalMenu.grid(row=6, column=0)
                    self.termPrint('Info - connected')
                    self.sensorOptions.config(state='disabled')
                except Exception:
                    messagebox.showinfo('Error', 'There is no connection')
                    self.commStatus = False
        else:
            try:
                self.commButton.config(text='Connect')
                self.requestTitleMenu.grid_forget()
                self.begRequestMenu.grid_forget()
                self.terminalMenu.grid_forget()
                self.sendBtn.grid_forget()
                self.commStatus = False
            except Exception:
                messagebox.showinfo('Error', 'Unable to disconnect')
        self.commStatuss.config(text=str(self.commStatus))

    def sendMsg(self):
        msg: str
        if self.sensor.get() == 'BEG':
            service = (self.begServicesList[self.begService.get()])
            if service[0] == 'Read Data' and self.begDID.get() != '':
                msg = self.begRDBIList.get(self.begDID.get())
                self.termPrint('Request', msg)
            elif service[0] == 'Write Data' and self.begDID.get() != '':
                did = self.begWDBIList.get(self.begDID.get())
                if self.begDTW.get() != '':
                    dtw = self.begDTWList.get(did)
                    dtw = dtw.get(self.begDTW.get())
                    msg = did + dtw
                    self.termPrint('Request', msg)
                elif self.begDataEntry.get != '':
                    try:
                        dtw = self.begDataEntry.get()
                        msg = did + bytes.fromhex(dtw)
                        self.termPrint('Request', msg)
                    except Exception:
                        messagebox.showinfo('Error',
                                            'Incorrect data provided.')
                else:
                    messagebox.showinfo('Error', 'Complete the request')
            else:
                messagebox.showinfo('Error', 'Complete the request')
        with Client(self.conn,
                    request_timeout=1,
                    config={'exception_on_unexpected_response':
                            False}) as client:  # noqa: F841

            if self.sensor.get() == 'BEG':
                if self.begDID.get() != '':
                    msg = self.begRDBIList.get(self.begDID.get())
                    try:
                        self.conn.send(msg)
                        self.termPrint('Request', msg)
                        payload = self.conn.wait_frame(timeout=1)
                        response = Response.\
                            from_payload(payload)  # noqa: F841, E501
                        self.termPrint('Response', response.data)
                    except Exception as e:
                        print(e)
                else:
                    messagebox.showinfo('Error', 'No service selected')

    def testerPresent(self, *args):
        try:
            with Client(self.conn,
                        request_timeout=1,
                        config={'exception_on_unexpected_response':
                                False}) as client:  # noqa: F841
                self.conn.send(b'\x10\x03')
                self.termPrint('Request', b'\x10\x03')
                payload = self.conn.wait_frame(timeout=1)
                response = Response.\
                    from_payload(payload)  # noqa: F841, E501
                response = str(response).split('<')
                response = (response[1].split('-'))[0]
                self.termPrint(response)
                self.conn.send(b'\x27\x63')
                self.termPrint('Request', b'\x27\x63')
                payload = self.conn.wait_frame(timeout=1)
                response = Response.from_payload(payload)
                seed = (response.data.hex()[2:])
                sA = sec.securityAlgo(seed, 'series')
                sleep(.1)
                key = b'\x27\x64' + sA.calculatedKey
                response = str(response).split('<')
                response = (response[1].split('-'))[0]
                self.conn.send(key)
                payload = self.conn.wait_frame(timeout=1)
                response = Response.from_payload(payload)
                response = str(response).split('<')
                response = (response[1].split('-'))[0]
                self.termPrint(response)
            self.tpTime += 4
            service = (self.begServicesList[self.begService.get()])[0]
            while self.commStatus and service == 'Write Data':
                if time() - self.tpTime >= 4:
                    self.tpTime = time()
                    with Client(
                            self.conn,
                            request_timeout=1,
                            config={'exception_on_unexpected_response':
                                    False}) as client:  # noqa: F841
                        msg = b'\x3E\x00'
                        self.conn.send(msg)
                        self.termPrint('Request', msg)
                        '''payload = self.conn.wait_frame(timeout=1)
                        response = Response.\
                            from_payload(payload)  # noqa: F841, E501
                        self.termPrint('Response', response.data)'''
                service = (self.begServicesList[self.begService.get()])[0]
            self.begService.set(0)
        except Exception as e:
            messagebox.showinfo('Function unavailable', e)
            self.begService.set(0)

    def startThread(self, func):
        Thread(target=func).start()

    def termPrint(self, action, msg=''):
        now = datetime.now()
        now = now.strftime('%m/%d/%Y, %H:%M:%S')
        self.term.config(state=tk.NORMAL)
        if action == 'Request' or action == 'Response':
            msg = msg.hex()
            self.term.insert('insert',
                             now + ': ' + '\n' + (action) + ' - ' + msg + '\n')
        else:
            self.term.insert('insert', now + ': ' + '\n' + (action) + '\n')
        self.term.see("end")
        self.term.config(state=tk.DISABLED)

    def begServices(self):
        service = (self.begServicesList[self.begService.get()])
        if service[0] == 'Read Data':
            self.begDTWOptions.grid_forget()
            self.begDataEntry.grid_forget()
            options = self.begRDBIList.keys()
            self.begDID.set('')
            menu = self.begDIDOptions['menu']
            menu.delete(0, 'end')
            for option in options:
                menu.add_command(
                    label=option,
                    command=lambda selected=option: self.begDID.set(selected))
        elif service[0] == 'Write Data':
            Thread(target=self.testerPresent, daemon=True).start()
            options = self.begWDBIList.keys()
            self.begDID.set('')
            menu = self.begDIDOptions['menu']
            menu.delete(0, 'end')
            for option in options:
                menu.add_command(
                    label=option,
                    command=lambda selected=option: self.begDID.set(selected))

    def begDIDUpdate(self, *args):
        service = (self.begServicesList[self.begService.get()])
        if service[0] == 'Write Data':
            dtw = self.begWDBIList.get(self.begDID.get(), '')
            begdid = (self.begDID.get())
            if begdid == 'Configure mounting position':
                self.mountingWindow()
            else:
                self.begDataEntry.config(state='normal')
            if self.begDTWList.get(dtw, '') != '':
                self.begDataEntry.grid_forget()
                self.begDataEntry.delete(0, "end")
                self.begDTWOptions.grid(row=3, column=1)
                options = self.begDTWList.get(dtw, '')
                self.begDTW.set('')
                menu = self.begDTWOptions['menu']
                menu.delete(0, 'end')
                for option in options:
                    menu.add_command(label=option,
                                     command=lambda selected=option: self.
                                     begDTW.set(selected))
            elif dtw != '':
                self.begDTWOptions.grid_forget()
                self.begDataEntry.grid(row=3, column=1)
                self.begDataEntry.delete(0, "end")
                self.begDTW.set('')

    def mountingWindow(self):
        self.newWindow = tk.Toplevel(self.master)

        self.newWindow.iconphoto(False, tk.PhotoImage(file='logo.png'))
        self.newWindow.title('Mounting Position')

        title = tk.Canvas(self.newWindow)
        tk.Label(title,
                 text="Mounting Position",
                 relief=tk.RIDGE,
                 font=('verdana', 10, 'bold')).pack(pady=15)
        title.grid(row=0, column=0)
        entrys = tk.Canvas(self.newWindow)

        sensorHAngle = tk.Label(entrys, text='Sensor horizont. angle:')
        self.shaId = tk.Entry(entrys, bd=5, width=10, justify='center')
        sensorVAngle = tk.Label(entrys, text='Sensor vertical angle:')
        self.svaId = tk.Entry(entrys, bd=5, width=10, justify='center')

        vehicleCSX = tk.Label(entrys, text='Vehicle coordinate system x:')
        self.vcsxId = tk.Entry(entrys, bd=5, width=10, justify='center')
        vehicleCSY = tk.Label(entrys, text='Vehicle coordinate system y:')
        self.vcsyId = tk.Entry(entrys, bd=5, width=10, justify='center')
        vehicleCSZ = tk.Label(entrys, text='Vehicle coordinate system z:')
        self.vcszId = tk.Entry(entrys, bd=5, width=10, justify='center')

        sensorXC = tk.Label(entrys, text='Sensor x-coordinate:')
        self.sxcId = tk.Entry(entrys, bd=5, width=10, justify='center')
        sensorYC = tk.Label(entrys, text='Sensor y-coordinate:')
        self.sycId = tk.Entry(entrys, bd=5, width=10, justify='center')
        sensorZC = tk.Label(entrys, text='Sensor z-coordinate:')
        self.szcId = tk.Entry(entrys, bd=5, width=10, justify='center')

        ground = tk.Label(entrys, text='Ground:')
        self.gId = tk.Entry(entrys, bd=5, width=10, justify='center')

        sensorHAngle.grid(row=0, column=0, pady=1, padx=1)
        self.shaId.grid(row=0, column=1)
        sensorVAngle.grid(row=1, column=0, pady=1, padx=1)
        self.svaId.grid(row=1, column=1)

        vehicleCSX.grid(row=2, column=0, pady=1,
                        padx=1), self.vcsxId.grid(row=2,
                                                  column=1)  # noqa: E501
        vehicleCSY.grid(row=3, column=0, pady=1,
                        padx=1), self.vcsyId.grid(row=3,
                                                  column=1)  # noqa: E501
        vehicleCSZ.grid(row=4, column=0, pady=1,
                        padx=1), self.vcszId.grid(row=4,
                                                  column=1)  # noqa: E501

        sensorXC.grid(row=5, column=0, pady=1,
                      padx=1), self.sxcId.grid(row=5, column=1)  # noqa: E501
        sensorYC.grid(row=6, column=0, pady=1,
                      padx=1), self.sycId.grid(row=6, column=1)  # noqa: E501
        sensorZC.grid(row=7, column=0, pady=1,
                      padx=1), self.szcId.grid(row=7, column=1)  # noqa: E501

        ground.grid(row=8, column=0, pady=1,
                    padx=1), self.gId.grid(row=8, column=1)  # noqa: E501

        entrys.grid(row=1, column=0)

        done = tk.Canvas(self.newWindow)

        tk.Button(done, text="Done", command=self.getValues).pack()
        done.grid(row=2, column=0, pady=15)

    def getValues(self):
        sha, sva = float(self.shaId.get()), float(self.svaId.get())
        vcsx, vcsy, vcsz = float(self.vcsxId.get()), float(
            self.vcsyId.get()), float(self.vcszId.get())  # noqa: E501
        sxc, syc, szc = float(self.sxcId.get()), float(
            self.sycId.get()), float(self.szcId.get())  # noqa: E501
        g = float(self.gId.get())
        sha, sva = self.calcData(sha, self.mpMessage[0]), self.calcData(
            sva, self.mpMessage[1])  # noqa: E501
        vcsx, vcsy, vcsz = self.calcData(
            vcsx, self.mpMessage[2]), self.calcData(
                vcsy, self.mpMessage[2]), self.calcData(
                    vcsz, self.mpMessage[2])  # noqa: E501
        sxc, syc, szc = self.calcData(sxc, self.mpMessage[2]), self.calcData(
            syc,
            self.mpMessage[2]), self.calcData(szc,
                                              self.mpMessage[2])  # noqa: E501
        g = self.calcData(g, self.mpMessage[3])
        if (sha != 0 and sva != 0 and vcsx != 0 and vcsy != 0 and vcsz != 0
                and sxc != 0 and syc != 0 and szc != 0 and g != 0):
            minfo = (sha + sva + vcsx + vcsy + vcsz + sxc + syc + szc +
                     g).hex()  # noqa: E501
            self.begDataEntry.delete(0, 'end')
            self.begDataEntry.insert(0, minfo)
            self.newWindow.destroy()

        else:
            messagebox.showinfo('Error', 'Invalid value(s).')

    def calcData(self, data, info):
        if info[2] <= data <= info[3]:
            data += 0.0001
            data = (int((data - (-info[1])) / info[0]))
            data = data.to_bytes(3, 'big', signed=True)
            data = bytearray(data)
            data = data[1:]
        else:
            data = 0
        return data
Ejemplo n.º 8
0
class UDS(object):
    def __init__(self, parent):
        self.parent = parent
        self.bus = None

        self.Repro_numTotal = 0
        self.Repro_num = 0
        self.Repro_completeflag = False
        self.statusText = ''

        self.Func_addr = None
        self.Func_stack = None
        self.Func_conn = None

        self.Phys_addr = None
        self.Phys_stack = None
        self.Phys_conn = None

        # Vector Bus
        try:
            self.bus = VectorBus(channel=0,
                                 app_name='SANY SJB Reprogram',
                                 bitrate=250000)  # Link Layer (CAN protocol)
        except:
            self.set_statusText(
                color='red',
                text='CAN Open fail. Check the vector Hardware Configuration.')
        else:
            udsoncan.setup_logging('logging.conf')
            self.set_statusText(color='green', text='CAN Open Success.')
            self.parent.canOpenSuccess()

    def set_statusText(self, color=None, text='Missing Message'):
        if color == 'red':
            tmptext = "<font color=red><b>"
        elif color == 'green':
            tmptext = "<font color=green><b>"
        elif color == 'blue':
            tmptext = "<font color=blue><b>"
        else:
            tmptext = "<font color=black><b>"
        tmptext += text
        self.statusText = tmptext + "</b></font>"

    def connect(self):
        try:
            self.Func_addr = isotp.Address(isotp.AddressingMode.Normal_29bits,
                                           txid=0x18DB33F1,
                                           rxid=0x18DBF133)
            self.Phys_addr = isotp.Address(isotp.AddressingMode.Normal_29bits,
                                           txid=0x18DA87F1,
                                           rxid=0x18DAF187)
            self.Func_stack = isotp.CanStack(
                bus=self.bus, address=self.Func_addr, params=isotp_params_Func
            )  # Network/Transport layer (IsoTP protocol)
            self.Phys_stack = isotp.CanStack(
                bus=self.bus, address=self.Phys_addr, params=isotp_params_Phys
            )  # Network/Transport layer (IsoTP protocol)
            self.Func_conn = PythonIsoTpConnection(
                self.Func_stack
            )  # interface between Application and Transport layer
            self.Phys_conn = PythonIsoTpConnection(
                self.Phys_stack
            )  # interface between Application and Transport layer
        except:
            self.set_statusText(color='red', text='ISOTP Connection fail.')
            if self.Func_conn.is_open():
                self.Func_conn.close()
            if self.Phys_conn.is_open():
                self.Phys_conn.close()
        else:
            self.set_statusText(color='green',
                                text='ISOTP Connection Success.')

    def disconnect(self):
        self.set_statusText(color='green', text='ISOTP Disconnection Success.')
        if self.Func_conn.is_open():
            self.Func_conn.close()
        if self.Phys_conn.is_open():
            self.Phys_conn.close()

    def readAppVersion(self):
        with Client(self.Phys_conn, request_timeout=1,
                    config=config) as client:
            client.logger.info(
                '============================================================')
            client.logger.info(
                '================= Read Application Version =================')
            client.logger.info(
                '============================================================')
            try:
                response = client.read_data_by_identifier_first(0xF189)
            except:
                exc = sys.exc_info()[1]
                self.parent.lineEdit_AppVersion.setPalette(
                    self.parent.palette_red)
                self.parent.lineEdit_AppVersion.setText(str(exc))
                self.set_statusText(
                    color='red',
                    text=
                    'Read Application Version - Fail.    Application may not exist.'
                )
            else:
                self.parent.lineEdit_AppVersion.setPalette(
                    self.parent.palette_blue)
                self.parent.lineEdit_AppVersion.setText(response)
                self.set_statusText(color='green',
                                    text='Read Application Version - Success.')

    def readBootVersion(self):
        with Client(self.Phys_conn, request_timeout=1,
                    config=config) as client:
            client.logger.info(
                '============================================================')
            client.logger.info(
                '================= Read BootLoader Version ==================')
            client.logger.info(
                '============================================================')
            try:
                response = client.read_data_by_identifier_first(0xF195)
            except:
                exc = sys.exc_info()[1]
                self.parent.lineEdit_BootVersion.setPalette(
                    self.parent.palette_red)
                self.parent.lineEdit_BootVersion.setText(str(exc))
                self.set_statusText(color='red',
                                    text='Read BootLoader Version - Fail.')
            else:
                self.parent.lineEdit_BootVersion.setPalette(
                    self.parent.palette_blue)
                self.parent.lineEdit_BootVersion.setText(response)
                self.set_statusText(color='green',
                                    text='Read BootLoader Version - Success.')

    def diagSessionControl(self, Reqtype=0, session=0, spr=False):
        if Reqtype == 0:  # Functional Request
            with Client(self.Func_conn, request_timeout=1,
                        config=config) as client:
                try:
                    if spr == True:
                        with client.suppress_positive_response:
                            client.change_session(session)
                            time.sleep(0.1)
                    else:
                        client.change_session(session)
                except:
                    exc = sys.exc_info()[1]
                    self.set_statusText(color='red', text=str(exc))
                else:
                    self.set_statusText(
                        color='green',
                        text='Diagnostic session change - Success.')
        elif Reqtype == 1:  # Physical Request
            with Client(self.Phys_conn, request_timeout=1,
                        config=config) as client:
                try:
                    if spr == True:
                        with client.suppress_positive_response:
                            client.change_session(session)
                            time.sleep(0.1)
                    else:
                        client.change_session(session)
                except:
                    exc = sys.exc_info()[1]
                    self.set_statusText(color='red', text=str(exc))
                else:
                    self.set_statusText(
                        color='green',
                        text='Diagnostic session change - Success.')
        else:
            self.set_statusText(color='red',
                                text='Diagnostic session change - Fail.')

    def communicationControl(self, control_type=0):
        communication_type = udsoncan.CommunicationType(
            subnet=0, normal_msg=True, network_management_msg=False)

        with Client(self.Func_conn, request_timeout=1,
                    config=config) as client:
            try:
                with client.suppress_positive_response:
                    client.communication_control(control_type,
                                                 communication_type)
                    time.sleep(0.1)
            except:
                exc = sys.exc_info()[1]
                self.set_statusText(color='red', text=str(exc))
            else:
                self.set_statusText(color='green',
                                    text='Communication Control - Success.')

    def tester_Present(self, spr=False):
        with Client(self.Func_conn, request_timeout=1,
                    config=config) as client:
            try:
                if spr == True:
                    with client.suppress_positive_response:
                        client.tester_present()
                        time.sleep(0.1)
                else:
                    client.tester_present()
            except:
                exc = sys.exc_info()[1]
                self.set_statusText(color='red', text=str(exc))
            else:
                pass

    def routineControl(self, rtid=0x0000, control_type=0x01, spr=False):
        # control_type = 1(start routine), 2(stop routine), 3(requestRoutineResult)
        with Client(self.Phys_conn, request_timeout=5,
                    config=config) as client:
            client.logger.info(
                '============================================================')
            client.logger.info(
                '===================== Erase Application ====================')
            client.logger.info(
                '============================================================')
            try:
                if spr == True:
                    with client.suppress_positive_response:
                        client.routine_control(rtid, control_type)
                        time.sleep(0.1)
                else:
                    client.routine_control(rtid, control_type)
            except:
                exc = sys.exc_info()[1]
                self.set_statusText(color='red', text=str(exc))
            else:
                if rtid == 0xFF00:
                    self.set_statusText(
                        color='green',
                        text='Routine Control - Erase Application - Success.')
                else:
                    self.set_statusText(color='green',
                                        text='Routine Control Send - Success.')

    def ecuReset(self, reset_type=0x01):
        # reset_type = 0x01(Hard Reset), 0x10(Reset to App), 0x20(Reset to BT)
        with Client(self.Phys_conn, request_timeout=2,
                    config=config) as client:
            client.logger.info(
                '============================================================')
            client.logger.info(
                '========================= ECU Reset ========================')
            client.logger.info(
                '============================================================')
            try:
                client.ecu_reset(reset_type)
            except:
                exc = sys.exc_info()[1]
                self.set_statusText(color='red', text=str(exc))
            else:
                if reset_type == 0x01:
                    text = "Reset ECU - Hard Reset."
                elif reset_type == 0x10:
                    text = "Reset ECU - Reset to Application."
                elif reset_type == 0x20:
                    text = "Reset ECU - Reset to BootLoader."
                else:
                    pass
                self.set_statusText(color='green', text=text)

    def runFlashData(self):
        self.Repro_numTotal = 0
        self.Repro_num = 0
        self.Repro_completeflag = False
        timeStart = time.time()
        for index in self.parent.srecs:
            if index.type == "S2":
                self.Repro_numTotal = self.Repro_numTotal + 1
        self.parent.progressBarDN.setMaximum(self.Repro_numTotal)

        with Client(self.parent.uds.Phys_conn,
                    request_timeout=1,
                    config=config) as client:
            client.logger.info(
                '============================================================')
            client.logger.info(
                '====================== Start Reprogram =====================')
            client.logger.info(
                '============================================================')

            self.Repro_completeflag = True
            for index in self.parent.srecs:
                if index.type == "S2":
                    data = index.addr.to_bytes(4, byteorder='big') + index.data
                    try:
                        sequenceNum = self.Repro_num % 100
                        client.transfer_data(sequenceNum, data)
                    except:
                        exc = sys.exc_info()[1]
                        self.set_statusText(color='red', text=str(exc))
                        self.Repro_completeflag = False
                        print('... Exception FlashData Thread ...')
                        break
                    else:
                        self.Repro_num = self.Repro_num + 1
                        text = str(self.Repro_num) + "/" + str(
                            self.Repro_numTotal) + " Data is sent."
                        self.set_statusText(color='green', text=text)
                        client.logger.info(text)

            if self.Repro_completeflag is True:
                text = "Flash is complete." + "(" + str(
                    round((time.time() - timeStart), 3)) + " sec)"
                self.set_statusText(color='green', text=text)
            else:
                text = "Flash is not complete." + "(" + str(
                    round((time.time() - timeStart), 3)) + " sec)"
                self.set_statusText(color='red', text=text)

            client.logger.info(
                '============================================================')
            client.logger.info(
                '======================= End Reprogram ======================')
            client.logger.info(
                '============================================================')

        print('... End FlashData Thread ...')