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
