def __init__(self):
can.rc['interface'] = 'socketcan_native'
can.rc['channel'] = 'vcan0'
can.rc['bitrate'] = 500000
self.bus = Bus()
self.buffered_reader = can.BufferedReader()
self.notifier = can.Notifier(self.bus, [self.buffered_reader])
def main():
global device_id
global encoder_value_send_task
if len(sys.argv) != 2:
usage()
sys.exit(1)
device_id = int(sys.argv[1])
if device_id < 0 or device_id >= 63:
usage()
sys.exit(1)
can.rc['interface'] = 'socketcan_ctypes'
can.rc['channel'] = 'vcan0'
bus = Bus()
notifier = can.Notifier(bus, [Listener()])
status_3_msg = can.Message(arbitration_id=(talon_srx.STATUS_3 | device_id),
extended_id=True,
data=make_status_3_msg())
status_3_task = can.send_periodic(can.rc['channel'], status_3_msg, 0.1)
while True:
status_3_msg.data = make_status_3_msg()
status_3_task.modify_data(status_3_msg)
time.sleep(0.05)
notifier.stop()
def Can(id):
global adc_val
can_interface = 'can0'
bus = Bus(can_interface)
print "send message..."
Message.extended_id = False
Message.extended_id = False
Message.is_remote_frame = False
Message.id_type = 1
Message.is_error_frame=False
if id==0x22:
Message.arbitration_id=id
Message.dlc=3
adc_val1=adc_val/ 10
adc_val2=adc_val %10
#message data frame
Message.data=[0x00,adc_val1,adc_val2]
#exception for error handling
try:
bus.send(Message);
print"data=",Message.data
print "id=",id
except:
print "OOPS somthing went wrong"
sleep(3)
def __init__(self, interface, verbose = False, listeners = None): self.bus = Bus(interface, bustype = 'socketcan') self.verbose = verbose self.listeners = listeners self.bms = bms.bms() self.ccs = ccs.ccs() self.notifier = can.Notifier(self.bus, [self.on_message_received])
def main():
data=0
while(1):
can_interface = 'can0'
bus = Bus(can_interface)
print "send message....."
sleep(3)
Message.extended_id =False
Message.is_remote_frame = False
Message.id_type = 1
Message.is_error_frame=False
Message.arbitration_id = 0x33
Message.dlc = 1
Message.data=[data]
try:
bus.send(Message);
print Messgae.data
except:
print "invalid operation!!!!!!"
sleep(0.1)
def main():
can_interface = 'can0'
bus = Bus(can_interface)
data_scoket = s.recv(1024)
print(data_scoket)
data_can = [0x01]
if data_scoket[0] == '0':
data_can = [0x00]
elif data_scoket[0] == '+':
data_can = [0x02]
print(data_can)
print "send a message..."
Message.extended_id = False
Message.is_remote_frame = False
Message.id_type = 0
Message.is_error_frame = False
Message.arbitration_id = 0x65D
Message.dlc = 1
Message.data = data_can
try:
bus.send(Message)
except:
print "Upss something went wrong"
def __init__(self, interface, channel):
can.rc['interface'] = interface
can.rc['channel'] = channel
log.info('Opening CAN connection on {0}'.format(can.rc['channel']))
self.bus = Bus(bitrate=250000)
self.periodic_tasks = list()
self._rxHandlers = list()
def producer(id):
""":param id: Spam the bus with messages including the data id."""
bus = Bus(can_interface)
for i in range(16):
msg = can.Message(arbitration_id=0x0cf02200, data=[id, i, 0, 1, 3, 1, 4, 1])
bus.send(msg)
# TODO Issue #3: Need to keep running to ensure the writing threads stay alive. ?
time.sleep(2)
def __init__(self):
super(CanStore, self).__init__()
self.frameDictionary = {}
# setup worker multiprocessing to listen to the can bus
self.parent, self.child = Pipe()
self.canWorker = Process(target=canListener, args=(self.child, ))
self.canWorker.start()
# set up can bus interface
self.bus = Bus(self.can_interface)
def main():
can_interface = 'can1'
bus = Bus(can_interface)
try:
while True:
Message = bus.recv(0.0)
if Message:
check_rx(Message.arbitration_id, Message.data[0])
except KeyboardInterrupt:
bus.shutdown()
def canListener(pipe):
data = {}
bus = Bus(env.bus)
while 1:
frame = bus.recv(timeout=0.005)
data[hex(frame.arbitration_id)] = frame.data
if (pipe.poll(timeout=0)):
# flush out the pipe from any flags for writing
while pipe.poll(timeout=0):
pipe.recv()
pipe.send(data)
pipe.close()
return # execution really should not get here
def __init__(self, can_interface):
can.rc['interface'] = 'socketcan_ctypes'
if can_interface is None:
can_interface = 'can0'
self._can_interface = can_interface
if not self.status():
raise IOError("CAN Bus not available")
self._bus = Bus(self._can_interface)
self._bitrate = 500000
if self._bus is None:
raise IOError("Can't find CAN bus interface")
self._rcv_thread_quit = False
self._rcv_thread = None
self._rcv_queue = queue.Queue(maxsize=1024)
class CanMessageRead(object):
bus = Bus(can_interface)
def __init__(self):
self.id = 0
self.currentDistance = 0
self.prevDistance = 0
def readBus(self):
try:
msg = self.bus.recv()
self.id = msg.data[0]
self.prevDistance = self.currentDistance
self.currentDistance = msg.data[1]
except:
print("TODO m: We need to catch this, yo")
def main():
can_interface = 'can1'
bus = Bus(can_interface)
print "Send a message..."
Message.extended_id = True
Message.is_remote_frame = False
Message.id_type = 1
Message.is_error_frame = False
Message.arbitration_id = 0x65D
Message.dlc = 1
Message.data = [ 0x01]
try:
bus.send(Message);
except:
print "Ups something went wrong!"
def response(payloads, quiet_response, channel_in):
can.rc['interface'] = 'socketcan_ctypes'
can.rc['channel'] = channel_in
bus = Bus()
send_recv = "receive"
# if(payloads != None):
# continue
consecutive_messages = 1;
last_message_id = -1;
mod = 1
current = None
while 1:
if current != None:
send_recv == "send"
if send_recv == "receive":
while 1:
current = payloads.get()
#print(current)
# if current != None:
print(current)
# break
# print(current)
# continue
elif send_recv == "send":
message = can.Message(extended_id = False, is_error_frame = False, arbitration_id = current.arbitration_id, data = [0])
count = 0
while 1:
bus.send(message)
count += 1
if (count%mod)==0:
send_recv = "receive"
mod *= 2
current = None
break
def main():
data=0
while(1):
can_interface = 'can0'
bus = Bus(can_interface)
#print "Send a message...a heart beat"
Message.extended_id = False
Message.is_remote_frame = False
Message.id_type = 1
Message.is_error_frame = False
Message.arbitration_id = 0x33
Message.dlc = 1
data=data+1
Message.data = [data]
try:
bus.send(Message);
print (Message.data)
except:
print ("Ups something went wrong!")
sleep(0.1)
def Can(id):
can_interface = 'can0'
bus = Bus(can_interface)
Message.extended_id = False
Message.is_remote_frame = False
Message.id_type = 1
Message.is_error_frame = False
if id==0x22:
Message.arbitration_id=id
Message.dlc=3
Message.data=[0x22]
if id==0x11:
Message.arbitration_id=id
Message.dlc=3
Message.data=[0x11]
try:
bus.send(Message);
print ("Data=",Message.data)
print ("ID=",id)
except:
print ("Oops!!! Something went wrong!")
import sys,signal,can
from PyQt5 import QtGui, QtCore, QtWidgets
from can.interfaces.interface import Bus
#200 -> 4,5 == speed 6,7 == ?
device = sys.argv[1]
can.rc['interface'] = 'socketcan_ctypes'
can.rc['channel'] = device
bus = Bus()
class Main(QtWidgets.QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.timer = QtCore.QTimer(self)
self.timer.timeout.connect(self.CAN)
self.timer.start(1)
self.lcd = QtWidgets.QLCDNumber(self)
#set widget size
self.lcd.setFixedSize(500,200)
self.lcd.display(0)
self.setGeometry(50,50,500,200)
self.setWindowTitle("Speedometer")
import log_utils
from timeit import default_timer
import sys
import can
from can.interfaces.interface import Bus
#python3 send_from_log.py [device name] [logfile]
can.rc['interface'] = 'socketcan_ctypes'
can.rc['channel'] = 'can0'
bus = Bus()
chan_in = sys.argv[1]
LOGFILE = sys.argv[2]
#ID = int(sys.argv[2])
can.rc['interface'] = 'socketcan_ctypes'
can.rc['channel'] = chan_in
bus = Bus()
def send_message(message):
soc_message = can.Message(extended_id=False,
is_error_frame=False,
arbitration_id=message.can_id,
data=message.data)
bus.send(soc_message)
def message_alter(message, altered_bytes):
for i in range(len(message.data)):
description='Simulates CAN bus messages from CCS')
parser.add_argument("--verbose",
type=str2bool,
nargs='?',
const=True,
default=False,
help="Prints verbose logger messages")
args = parser.parse_args()
# Add verbose logger
if args.verbose:
logging.basicConfig()
logging.getLogger('apscheduler').setLevel(logging.DEBUG)
# Init CAN
bus = Bus('can1', bustype='socketcan')
# Pose as CCS and send out some messages
scheduler = BackgroundScheduler()
scheduler.add_job(_send_ccs_rand, 'interval', args=[bus], seconds=1)
scheduler.start()
# Enter blocking loop to keep daemon alive
while True:
try:
time.sleep(1)
except:
# Gracefully shutdown scheduler
click.echo(
click.style('Exception Handled! Killing thread',
bg='red',
def initializeInstances(self):
self.bus = Bus(can_interface, can_filters=FILTER_DICTIONARY_LIST)
self.can_tools = CAN_Opener.Can_Opener()
def dumpcan():
global var
windowid = 0
for message in Bus(can_interface):
if var == 1:
msg = unicode(message).encode('utf-8')
canid = msg[26:29]
msg = msg[48:99]
if canid == ("464"):
if msg == ("20 02 02 00"): #Button Up - KODI Up
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Input.Up","id":1}')
if msg == ("20 02 20 00"): #Button Down - KODI Down
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Input.Down","id":1}')
if msg == ("20 02 01 00"): #Button Left - KODI Left
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Input.Left","id":1}')
if msg == ("20 02 03 00"): #Button Right - KODI Right
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Input.Right","id":1}')
if msg == ("20 02 04 00"): #Button AS - KODI OK
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Input.Select","id":1}')
if msg == ("20 02 00 50"): #Button Return - KODI Back
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Input.Back","id":1}')
if msg == ("20 02 00 05"): #Encoder Button Pressed - KODI OK
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Input.Select","id":1}')
if msg == ("20 01 00 ff"
): #Right Encoder Rotation to Left - KODI UP
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Input.Up","id":1}')
if msg == ("20 01 01 ff"
): #Right Encoder Rotation to Left - KODI Down
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Input.Down","id":1}')
if msg == ("20 02 00 20"): #Button - Kodi Up
windowid = xbmcgui.getCurrentWindowId()
if (windowid == 12006): # MusicVisualisation.xml
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Player.Seek","params":{"playerid":0,"value":"bigforward"},"id":1}'
)
elif (windowid == 12005): # VideoFullScreen.xml
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Player.Seek","params":{"playerid":1,"value":"bigforward"},"id":1}'
)
else:
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Input.Up","id":1}')
if msg == ("20 02 00 01"): #Button + KODI -
windowid = xbmcgui.getCurrentWindowId()
if (windowid == 12006): # MusicVisualisation.xml
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Player.Seek","params":{"playerid":0,"value":"bigbackward"},"id":1}'
)
elif (windowid == 12005): # VideoFullScreen.xml
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Player.Seek","params":{"playerid":1,"value":"bigbackward"},"id":1}'
)
else:
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Input.Down","id":1}')
if msg == ("20 02 00 03"): #Button Mode - KODI Context menu
windowid = xbmcgui.getCurrentWindowId()
if (windowid == 12006): # MusicVisualisation.xml
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Input.ShowOSD","id":1}'
)
elif (windowid == 12005): # VideoFullScreen.xml
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Input.ShowOSD","id":1}'
)
else:
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Input.ContextMenu","id":1}'
)
if msg == ("00 02"): #Stop Player if power OFF
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Player.Stop","params":{"playerid":1},"id":1}'
)
if canid == ("218"):
if msg == ("01 02"): #Stop Player if key disable
xbmc.executeJSONRPC(
'{"jsonrpc":"2.0","method":"Player.Stop","params":{"playerid":1},"id":1}'
)
def __init__(self):
self.bus = Bus('can0', bustype='socketcan_ctypes')
self.rx_buff = []
self.tx_buff = []
import time
import can
import sys
from can.interfaces.interface import Bus
can_interface = 'can0'
#
# TODO: keep sending 700/02 3e 80
#
#
bus = Bus(can_interface)
receivers = []
def hexdump(x):
return ' '.join("%02x" % y for y in bytearray(x))
class IsoTp:
PAD = bytes([0x55])
def __init__(self, bus, id_source, id_target, add_address_info = None):
global receivers
self.id_source = id_source
self.id_target = id_target
self.add_address_info = add_address_info
self.bus = bus
receivers.append(self)
self.rx_pdu = None
self.rx_dl = None
self.rx_exp_sn = None
self.debug = True
def pushCan(canId, data):
bus = Bus(channel=can_interface)
msg = can.Message(arbitration_id=canId,
data=(data).to_bytes(4, byteorder='little'),
extended_id=True)
bus.send(msg)
def main():
can_interface = 'can1'
bus = Bus(can_interface)
attack_choice = showoptions()
print attack_choice
print "Attack initiated......"
try:
while (1):
try:
if attack_choice == '1':
changespeed_50()
bus.send(Message)
elif attack_choice == '2':
changespeed_100()
bus.send(Message)
elif attack_choice == '3':
changespeed_150()
bus.send(Message)
elif attack_choice == '4':
changespeed_full()
bus.send(Message)
elif attack_choice == '5':
changespeed_randomtrip()
elif attack_choice == '6':
changefuel_full()
bus.send(Message)
elif attack_choice == '7':
changefuel_threequarter()
bus.send(Message)
elif attack_choice == '8':
changefuel_half()
bus.send(Message)
elif attack_choice == '9':
changefuel_quarter()
bus.send(Message)
elif attack_choice == '10':
changefuel_emptybeep()
bus.send(Message)
elif attack_choice == '11':
open_driverdoor()
bus.send(Message)
elif attack_choice == '12':
open_passengerdoor()
bus.send(Message)
elif attack_choice == '13':
open_reardoors()
bus.send(Message)
elif attack_choice == '14':
open_frontdoors()
bus.send(Message)
elif attack_choice == '15':
close_alldoor()
bus.send(Message)
elif attack_choice == '16':
highbeam()
bus.send(Message)
elif attack_choice == '17':
headlamp()
bus.send(Message)
elif attack_choice == '18':
interiorlight()
bus.send(Message)
elif attack_choice == '19':
lightsoff()
bus.send(Message)
else:
print "Invalid Choice. Please Re-enter correct choice."
time.sleep(2)
os.system('clear')
main()
except KeyboardInterrupt:
print "Attack Stopped"
time.sleep(2)
os.system('clear')
main()
except:
print "Oops something went wrong!"
time.sleep(2)
os.system('clear')
main()
except KeyboardInterrupt:
os.system('clear')
main()
