def wrapper():
p = Panda()
for i in [0, 1, 2, 0xFFFF]:
p.can_clear(i)
p.reset()
p.close()
fn()
def wrapper(*args, **kwargs):
p = Panda()
for i in [0, 1, 2, 0xFFFF]:
p.can_clear(i)
p.reset()
p.close()
f(*args, **kwargs)
def wrapper(*args, **kwargs):
for serial in Panda.list():
p = Panda(serial)
for i in [0, 1, 2, 3, 0xFFFF]:
p.can_clear(i)
p.reset()
p.close()
f(*args, **kwargs)
class Prius(object):
def __init__(self):
panda_list = Panda.list()
# choose panda serial prot
if len(panda_list) > 1:
for i, s in enumerate(panda_list, 1):
print('{}) {}'.format(i, s))
serial = panda_list[input('Please input 1, 2,.... or 10 number: ')
- 1]
else:
serial = panda_list[0]
# Connect to panda
if serial in panda_list:
self.panda = Panda(serial)
self.panda.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
self.panda.can_clear(0)
self.frame = 0
print('Connect Panda [Send]')
else:
print('Not Panda connect')
exit()
def send_speed(self, speed=0):
can_send = []
# speedometer
can_send.append(create_speedometer(self.frame, 0xB4, speed, 0, True))
can_send.append(create_speedometer2(self.frame, 0xB1, speed, 0, True))
can_send.append(create_speedometer3(self.frame, 0xB3, speed, 0, True))
can_send.append(create_speedometer4(self.frame, 0x3ca, speed, 0))
self.frame += 1
self.panda.can_send_many(can_send)
def send_door_lock(self, lock=True):
can_send = []
if lock:
msg = struct.pack('!BBB', 0xe4, 0x81, 0x00)
can_send.append([0x5B6, 0, msg, 0])
self.panda.can_send_many(can_send)
else:
msg = struct.pack('!BBB', 0xe4, 0x00, 0x00)
can_send.append([0x5B6, 0, msg, 0])
self.panda.can_send_many(can_send)
def recv(self):
can_msgs = self.panda.can_recv()
can_msgs_bytes = []
for address, _, dat, src in can_msgs:
can_msgs_bytes.append((address, 0, bytes(dat), src))
if address == 0xb4:
print("Address: {}\t Data: {}\t src: {}".format(
address, binary_show(dat), src))
def can_proxy():
print("Trying to connect to Panda over USB...")
p = Panda()
p.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
p.can_clear(0)
try:
while True:
can_recv = p.can_recv()
for address, _, dat, src in can_recv:
if src == 2:
if address == 0x180:
dat = can_modify(dat)
p.can_send(address, bytearray(dat), 0)
print("sent message")
except KeyboardInterrupt:
print("\nNow exiting.")
while 1:
supported = struct.unpack(">I", get_current_data_for_pid(pid)[2:])[0]
for i in range(1 + pid, 0x21 + pid):
if supported & 0x80000000:
ret.append(i)
supported <<= 1
pid += 0x20
if pid not in ret:
break
return ret
if __name__ == "__main__":
panda = Panda()
panda.set_safety_mode(Panda.SAFETY_ELM327)
panda.can_clear(0)
# 09 02 = Get VIN
isotp_send(panda, b'\x09\x02', 0x7df)
ret = isotp_recv(panda, 0x7e8)
hexdump(ret)
print "VIN: %s" % ret[2:]
# 03 = get DTCS
isotp_send(panda, b'\x03', 0x7e0)
dtcs = isotp_recv(panda, 0x7e8)
print "DTCs:", dtcs[2:].encode("hex")
supported_pids = get_supported_pids()
print "Supported PIDs:", supported_pids
app.css.config.serve_locally = True
app.scripts.config.serve_locally = True
# Boostrap CSS file (local)
@app.server.route('/static/<path:path>')
def static_file(path):
static_folder = os.path.join(os.getcwd(), 'static')
return send_from_directory(static_folder, path)
# Global variables and initialization
# Open panda device (comma ai) and clear the buffer
panda_port = get_panda_id('ford_f150', 'send')
PANDA = Panda(panda_port)
PANDA.can_clear(0xFFFF)
PANDA.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
# Send request to broadcast leddar messages
dat = '0301000000000000'
PANDA.can_send(0x740, dat.decode('hex'), 1)
# DBC files: car and leddar
base_path = dirname(abspath(__file__))
leddar = join(base_path, 'dbc_files/leddar_vu_8_segments.dbc')
car = join(base_path, 'dbc_files/ford_f150_2017.dbc')
CAR_DBC = cantools.database.load_file(car)
LEDDAR_DBC = cantools.database.load_file(leddar)
CAN_VARIABLES = []
PROPS_VIS = visualization_props()
# Layout of the app
def can_logger(car_dbc=None,
leddar_dbc=None,
port=None,
sample_time=0.2,
filename=None,
ni_device='Dev1'):
try:
print("Trying to connect to Panda over USB...")
if port != None:
p = Panda(port)
else:
p = Panda() # default port
p.can_clear(0xFFFF)
print('Buffer cleaned')
# Send leddar request to start transmitting - Read LeddarVu 8 documentation
p.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
dat = '0301000000000000'
p.can_send(0x740, dat.decode('hex'), 1)
p.serial_clear(1)
except AssertionError:
print("USB connection failed. Trying WiFi...")
try:
p = Panda("WIFI")
except:
print("WiFi connection timed out. Please make sure\
your Panda is connected and try again.")
sys.exit(0)
try:
columns = [
'time_rel', 'timestamp', 'vehicle_speed_mph', 'eng_speed_rpm',
'pedal_per', 'gap_m', 'latitude_deg', 'longitude_deg',
'axle_torque_ch_0_V', 'axle_torque_ch_1_V'
]
df = pd.DataFrame(columns=columns)
rel_time = 0
dt = sample_time
while True:
time.sleep(dt)
row = {}
row[columns[0]] = rel_time
row[columns[1]] = str(datetime.now())
can_recv = p.can_recv()
gps = p.serial_read(1)
for address, _, dat, _ in can_recv:
if address == 0x215:
msg = car_dbc.decode_message(address, dat)
row[columns[2]] = (
msg['Veh_wheel_speed_RR_CAN_kph_'] +
msg['Veh_wheel_speed_FL_CAN_kph_'] +
msg['Veh_wheel_speed_RL_CAN_kph_'] +
msg['Veh_wheel_speed_FR_CAN_kph_']) * 0.25 * 0.62137119
elif address == 0x201:
msg = car_dbc.decode_message(address, dat)
row[columns[3]] = msg['Eng_speed_CAN_rpm_']
row[columns[4]] = msg['Pedal_accel_pos_CAN_per_']
elif (address == 0x752 or address == 0x753 or address == 0x754
or address == 0x755 or address == 0x756
or address == 0x757 or address == 0x758
or address == 0x759):
msg = leddar_dbc.decode_message(address, dat)
if msg['lidar_channel'] == 4:
row[columns[5]] = msg['lidar_distance_m']
# Clear the CAN bus to avoid the buffer
p.can_clear(0xFFFF)
lat, long = lat_longitude_from_serial(gps)
row[columns[6]] = lat
row[columns[7]] = long
# Add nidaqmx channels
with nidaqmx.Task() as task:
task.ai_channels.add_ai_voltage_chan(
device + "/ai0", terminal_config=TerminalConfiguration.RSE)
task.ai_channels.add_ai_voltage_chan(
device + "/ai1", terminal_config=TerminalConfiguration.RSE)
analog_channels = np.array(
task.read(number_of_samples_per_channel=100)).mean(axis=1)
row[columns[8]] = analog_channels[0]
row[columns[9]] = analog_channels[1]
print(row)
df = df.append(row, ignore_index=True)
rel_time += dt
except KeyboardInterrupt:
if filename == None:
filename = datetime.now().strftime("%Y%m%d%H%M%S") + '_output.csv'
else:
filename = datetime.now().strftime(
"%Y%m%d%H%M%S") + '_' + filename + '.csv'
df.to_csv(filename, index=False)
# Print and plot results in the screen
plt.figure()
plt.subplot(2, 1, 1)
plt.plot(df['time_rel'], df['gap_m'])
plt.ylabel('gap (m)')
plt.subplot(2, 1, 2)
plt.plot(df['time_rel'], df['axle_torque_ch_0_V'])
plt.plot(df['time_rel'], df['axle_torque_ch_1_V'])
plt.ylabel('torque voltages')
plt.xlabel('time (sec)')
plt.legend()
plt.show()
# Converts messages sent by Panda (bus 128+) to the actual bus number.
# format from Cabana's Save Log:
# time,addr,bus,data
# 0.06194250166663551,308,0,08007c630a00d064
# To exclude some messages, filter them out from the CSV first:
# fgrep -v ,658, from-cabana.csv > filtered.csv
# Then run it with:
# ./can_replay.py filtered.csv
print("Trying to connect to Panda over USB...")
p = Panda()
p.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
p.can_clear(0)
# TODO loop until ignition is detected
prev_time = 0.0
with open(sys.argv[1]) as f:
reader = csv.reader(f)
for row in reader:
(timestamp, address, bus, data) = row
if 'time' == timestamp:
continue # skip CSV header
timestamp = float(timestamp)
time.sleep(timestamp - prev_time)
prev_time = timestamp
bus = int(bus)
if bus >= 128:
from __future__ import print_function
import struct
import sys
from panda import Panda
from binascii import hexlify, unhexlify
from time import sleep
CAN_BUS = 0x0
if __name__ == "__main__":
try:
panda = Panda()
# allow all output
panda.set_safety_mode(0x1337)
# clear tx buffer
panda.can_clear(0x0)
# clear rx buffer
panda.can_clear(0xFFFF)
data = unhexlify(b'10082324F0010098')
addr = 0x0
for i in range(0x800):
print('Try', hex(addr + i))
panda.can_send(addr + i, data, CAN_BUS)
sleep(0.1)
for _ in range(100):
messages = panda.can_recv()
for rx_addr, rx_ts, rx_data, rx_bus in messages:
if rx_data[0:1] == unhexlify(b'30'):
print('Found addr', hex(addr + i))
sys.exit(0)
if __name__ == "__main__":
pl = Panda.list()
assert (len(pl) == 2)
p0 = Panda(pl[1])
p1 = Panda(pl[0])
p0.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
p1.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
print("0: ", p0.get_type())
print("1: ", p1.get_type())
set_gmlan(p0)
set_gmlan(p1)
p0.can_clear(0xFFFF)
p1.can_clear(0xFFFF)
loops = 0
while True:
for speed in [33.3, 83.3]:
set_speed_kbps(p0, speed)
set_speed_kbps(p1, speed)
p0.can_clear(0xFFFF)
p1.can_clear(0xFFFF)
print(f"Speed: {speed}")
time.sleep(0.1)
print("Send 1 -> 0")
send(p1, 1, b"1to0:" + bytes(str(loops % 100), "utf-8"))
class canshell(cmd.Cmd):
prompt = '> '
def __init__(self):
print "Panda/CanBus shell:"
print "Ctrl-C - interrupt running command"
print "Ctrl-D - exit canshell"
print(" ! <expr> - evaluate python expression")
print(" help - list commands")
print(" help <command> - command help")
print("")
cmd.Cmd.__init__(self)
self.__baseline__ = set()
self.__ignore__ = set()
try:
print("Trying to connect to Panda over USB...")
self.panda = Panda()
except AssertionError:
print("USB connection failed. Trying WiFi...")
#self.panda = None
try:
self.panda = Panda("WIFI")
except:
print(
"WiFi connection timed out. Please make sure your Panda is connected and try again."
)
sys.exit(0)
self.panda.can_clear(0)
def do_EOF(self, args):
sys.exit(0)
def do_shell(self, args):
"Evaluate Python expression."
panda = self.panda
def send(id, msg, bus):
panda.can_send(id, msg, bus)
def recv():
return panda.can_recv()
print eval(args)
def do_clear(self, args):
"clear panda buffer, requires int arg"
self.panda.can_clear(int(args))
def do_safety(self, args):
"set panda safety level"
s = eval("Panda.SAFETY_%s" % args.upper())
self.panda.set_safety_mode(s)
def complete_safety(self, text, line, begidx, endidx):
v = [
"NOOUTPUT",
"HONDA",
"TOYOTA",
"GM",
"HONDA_BOSCH",
"FORD",
"CADILLAC",
"HYUNDAI",
"TESLA",
"CHRYSLER",
"TOYOTA_IPAS",
"TOYOTA_NOLIMITS",
"ALLOUTPUT",
"ELM327",
]
k = line[begidx:endidx].upper()
return [s for s in v if s.startswith(k)]
def do_baseline(self, args):
"record baseline ignored in recv"
while True:
msgs = self.panda.can_recv()
for (id, _, dat, src) in msgs:
msg = (id, dat, src)
self.__baseline__.add(msg)
def do_ignore(self, args):
"ignore given ids in recv"
for a in _parse_ids(args):
self.__ignore__.add(a)
def do_discover(self, args):
"""
discover unique ids or messages with optional hex mask
Examples:
discover
discover 0x152
discover 0x152 mask 0x0f0f
"""
(ids, mask) = _parse_discover_args(args)
seen = set()
while True:
msgs = self.panda.can_recv()
for (id, _, data, src) in msgs:
if ids:
data = bytearray(data)
for i, b in enumerate(mask):
data[i] &= b
if id not in ids: continue
k = (id, str(data), src)
if k in seen: continue
print(format(*k))
seen.add(k)
else:
if id in seen: continue
print(hex(id))
seen.add(id)
def do_recv(self, args):
"""
recv from any or from given address(es)
Examples:
recv
recv 0x152
recv 0x374,0x374
"""
ids = _parse_ids(args)
while True:
msgs = self.panda.can_recv()
for (id, _, data, src) in msgs:
if not ids:
if id in self.__ignore__: continue
if (id, data, src) in self.__baseline__: continue
else:
if not id in ids: continue
print(format(id, data, src))
def do_send(self, args):
"""
send one or more messages once or with given frequency
Examples:
send 0x375,0xffffffffffffffff,0
send 0x375,0xffffffffffffffff,0 0x375,0x0000000000000000,0
send 0x375,0xffffffffffffffff,0 freq 10
"""
(msgs, freq) = _parse_send_args(args)
while True:
for (id, data, bus) in msgs:
#print (format(id, data, bus))
self.panda.can_send(id, data, bus)
if freq:
time.sleep(1.0 / freq)
continue
break
def onecmd(self, line):
try:
return cmd.Cmd.onecmd(self, line)
except Exception, e:
print e
return False # don't stop
class Prius(object):
def __init__(self, dbc=False):
panda_list = Panda.list()
# choose panda serial prot
if len(panda_list) > 1:
for i, s in enumerate(panda_list, 1):
print('{}) {}'.format(i, s))
serial = panda_list[input('Please input 1, 2,.... or 10 number: ')
- 1]
else:
serial = panda_list[0]
# Connect to panda
if serial in panda_list:
self.panda = Panda(serial)
self.panda.set_safety_mode(Panda.SAFETY_ALLOUTPUT)
self.panda.can_clear(0)
self.frame = 0
print('Connect Panda [Send]')
else:
print('Not Panda connect')
exit()
# add dbc decoder
if dbc:
self.can_msg_parser = load_dbc_file(dbc)
print(self.can_msg_parser.messages)
self.upload_data = OrderedDict(
(('wheel_angle', 0), ('SPEED', 0), ('gear_1', 35), ('gear_2', 96),
('brake_LI', 0), ('brake_H', 0), ('handcrat', 0),
('LIGHT_SMALL', 0), ('LIGHT_BIG', 0), ('LIGHT_FLASH',
0), ('door_lock', 128)))
def send_speed(self, speed=0):
can_send = [
create_speedometer_B4(self.frame, speed, 0, True),
create_speedometer_B1(speed, 0, True),
create_speedometer_B3(speed, 0, True),
create_speedometer_3CA(speed, 0)
]
# speedometer
self.frame += 1
self.panda.can_send_many(can_send)
def send_door_lock(self, lock=True):
can_send = []
if lock:
msg = struct.pack('!BBB', 0xe4, 0x81, 0x00)
can_send.append([0x5B6, 0, msg, 0])
self.panda.can_send_many(can_send)
else:
msg = struct.pack('!BBB', 0xe4, 0x00, 0x00)
can_send.append([0x5B6, 0, msg, 0])
self.panda.can_send_many(can_send)
def recv_print(self, mode='all'):
can_msgs = self.panda.can_recv()
if mode == 'dbc':
for msg in can_msgs:
if msg[0] in fingerprint.keys():
try:
print(msg[0])
print(
self.can_msg_parser.decode_message(msg[0], msg[2]))
except:
pass
else:
can_msgs_bytes = []
for address, _, dat, src in can_msgs:
can_msgs_bytes.append((address, 0, bytes(dat), src))
if mode == 'all':
print("Address: {}\t Data: {}\t src: {}".format(
address, binary_show(dat), src))
elif address == 0xb4:
print("Address: {}\t Data: {}\t src: {}".format(
address, binary_show(dat), src))
def recv(self):
can_msgs = self.panda.can_recv()
for msg in can_msgs:
try:
if msg[0] in fingerprint.keys():
data_dict = self.can_msg_parser.decode_message(
msg[0], msg[2])
for i in fingerprint[msg[0]]:
self.upload_data[i] = data_dict[i]
except:
pass
return self.upload_data
