def get_result(self): #b'AT SH ' + b'7E8' + b' ' """Internal use only: not a public interface""" #time.sleep(0.01) repeat_count = 0 if self.port is not None: buffer = "" while 1: c = self.port.read(1) if len(c) == 0: if(repeat_count == 5): break print("Got nothing\n") repeat_count = repeat_count + 1 continue if c == '\r'.encode("utf-8"): continue if c == ">".encode("utf-8"): break if buffer != "" or c != ">": #if something is in buffer, add everything buffer = buffer + c.decode("utf-8") #debug_display(self._notify_window, 3, "Get result:" + buffer) if(buffer == ""): return None return buffer else: debug_display(self._notify_window, 3, "NO self.port!") return None
def get_result(self): """Internal use only: not a public interface""" #time.sleep(0.01) repeat_count = 0 if self.port is not None: buffer = "" while 1: c = self.port.read(1) #print(c) if len(c) == 0: if(repeat_count == 1):##originally 5 break #print("Got nothing\n") repeat_count = repeat_count + 1 continue if c.decode() == '\r': continue if c.decode() == ">": break; if buffer != "" or c != ">": #if something is in buffer, add everything buffer = buffer + c.decode()##jwg #debug_display(self._notify_window, 3, "Get result:" + buffer) if(buffer == ""): return None return buffer else: debug_display(self._notify_window, 3, "NO self.port!") return None
def get_result(self): """Internal use only: not a public interface""" #time.sleep(0.01) repeat_count = 0 if self.port is not None: buffer = "" while 1: c = self.port.read(1) if len(c) == 0: if(repeat_count == 5): #not implemented in original break print "Got nothing\n" repeat_count = repeat_count + 1 continue if c == '\r': #in original \r breaks, why? continue if c == ">": break; if buffer != "" or c != ">": #if something is in buffer, add everything buffer = buffer + c #debug_display(self._notify_window, 3, "Get result:" + buffer) if(buffer == ""): return None return buffer else: debug_display(self._notify_window, 3, "NO self.port!") return None
def get_result(self): """Internal use only: not a public interface""" #time.sleep(0.01) repeat_count = 0 if self.port is not None: buffer = "" while 1: c = self.port.read(1) if len(c) == 0: if(repeat_count == 5): break print "Got nothing\n" repeat_count = repeat_count + 1 continue if c == '\r': continue if c == ">": break; if buffer != "" or c != ">": #if something is in buffer, add everything buffer = buffer + c #debug_display(self._notify_window, 3, "Get result:" + buffer) if(buffer == ""): return None return buffer else: debug_display(self._notify_window, 3, "NO self.port!") return None
def send_command(self, cmd): """Internal use only: not a public interface""" if self.port: self.port.flushOutput() self.port.flushInput() for c in cmd: self.port.write(c.encode()) self.port.write("\r\n".encode()) debug_display(self._notify_window, 3, "Send command:" + cmd)
def send_command(self, cmd, wait_response=True): """Sends a command and waits for a response""" self.send_raw(cmd + "\r\n") if wait_response: res = self.recv_result() debug_display( self._notify_window, DebugEvent.DISPLAY_DEBUG, "cmd: \"%s\" -> \"%s\"" % (cmd, res.replace('\r', '\\r'))) if res == "CAN ERROR": raise IOError("Disconnected from CAN bus") return res debug_display(self._notify_window, DebugEvent.DISPLAY_DEBUG, "cmd: \"%s\"" % cmd) return None
def get_result(self): """Internal use only: not a public interface""" #time.sleep(0.01) repeat_count = 0 if self.port is not None: buffer = "" while 1: c = self.port.read(1) if len(c) == 0: if (repeat_count == 10): break ####Extra by me##### localtime = datetime.now() current_time = str(localtime.hour) + ":" + str( localtime.minute) + ":" + str( localtime.second) + "." + str( localtime.microsecond) log_string = current_time #logtime = "Time:" + str(current_time) + "\t"+ "The OBD Not connected OR The Car can not support OBD2" #logtimenotcon = '/home/pi/Desktop/pyobd-pi/Score/'+"car-"+str(localtime[0])+"-"+str(localtime[1])+"-"+str(localtime[2])+"-"+str(localtime[3])+"-"+str(localtime[4])+"-"+str(localtime[5])+".log" #logtime_file = open(logtimenotcon, "w", 128) #logtime_file.write(logtime+"\n") ####### print "Got nothing\n" repeat_count = repeat_count + 1 continue if c == '\r': continue if c == ">": break if buffer != "" or c != ">": #if something is in buffer, add everything buffer = buffer + c #debug_display(self._notify_window, 3, "Get result:" + buffer) if (buffer == ""): return None return buffer else: debug_display(self._notify_window, 3, "NO self.port!") return None
def get_result(self): """Internal use only: not a public interface""" # time.sleep(0.01) repeat_count = 0 if self.port is not None: buffer = "" while 1: c = self.port.read(1) if len(c) == 0: if (repeat_count == self.retrymax): debug_display(self._notify_window, 2, "Reconnect limit reached, giving up") break debug_display(self._notify_window, 1, "Retrying...") repeat_count = repeat_count + 1 continue if c == '\r': continue if c == ">": break if buffer != "" or c != ">": # if something is in buffer, add everything buffer = buffer + c #debug_display(self._notify_window, 3, "Get result:" + buffer) if (buffer == ""): return None return buffer else: debug_display(self._notify_window, 3, "NO self.port!") return None
def get_result(self): """Internal use only: not a public interface""" #time.sleep(0.01) repeat_count = 0 # Verify a port is connected if self.port is not None: buffer = "" # Loop to increment through the buffer one bit at a time # building the contents of the buffer in the buffer variable while 1: c = self.port.read(1) if len(c) == 0: if(repeat_count == 5): break print "Got nothing\n" repeat_count = repeat_count + 1 continue if c == '\r': continue if c == ">": break; if buffer != "" or c != ">": #if something is in buffer, add everything buffer = buffer + c #debug_display(self._notify_window, 3, "Get result:" + buffer) if(buffer == ""): return None return buffer else: debug_display(self._notify_window, 3, "NO self.port!") return None
def __init__(self,portnum,_notify_window,SERTIMEOUT,RECONNATTEMPTS): """Initializes port by resetting device and gettings supported PIDs. """ # These should really be set by the user. baud = 38400 databits = 8 par = serial.PARITY_NONE # parity sb = 1 # stop bits to = SERTIMEOUT self.ELMver = "Unknown" self.State = 1 #state SERIAL is 1 connected, 0 disconnected (connection failed) self.port = None self._notify_window=_notify_window debug_display(self._notify_window, 1, "Opening interface (serial port)") try: self.port = serial.Serial(portnum,baud, \ parity = par, stopbits = sb, bytesize = databits,timeout = to) except serial.SerialException as e: print(e) self.State = 0 return None debug_display(self._notify_window, 1, "Interface successfully " + self.port.portstr + " opened") debug_display(self._notify_window, 1, "Connecting to ECU...") try: self.send_command("atz") # initialize time.sleep(1) except serial.SerialException: self.State = 0 return None self.ELMver = self.get_result() if(self.ELMver is None): self.State = 0 return None debug_display(self._notify_window, 2, "atz response:" + self.ELMver) self.send_command("ate0") # Echo off debug_display(self._notify_window, 2, "ate0 response:" + self.get_result()) self.send_command("atl0") # Use \r to mark new line debug_display(self._notify_window, 2, "atl0 response:" + self.get_result()) self.send_command("ats0") # Print Spaces (Get rid of spaces for speed) debug_display(self._notify_window, 2, "ats0 response:" + self.get_result()) # self.send_command("atm0") # Sniffing or Memory Unsure (Not Touching for Now) # debug_display(self._notify_window, 2, "atm0 response:" + self.get_result()) # self.send_command("atst64") # Timeout set timeout to 4*64 ms # debug_display(self._notify_window, 2, "ath1 response:" + self.get_result()) # self.send_command("attp0") # Automatic Protocol # May Want To Set # debug_display(self._notify_window, 2, "ath1 response:" + self.get_result()) self.send_command("atst64") # Timeout set timeout to 4*64 ms debug_display(self._notify_window, 2, "atst64 response:" + self.get_result()) self.send_command("atdp") # Headers on debug_display(self._notify_window, 2, "atdp response:" + self.get_result()) self.send_command("ath1") # Headers on debug_display(self._notify_window, 2, "ath1 response:" + self.get_result()) self.send_command("0100") ready = self.get_result() if(ready is None): self.State = 0 return None debug_display(self._notify_window, 2, "0100 response:" + ready) return None
def __init__(self, portnum, _notify_window, SERTIMEOUT, RECONNATTEMPTS): """Initializes port by resetting device and gettings supported PIDs. """ # These should really be set by the user. baud = 38400 databits = 8 par = serial.PARITY_NONE # parity sb = 1 # stop bits to = SERTIMEOUT self.ELMver = "Unknown" self.State = 1 #state SERIAL is 1 connected, 0 disconnected (connection failed) self.port = None self._notify_window = _notify_window debug_display(self._notify_window, 1, "Opening interface (serial port)") try: self.port = serial.Serial(portnum,baud, \ parity = par, stopbits = sb, bytesize = databits,timeout = to) except serial.SerialException as e: print e self.State = 0 return None debug_display( self._notify_window, 1, "Interface successfully " + self.port.portstr + " opened") debug_display(self._notify_window, 1, "Connecting to ECU...") try: self.send_command("atz") # initialize time.sleep(1) except serial.SerialException: self.State = 0 return None self.ELMver = self.get_result() if (self.ELMver is None): self.State = 0 return None debug_display(self._notify_window, 2, "atz response:" + self.ELMver) self.send_command("ate0") # echo off debug_display(self._notify_window, 2, "ate0 response:" + self.get_result()) self.send_command("0100") ready = self.get_result() if (ready is None): self.State = 0 return None debug_display(self._notify_window, 2, "0100 response:" + ready) return None
def __init__(self, portnum, _notify_window, SERTIMEOUT, RECONNATTEMPTS): """Initializes port by resetting device and gettings supported PIDs. """ # These should really be set by the user. baud = 9600 #38400 databits = 8 par = serial.PARITY_NONE # parity sb = 1 # stop bits to = SERTIMEOUT self.ELMver = "Unknown" self.State = 1 #state SERIAL is 1 connected, 0 disconnected (connection failed) self.port = None self._notify_window = _notify_window debug_display(self._notify_window, 1, "Opening interface (serial port)") try: self.port = serial.Serial(portnum,baud, \ parity = par, stopbits = sb, bytesize = databits,timeout = to) except serial.SerialException as e: print e self.State = 0 return None debug_display( self._notify_window, 1, "Interface successfully " + self.port.portstr + " opened") debug_display(self._notify_window, 1, "Connecting to ECU...") debug_display( self._notify_window, 2, "Status:" + self.get_result() ) #add by me, becoz after connected, elm327 return "connected" try: self.send_command("atz") # initialize time.sleep(1) except serial.SerialException: self.State = 0 return None self.ELMver = self.get_result() if (self.ELMver is None): self.State = 0 return None debug_display(self._notify_window, 2, "atz response:" + self.ELMver) self.send_command("ate0") # echo off debug_display(self._notify_window, 2, "ate0 (echo off)response:" + self.get_result()) ###SIENTA SPECIFIC#### #To set protocol suitable for toyota SIENTA add the following to set protocol spec. #atib96 \n atiia13 \n atsh8113f1 \n atspa4 \n atsw00 debug_display(self._notify_window, 2, "setting protocol to TOYOTA K-LINE") self.send_command("atib96") debug_display(self._notify_window, 2, "atib96 response:" + self.get_result()) self.send_command("atiia13") debug_display(self._notify_window, 2, "atiia13 response:" + self.get_result()) self.send_command("atsh8113f1") debug_display(self._notify_window, 2, "atsh8113f1 response:" + self.get_result()) self.send_command("atspa4") debug_display(self._notify_window, 2, "atspa4 response:" + self.get_result()) self.send_command("atsw00") debug_display(self._notify_window, 2, "atsw00 response:" + self.get_result()) debug_display(self._notify_window, 2, "Protocol set to TOYOTA K-LINE for SIENTA") ### END of SIENTA SPECIFIC33333333333 self.send_command("0100") ready = self.get_result() if (ready is None): self.State = 0 return None debug_display(self._notify_window, 2, "0100 response:" + ready) return None
if c == '\r': continue if c == ">": break; if buffer != "" or c != ">": #if something is in buffer, add everything buffer = buffer + c #debug_display(self._notify_window, 3, "Get result:" + buffer) if(buffer == ""): return None print "Received Data\n" return buffer else: debug_display(self._notify_window, 3, "NO self.port!") return None # get sensor value from command def get_sensor_value(self,sensor): """Internal use only: not a public interface""" cmd = sensor.cmd self.send_command(cmd) data = self.get_result() if data: data = self.interpret_result(data) if data != "NODATA": data = sensor.value(data) else: return "NORESPONSE"
def __init__(self,portnum,_notify_window,SERTIMEOUT,RECONNATTEMPTS): """Initializes port by resetting device and gettings supported PIDs. """ # These should really be set by the user. baud = 38400 databits = 8 par = serial.PARITY_NONE # parity sb = 1 # stop bits to = SERTIMEOUT self.ELMver = "Unknown" self.State = 1 #state SERIAL is 1 connected, 0 disconnected (connection failed) self.port = None # Display connection in a notification window, if supplied in arguments self._notify_window=_notify_window debug_display(self._notify_window, 1, "Opening interface (serial port)") # Attempt to connect to the serial port, with the specified parameters try: self.port = serial.Serial(portnum,baud, \ parity = par, stopbits = sb, bytesize = databits,timeout = to) # Connection failed, set state to zero and return 'None' except serial.SerialException as e: print e self.State = 0 return None # Display the connection has been successful in the window debug_display(self._notify_window, 1, "Interface successfully " + self.port.portstr + " opened") debug_display(self._notify_window, 1, "Connecting to ECU...") # Attempt to send an initialize command to the OBD try: self.send_command("atz") # initialize time.sleep(1) # Command failed, set state to zero and return 'None' except serial.SerialException: self.State = 0 return None # Set the value of ELMver # The version will be stored in the buffer from # sending the 'atz' command self.ELMver = self.get_result() # Verify the version is not 'None' # if 'None' is returned set the state to zero and return 'None' if(self.ELMver is None): self.State = 0 return None debug_display(self._notify_window, 2, "atz response:" + self.ELMver) self.send_command("ate0") # echo off debug_display(self._notify_window, 2, "ate0 response:" + self.get_result()) self.send_command("0100") ready = self.get_result() if(ready is None): self.State = 0 return None debug_display(self._notify_window, 2, "0100 response:" + ready) return None
def __init__(self, portnum, _notify_window, SERTIMEOUT, RECONNATTEMPTS): """Initializes port by resetting device and gettings supported PIDs. """ # These should really be set by the user. baud = 38400 databits = 8 par = serial.PARITY_NONE # parity sb = 1 # stop bits to = SERTIMEOUT self.ELMver = "Unknown" self.PortName = "Unknown" # state SERIAL is 1 connected, 0 disconnected (connection failed) self.State = 0 self.Error = None self._echo_enabled = True # enabled by default self._monitor_mode = False # flagged if we're in monitor mode self._recv_buf = '' self._notify_window = _notify_window if is_mac_address(portnum): debug_display(self._notify_window, DebugEvent.DISPLAY_DEBUG, "Opening interface (bluetooth RFCOMM)") self._transport = CreateTransport(TransportType.BLUETOOTH) else: debug_display(self._notify_window, DebugEvent.DISPLAY_DEBUG, "Opening interface (serial port)") self._transport = CreateTransport(TransportType.SERIAL) for i in range(0, RECONNATTEMPTS): if self._transport.Connect(portnum): break if not self._transport.IsConnected(): debug_display(self._notify_window, DebugEvent.DISPLAY_ERROR, "Exhausted connection attempts.") self.Error = self._transport.GetErrorString() return None debug_display(self._notify_window, DebugEvent.DISPLAY_DEBUG, "Interface successfully opened") debug_display(self._notify_window, DebugEvent.DISPLAY_DEBUG, "Connecting to ECU...") self.State = 1 try: self.send_command("ATZ") # initialize except IOError as e: debug_display(self._notify_window, 2, "failed to send atz (%s)" % e) return None # Disable command echo - we don't need it. self.enable_echo(False) # Verify the ELM327 version self.ELMver = self.send_command("ATI") if self.ELMver[0:6] != 'ELM327': debug_display( self._notify_window, DebugEvent.DISPLAY_DEBUG, "Invalid ELM327 version \"%s\" returned" % self.ELMver) self.Error = "Invalid ELM327 version \"%s\" returned" % self.ELMver return None initial_protocol = 0 # Automatic search debug_display(self._notify_window, DebugEvent.DISPLAY_DEBUG, "ELM Version: " + self.ELMver) res = self.send_command("ATSP%.1X" % initial_protocol) if res != 'OK': debug_display(self._notify_window, DebugEvent.DISPLAY_ERROR, "Failed to select protocol 6") return None # Query available PIDs res = self.send_command("0100") ready = True proto = initial_protocol if 'UNABLE TO CONNECT' in res or 'ERROR' in res or 'NO DATA' in res: debug_display(self._notify_window, DebugEvent.DISPLAY_ERROR, "Protocol %d: error %s" % (initial_protocol, res)) # Loop through all possible protocols for i in range(0x1, 0xB): res = self.send_command("ATTP%.1X" % i) if res != 'OK': print(("Unable to select protocol %.1X" % i)) break res = self.send_command("0100") if 'UNABLE TO CONNECT' in res or 'NO DATA' in res or 'ERROR' in res: debug_display(self._notify_window, DebugEvent.DISPLAY_ERROR, "Protocol %d: error %s" % (i, res)) ready = False continue else: proto = i ready = True break # Found a protocol. Save it. if ready: res = self.send_command("ATSP%.1X" % proto) if res != 'OK': debug_display(self._notify_window, DebugEvent.DISPLAY_ERROR, "Failed to select protocol %.1X" % proto) self.State = 0 return None if not ready: self.Error = "Failed to connect to ECU (is the car on?)" self.State = 0 self.close() return None # Now connected self.State = 1 debug_display(self._notify_window, DebugEvent.DISPLAY_DEBUG, "Connected to ECU on protocol 0x%.1X" % proto) debug_display(self._notify_window, DebugEvent.DISPLAY_DEBUG, "0100 response: " + res) return None
def __init__(self,portnum,_notify_window,SERTIMEOUT,RECONNATTEMPTS): """Initializes port by resetting device and gettings supported PIDs. """ # These should really be set by the user. baud = 38400 databits = 8 par = serial.PARITY_NONE # parity sb = 1 # stop bits to = SERTIMEOUT self.ELMver = "Unknown" self.State = 1 #state SERIAL is 1 connected, 0 disconnected (connection failed) self.port = None self._notify_window=_notify_window debug_display(self._notify_window, 1, "Opening interface (serial port)") try: self.port = serial.Serial(portnum,baud, \ parity = par, stopbits = sb, bytesize = databits,timeout = to) except serial.SerialException as e: print e self.State = 0 return None debug_display(self._notify_window, 1, "Interface successfully " + self.port.portstr + " opened") debug_display(self._notify_window, 1, "Connecting to ECU...") try: self.send_command("atz") # initialize time.sleep(1) except serial.SerialException: self.State = 0 return None self.ELMver = self.get_result() if(self.ELMver is None): self.State = 0 return None debug_display(self._notify_window, 2, "atz response:" + self.ELMver) self.send_command("AT@1") debug_display(self._notify_window, 2, "@1 response:" + self.get_result()) self.send_command("ATDP") debug_display(self._notify_window, 2, "ATDP response:" + self.get_result()) self.send_command("ate0") # echo off debug_display(self._notify_window, 2, "ate0 response:" + self.get_result()) self.send_command("0100") ready = self.get_result() if(ready is None or "ERROR" in ready): print "Initialization error. Reconnecting" self.State = 0 return None debug_display(self._notify_window, 2, "0100 response:" + ready) return None
def __init__(self, portnum, _notify_window, SERTIMEOUT, RECONNATTEMPTS): """Initializes port by resetting device and gettings supported PIDs. """ # These should really be set by the user. #baud = 9600 # set the baud rate either to 9600 or 38400. In my case 38400. 9141-2 baud-rate is 10.4 kbps baud = 38400 # set the baud rate either to 9600 or 38400. In my case 38400. 9141-2 baud-rate is 10.4 kbps #baud = 10400 # set the baud rate either to 9600 or 38400. In my case 38400. 9141-2 baud-rate is 10.4 kbps databits = 8 par = serial.PARITY_NONE # parity sb = 1 # stop bits to = SERTIMEOUT self.ELMver = "Unknown" self.State = 1 #state SERIAL is 1 connected, 0 disconnected (connection failed) self.port = None self._notify_window = _notify_window debug_display(self._notify_window, 1, "Opening interface (serial port)") try: self.port = serial.Serial(portnum,baud, \ parity = par, stopbits = sb, bytesize = databits,timeout = to) except serial.SerialException as e: print(e) self.State = 0 return None debug_display( self._notify_window, 1, "Interface successfully " + self.port.portstr + " opened") debug_display(self._notify_window, 1, "Connecting to ECU...") try: self.send_command("atz") # initialize time.sleep(1) except serial.SerialException: self.State = 0 return None self.ELMver = self.get_result() if (self.ELMver is None): self.State = 0 return None debug_display(self._notify_window, 2, "atz response:" + self.ELMver) self.send_command("ate0") # echo off debug_display(self._notify_window, 2, "ate0 response:" + self.get_result()) self.send_command( "AT SP " + PROTOCOL ) # telling the program to use 9141-2 protocol for Asian cars. Ford's 'ISO 15765-4 CAN' protocol is 6 debug_display(self._notify_window, 2, "atsp response:" + self.get_result()) self.send_command("0100") ready = self.get_result() if (ready is None): self.State = 0 return None debug_display(self._notify_window, 2, "0100 response:" + ready) return None