479 lines
13 KiB
Python
479 lines
13 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
|
|
import sys, os
|
|
import time
|
|
import pickle
|
|
import codecs
|
|
import string
|
|
import threading
|
|
import mod_utils
|
|
import mod_ddt_utils
|
|
|
|
os.chdir(os.path.dirname(os.path.realpath(sys.argv[0])))
|
|
|
|
import pickle
|
|
|
|
import mod_globals
|
|
import mod_db_manager
|
|
import mod_elm
|
|
|
|
from mod_elm import ELM
|
|
|
|
from mod_ddt_ecu import DDTECU
|
|
from mod_utils import clearScreen
|
|
from mod_utils import ChoiceLong
|
|
from mod_utils import KBHit
|
|
from mod_utils import pyren_encode
|
|
|
|
from xml.dom.minidom import parse
|
|
import xml.dom.minidom
|
|
|
|
mod_globals.os = os.name
|
|
|
|
if mod_globals.os == 'nt':
|
|
import pip
|
|
|
|
try:
|
|
import serial
|
|
except ImportError:
|
|
pip.main(['install','pyserial'])
|
|
|
|
try:
|
|
import colorama
|
|
except ImportError:
|
|
pip.main(['install','colorama'])
|
|
try:
|
|
import colorama
|
|
except ImportError:
|
|
print("\n\n\n\t\t\tGive me access to the Internet for download modules\n\n\n")
|
|
sys.exit()
|
|
colorama.init()
|
|
else:
|
|
# let's try android
|
|
try:
|
|
import androidhelper as android
|
|
mod_globals.os = 'android'
|
|
except:
|
|
try:
|
|
import android
|
|
mod_globals.os = 'android'
|
|
except:
|
|
pass
|
|
|
|
if mod_globals.os != 'android':
|
|
try:
|
|
import serial
|
|
from serial.tools import list_ports
|
|
#import ply
|
|
except ImportError:
|
|
print("\n\n\n\tPleas install additional modules")
|
|
print("\t\t>sudo easy_install pyserial")
|
|
#print "\t\t>sudo easy_install ply"
|
|
sys.exit()
|
|
|
|
class DDT_MON():
|
|
|
|
decu = None #ddt ecu
|
|
|
|
frames = {} #frame statistic
|
|
datas = {} #last data value
|
|
f2r = {} #frame to decu.request mapper
|
|
showList = [] #data we will
|
|
|
|
lt = 0 #last time we showed the screen
|
|
|
|
screenMode = 0
|
|
framefilter = ''
|
|
|
|
def __init__(self, elm, xmlfile, outfile, infile ):
|
|
self.elm = elm
|
|
|
|
clearScreen()
|
|
print("Starting DDT process")
|
|
|
|
mod_ddt_utils.searchddtroot()
|
|
|
|
#make or load ddt ecu
|
|
decucashfile = "./cache/ddt_"+xmlfile+".p"
|
|
|
|
if os.path.isfile(decucashfile): #if cache exists
|
|
self.decu = pickle.load( open( decucashfile, "rb" ) ) #load it
|
|
else: #else
|
|
self.decu = DDTECU( None ) #init class
|
|
self.decu.setELM(self.elm) #define ELM for it
|
|
self.decu.loadXml( 'ecus/'+xmlfile ) #loading original data for chosen ECU
|
|
self.decu.setELM( None ) #clear elm before serialization
|
|
if len(self.decu.ecufname)>0:
|
|
pickle.dump( self.decu, open( decucashfile, "wb" ) ) #and save cache
|
|
|
|
if len(outfile)>0:
|
|
self.saveOutAndExit()
|
|
|
|
self.showList = []
|
|
self.screenMode = 0
|
|
if len(infile)>0:
|
|
self.loadInFile( infile )
|
|
self.screenMode = 1
|
|
#make elm filter
|
|
elmFilter = []
|
|
for d in self.showList:
|
|
if d in list(self.decu.req4data.keys()):
|
|
fid = self.decu.requests[self.decu.req4data[d]].SentBytes[1:]
|
|
elmFilter.append(fid)
|
|
self.setFilter( elmFilter )
|
|
|
|
self.decu.setELM(self.elm) #re-define ELM
|
|
|
|
self.frames = {}
|
|
self.datas = {}
|
|
self.f2r = {}
|
|
|
|
for r in list(self.decu.requests.keys()):
|
|
self.f2r[self.decu.requests[r].SentBytes[1:]] = self.decu.requests[r]
|
|
|
|
#addr = "7A"
|
|
|
|
if '250' in mod_globals.opt_protocol or self.decu.BaudRate == "250000":
|
|
# CAN 250
|
|
elm.init_can()
|
|
elm.cmd("at sp 8")
|
|
else:
|
|
# CAN 500
|
|
elm.init_can()
|
|
elm.cmd("at sp 6")
|
|
|
|
self.sendAllow = threading.Event()
|
|
self.sendAllow.clear()
|
|
self.elm.startMonitor( self.parser, self.sendAllow )
|
|
|
|
def setFilter( self, f ):
|
|
|
|
if isinstance(f,list):
|
|
bmask = ['0','1','1','1','1','1','1','1','1','1','1','1']
|
|
filter = list(bin(int(f[0],16))[2:].zfill(12))
|
|
#print f[0],filter
|
|
for fi in f[1:]:
|
|
fl = list(bin(int(fi,16))[2:].zfill(12))
|
|
#print fi, fl
|
|
for i in range(0,12):
|
|
if filter[i]!=fl[i]:
|
|
bmask[i] = '0'
|
|
mask = hex(int(''.join(bmask),2))[2:].zfill(3)
|
|
self.elm.setMonitorFilter( filter, mask )
|
|
elif isinstance(f,str) and all(c in string.hexdigits for c in f) and len(f)<4:
|
|
filter = f+'0'*(3-len(f))
|
|
if len(f)==1: mask = '700'
|
|
elif len(f)==2: mask = '7F0'
|
|
else: mask = '7FF'
|
|
self.elm.setMonitorFilter( filter, mask )
|
|
|
|
def parser(self, buf ):
|
|
|
|
global show_loc
|
|
|
|
if show_loc == None or show_loc.isSet():
|
|
self.sendAllow.clear()
|
|
return
|
|
|
|
ct = mod_elm.pyren_time()
|
|
|
|
for f in buf.split('\n'):
|
|
f = f.strip()
|
|
if len(f)==0: continue
|
|
fid = f[:3]
|
|
data = f[6:]
|
|
if fid not in list(self.frames.keys()):
|
|
self.frames[fid] = {'FirstSeen':ct, 'LastSeen':ct, 'Count':1, 'Name':'', 'data':'', 'changes':0}
|
|
if fid in list(self.f2r.keys()):
|
|
name = self.f2r[fid].Name
|
|
else:
|
|
name = 'Unknown'
|
|
self.frames[fid]['Name'] = name
|
|
|
|
self.frames[fid]['LastSeen'] = ct
|
|
self.frames[fid]['Count'] = self.frames[fid]['Count'] + 1
|
|
if len(self.frames[fid]['data']) and self.frames[fid]['data']!=data:
|
|
self.frames[fid]['changes'] = self.frames[fid]['changes'] + 1
|
|
self.frames[fid]['data'] = data
|
|
|
|
self.sendAllow.clear()
|
|
|
|
def saveOutAndExit( self ):
|
|
print("Saving output file:"+outfile+'\n')
|
|
of = codecs.open(outfile,'w',encoding='utf8')
|
|
for d in list(self.decu.datas.keys()):
|
|
d_type = ''
|
|
if len(self.decu.datas[d].List)>0:
|
|
d_type = ';LIST'
|
|
elif self.decu.datas[d].Scaled:
|
|
d_type = ';SCALED;'+self.decu.datas[d].Unit
|
|
of.write(d+d_type+'\n')
|
|
of.close()
|
|
exit()
|
|
|
|
def loadInFile( self, infile ):
|
|
print("Loading show list:"+infile+'\n')
|
|
lf = codecs.open(infile,'rt',encoding='utf8')
|
|
lff = lf.read()
|
|
self.showList = []
|
|
for l in lff.split('\n'):
|
|
l = l.strip()
|
|
if len(l)==0: continue
|
|
self.showList.append( l.split(';')[0] )
|
|
|
|
def showData( self, ct ):
|
|
|
|
if self.screenMode==0: #frame monitor mode
|
|
if len(self.framefilter)==3 and self.framefilter in list(self.frames.keys()):
|
|
fid = self.framefilter
|
|
if self.frames[fid]['Name'] != 'Unknown':
|
|
for d in list(self.f2r[fid].ReceivedDI.values()):
|
|
val = self.decu.getValue(d.Name, False, self.f2r[fid], self.frames[fid]['data'])
|
|
self.datas[d.Name] = val
|
|
|
|
clearScreen()
|
|
#if self.screenMode == '' and len(self.frames.keys()):
|
|
if '<' not in self.framefilter and len(self.framefilter)<4:
|
|
for l in sorted(self.frames.keys()):
|
|
if not l.startswith(self.framefilter): continue
|
|
|
|
#debug
|
|
#if self.frames[l]['changes']==0 or self.frames[l]['changes']>10: continue
|
|
|
|
if self.frames[l]['Name'] != 'Unknown':
|
|
ost = pyren_encode('%s : %-30s #%d:%d' % (l, self.frames[l]['Name'],
|
|
self.frames[l]['Count'], self.frames[l]['changes']))
|
|
else:
|
|
ost = pyren_encode('%s : %-30s #%d:%d' % (l, self.frames[l]['data'],
|
|
self.frames[l]['Count'], self.frames[l]['changes']))
|
|
print(ost)
|
|
#if len(self.framefilter)==3 and self.framefilter in self.frames.keys():
|
|
if len(self.framefilter)==3 and self.framefilter in list(self.f2r.keys()):
|
|
print('*'*50)
|
|
for l in list(self.f2r[self.framefilter].ReceivedDI.values()):
|
|
ost = pyren_encode('%-50s %s' % (l.Name, self.datas[l.Name]))
|
|
print(ost)
|
|
print('Frame filter (Q for exit, R for reset counter):', self.framefilter, end=' ')
|
|
sys.stdout.flush()
|
|
return
|
|
|
|
if self.screenMode==1: # show list mode
|
|
for d in self.showList:
|
|
if d in list(self.decu.req4data.keys()):
|
|
fid = self.decu.requests[self.decu.req4data[d]].SentBytes[1:]
|
|
if fid in list(self.f2r.keys()) and fid in list(self.frames.keys()):
|
|
val = self.decu.getValue(d, False, self.f2r[fid], self.frames[fid]['data'])
|
|
else:
|
|
val = mod_globals.none_val
|
|
self.datas[d] = val
|
|
|
|
clearScreen()
|
|
|
|
for d in self.showList:
|
|
if d in list(self.datas.keys()):
|
|
ost = pyren_encode('%-50s %s' % (d, self.datas[d]))
|
|
print(ost)
|
|
|
|
candef = ''
|
|
outfile = ''
|
|
infile = ''
|
|
show_loc = None
|
|
|
|
def optParser():
|
|
'''Parsing of command line parameters. User should define at least com port name'''
|
|
|
|
import argparse
|
|
|
|
global candef
|
|
global outfile
|
|
global infile
|
|
|
|
parser = argparse.ArgumentParser(
|
|
description = "bus_monitor - python program for diagnostic Renault cars"
|
|
)
|
|
|
|
parser.add_argument('-p',
|
|
help="ELM327 com port name",
|
|
dest="port",
|
|
default="")
|
|
|
|
parser.add_argument("-r",
|
|
help="com port rate during diagnostic session {38400[default],57600,115200,230400,500000}",
|
|
dest="rate",
|
|
default="38400",)
|
|
|
|
parser.add_argument("-i",
|
|
help="interface protocol [250|500]",
|
|
dest="protocol",
|
|
default='UnDef')
|
|
|
|
parser.add_argument("-a",
|
|
help="filter for canId",
|
|
dest="ecuAddr",
|
|
default="")
|
|
|
|
parser.add_argument("-x",
|
|
help="xml file with frames defenition",
|
|
dest="xmlfile",
|
|
default="")
|
|
|
|
parser.add_argument("-o",
|
|
help="output file for saving parameters list",
|
|
dest="outfile",
|
|
default="")
|
|
|
|
parser.add_argument("-f",
|
|
help="file with selected parameters list",
|
|
dest="infile",
|
|
default="")
|
|
|
|
parser.add_argument("--log",
|
|
help="log file name",
|
|
dest="logfile",
|
|
default="")
|
|
|
|
parser.add_argument("-L",
|
|
help="language option {RU[default],GB,FR,IT,...}",
|
|
dest="lang",
|
|
default="RU")
|
|
|
|
parser.add_argument("--demo",
|
|
help="for debuging purpose. Work without car and ELM",
|
|
dest="demo",
|
|
default=False,
|
|
action="store_true")
|
|
|
|
options = parser.parse_args()
|
|
|
|
if options.outfile=='' and not options.port and mod_globals.os != 'android':
|
|
parser.print_help()
|
|
iterator = sorted(list(list_ports.comports()))
|
|
print("")
|
|
print("Available COM ports:")
|
|
for port, desc, hwid in iterator:
|
|
print("%-30s \n\tdesc: %s \n\thwid: %s" % (port,desc,hwid))
|
|
print("")
|
|
exit(2)
|
|
else:
|
|
mod_globals.opt_port = options.port
|
|
mod_globals.opt_rate = int(options.rate)
|
|
mod_globals.opt_log = options.logfile
|
|
mod_globals.opt_ecuAddr = options.ecuAddr.upper()
|
|
mod_globals.opt_demo = options.demo
|
|
if '250' in options.protocol:
|
|
mod_globals.opt_protocol = '250'
|
|
elif '500' in options.protocol:
|
|
mod_globals.opt_protocol = '500'
|
|
else:
|
|
mod_globals.opt_protocol = 'UnDef'
|
|
candef = options.xmlfile
|
|
outfile = options.outfile
|
|
infile = options.infile
|
|
mod_globals.opt_exp = True
|
|
|
|
def chooseXml():
|
|
|
|
import projects
|
|
|
|
p_list = projects.projects.split('\n')
|
|
menu = []
|
|
for pr in p_list:
|
|
pr = pr.strip()
|
|
if len(pr)<2: continue
|
|
p_params = pr.split(';')
|
|
|
|
menu.append( "%-6s : %s" % ( p_params[0], p_params[1] ) )
|
|
|
|
menu.append("<Exit>")
|
|
choice = ChoiceLong(menu, "Choose :", "")
|
|
if choice[0]=="<Exit>": return
|
|
|
|
p = p_list[int(choice[1])].split(';')
|
|
|
|
if len(p)==3:
|
|
return p[2]
|
|
|
|
menu = []
|
|
for x in p[2:]:
|
|
menu.append(x)
|
|
|
|
choice = ChoiceLong(menu, "Choose :", choice[0])
|
|
|
|
return choice[0]
|
|
|
|
|
|
|
|
def main():
|
|
|
|
global candef
|
|
global outfile
|
|
global infile
|
|
global show_loc
|
|
|
|
optParser()
|
|
|
|
mod_utils.chkDirTree()
|
|
mod_db_manager.find_DBs()
|
|
|
|
if len(candef)==0:
|
|
candef = chooseXml()
|
|
|
|
elm = None
|
|
if len(outfile)==0:
|
|
print('Opening ELM')
|
|
elm = ELM( mod_globals.opt_port, mod_globals.opt_speed, mod_globals.opt_log )
|
|
|
|
#change serial port baud rate
|
|
if mod_globals.opt_speed<mod_globals.opt_rate and not mod_globals.opt_demo:
|
|
elm.port.soft_boudrate( mod_globals.opt_rate )
|
|
|
|
print(candef)
|
|
mon = DDT_MON( elm, candef, outfile, infile )
|
|
|
|
kb = KBHit()
|
|
|
|
lt = ct = mod_elm.pyren_time()
|
|
|
|
show_loc = threading.Event()
|
|
|
|
if mod_globals.opt_ecuAddr != '':
|
|
mon.framefilter = mod_globals.opt_ecuAddr
|
|
mon.setFilter(mon.framefilter)
|
|
|
|
while(1):
|
|
c = ''
|
|
if kb.kbhit():
|
|
c = kb.getch()
|
|
if c=='q' or c=='Q' or c=='\x71' or c=='\x51' :
|
|
print()
|
|
mon.elm.stopMonitor()
|
|
mon.elm.reset_elm()
|
|
break;
|
|
if c == 'r' or c == 'R' or c == '\x72' or c == '\x52':
|
|
for l in list(mon.frames.keys()):
|
|
mon.frames[l]['changes']=0
|
|
continue
|
|
if c>='a' and c<='f':
|
|
c = chr(ord(c) - 32)
|
|
if (c>='0' and c<='9') or (c>='A' and c<='F'):
|
|
mon.framefilter = mon.framefilter + c
|
|
mon.setFilter( mon.framefilter )
|
|
elif c=='\x7f' or c=='\x08': #backspase
|
|
mon.framefilter = mon.framefilter[:-1]
|
|
mon.setFilter( mon.framefilter )
|
|
else:
|
|
pass
|
|
#mon.framefilter = mon.framefilter + '<' + str(ord(c)) + '>'
|
|
|
|
time.sleep( 0.03 )
|
|
ct = mod_elm.pyren_time()
|
|
if (ct-lt)>0.1:
|
|
lt = ct
|
|
show_loc.set()
|
|
mon.showData( ct )
|
|
show_loc.clear()
|
|
|
|
if __name__ == '__main__':
|
|
main()
|